Bump swift-actions/setup-swift from 2 to 3

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

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

Signed-off-by: dependabot[bot] <support@github.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
@@ -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,7 +191,7 @@ jobs:
 
   build-dotnet-windows:
     name: Build .NET Windows
-    runs-on: windows-2022-64core
+    runs-on: windows-2022
     strategy:
       matrix:
         configuration: [
@@ -246,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
@@ -289,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
@@ -314,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
@@ -373,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}}
@@ -394,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
@@ -417,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
@@ -446,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
@@ -499,7 +499,7 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
     - uses: actions/checkout@v6
-    - uses: swift-actions/setup-swift@v2
+    - uses: swift-actions/setup-swift@v3
       with:
         swift-version: ${{ matrix.swift }}
     - name: Get swift version
@@ -523,7 +523,7 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
        - uses: actions/checkout@v6
-       - uses: swift-actions/setup-swift@v2
+       - uses: swift-actions/setup-swift@v3
          with:
            swift-version: 6.2.1
        - uses: bytecodealliance/actions/wasmtime/setup@v1

.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'
 

CMakeLists.txt

@@ -238,13 +238,8 @@ set(FlatBuffers_Tests_SRCS
   tests/util_test.cpp
   tests/vector_table_naked_ptr_test.h
   tests/vector_table_naked_ptr_test.cpp
-  tests/test_vector_type.h
-  tests/cpp_vector_type_test.h
-  tests/cpp_vector_type_test.cpp
   tests/native_type_test_impl.h
   tests/native_type_test_impl.cpp
-  tests/bigfoot_ref_test_impl.h
-  tests/bigfoot_ref_test_impl.cpp
   tests/alignment_test.h
   tests/alignment_test.cpp
   tests/64bit/offset64_test.h
@@ -553,20 +548,18 @@ if(FLATBUFFERS_BUILD_TESTS)
   # The flattest target needs some generated files
   SET(FLATC_OPT_COMP --cpp --gen-compare --gen-mutable --gen-object-api --reflect-names)
   SET(FLATC_OPT_SCOPED_ENUMS ${FLATC_OPT_COMP};--scoped-enums)
-  SET(FLATC_OPT_CPP_VECTOR_TYPE ${FLATC_OPT_COMP};--cpp-include;test_vector_type.h;--cpp-vector-type;::flatbuffers::tests::CustomVector)
 
   compile_schema_for_test(tests/alignment_test.fbs "${FLATC_OPT_COMP}")
   compile_schema_for_test_fbsh(tests/default_vectors_strings_test.fbs "${FLATC_OPT_COMP}")
   compile_schema_for_test(tests/arrays_test.fbs "${FLATC_OPT_SCOPED_ENUMS}")
   compile_schema_for_test(tests/native_inline_table_test.fbs "${FLATC_OPT_COMP}")
   compile_schema_for_test(tests/native_type_test.fbs "${FLATC_OPT_COMP}")
-  compile_schema_for_test(tests/bigfoot_ref_test.fbs "${FLATC_OPT_COMP}")
   compile_schema_for_test(tests/key_field/key_field_sample.fbs "${FLATC_OPT_COMP}")
   compile_schema_for_test(tests/64bit/test_64bit.fbs "${FLATC_OPT_COMP};--bfbs-gen-embed")
   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/cpp_vector_type.fbs "${FLATC_OPT_CPP_VECTOR_TYPE}")
+  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

@@ -23,7 +23,7 @@ bazel_dep(
 )
 bazel_dep(
     name = "grpc",
-    version = "1.70.1",
+    version = "1.76.0",
     repo_name = "com_github_grpc_grpc",
 )
 bazel_dep(
@@ -49,7 +49,7 @@ 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",
 )
@@ -63,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

@@ -168,12 +168,6 @@ list of `FILES...`.
     std::string from Flatbuffers, but (char* + length). This allows efficient
 	construction of custom string types, including zero-copy construction.
 
--   `--cpp-vector-type T` : Set object API vector type (default std::vector).
-    T must be a template taking a single element type argument and support
-    resize(), reserve(), size(), data(), operator[], emplace_back() and
-    begin()/end(), matching the subset of std::vector's interface generated
-    code relies on.
-
 -   `--no-cpp-direct-copy` : Don't generate direct copy methods for C++
     object-based API.
 

docs/source/languages/cpp.md

@@ -242,42 +242,6 @@ provide the following functions to aide in the serialization process:
     }
 ```
 
--   `bigfoot_ref_wrapper("type")` (on a struct) together with `bigfoot_ref("type")`
-    (on a field of that struct type): Bigfoot-specific sugar for a
-    UUID-addressed reference to another native type. `bigfoot_ref_wrapper`
-    marks a struct as a reference-wrapper template (e.g. Bigfoot's
-    `HardReference`/`SoftReference`); `bigfoot_ref` on a field of that type
-    names the referenced native type, e.g. `bigfoot_ref: "::Bigfoot::AssetA"`
-    on a `HardReference`-typed field with `bigfoot_ref_wrapper:
-    "::Bigfoot::HardReference"` produces the field's native type
-    `::Bigfoot::HardReference<::Bigfoot::AssetA>` (auto-deriving a
-    `native_type_pack_name` of `HardReferenceAssetA`, same short-name
-    convention as `native_type_pack_name`). Unlike a hand-written
-    `native_type`, `bigfoot_ref` also emits, directly into the generated
-    header:
-    -   a forward declaration of the referenced type (so the referencing
-        schema's generated header never needs that type's real definition -
-        only the wrapper template's constructor and a `GetUUID()` accessor
-        are used, and those don't require the referenced type to be
-        complete), and
-    -   `inline` `Pack<Name>`/`UnPack<Name>` definitions for it (so no
-        hand-written implementation is required anywhere).
-
-```cpp
-    struct HardReference (bigfoot_ref_wrapper: "::Bigfoot::HardReference") {
-      uuid: UUID;
-    }
-
-    table AssetB {
-      ref_a: HardReference (bigfoot_ref: "::Bigfoot::AssetA");
-    }
-```
-
-    is enough on its own - no forward declaration of `::Bigfoot::AssetA` and
-    no `flatbuffers::Pack/UnPackHardReferenceAssetA` implementation need to
-    be written by hand. `bigfoot_ref` is only valid on fields whose type is a
-    struct (or vector of structs) that declares `bigfoot_ref_wrapper`.
-
 -   `native_type("type")` (on a table): Tables can also be represented with
 native types. For example, the following schema:
 
@@ -373,27 +337,6 @@ constructor in the following format: `custom_str_class(const char *, size_t)`.
 Please note that the character array is not guaranteed to be NULL terminated,
 you should always use the provided size to determine end of string.
 
-## Using different vector type
-
-By default the object tree's vector fields are built out of `std::vector`,
-but you can influence this either globally (using the `--cpp-vector-type`
-argument to `flatc`) or per field using the `cpp_vector_type` attribute, to
-use any other vector-like template type (e.g. `eastl::vector`).
-
-The type must be a template taking a single element type argument
-(`my_vector<T>`), and must support the following member functions:
-`resize()`, `reserve()`, `size()`, `data()`, `operator[]`, `emplace_back()`,
-and `begin()`/`end()`. This matches the subset of `std::vector`'s interface
-that generated code relies on.
-
-Note that unlike `std::vector<bool>`, the custom vector type must not use a
-bit-packed specialization for `bool` elements, since generated code accesses
-`data()` as a contiguous `bool` array.
-
-As with custom string types, the header defining the custom vector type is
-not automatically included; use `--cpp-include` to add the necessary
-`#include`.
-
 ## Reflection (& Resizing)
 
 There is experimental support for reflection in FlatBuffers, allowing you to

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

goldens/rust/basic_generated.rs

@@ -1,297 +1,322 @@
 // automatically generated by the FlatBuffers compiler, do not modify
 // @generated
-
 extern crate alloc;
 
 #[allow(unused_imports, dead_code)]
 pub mod flatbuffers {
+    extern crate alloc;
 
-extern crate alloc;
+    #[allow(unused_imports, dead_code)]
-#[allow(unused_imports, dead_code)]
+    pub mod goldens {
-pub mod goldens {
+        extern crate alloc;
 
-extern crate alloc;
+        pub enum GalaxyOffset {}
 
-pub enum GalaxyOffset {}
+        #[derive(Copy, Clone, PartialEq)]
-#[derive(Copy, Clone, PartialEq)]
+        pub struct Galaxy<'a> {
+            pub _tab: ::flatbuffers::Table<'a>,
+        }
 
-pub struct Galaxy<'a> {
+        impl<'a> ::flatbuffers::Follow<'a> for Galaxy<'a> {
-  pub _tab: ::flatbuffers::Table<'a>,
+            type Inner = Galaxy<'a>;
-}
 
-impl<'a> ::flatbuffers::Follow<'a> for Galaxy<'a> {
+            #[inline]
-  type Inner = Galaxy<'a>;
+            unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-  #[inline]
+                Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
-  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;
+            pub const VT_NUM_STARS: ::flatbuffers::VOffsetT = 4;
 
-  #[inline]
+            #[inline]
-  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+            pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-    Galaxy { _tab: table }
+                Galaxy { _tab: table }
-  }
+            }
-  #[allow(unused_mut)]
+
-  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
+            #[allow(unused_mut)]
-    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
+            pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
-    args: &'args GalaxyArgs
+                _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
-  ) -> ::flatbuffers::WIPOffset<Galaxy<'bldr>> {
+                args: &'args GalaxyArgs
-    let mut builder = GalaxyBuilder::new(_fbb);
+            ) -> ::flatbuffers::WIPOffset<Galaxy<'bldr>> {
-    builder.add_num_stars(args.num_stars);
+                let mut builder = GalaxyBuilder::new(_fbb);
-    builder.finish()
+                builder.add_num_stars(args.num_stars);
-  }
+                builder.finish()
+            }
 
 
-  #[inline]
+            #[inline]
-  pub fn num_stars(&self) -> i64 {
+            pub fn num_stars(&self) -> i64 {
-    // Safety:
+                // Safety:
-    // Created from valid Table for this object
+                // Created from valid Table for this object
-    // which contains a valid value in this slot
+                // which contains a valid value in this slot
-    unsafe { self._tab.get::<i64>(Galaxy::VT_NUM_STARS, Some(0)).unwrap()}
+                unsafe { self._tab.get::<i64>(Galaxy::VT_NUM_STARS, Some(0)).unwrap()}
-  }
+            }
-}
+        }
 
-impl ::flatbuffers::Verifiable for Galaxy<'_> {
+        impl ::flatbuffers::Verifiable for Galaxy<'_> {
-  #[inline]
+            #[inline]
-  fn run_verifier(
+            fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+                v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+            ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    v.visit_table(pos)?
+                v.visit_table(pos)?
-     .visit_field::<i64>("num_stars", Self::VT_NUM_STARS, false)?
+                    .visit_field::<i64>("num_stars", Self::VT_NUM_STARS, false)?
-     .finish();
+                    .finish();
-    Ok(())
+                Ok(())
-  }
+            }
-}
+        }
-pub struct GalaxyArgs {
-    pub num_stars: i64,
-}
-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 GalaxyArgs {
-  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+            pub num_stars: i64,
-  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+        }
-}
-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();
-    GalaxyBuilder {
-      fbb_: _fbb,
-      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<'a> Default for GalaxyArgs {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            #[inline]
-    let mut ds = f.debug_struct("Galaxy");
+            fn default() -> Self {
-      ds.field("num_stars", &self.num_stars());
+                GalaxyArgs {
-      ds.finish()
+                    num_stars: 0,
-  }
+                }
-}
+            }
-pub enum UniverseOffset {}
+        }
-#[derive(Copy, Clone, PartialEq)]
 
-pub struct Universe<'a> {
+        pub struct GalaxyBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
-  pub _tab: ::flatbuffers::Table<'a>,
+            fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-}
+            start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+        }
 
-impl<'a> ::flatbuffers::Follow<'a> for Universe<'a> {
+        impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> GalaxyBuilder<'a, 'b, A> {
-  type Inner = Universe<'a>;
+            #[inline]
-  #[inline]
+            pub fn add_num_stars(&mut self, num_stars: i64) {
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+                self.fbb_.push_slot::<i64>(Galaxy::VT_NUM_STARS, num_stars, 0);
-    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+            }
-  }
-}
 
-impl<'a> Universe<'a> {
+            #[inline]
-  pub const VT_AGE: ::flatbuffers::VOffsetT = 4;
+            pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> GalaxyBuilder<'a, 'b, A> {
-  pub const VT_GALAXIES: ::flatbuffers::VOffsetT = 6;
+                let start = _fbb.start_table();
+                GalaxyBuilder {
+                    fbb_: _fbb,
+                    start_: start,
+                }
+            }
 
-  #[inline]
+            #[inline]
-  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+            pub fn finish(self) -> ::flatbuffers::WIPOffset<Galaxy<'a>> {
-    Universe { _tab: table }
+                let o = self.fbb_.end_table(self.start_);
-  }
+                ::flatbuffers::WIPOffset::new(o.value())
-  #[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 UniverseArgs<'args>
+        impl ::core::fmt::Debug for Galaxy<'_> {
-  ) -> ::flatbuffers::WIPOffset<Universe<'bldr>> {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-    let mut builder = UniverseBuilder::new(_fbb);
+                let mut ds = f.debug_struct("Galaxy");
-    builder.add_age(args.age);
+                ds.field("num_stars", &self.num_stars());
-    if let Some(x) = args.galaxies { builder.add_galaxies(x); }
+                ds.finish()
-    builder.finish()
+            }
-  }
+        }
+
+        pub enum UniverseOffset {}
+
+        #[derive(Copy, Clone, PartialEq)]
+        pub struct Universe<'a> {
+            pub _tab: ::flatbuffers::Table<'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> {
+            pub const VT_AGE: ::flatbuffers::VOffsetT = 4;
+            pub const VT_GALAXIES: ::flatbuffers::VOffsetT = 6;
+
+            #[inline]
+            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>,
+                args: &'args UniverseArgs<'args>
+            ) -> ::flatbuffers::WIPOffset<Universe<'bldr>> {
+                let mut builder = UniverseBuilder::new(_fbb);
+                builder.add_age(args.age);
+                if let Some(x) = args.galaxies { builder.add_galaxies(x); }
+                builder.finish()
+            }
 
 
-  #[inline]
+            #[inline]
-  pub fn age(&self) -> f64 {
+            pub fn age(&self) -> f64 {
-    // Safety:
+                // Safety:
-    // Created from valid Table for this object
+                // Created from valid Table for this object
-    // which contains a valid value in this slot
+                // which contains a valid value in this slot
-    unsafe { self._tab.get::<f64>(Universe::VT_AGE, Some(0.0)).unwrap()}
+                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:
-    // Created from valid Table for this object
-    // 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<'_> {
+            #[inline]
-  #[inline]
+            pub fn galaxies(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy<'a>>>> {
-  fn run_verifier(
+                // Safety:
-    v: &mut ::flatbuffers::Verifier, pos: usize
+                // Created from valid Table for this object
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+                // which contains a valid value in this slot
-    v.visit_table(pos)?
+                unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy>>>>(Universe::VT_GALAXIES, None)}
-     .visit_field::<f64>("age", Self::VT_AGE, false)?
+            }
-     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Galaxy>>>>("galaxies", Self::VT_GALAXIES, false)?
+        }
-     .finish();
-    Ok(())
-  }
-}
-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> {
-  #[inline]
-  fn default() -> Self {
-    UniverseArgs {
-      age: 0.0,
-      galaxies: None,
-    }
-  }
-}
 
-pub struct UniverseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
+        impl ::flatbuffers::Verifiable for Universe<'_> {
-  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+            #[inline]
-  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+            fn run_verifier(
-}
+                v: &mut ::flatbuffers::Verifier, pos: usize
-impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UniverseBuilder<'a, 'b, A> {
+            ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-  #[inline]
+                v.visit_table(pos)?
-  pub fn add_age(&mut self, age: f64) {
+                    .visit_field::<f64>("age", Self::VT_AGE, false)?
-    self.fbb_.push_slot::<f64>(Universe::VT_AGE, age, 0.0);
+                    .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Galaxy>>>>("galaxies", Self::VT_GALAXIES, false)?
-  }
+                    .finish();
-  #[inline]
+                Ok(())
-  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();
-    UniverseBuilder {
-      fbb_: _fbb,
-      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<'_> {
+        pub struct UniverseArgs<'a> {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            pub age: f64,
-    let mut ds = f.debug_struct("Universe");
+            pub galaxies: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy<'a>>>>>,
-      ds.field("age", &self.age());
+        }
-      ds.field("galaxies", &self.galaxies());
-      ds.finish()
-  }
-}
-#[inline]
-/// Verifies that a buffer of bytes contains a `Universe`
-/// 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_universe_unchecked`.
-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
-/// `Universe` 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_universe_unchecked`.
-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
-/// contains a `Universe` 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_universe_unchecked`.
-pub fn root_as_universe_with_opts<'b, 'o>(
-  opts: &'o ::flatbuffers::VerifierOptions,
-  buf: &'b [u8],
-) -> Result<Universe<'b>, ::flatbuffers::InvalidFlatbuffer> {
-  ::flatbuffers::root_with_opts::<Universe<'b>>(opts, buf)
-}
-#[inline]
-/// Verifies, with the given verifier options, that a buffer of
-/// bytes contains a size prefixed `Universe` 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_universe_unchecked`.
-pub fn size_prefixed_root_as_universe_with_opts<'b, 'o>(
-  opts: &'o ::flatbuffers::VerifierOptions,
-  buf: &'b [u8],
-) -> 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.
-/// # Safety
-/// Callers must trust the given bytes do indeed contain a valid `Universe`.
-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.
-/// # Safety
-/// 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<'_> {
-  unsafe { ::flatbuffers::size_prefixed_root_unchecked::<Universe>(buf) }
-}
-#[inline]
-pub fn finish_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
-    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-    root: ::flatbuffers::WIPOffset<Universe<'a>>) {
-  fbb.finish(root, None);
-}
 
-#[inline]
+        impl<'a> Default for UniverseArgs<'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>>) {
+            #[inline]
-  fbb.finish_size_prefixed(root, None);
+            fn default() -> Self {
-}
+                UniverseArgs {
-}  // pub mod goldens
+                    age: 0.0,
-}  // pub mod flatbuffers
+                    galaxies: None,
+                }
+            }
+        }
 
+        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> {
+            #[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();
+                UniverseBuilder {
+                    fbb_: _fbb,
+                    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<'_> {
+            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()
+            }
+        }
+
+        /// Verifies that a buffer of bytes contains a `Universe`
+        /// 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_universe_unchecked`.
+        #[inline]
+        pub fn root_as_universe(buf: &[u8]) -> Result<Universe<'_>, ::flatbuffers::InvalidFlatbuffer> {
+            ::flatbuffers::root::<Universe>(buf)
+        }
+
+        /// Verifies that a buffer of bytes contains a size prefixed
+        /// `Universe` 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_universe_unchecked`.
+        #[inline]
+        pub fn size_prefixed_root_as_universe(buf: &[u8]) -> Result<Universe<'_>, ::flatbuffers::InvalidFlatbuffer> {
+            ::flatbuffers::size_prefixed_root::<Universe>(buf)
+        }
+
+        /// Verifies, with the given options, that a buffer of bytes
+        /// contains a `Universe` 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_universe_unchecked`.
+        #[inline]
+        pub fn root_as_universe_with_opts<'b, 'o>(
+            opts: &'o ::flatbuffers::VerifierOptions,
+            buf: &'b [u8],
+        ) -> Result<Universe<'b>, ::flatbuffers::InvalidFlatbuffer> {
+            ::flatbuffers::root_with_opts::<Universe<'b>>(opts, buf)
+        }
+
+        /// Verifies, with the given verifier options, that a buffer of
+        /// bytes contains a size prefixed `Universe` 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_universe_unchecked`.
+        #[inline]
+        pub fn size_prefixed_root_as_universe_with_opts<'b, 'o>(
+            opts: &'o ::flatbuffers::VerifierOptions,
+            buf: &'b [u8],
+        ) -> Result<Universe<'b>, ::flatbuffers::InvalidFlatbuffer> {
+            ::flatbuffers::size_prefixed_root_with_opts::<Universe<'b>>(opts, buf)
+        }
+
+        /// Assumes, without verification, that a buffer of bytes contains a Universe and returns it.
+        /// # Safety
+        /// Callers must trust the given bytes do indeed contain a valid `Universe`.
+        #[inline]
+        pub unsafe fn root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> {
+            unsafe { ::flatbuffers::root_unchecked::<Universe>(buf) }
+        }
+
+        /// Assumes, without verification, that a buffer of bytes contains a size prefixed Universe and returns it.
+        /// # Safety
+        /// Callers must trust the given bytes do indeed contain a valid size prefixed `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>(
+            fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+            root: ::flatbuffers::WIPOffset<Universe<'a>>
+        ) {
+            fbb.finish(root, None);
+        }
+
+        #[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>>
+        ) {
+            fbb.finish_size_prefixed(root, None);
+        }
+    } // 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/flatbuffers/base.h

@@ -142,19 +142,6 @@
 #define FLATBUFFERS_VERSION_MAJOR 25
 #define FLATBUFFERS_VERSION_MINOR 12
 #define FLATBUFFERS_VERSION_REVISION 19
-
-// Identifies this header as Bigfoot's fork of flatbuffers, and versions the
-// fork's own generated-code-affecting changes independently of the upstream
-// FLATBUFFERS_VERSION_* triplet above (which just tracks the upstream
-// version this fork is based on, and would still match an unforked, stock
-// flatbuffers install of the same version). Generated headers assert on
-// this - see GenFlatbuffersVersionCheck() in idl_gen_cpp.cpp - so building
-// Bigfoot-generated code against stock flatbuffers, or a differently
-// versioned Bigfoot fork, fails to compile immediately instead of silently
-// miscompiling. Bump this whenever a change here affects what generated
-// code assumes about this header (e.g. adding bigfoot_ref/bigfoot_ref_wrapper).
-#define FLATBUFFERS_BIGFOOT_VERSION 1
-
 #define FLATBUFFERS_STRING_EXPAND(X) #X
 #define FLATBUFFERS_STRING(X) FLATBUFFERS_STRING_EXPAND(X)
 namespace flatbuffers {

include/flatbuffers/idl.h

@@ -677,7 +677,6 @@ struct IDLOptions {
   std::string cpp_object_api_pointer_type;
   std::string cpp_object_api_string_type;
   bool cpp_object_api_string_flexible_constructor;
-  std::string cpp_object_api_vector_type;
   CaseStyle cpp_object_api_field_case_style;
   bool cpp_direct_copy;
   bool gen_nullable;
@@ -1013,13 +1012,10 @@ class Parser : public ParserState {
     known_attributes_["cpp_ptr_type_get"] = true;
     known_attributes_["cpp_str_type"] = true;
     known_attributes_["cpp_str_flex_ctor"] = true;
-    known_attributes_["cpp_vector_type"] = true;
     known_attributes_["native_inline"] = true;
     known_attributes_["native_custom_alloc"] = true;
     known_attributes_["native_type"] = true;
     known_attributes_["native_type_pack_name"] = true;
-    known_attributes_["bigfoot_ref_wrapper"] = true;
-    known_attributes_["bigfoot_ref"] = true;
     known_attributes_["native_default"] = true;
     known_attributes_["flexbuffer"] = true;
     known_attributes_["private"] = true;

net/FlatBuffers/FlatBufferBuilder.cs

@@ -438,8 +438,7 @@ namespace Google.FlatBuffers
             if (off > Offset)
                 throw new ArgumentException();
 
-            if (off != 0)
+            off = Offset - off + sizeof(int);
-                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);

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==}
@@ -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:
@@ -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/reflection/Enum.py

@@ -159,7 +159,7 @@ def EnumCreateValuesVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateValuesVector(builder, data):
-    EnumCreateValuesVector(builder, data)
+    return EnumCreateValuesVector(builder, data)
 
 def EnumAddIsUnion(builder, isUnion):
     builder.PrependBoolSlot(2, isUnion, 0)
@@ -189,7 +189,7 @@ def EnumCreateAttributesVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateAttributesVector(builder, data):
-    EnumCreateAttributesVector(builder, data)
+    return EnumCreateAttributesVector(builder, data)
 
 def EnumAddDocumentation(builder, documentation):
     builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
@@ -207,7 +207,7 @@ def EnumCreateDocumentationVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateDocumentationVector(builder, data):
-    EnumCreateDocumentationVector(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

@@ -138,7 +138,7 @@ def EnumValCreateDocumentationVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateDocumentationVector(builder, data):
-    EnumValCreateDocumentationVector(builder, data)
+    return EnumValCreateDocumentationVector(builder, data)
 
 def EnumValAddAttributes(builder, attributes):
     builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
@@ -156,7 +156,7 @@ def EnumValCreateAttributesVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateAttributesVector(builder, data):
-    EnumValCreateAttributesVector(builder, data)
+    return EnumValCreateAttributesVector(builder, data)
 
 def EnumValEnd(builder):
     return builder.EndObject()

python/flatbuffers/reflection/Field.py

@@ -239,7 +239,7 @@ def FieldCreateAttributesVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateAttributesVector(builder, data):
-    FieldCreateAttributesVector(builder, data)
+    return FieldCreateAttributesVector(builder, data)
 
 def FieldAddDocumentation(builder, documentation):
     builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
@@ -257,7 +257,7 @@ def FieldCreateDocumentationVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateDocumentationVector(builder, data):
-    FieldCreateDocumentationVector(builder, data)
+    return FieldCreateDocumentationVector(builder, data)
 
 def FieldAddOptional(builder, optional):
     builder.PrependBoolSlot(11, optional, 0)

python/flatbuffers/reflection/Object.py

@@ -162,7 +162,7 @@ def ObjectCreateFieldsVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateFieldsVector(builder, data):
-    ObjectCreateFieldsVector(builder, data)
+    return ObjectCreateFieldsVector(builder, data)
 
 def ObjectAddIsStruct(builder, isStruct):
     builder.PrependBoolSlot(2, isStruct, 0)
@@ -198,7 +198,7 @@ def ObjectCreateAttributesVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateAttributesVector(builder, data):
-    ObjectCreateAttributesVector(builder, data)
+    return ObjectCreateAttributesVector(builder, data)
 
 def ObjectAddDocumentation(builder, documentation):
     builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
@@ -216,7 +216,7 @@ def ObjectCreateDocumentationVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateDocumentationVector(builder, data):
-    ObjectCreateDocumentationVector(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

@@ -142,7 +142,7 @@ def RPCCallCreateAttributesVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateAttributesVector(builder, data):
-    RPCCallCreateAttributesVector(builder, data)
+    return RPCCallCreateAttributesVector(builder, data)
 
 def RPCCallAddDocumentation(builder, documentation):
     builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
@@ -160,7 +160,7 @@ def RPCCallCreateDocumentationVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateDocumentationVector(builder, data):
-    RPCCallCreateDocumentationVector(builder, data)
+    return RPCCallCreateDocumentationVector(builder, data)
 
 def RPCCallEnd(builder):
     return builder.EndObject()

python/flatbuffers/reflection/Schema.py

@@ -184,7 +184,7 @@ def SchemaCreateObjectsVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateObjectsVector(builder, data):
-    SchemaCreateObjectsVector(builder, data)
+    return SchemaCreateObjectsVector(builder, data)
 
 def SchemaAddEnums(builder, enums):
     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(enums), 0)
@@ -202,7 +202,7 @@ def SchemaCreateEnumsVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateEnumsVector(builder, data):
-    SchemaCreateEnumsVector(builder, data)
+    return SchemaCreateEnumsVector(builder, data)
 
 def SchemaAddFileIdent(builder, fileIdent):
     builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(fileIdent), 0)
@@ -238,7 +238,7 @@ def SchemaCreateServicesVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateServicesVector(builder, data):
-    SchemaCreateServicesVector(builder, data)
+    return SchemaCreateServicesVector(builder, data)
 
 def SchemaAddAdvancedFeatures(builder, advancedFeatures):
     builder.PrependUint64Slot(6, advancedFeatures, 0)
@@ -262,7 +262,7 @@ def SchemaCreateFbsFilesVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateFbsFilesVector(builder, data):
-    SchemaCreateFbsFilesVector(builder, data)
+    return SchemaCreateFbsFilesVector(builder, data)
 
 def SchemaEnd(builder):
     return builder.EndObject()

python/flatbuffers/reflection/SchemaFile.py

@@ -88,7 +88,7 @@ def SchemaFileCreateIncludedFilenamesVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateIncludedFilenamesVector(builder, data):
-    SchemaFileCreateIncludedFilenamesVector(builder, data)
+    return SchemaFileCreateIncludedFilenamesVector(builder, data)
 
 def SchemaFileEnd(builder):
     return builder.EndObject()

python/flatbuffers/reflection/Service.py

@@ -141,7 +141,7 @@ def ServiceCreateCallsVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateCallsVector(builder, data):
-    ServiceCreateCallsVector(builder, data)
+    return ServiceCreateCallsVector(builder, data)
 
 def ServiceAddAttributes(builder, attributes):
     builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
@@ -159,7 +159,7 @@ def ServiceCreateAttributesVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateAttributesVector(builder, data):
-    ServiceCreateAttributesVector(builder, data)
+    return ServiceCreateAttributesVector(builder, data)
 
 def ServiceAddDocumentation(builder, documentation):
     builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
@@ -177,7 +177,7 @@ def ServiceCreateDocumentationVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateDocumentationVector(builder, data):
-    ServiceCreateDocumentationVector(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 {
@@ -931,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() {
@@ -940,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 {

samples/monster_generated.h

@@ -643,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/mod.rs

@@ -1,18 +1,18 @@
 // Automatically generated by the Flatbuffers compiler. Do not modify.
 // @generated
 pub mod my_game {
-  use super::*;
-  pub mod sample {
     use super::*;
-    mod color_generated;
+    pub mod sample {
-    pub use self::color_generated::*;
+        use super::*;
-    mod equipment_generated;
+        mod color_generated;
-    pub use self::equipment_generated::*;
+        pub use self::color_generated::*;
-    mod vec_3_generated;
+        mod equipment_generated;
-    pub use self::vec_3_generated::*;
+        pub use self::equipment_generated::*;
-    mod monster_generated;
+        mod vec_3_generated;
-    pub use self::monster_generated::*;
+        pub use self::vec_3_generated::*;
-    mod weapon_generated;
+        mod monster_generated;
-    pub use self::weapon_generated::*;
+        pub use self::monster_generated::*;
-  } // sample
+        mod weapon_generated;
+        pub use self::weapon_generated::*;
+    } // sample
 } // my_game

samples/rust_generated/my_game/sample/color_generated.rs

@@ -2,64 +2,73 @@
 // @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] = [
-  Color::Red,
+    Color::Red,
-  Color::Green,
+    Color::Green,
-  Color::Blue,
+    Color::Blue,
 ];
 
 #[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);
+    pub const Red: Self = Self(0);
-  pub const Green: Self = Self(1);
+    pub const Green: Self = Self(1);
-  pub const Blue: Self = Self(2);
+    pub const Blue: Self = Self(2);
 
-  pub const ENUM_MIN: i8 = 0;
+    pub const ENUM_MIN: i8 = 0;
-  pub const ENUM_MAX: i8 = 2;
+    pub const ENUM_MAX: i8 = 2;
-  pub const ENUM_VALUES: &'static [Self] = &[
+    pub const ENUM_VALUES: &'static [Self] = &[
-    Self::Red,
+        Self::Red,
-    Self::Green,
+        Self::Green,
-    Self::Blue,
+        Self::Blue,
-  ];
+    ];
-  /// Returns the variant's name or "" if unknown.
+
-  pub fn variant_name(self) -> Option<&'static str> {
+    /// Returns the variant's name or "" if unknown.
-    match self {
+    pub fn variant_name(self) -> Option<&'static str> {
-      Self::Red => Some("Red"),
+        match self {
-      Self::Green => Some("Green"),
+            Self::Red => Some("Red"),
-      Self::Blue => Some("Blue"),
+            Self::Green => Some("Green"),
-      _ => None,
+            Self::Blue => Some("Blue"),
+            _ => None,
+        }
     }
-  }
 }
+
 impl ::core::fmt::Debug for Color {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-    if let Some(name) = self.variant_name() {
+        if let Some(name) = self.variant_name() {
-      f.write_str(name)
+            f.write_str(name)
-    } else {
+        } else {
-      f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
+            f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
+        }
     }
-  }
 }
+
 impl<'a> ::flatbuffers::Follow<'a> for Color {
-  type Inner = Self;
+    type Inner = Self;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    let b = unsafe { ::flatbuffers::read_scalar_at::<i8>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-    Self(b)
+        let b = unsafe { ::flatbuffers::read_scalar_at::<i8>(buf, loc) };
-  }
+        Self(b)
+    }
 }
 
 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) };
@@ -67,26 +76,28 @@ impl ::flatbuffers::Push for Color {
 }
 
 impl ::flatbuffers::EndianScalar for Color {
-  type Scalar = i8;
+    type Scalar = i8;
-  #[inline]
+
-  fn to_little_endian(self) -> i8 {
+    #[inline]
-    self.0.to_le()
+    fn to_little_endian(self) -> i8 {
-  }
+        self.0.to_le()
-  #[inline]
+    }
-  #[allow(clippy::wrong_self_convention)]
+
-  fn from_little_endian(v: i8) -> Self {
+    #[inline]
-    let b = i8::from_le(v);
+    #[allow(clippy::wrong_self_convention)]
-    Self(b)
+    fn from_little_endian(v: i8) -> Self {
-  }
+        let b = i8::from_le(v);
+        Self(b)
+    }
 }
 
 impl<'a> ::flatbuffers::Verifiable for Color {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    i8::run_verifier(v, pos)
+        i8::run_verifier(v, pos)
-  }
+    }
 }
 
 impl ::flatbuffers::SimpleToVerifyInSlice for Color {}

samples/rust_generated/my_game/sample/equipment_generated.rs

@@ -2,60 +2,69 @@
 // @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] = [
-  Equipment::NONE,
+    Equipment::NONE,
-  Equipment::Weapon,
+    Equipment::Weapon,
 ];
 
 #[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);
+    pub const NONE: Self = Self(0);
-  pub const Weapon: Self = Self(1);
+    pub const Weapon: Self = Self(1);
 
-  pub const ENUM_MIN: u8 = 0;
+    pub const ENUM_MIN: u8 = 0;
-  pub const ENUM_MAX: u8 = 1;
+    pub const ENUM_MAX: u8 = 1;
-  pub const ENUM_VALUES: &'static [Self] = &[
+    pub const ENUM_VALUES: &'static [Self] = &[
-    Self::NONE,
+        Self::NONE,
-    Self::Weapon,
+        Self::Weapon,
-  ];
+    ];
-  /// Returns the variant's name or "" if unknown.
+
-  pub fn variant_name(self) -> Option<&'static str> {
+    /// Returns the variant's name or "" if unknown.
-    match self {
+    pub fn variant_name(self) -> Option<&'static str> {
-      Self::NONE => Some("NONE"),
+        match self {
-      Self::Weapon => Some("Weapon"),
+            Self::NONE => Some("NONE"),
-      _ => None,
+            Self::Weapon => Some("Weapon"),
+            _ => None,
+        }
     }
-  }
 }
+
 impl ::core::fmt::Debug for Equipment {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-    if let Some(name) = self.variant_name() {
+        if let Some(name) = self.variant_name() {
-      f.write_str(name)
+            f.write_str(name)
-    } else {
+        } else {
-      f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
+            f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
+        }
     }
-  }
 }
+
 impl<'a> ::flatbuffers::Follow<'a> for Equipment {
-  type Inner = Self;
+    type Inner = Self;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-    Self(b)
+        let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
-  }
+        Self(b)
+    }
 }
 
 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) };
@@ -63,75 +72,85 @@ impl ::flatbuffers::Push for Equipment {
 }
 
 impl ::flatbuffers::EndianScalar for Equipment {
-  type Scalar = u8;
+    type Scalar = u8;
-  #[inline]
+
-  fn to_little_endian(self) -> u8 {
+    #[inline]
-    self.0.to_le()
+    fn to_little_endian(self) -> u8 {
-  }
+        self.0.to_le()
-  #[inline]
+    }
-  #[allow(clippy::wrong_self_convention)]
+
-  fn from_little_endian(v: u8) -> Self {
+    #[inline]
-    let b = u8::from_le(v);
+    #[allow(clippy::wrong_self_convention)]
-    Self(b)
+    fn from_little_endian(v: u8) -> Self {
-  }
+        let b = u8::from_le(v);
+        Self(b)
+    }
 }
 
 impl<'a> ::flatbuffers::Verifiable for Equipment {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    u8::run_verifier(v, pos)
+        u8::run_verifier(v, pos)
-  }
+    }
 }
 
 impl ::flatbuffers::SimpleToVerifyInSlice for Equipment {}
+
 pub struct EquipmentUnionTableOffset {}
 
 #[allow(clippy::upper_case_acronyms)]
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub enum EquipmentT {
-  NONE,
+    NONE,
-  Weapon(alloc::boxed::Box<WeaponT>),
+    Weapon(alloc::boxed::Box<WeaponT>),
 }
+
 impl Default for EquipmentT {
-  fn default() -> Self {
+    fn default() -> Self {
-    Self::NONE
+        Self::NONE
-  }
+    }
 }
+
 impl EquipmentT {
-  pub fn equipment_type(&self) -> Equipment {
+    pub fn equipment_type(&self) -> Equipment {
-    match self {
+        match self {
-      Self::NONE => Equipment::NONE,
+            Self::NONE => Equipment::NONE,
-      Self::Weapon(_) => Equipment::Weapon,
+            Self::Weapon(_) => Equipment::Weapon,
+        }
     }
-  }
+
-  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> {
+    pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> {
-    match self {
+        match self {
-      Self::NONE => None,
+            Self::NONE => None,
-      Self::Weapon(v) => Some(v.pack(fbb).as_union_value()),
+            Self::Weapon(v) => Some(v.pack(fbb).as_union_value()),
+        }
     }
-  }
+
-  /// If the union variant matches, return the owned WeaponT, setting the union to NONE.
+    /// 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>> {
+    pub fn take_weapon(&mut self) -> Option<alloc::boxed::Box<WeaponT>> {
-    if let Self::Weapon(_) = self {
+        if let Self::Weapon(_) = self {
-      let v = ::core::mem::replace(self, Self::NONE);
+            let v = ::core::mem::replace(self, Self::NONE);
-      if let Self::Weapon(w) = v {
+            if let Self::Weapon(w) = v {
-        Some(w)
+                Some(w)
-      } else {
+            } else {
-        unreachable!()
+                unreachable!()
-      }
+            }
-    } else {
+        } else {
-      None
+            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 }
     }
-  }
-  /// 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,212 +2,225 @@
 // @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>,
+    pub _tab: ::flatbuffers::Table<'a>,
 }
 
 impl<'a> ::flatbuffers::Follow<'a> for Monster<'a> {
-  type Inner = Monster<'a>;
+    type Inner = Monster<'a>;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-  }
+        Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    }
 }
 
 impl<'a> Monster<'a> {
-  pub const VT_POS: ::flatbuffers::VOffsetT = 4;
+    pub const VT_POS: ::flatbuffers::VOffsetT = 4;
-  pub const VT_MANA: ::flatbuffers::VOffsetT = 6;
+    pub const VT_MANA: ::flatbuffers::VOffsetT = 6;
-  pub const VT_HP: ::flatbuffers::VOffsetT = 8;
+    pub const VT_HP: ::flatbuffers::VOffsetT = 8;
-  pub const VT_NAME: ::flatbuffers::VOffsetT = 10;
+    pub const VT_NAME: ::flatbuffers::VOffsetT = 10;
-  pub const VT_INVENTORY: ::flatbuffers::VOffsetT = 14;
+    pub const VT_INVENTORY: ::flatbuffers::VOffsetT = 14;
-  pub const VT_COLOR: ::flatbuffers::VOffsetT = 16;
+    pub const VT_COLOR: ::flatbuffers::VOffsetT = 16;
-  pub const VT_WEAPONS: ::flatbuffers::VOffsetT = 18;
+    pub const VT_WEAPONS: ::flatbuffers::VOffsetT = 18;
-  pub const VT_EQUIPPED_TYPE: ::flatbuffers::VOffsetT = 20;
+    pub const VT_EQUIPPED_TYPE: ::flatbuffers::VOffsetT = 20;
-  pub const VT_EQUIPPED: ::flatbuffers::VOffsetT = 22;
+    pub const VT_EQUIPPED: ::flatbuffers::VOffsetT = 22;
-  pub const VT_PATH: ::flatbuffers::VOffsetT = 24;
+    pub const VT_PATH: ::flatbuffers::VOffsetT = 24;
 
-  pub const fn get_fully_qualified_name() -> &'static str {
+    pub const fn get_fully_qualified_name() -> &'static str {
-    "MyGame.Sample.Monster"
+        "MyGame.Sample.Monster"
-  }
-
-  #[inline]
-  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>,
-    args: &'args MonsterArgs<'args>
-  ) -> ::flatbuffers::WIPOffset<Monster<'bldr>> {
-    let mut builder = MonsterBuilder::new(_fbb);
-    if let Some(x) = args.path { builder.add_path(x); }
-    if let Some(x) = args.equipped { builder.add_equipped(x); }
-    if let Some(x) = args.weapons { builder.add_weapons(x); }
-    if let Some(x) = args.inventory { builder.add_inventory(x); }
-    if let Some(x) = args.name { builder.add_name(x); }
-    if let Some(x) = args.pos { builder.add_pos(x); }
-    builder.add_hp(args.hp);
-    builder.add_mana(args.mana);
-    builder.add_equipped_type(args.equipped_type);
-    builder.add_color(args.color);
-    builder.finish()
-  }
-
-  pub fn unpack(&self) -> MonsterT {
-    let pos = self.pos().map(|x| {
-      x.unpack()
-    });
-    let mana = self.mana();
-    let hp = self.hp();
-    let name = self.name().map(|x| {
-      alloc::string::ToString::to_string(x)
-    });
-    let inventory = self.inventory().map(|x| {
-      x.into_iter().collect()
-    });
-    let color = self.color();
-    let weapons = self.weapons().map(|x| {
-      x.iter().map(|t| t.unpack()).collect()
-    });
-    let equipped = match self.equipped_type() {
-      Equipment::NONE => EquipmentT::NONE,
-      Equipment::Weapon => EquipmentT::Weapon(alloc::boxed::Box::new(
-        self.equipped_as_weapon()
-            .expect("Invalid union table, expected `Equipment::Weapon`.")
-            .unpack()
-      )),
-      _ => EquipmentT::NONE,
-    };
-    let path = self.path().map(|x| {
-      x.iter().map(|t| t.unpack()).collect()
-    });
-    MonsterT {
-      pos,
-      mana,
-      hp,
-      name,
-      inventory,
-      color,
-      weapons,
-      equipped,
-      path,
     }
-  }
 
-  #[inline]
+    #[inline]
-  pub fn pos(&self) -> Option<&'a Vec3> {
+    pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-    // Safety:
+        Monster { _tab: table }
-    // Created from valid Table for this object
-    // which contains a valid value in this slot
-    unsafe { self._tab.get::<Vec3>(Monster::VT_POS, None)}
-  }
-  #[inline]
-  pub fn mana(&self) -> i16 {
-    // Safety:
-    // Created from valid Table for this object
-    // 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:
-    // Created from valid Table for this object
-    // 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:
-    // Created from valid Table for this object
-    // 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:
-    // Created from valid Table for this object
-    // 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:
-    // Created from valid Table for this object
-    // 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:
-    // Created from valid Table for this object
-    // 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:
-    // Created from valid Table for this object
-    // 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:
-    // Created from valid Table for this object
-    // 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:
-    // Created from valid Table for this object
-    // 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>> {
-    if self.equipped_type() == Equipment::Weapon {
-      self.equipped().map(|t| {
-       // Safety:
-       // Created from a valid Table for this object
-       // Which contains a valid union in this slot
-       unsafe { Weapon::init_from_table(t) }
-     })
-    } else {
-      None
     }
-  }
 
+    #[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 MonsterArgs<'args>
+    ) -> ::flatbuffers::WIPOffset<Monster<'bldr>> {
+        let mut builder = MonsterBuilder::new(_fbb);
+        if let Some(x) = args.path { builder.add_path(x); }
+        if let Some(x) = args.equipped { builder.add_equipped(x); }
+        if let Some(x) = args.weapons { builder.add_weapons(x); }
+        if let Some(x) = args.inventory { builder.add_inventory(x); }
+        if let Some(x) = args.name { builder.add_name(x); }
+        if let Some(x) = args.pos { builder.add_pos(x); }
+        builder.add_hp(args.hp);
+        builder.add_mana(args.mana);
+        builder.add_equipped_type(args.equipped_type);
+        builder.add_color(args.color);
+        builder.finish()
+    }
+
+    pub fn unpack(&self) -> MonsterT {
+        let pos = self.pos().map(|x| {
+            x.unpack()
+        });
+        let mana = self.mana();
+        let hp = self.hp();
+        let name = self.name().map(|x| {
+            alloc::string::ToString::to_string(x)
+        });
+        let inventory = self.inventory().map(|x| {
+            x.into_iter().collect()
+        });
+        let color = self.color();
+        let weapons = self.weapons().map(|x| {
+            x.iter().map(|t| t.unpack()).collect()
+        });
+        let equipped = match self.equipped_type() {
+            Equipment::NONE => EquipmentT::NONE,
+            Equipment::Weapon => EquipmentT::Weapon(alloc::boxed::Box::new(
+                self.equipped_as_weapon()
+                    .expect("Invalid union table, expected `Equipment::Weapon`.")
+                    .unpack()
+            )),
+            _ => EquipmentT::NONE,
+        };
+        let path = self.path().map(|x| {
+            x.iter().map(|t| t.unpack()).collect()
+        });
+        MonsterT {
+            pos,
+            mana,
+            hp,
+            name,
+            inventory,
+            color,
+            weapons,
+            equipped,
+            path,
+        }
+    }
+
+    #[inline]
+    pub fn pos(&self) -> Option<&'a Vec3> {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe { self._tab.get::<Vec3>(Monster::VT_POS, None)}
+    }
+
+    #[inline]
+    pub fn mana(&self) -> i16 {
+        // Safety:
+        // Created from valid Table for this object
+        // 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:
+        // Created from valid Table for this object
+        // 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:
+        // Created from valid Table for this object
+        // 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:
+        // Created from valid Table for this object
+        // 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:
+        // Created from valid Table for this object
+        // 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:
+        // Created from valid Table for this object
+        // 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:
+        // Created from valid Table for this object
+        // 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:
+        // Created from valid Table for this object
+        // 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:
+        // Created from valid Table for this object
+        // 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>> {
+        if self.equipped_type() == Equipment::Weapon {
+            self.equipped().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { Weapon::init_from_table(t) }
+            })
+        } else {
+            None
+        }
+    }
 }
 
 impl ::flatbuffers::Verifiable for Monster<'_> {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    v.visit_table(pos)?
+        v.visit_table(pos)?
-     .visit_field::<Vec3>("pos", Self::VT_POS, false)?
+            .visit_field::<Vec3>("pos", Self::VT_POS, false)?
-     .visit_field::<i16>("mana", Self::VT_MANA, false)?
+            .visit_field::<i16>("mana", Self::VT_MANA, false)?
-     .visit_field::<i16>("hp", Self::VT_HP, false)?
+            .visit_field::<i16>("hp", Self::VT_HP, false)?
-     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
+            .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
-     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("inventory", Self::VT_INVENTORY, false)?
+            .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("inventory", Self::VT_INVENTORY, false)?
-     .visit_field::<Color>("color", Self::VT_COLOR, false)?
+            .visit_field::<Color>("color", Self::VT_COLOR, false)?
-     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Weapon>>>>("weapons", Self::VT_WEAPONS, false)?
+            .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Weapon>>>>("weapons", Self::VT_WEAPONS, false)?
-     .visit_union::<Equipment, _>("equipped_type", Self::VT_EQUIPPED_TYPE, "equipped", Self::VT_EQUIPPED, false, |key, v, pos| {
+            .visit_union::<Equipment, _>("equipped_type", Self::VT_EQUIPPED_TYPE, "equipped", Self::VT_EQUIPPED, false, |key, v, pos| {
-        match key {
+                match key {
-          Equipment::Weapon => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<Weapon>>("Equipment::Weapon", pos),
+                    Equipment::Weapon => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<Weapon>>("Equipment::Weapon", pos),
-          _ => Ok(()),
+                    _ => Ok(()),
-        }
+                }
-     })?
+            })?
-     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Vec3>>>("path", Self::VT_PATH, false)?
+            .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Vec3>>>("path", Self::VT_PATH, false)?
-     .finish();
+            .finish();
-    Ok(())
+        Ok(())
-  }
+    }
 }
+
 pub struct MonsterArgs<'a> {
     pub pos: Option<&'a Vec3>,
     pub mana: i16,
@@ -220,246 +233,273 @@ 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]
+    #[inline]
-  fn default() -> Self {
+    fn default() -> Self {
-    MonsterArgs {
+        MonsterArgs {
-      pos: None,
+            pos: None,
-      mana: 150,
+            mana: 150,
-      hp: 100,
+            hp: 100,
-      name: None,
+            name: None,
-      inventory: None,
+            inventory: None,
-      color: Color::Blue,
+            color: Color::Blue,
-      weapons: None,
+            weapons: None,
-      equipped_type: Equipment::NONE,
+            equipped_type: Equipment::NONE,
-      equipped: None,
+            equipped: None,
-      path: None,
+            path: None,
+        }
     }
-  }
 }
 
 pub struct MonsterBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
-  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+    fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+    start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
 }
+
 impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> MonsterBuilder<'a, 'b, A> {
-  #[inline]
+    #[inline]
-  pub fn add_pos(&mut self, pos: &Vec3) {
+    pub fn add_pos(&mut self, pos: &Vec3) {
-    self.fbb_.push_slot_always::<&Vec3>(Monster::VT_POS, pos);
+        self.fbb_.push_slot_always::<&Vec3>(Monster::VT_POS, pos);
-  }
+    }
-  #[inline]
+
-  pub fn add_mana(&mut self, mana: i16) {
+    #[inline]
-    self.fbb_.push_slot::<i16>(Monster::VT_MANA, mana, 150);
+    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_hp(&mut self, hp: i16) {
-  #[inline]
+        self.fbb_.push_slot::<i16>(Monster::VT_HP, hp, 100);
-  pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b  str>) {
+    }
-    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_NAME, name);
+
-  }
+    #[inline]
-  #[inline]
+    pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b  str>) {
-  pub fn add_inventory(&mut self, inventory: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) {
+        self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_NAME, name);
-    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_INVENTORY, inventory);
+    }
-  }
+
-  #[inline]
+    #[inline]
-  pub fn add_color(&mut self, color: Color) {
+    pub fn add_inventory(&mut self, inventory: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) {
-    self.fbb_.push_slot::<Color>(Monster::VT_COLOR, color, Color::Blue);
+        self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_INVENTORY, inventory);
-  }
+    }
-  #[inline]
+
-  pub fn add_weapons(&mut self, weapons: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Weapon<'b >>>>) {
+    #[inline]
-    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_WEAPONS, weapons);
+    pub fn add_color(&mut self, color: Color) {
-  }
+        self.fbb_.push_slot::<Color>(Monster::VT_COLOR, color, Color::Blue);
-  #[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_weapons(&mut self, weapons: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Weapon<'b >>>>) {
-  #[inline]
+        self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_WEAPONS, weapons);
-  pub fn add_equipped(&mut self, equipped: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
+    }
-    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_EQUIPPED, equipped);
+
-  }
+    #[inline]
-  #[inline]
+    pub fn add_equipped_type(&mut self, equipped_type: Equipment) {
-  pub fn add_path(&mut self, path: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Vec3>>) {
+        self.fbb_.push_slot::<Equipment>(Monster::VT_EQUIPPED_TYPE, equipped_type, Equipment::NONE);
-    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_PATH, path);
+    }
-  }
+
-  #[inline]
+    #[inline]
-  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> {
+    pub fn add_equipped(&mut self, equipped: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
-    let start = _fbb.start_table();
+        self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_EQUIPPED, equipped);
-    MonsterBuilder {
+    }
-      fbb_: _fbb,
+
-      start_: start,
+    #[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();
+        MonsterBuilder {
+            fbb_: _fbb,
+            start_: start,
+        }
+    }
+
+    #[inline]
+    pub fn finish(self) -> ::flatbuffers::WIPOffset<Monster<'a>> {
+        let o = self.fbb_.end_table(self.start_);
+        ::flatbuffers::WIPOffset::new(o.value())
     }
-  }
-  #[inline]
-  pub fn finish(self) -> ::flatbuffers::WIPOffset<Monster<'a>> {
-    let o = self.fbb_.end_table(self.start_);
-    ::flatbuffers::WIPOffset::new(o.value())
-  }
 }
 
 impl ::core::fmt::Debug for Monster<'_> {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-    let mut ds = f.debug_struct("Monster");
+        let mut ds = f.debug_struct("Monster");
-      ds.field("pos", &self.pos());
+        ds.field("pos", &self.pos());
-      ds.field("mana", &self.mana());
+        ds.field("mana", &self.mana());
-      ds.field("hp", &self.hp());
+        ds.field("hp", &self.hp());
-      ds.field("name", &self.name());
+        ds.field("name", &self.name());
-      ds.field("inventory", &self.inventory());
+        ds.field("inventory", &self.inventory());
-      ds.field("color", &self.color());
+        ds.field("color", &self.color());
-      ds.field("weapons", &self.weapons());
+        ds.field("weapons", &self.weapons());
-      ds.field("equipped_type", &self.equipped_type());
+        ds.field("equipped_type", &self.equipped_type());
-      match self.equipped_type() {
+        match self.equipped_type() {
-        Equipment::Weapon => {
+            Equipment::Weapon => {
-          if let Some(x) = self.equipped_as_weapon() {
+                if let Some(x) = self.equipped_as_weapon() {
-            ds.field("equipped", &x)
+                    ds.field("equipped", &x)
-          } else {
+                } else {
-            ds.field("equipped", &"InvalidFlatbuffer: Union discriminant does not match value.")
+                    ds.field("equipped", &"InvalidFlatbuffer: Union discriminant does not match value.")
-          }
+                }
-        },
+            },
-        _ => {
+            _ => {
-          let x: Option<()> = None;
+                let x: Option<()> = None;
-          ds.field("equipped", &x)
+                ds.field("equipped", &x)
-        },
+            },
-      };
+        };
-      ds.field("path", &self.path());
+        ds.field("path", &self.path());
-      ds.finish()
+        ds.finish()
-  }
+    }
 }
+
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub struct MonsterT {
-  pub pos: Option<Vec3T>,
+    pub pos: Option<Vec3T>,
-  pub mana: i16,
+    pub mana: i16,
-  pub hp: i16,
+    pub hp: i16,
-  pub name: Option<alloc::string::String>,
+    pub name: Option<alloc::string::String>,
-  pub inventory: Option<alloc::vec::Vec<u8>>,
+    pub inventory: Option<alloc::vec::Vec<u8>>,
-  pub color: Color,
+    pub color: Color,
-  pub weapons: Option<alloc::vec::Vec<WeaponT>>,
+    pub weapons: Option<alloc::vec::Vec<WeaponT>>,
-  pub equipped: EquipmentT,
+    pub equipped: EquipmentT,
-  pub path: Option<alloc::vec::Vec<Vec3T>>,
+    pub path: Option<alloc::vec::Vec<Vec3T>>,
 }
+
 impl Default for MonsterT {
-  fn default() -> Self {
+    fn default() -> Self {
-    Self {
+        Self {
-      pos: None,
+            pos: None,
-      mana: 150,
+            mana: 150,
-      hp: 100,
+            hp: 100,
-      name: None,
+            name: None,
-      inventory: None,
+            inventory: None,
-      color: Color::Blue,
+            color: Color::Blue,
-      weapons: None,
+            weapons: None,
-      equipped: EquipmentT::NONE,
+            equipped: EquipmentT::NONE,
-      path: None,
+            path: None,
+        }
     }
-  }
 }
+
 impl MonsterT {
-  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
+    pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
-    &self,
+        &self,
-    _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
+        _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
-  ) -> ::flatbuffers::WIPOffset<Monster<'b>> {
+    ) -> ::flatbuffers::WIPOffset<Monster<'b>> {
-    let pos_tmp = self.pos.as_ref().map(|x| x.pack());
+        let pos_tmp = self.pos.as_ref().map(|x| x.pack());
-    let pos = pos_tmp.as_ref();
+        let pos = pos_tmp.as_ref();
-    let mana = self.mana;
+        let mana = self.mana;
-    let hp = self.hp;
+        let hp = self.hp;
-    let name = self.name.as_ref().map(|x|{
+        let name = self.name.as_ref().map(|x|{
-      _fbb.create_string(x)
+            _fbb.create_string(x)
-    });
+        });
-    let inventory = self.inventory.as_ref().map(|x|{
+        let inventory = self.inventory.as_ref().map(|x|{
-      _fbb.create_vector(x)
+            _fbb.create_vector(x)
-    });
+        });
-    let color = self.color;
+        let color = self.color;
-    let weapons = self.weapons.as_ref().map(|x|{
+        let weapons = self.weapons.as_ref().map(|x|{
-      let w: alloc::vec::Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w)
+            let w: alloc::vec::Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w)
-    });
+        });
-    let equipped_type = self.equipped.equipment_type();
+        let equipped_type = self.equipped.equipment_type();
-    let equipped = self.equipped.pack(_fbb);
+        let equipped = self.equipped.pack(_fbb);
-    let path = self.path.as_ref().map(|x|{
+        let path = self.path.as_ref().map(|x|{
-      let w: alloc::vec::Vec<_> = x.iter().map(|t| t.pack()).collect();_fbb.create_vector(&w)
+            let w: alloc::vec::Vec<_> = x.iter().map(|t| t.pack()).collect();_fbb.create_vector(&w)
-    });
+        });
-    Monster::create(_fbb, &MonsterArgs{
+        Monster::create(_fbb, &MonsterArgs{
-      pos,
+            pos,
-      mana,
+            mana,
-      hp,
+            hp,
-      name,
+            name,
-      inventory,
+            inventory,
-      color,
+            color,
-      weapons,
+            weapons,
-      equipped_type,
+            equipped_type,
-      equipped,
+            equipped,
-      path,
+            path,
-    })
+        })
-  }
+    }
 }
-#[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`.
-pub fn root_as_monster(buf: &[u8]) -> Result<Monster<'_>, ::flatbuffers::InvalidFlatbuffer> {
-  ::flatbuffers::root::<Monster>(buf)
-}
 #[inline]
+pub fn root_as_monster(buf: &[u8]) -> Result<Monster<'_>, ::flatbuffers::InvalidFlatbuffer> {
+    ::flatbuffers::root::<Monster>(buf)
+}
+
 /// 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`.
-pub fn size_prefixed_root_as_monster(buf: &[u8]) -> Result<Monster<'_>, ::flatbuffers::InvalidFlatbuffer> {
-  ::flatbuffers::size_prefixed_root::<Monster>(buf)
-}
 #[inline]
+pub fn size_prefixed_root_as_monster(buf: &[u8]) -> Result<Monster<'_>, ::flatbuffers::InvalidFlatbuffer> {
+    ::flatbuffers::size_prefixed_root::<Monster>(buf)
+}
+
 /// 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`.
-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]
+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)
+}
+
 /// 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`.
-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]
+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)
+}
+
 /// 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`.
-pub unsafe fn root_as_monster_unchecked(buf: &[u8]) -> Monster<'_> {
-  unsafe { ::flatbuffers::root_unchecked::<Monster>(buf) }
-}
 #[inline]
+pub unsafe fn root_as_monster_unchecked(buf: &[u8]) -> Monster<'_> {
+    unsafe { ::flatbuffers::root_unchecked::<Monster>(buf) }
+}
+
 /// 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`.
-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>(
+pub unsafe fn size_prefixed_root_as_monster_unchecked(buf: &[u8]) -> Monster<'_> {
-    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+    unsafe { ::flatbuffers::size_prefixed_root_unchecked::<Monster>(buf) }
-    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_monster_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
-  fbb.finish_size_prefixed(root, None);
+    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, 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>>
+) {
+    fbb.finish_size_prefixed(root, None);
 }

samples/rust_generated/my_game/sample/vec_3_generated.rs

@@ -2,47 +2,57 @@
 // @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 { 
+    fn default() -> Self {
-    Self([0; 12])
+        Self([0; 12])
-  }
+    }
 }
+
 impl ::core::fmt::Debug for Vec3 {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-    f.debug_struct("Vec3")
+        f.debug_struct("Vec3")
-      .field("x", &self.x())
+            .field("x", &self.x())
-      .field("y", &self.y())
+            .field("y", &self.y())
-      .field("z", &self.z())
+            .field("z", &self.z())
-      .finish()
+            .finish()
-  }
+    }
 }
 
 impl ::flatbuffers::SimpleToVerifyInSlice for Vec3 {}
+
 impl<'a> ::flatbuffers::Follow<'a> for Vec3 {
-  type Inner = &'a Vec3;
+    type Inner = &'a Vec3;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    unsafe { <&'a Vec3>::follow(buf, loc) }
+    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;
+    type Inner = &'a Vec3;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    unsafe { ::flatbuffers::follow_cast_ref::<Vec3>(buf, loc) }
+    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)
@@ -50,141 +60,150 @@ impl<'b> ::flatbuffers::Push for Vec3 {
 }
 
 impl<'a> ::flatbuffers::Verifiable for Vec3 {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    v.in_buffer::<Self>(pos)
+        v.in_buffer::<Self>(pos)
-  }
+    }
 }
 
 impl<'a> Vec3 {
-  #[allow(clippy::too_many_arguments)]
+    #[allow(clippy::too_many_arguments)]
-  pub fn new(
+    pub fn new(
-    x: f32,
+        x: f32,
-    y: f32,
+        y: f32,
-    z: f32,
+        z: f32,
-  ) -> Self {
+    ) -> Self {
-    let mut s = Self([0; 12]);
+        let mut s = Self([0; 12]);
-    s.set_x(x);
+        s.set_x(x);
-    s.set_y(y);
+        s.set_y(y);
-    s.set_z(z);
+        s.set_z(z);
-    s
+        s
-  }
-
-  pub const fn get_fully_qualified_name() -> &'static str {
-    "MyGame.Sample.Vec3"
-  }
-
-  pub fn x(&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_x(&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 y(&self) -> f32 {
+    pub const fn get_fully_qualified_name() -> &'static str {
-    let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
+        "MyGame.Sample.Vec3"
-    // 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[4..].as_ptr(),
-        mem.as_mut_ptr() as *mut u8,
-        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
-      );
-      mem.assume_init()
-    })
-  }
-
-  pub fn set_y(&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[4..].as_mut_ptr(),
-        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
-      );
     }
-  }
 
-  pub fn z(&self) -> f32 {
+    pub fn x(&self) -> f32 {
-    let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
+        let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
-    // Safety:
+        // Safety:
-    // Created from a valid Table for this object
+        // Created from a valid Table for this object
-    // Which contains a valid value in this slot
+        // Which contains a valid value in this slot
-    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
+        ::flatbuffers::EndianScalar::from_little_endian(unsafe {
-      ::core::ptr::copy_nonoverlapping(
+            ::core::ptr::copy_nonoverlapping(
-        self.0[8..].as_ptr(),
+                self.0[0..].as_ptr(),
-        mem.as_mut_ptr() as *mut u8,
+                mem.as_mut_ptr() as *mut u8,
-        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
+                ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
-      );
+            );
-      mem.assume_init()
+            mem.assume_init()
-    })
+        })
-  }
-
-  pub fn set_z(&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[8..].as_mut_ptr(),
-        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
-      );
     }
-  }
 
-  pub fn unpack(&self) -> Vec3T {
+    pub fn set_x(&mut self, x: f32) {
-    Vec3T {
+        let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
-      x: self.x(),
+        // Safety:
-      y: self.y(),
+        // Created from a valid Table for this object
-      z: self.z(),
+        // 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 y(&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[4..].as_ptr(),
+                mem.as_mut_ptr() as *mut u8,
+                ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
+            );
+            mem.assume_init()
+        })
+    }
+
+    pub fn set_y(&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[4..].as_mut_ptr(),
+                ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
+            );
+        }
+    }
+
+    pub fn z(&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[8..].as_ptr(),
+                mem.as_mut_ptr() as *mut u8,
+                ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
+            );
+            mem.assume_init()
+        })
+    }
+
+    pub fn set_z(&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[8..].as_mut_ptr(),
+                ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
+            );
+        }
+    }
+
+    pub fn unpack(&self) -> Vec3T {
+        Vec3T {
+            x: self.x(),
+            y: self.y(),
+            z: self.z(),
+        }
     }
-  }
 }
 
-#[derive(Debug, Clone, PartialEq, Default)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Vec3T {
-  pub x: f32,
+    pub x: f32,
-  pub y: f32,
+    pub y: f32,
-  pub z: f32,
+    pub z: f32,
 }
-impl Vec3T {
+impl Default for Vec3T {
-  pub fn pack(&self) -> Vec3 {
+    fn default() -> Self {
-    Vec3::new(
+        Self {
-      self.x,
+            x: 0.0,
-      self.y,
+            y: 0.0,
-      self.z,
+            z: 0.0,
-    )
+        }
-  }
+    }
 }
 
+impl Vec3T {
+    pub fn pack(&self) -> Vec3 {
+        Vec3::new(
+            self.x,
+            self.y,
+            self.z,
+        )
+    }
+}

samples/rust_generated/my_game/sample/weapon_generated.rs

@@ -2,159 +2,172 @@
 // @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>,
+    pub _tab: ::flatbuffers::Table<'a>,
 }
 
 impl<'a> ::flatbuffers::Follow<'a> for Weapon<'a> {
-  type Inner = Weapon<'a>;
+    type Inner = Weapon<'a>;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-  }
+        Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    }
 }
 
 impl<'a> Weapon<'a> {
-  pub const VT_NAME: ::flatbuffers::VOffsetT = 4;
+    pub const VT_NAME: ::flatbuffers::VOffsetT = 4;
-  pub const VT_DAMAGE: ::flatbuffers::VOffsetT = 6;
+    pub const VT_DAMAGE: ::flatbuffers::VOffsetT = 6;
 
-  pub const fn get_fully_qualified_name() -> &'static str {
+    pub const fn get_fully_qualified_name() -> &'static str {
-    "MyGame.Sample.Weapon"
+        "MyGame.Sample.Weapon"
-  }
-
-  #[inline]
-  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>,
-    args: &'args WeaponArgs<'args>
-  ) -> ::flatbuffers::WIPOffset<Weapon<'bldr>> {
-    let mut builder = WeaponBuilder::new(_fbb);
-    if let Some(x) = args.name { builder.add_name(x); }
-    builder.add_damage(args.damage);
-    builder.finish()
-  }
-
-  pub fn unpack(&self) -> WeaponT {
-    let name = self.name().map(|x| {
-      alloc::string::ToString::to_string(x)
-    });
-    let damage = self.damage();
-    WeaponT {
-      name,
-      damage,
     }
-  }
 
-  #[inline]
+    #[inline]
-  pub fn name(&self) -> Option<&'a str> {
+    pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-    // Safety:
+        Weapon { _tab: table }
-    // Created from valid Table for this object
+    }
-    // which contains a valid value in this slot
+
-    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Weapon::VT_NAME, None)}
+    #[allow(unused_mut)]
-  }
+    pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
-  #[inline]
+        _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
-  pub fn damage(&self) -> i16 {
+        args: &'args WeaponArgs<'args>
-    // Safety:
+    ) -> ::flatbuffers::WIPOffset<Weapon<'bldr>> {
-    // Created from valid Table for this object
+        let mut builder = WeaponBuilder::new(_fbb);
-    // which contains a valid value in this slot
+        if let Some(x) = args.name { builder.add_name(x); }
-    unsafe { self._tab.get::<i16>(Weapon::VT_DAMAGE, Some(0)).unwrap()}
+        builder.add_damage(args.damage);
-  }
+        builder.finish()
+    }
+
+    pub fn unpack(&self) -> WeaponT {
+        let name = self.name().map(|x| {
+            alloc::string::ToString::to_string(x)
+        });
+        let damage = self.damage();
+        WeaponT {
+            name,
+            damage,
+        }
+    }
+
+    #[inline]
+    pub fn name(&self) -> Option<&'a str> {
+        // Safety:
+        // Created from valid Table for this object
+        // 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:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe { self._tab.get::<i16>(Weapon::VT_DAMAGE, Some(0)).unwrap()}
+    }
 }
 
 impl ::flatbuffers::Verifiable for Weapon<'_> {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    v.visit_table(pos)?
+        v.visit_table(pos)?
-     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
+            .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
-     .visit_field::<i16>("damage", Self::VT_DAMAGE, false)?
+            .visit_field::<i16>("damage", Self::VT_DAMAGE, false)?
-     .finish();
+            .finish();
-    Ok(())
+        Ok(())
-  }
+    }
 }
+
 pub struct WeaponArgs<'a> {
     pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
     pub damage: i16,
 }
+
 impl<'a> Default for WeaponArgs<'a> {
-  #[inline]
+    #[inline]
-  fn default() -> Self {
+    fn default() -> Self {
-    WeaponArgs {
+        WeaponArgs {
-      name: None,
+            name: None,
-      damage: 0,
+            damage: 0,
+        }
     }
-  }
 }
 
 pub struct WeaponBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
-  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+    fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+    start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
 }
+
 impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> WeaponBuilder<'a, 'b, A> {
-  #[inline]
+    #[inline]
-  pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b  str>) {
+    pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b  str>) {
-    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Weapon::VT_NAME, name);
+        self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Weapon::VT_NAME, name);
-  }
+    }
-  #[inline]
+
-  pub fn add_damage(&mut self, damage: i16) {
+    #[inline]
-    self.fbb_.push_slot::<i16>(Weapon::VT_DAMAGE, damage, 0);
+    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();
+    #[inline]
-    WeaponBuilder {
+    pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> WeaponBuilder<'a, 'b, A> {
-      fbb_: _fbb,
+        let start = _fbb.start_table();
-      start_: start,
+        WeaponBuilder {
+            fbb_: _fbb,
+            start_: start,
+        }
+    }
+
+    #[inline]
+    pub fn finish(self) -> ::flatbuffers::WIPOffset<Weapon<'a>> {
+        let o = self.fbb_.end_table(self.start_);
+        ::flatbuffers::WIPOffset::new(o.value())
     }
-  }
-  #[inline]
-  pub fn finish(self) -> ::flatbuffers::WIPOffset<Weapon<'a>> {
-    let o = self.fbb_.end_table(self.start_);
-    ::flatbuffers::WIPOffset::new(o.value())
-  }
 }
 
 impl ::core::fmt::Debug for Weapon<'_> {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-    let mut ds = f.debug_struct("Weapon");
+        let mut ds = f.debug_struct("Weapon");
-      ds.field("name", &self.name());
+        ds.field("name", &self.name());
-      ds.field("damage", &self.damage());
+        ds.field("damage", &self.damage());
-      ds.finish()
+        ds.finish()
-  }
+    }
 }
+
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub struct WeaponT {
-  pub name: Option<alloc::string::String>,
+    pub name: Option<alloc::string::String>,
-  pub damage: i16,
+    pub damage: i16,
 }
+
 impl Default for WeaponT {
-  fn default() -> Self {
+    fn default() -> Self {
-    Self {
+        Self {
-      name: None,
+            name: None,
-      damage: 0,
+            damage: 0,
+        }
     }
-  }
 }
+
 impl WeaponT {
-  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
+    pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
-    &self,
+        &self,
-    _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
+        _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
-  ) -> ::flatbuffers::WIPOffset<Weapon<'b>> {
+    ) -> ::flatbuffers::WIPOffset<Weapon<'b>> {
-    let name = self.name.as_ref().map(|x|{
+        let name = self.name.as_ref().map(|x|{
-      _fbb.create_string(x)
+            _fbb.create_string(x)
-    });
+        });
-    let damage = self.damage;
+        let damage = self.damage;
-    Weapon::create(_fbb, &WeaponArgs{
+        Weapon::create(_fbb, &WeaponArgs{
-      name,
+            name,
-      damage,
+            damage,
-    })
+        })
-  }
+    }
 }

scripts/generate_code.py

@@ -251,21 +251,6 @@ flatc(
     schema="vector_table_naked_ptr.fbs",
 )
 
-flatc(
-    [
-        "--cpp",
-        "--gen-compare",
-        "--gen-mutable",
-        "--gen-object-api",
-        "--reflect-names",
-        "--cpp-include",
-        "test_vector_type.h",
-        "--cpp-vector-type",
-        "::flatbuffers::tests::CustomVector",
-    ],
-    schema="cpp_vector_type.fbs",
-)
-
 flatc(
     BASE_OPTS + CPP_OPTS + CS_OPTS + JAVA_OPTS + KOTLIN_OPTS + PHP_OPTS,
     prefix="union_vector",
@@ -409,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",
@@ -532,6 +522,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/flatc.cpp

@@ -145,12 +145,6 @@ const static FlatCOption flatc_options[] = {
     {"", "cpp-str-flex-ctor", "",
      "Don't construct custom string types by passing std::string from "
      "Flatbuffers, but (char* + length)."},
-    {"", "cpp-vector-type", "T",
-     "Set object API vector type (default std::vector). T must be a "
-     "template taking a single element type argument and support "
-     "resize(), reserve(), size(), data(), operator[], emplace_back(), and "
-     "begin()/end(). The custom type also needs its own header to be "
-     "included via --cpp-include."},
     {"", "cpp-field-case-style", "STYLE",
      "Generate C++ fields using selected case style. Supported STYLE values: * "
      "'unchanged' - leave unchanged (default) * 'upper' - schema snake_case "
@@ -551,9 +545,6 @@ FlatCOptions FlatCompiler::ParseFromCommandLineArguments(int argc,
         opts.cpp_object_api_string_type = argv[argi];
       } else if (arg == "--cpp-str-flex-ctor") {
         opts.cpp_object_api_string_flexible_constructor = true;
-      } else if (arg == "--cpp-vector-type") {
-        if (++argi >= argc) Error("missing type following: " + arg, true);
-        opts.cpp_object_api_vector_type = argv[argi];
       } else if (arg == "--no-cpp-direct-copy") {
         opts.cpp_direct_copy = false;
       } else if (arg == "--cpp-field-case-style") {

src/idl_gen_cpp.cpp

@@ -257,19 +257,6 @@ class CppGenerator : public BaseGenerator {
     code_ += "              FLATBUFFERS_VERSION_REVISION == " +
              std::to_string(FLATBUFFERS_VERSION_REVISION) + ",";
     code_ += "             \"Non-compatible flatbuffers version included\");";
-
-    code_ += "// Ensure the included flatbuffers.h is Bigfoot's fork - stock";
-    code_ += "// flatbuffers (or a differently versioned Bigfoot fork) is not compatible.";
-    code_ += "#ifndef FLATBUFFERS_BIGFOOT_VERSION";
-    code_ +=
-        "#error \"This file requires Bigfoot's flatbuffers fork - stock "
-        "flatbuffers is not compatible\"";
-    code_ += "#endif";
-    code_ += "static_assert(FLATBUFFERS_BIGFOOT_VERSION == " +
-             std::to_string(FLATBUFFERS_BIGFOOT_VERSION) + ",";
-    code_ +=
-        "             \"Non-compatible Bigfoot flatbuffers fork version "
-        "included\");";
   }
 
   void GenIncludeDependencies() {
@@ -542,8 +529,6 @@ class CppGenerator : public BaseGenerator {
       code_ += "";
     }
 
-    GenerateBigfootRefForwardDecls();
-
     // Generate preablmle code for mini reflection.
     if (opts_.mini_reflect != IDLOptions::kNone) {
       // To break cyclic dependencies, first pre-declare all tables/structs.
@@ -773,8 +758,6 @@ class CppGenerator : public BaseGenerator {
 
     if (cur_name_space_) SetNameSpace(nullptr);
 
-    GenerateBigfootRefImpls();
-
     // Close the include guard.
     code_ += "#endif  // " + include_guard;
 
@@ -909,24 +892,6 @@ class CppGenerator : public BaseGenerator {
     return opts_.gen_nullable ? " _Nullable " : "";
   }
 
-  // A field's `native_type`/`native_type_pack_name` normally come from the
-  // referenced struct's own declaration. A field can override both (see
-  // `bigfoot_ref` in idl_parser.cpp, which synthesizes these two attributes
-  // directly on the field) to instantiate a templated native type
-  // differently per field.
-  static const Value* EffectiveNativeType(const FieldDef& field,
-                                          const StructDef& struct_def) {
-    if (const auto v = field.attributes.Lookup("native_type")) return v;
-    return struct_def.attributes.Lookup("native_type");
-  }
-
-  static const Value* EffectiveNativeTypePackName(const FieldDef& field,
-                                                   const StructDef& struct_def) {
-    if (const auto v = field.attributes.Lookup("native_type_pack_name"))
-      return v;
-    return struct_def.attributes.Lookup("native_type_pack_name");
-  }
-
   static std::string NativeName(const std::string& name, const StructDef* sd,
                                 const IDLOptions& opts) {
     // If the table is a native_type, return the native_type name.
@@ -972,23 +937,6 @@ class CppGenerator : public BaseGenerator {
                       "std::string";  // Only for custom string types.
   }
 
-  const std::string NativeVectorType(const FieldDef* field) {
-    auto attr = field ? field->attributes.Lookup("cpp_vector_type") : nullptr;
-    auto& ret = attr ? attr->constant : opts_.cpp_object_api_vector_type;
-    if (ret.empty()) {
-      return "std::vector";
-    }
-    return ret;
-  }
-
-  // True if this field's native vector uses a custom (non-std::vector)
-  // container, meaning generated Pack() code can't rely on the std::vector
-  // specific CreateVector*() overloads and must fall back to data()/size()
-  // or per-element construction instead.
-  bool UsesCustomVectorType(const FieldDef* field) {
-    return NativeVectorType(field) != "std::vector";
-  }
-
   std::string GenTypeNativePtr(const std::string& type, const FieldDef* field,
                                bool is_constructor) {
     auto& ptr_type = PtrType(field);
@@ -1026,21 +974,20 @@ class CppGenerator : public BaseGenerator {
       case BASE_TYPE_VECTOR64:
       case BASE_TYPE_VECTOR: {
         const auto type_name = GenTypeNative(type.VectorType(), true, field);
-        const auto vector_type = NativeVectorType(&field);
+        if (type.struct_def &&
-        if (vector_type == "std::vector" && type.struct_def &&
             type.struct_def->attributes.Lookup("native_custom_alloc")) {
           auto native_custom_alloc =
               type.struct_def->attributes.Lookup("native_custom_alloc");
           return "std::vector<" + type_name + "," +
                  native_custom_alloc->constant + "<" + type_name + ">>";
         } else {
-          return vector_type + "<" + type_name + ">";
+          return "std::vector<" + type_name + ">";
         }
       }
       case BASE_TYPE_STRUCT: {
         auto type_name = WrapInNameSpace(*type.struct_def);
         if (IsStruct(type)) {
-          auto native_type = EffectiveNativeType(field, *type.struct_def);
+          auto native_type = type.struct_def->attributes.Lookup("native_type");
           if (native_type) {
             type_name = native_type->constant;
           }
@@ -2032,7 +1979,7 @@ class CppGenerator : public BaseGenerator {
       const std::string& full_type =
           (cpp_type
                ? (IsVector(field.value.type)
-                      ? NativeVectorType(&field) + "<" +
+                      ? "std::vector<" +
                             GenTypeNativePtr(cpp_type->constant, &field,
                                              false) +
                             "> "
@@ -3568,11 +3515,11 @@ class CppGenerator : public BaseGenerator {
       }
       case BASE_TYPE_STRUCT: {
         if (IsStruct(type)) {
-          const auto native_type = EffectiveNativeType(afield, *type.struct_def);
+          const auto& struct_attrs = type.struct_def->attributes;
+          const auto native_type = struct_attrs.Lookup("native_type");
           if (native_type) {
             std::string unpack_call = "::flatbuffers::UnPack";
-            const auto pack_name =
+            const auto pack_name = struct_attrs.Lookup("native_type_pack_name");
-                EffectiveNativeTypePackName(afield, *type.struct_def);
             if (pack_name) {
               unpack_call += pack_name->constant;
             }
@@ -3825,22 +3772,13 @@ class CppGenerator : public BaseGenerator {
       case BASE_TYPE_VECTOR64:
       case BASE_TYPE_VECTOR: {
         auto vector_type = field.value.type.VectorType();
-        // If the field's native container isn't std::vector, the
-        // std::vector-specific CreateVector*() overloads in
-        // flatbuffer_builder.h can't be used directly. Fall back to
-        // data()/size()-based overloads (which only require the container to
-        // support those, like std::vector does) or, where no such overload
-        // exists, to the same per-element lambda serialization already used
-        // above for custom string/table/union element types.
-        const bool custom_vector = UsesCustomVectorType(&field);
         switch (vector_type.base_type) {
           case BASE_TYPE_STRING: {
-            if (!custom_vector && NativeString(&field) == "std::string") {
+            if (NativeString(&field) == "std::string") {
               code += "_fbb.CreateVectorOfStrings(" + value + ")";
             } else {
               // Use by-function serialization to emulate
-              // CreateVectorOfStrings(); this works also with non-std strings
+              // CreateVectorOfStrings(); this works also with non-std strings.
-              // and non-std::vector vector types.
               code +=
                   "_fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::"
                   "String>>"
@@ -3855,37 +3793,20 @@ class CppGenerator : public BaseGenerator {
           }
           case BASE_TYPE_STRUCT: {
             if (IsStruct(vector_type)) {
-              const auto native_type =
+              const auto& struct_attrs =
-                  EffectiveNativeType(field, *field.value.type.struct_def);
+                  field.value.type.struct_def->attributes;
+              const auto native_type = struct_attrs.Lookup("native_type");
               if (native_type) {
                 code += "_fbb.CreateVectorOfNativeStructs<";
                 code += WrapInNameSpace(*vector_type.struct_def) + ", " +
                         native_type->constant + ">";
-                if (custom_vector) {
+                code += "(" + value;
-                  code += "(" + value + ".data(), " + value + ".size()";
+                const auto pack_name =
-                } else {
+                    struct_attrs.Lookup("native_type_pack_name");
-                  code += "(" + value;
-                }
-                const auto pack_name = EffectiveNativeTypePackName(
-                    field, *field.value.type.struct_def);
                 if (pack_name) {
                   code += ", ::flatbuffers::Pack" + pack_name->constant;
                 }
                 code += ")";
-              } else if (custom_vector &&
-                         (field.value.type.base_type == BASE_TYPE_VECTOR64 ||
-                          field.offset64)) {
-                // CreateVectorOfStructs64() (and CreateVectorOfStructs64<V>()
-                // for offset64) only accept a std::vector; use the
-                // equivalent explicit-template raw pointer overload instead.
-                const auto struct_type = WrapInNameSpace(*vector_type.struct_def);
-                const auto vector_t = field.value.type.base_type ==
-                                              BASE_TYPE_VECTOR64
-                                          ? "::flatbuffers::Vector64"
-                                          : "::flatbuffers::Vector";
-                code += "_fbb.CreateVectorOfStructs<" + struct_type +
-                        ", ::flatbuffers::Offset64, " + vector_t + ">(" +
-                        value + ".data(), " + value + ".size())";
               } else {
                 // If the field uses 64-bit addressing, create a 64-bit vector.
                 if (field.value.type.base_type == BASE_TYPE_VECTOR64) {
@@ -3897,18 +3818,16 @@ class CppGenerator : public BaseGenerator {
                     code += "64<::flatbuffers::Vector>";
                   }
                 }
-                if (custom_vector) {
+                code += "(" + value + ")";
-                  code += "(" + value + ".data(), " + value + ".size())";
-                } else {
-                  code += "(" + value + ")";
-                }
               }
             } else {
               code += "_fbb.CreateVector<::flatbuffers::Offset<";
               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])";
@@ -3920,17 +3839,7 @@ class CppGenerator : public BaseGenerator {
             break;
           }
           case BASE_TYPE_BOOL: {
-            if (custom_vector) {
+            code += "_fbb.CreateVector(" + value + ")";
-              // Vectors of bool are always stored on the wire as uint8_t
-              // (there is no Vector<bool>); CreateVectorScalarCast() does
-              // the per-element bool->uint8_t cast from a raw data()/size()
-              // pointer pair, avoiding any dependency on std::vector<bool>'s
-              // bit-packed specialization.
-              code += "_fbb.CreateVectorScalarCast<uint8_t>(" + value +
-                      ".data(), " + value + ".size())";
-            } else {
-              code += "_fbb.CreateVector(" + value + ")";
-            }
             break;
           }
           case BASE_TYPE_UNION: {
@@ -3966,11 +3875,9 @@ class CppGenerator : public BaseGenerator {
               // the underlying storage type (eg. uint8_t).
               const auto basetype = GenTypeBasic(
                   field.value.type.enum_def->underlying_type, false);
-              const std::string data_ptr =
+              code += "_fbb.CreateVectorScalarCast<" + basetype +
-                  custom_vector ? value + ".data()"
+                      ">(::flatbuffers::data(" + value + "), " + value +
-                                : "::flatbuffers::data(" + value + ")";
+                      ".size())";
-              code += "_fbb.CreateVectorScalarCast<" + basetype + ">(" +
-                      data_ptr + ", " + value + ".size())";
             } else if (field.attributes.Lookup("cpp_type")) {
               auto type = GenTypeBasic(vector_type, false);
               code += "_fbb.CreateVector<" + type + ">(" + value + ".size(), ";
@@ -3979,27 +3886,6 @@ class CppGenerator : public BaseGenerator {
               code += "static_cast<" + type + ">((*__va->__rehasher)";
               code += "(__va->_" + value + "[i]" + GenPtrGet(field) + ")) : 0";
               code += "; }, &_va )";
-            } else if (custom_vector) {
-              // Explicitly specify the element type so it can be deduced
-              // from a raw data()/size() pointer pair instead of relying on
-              // the std::vector<T, Alloc>-specific CreateVector overloads.
-              // Use the user-facing type (matches what GenTypeNative()
-              // stores in the native vector, e.g. the enum type itself for
-              // scoped-enum fields) so it matches data()'s pointee type.
-              auto type = GenTypeBasic(vector_type, true);
-              if (field.value.type.base_type == BASE_TYPE_VECTOR64) {
-                code += "_fbb.CreateVector<" + type +
-                        ", ::flatbuffers::Offset64, ::flatbuffers::Vector64>(" +
-                        value + ".data(), " + value + ".size())";
-              } else if (field.offset64) {
-                // This is normal 32-bit vector, with 64-bit addressing.
-                code += "_fbb.CreateVector<" + type +
-                        ", ::flatbuffers::Offset64, ::flatbuffers::Vector>(" +
-                        value + ".data(), " + value + ".size())";
-              } else {
-                code += "_fbb.CreateVector(" + value + ".data(), " + value +
-                        ".size())";
-              }
             } else {
               // If the field uses 64-bit addressing, create a 64-bit vector.
               if (field.value.type.base_type == BASE_TYPE_VECTOR64) {
@@ -4033,12 +3919,12 @@ class CppGenerator : public BaseGenerator {
       }
       case BASE_TYPE_STRUCT: {
         if (IsStruct(field.value.type)) {
-          const auto native_type =
+          const auto& struct_attribs = field.value.type.struct_def->attributes;
-              EffectiveNativeType(field, *field.value.type.struct_def);
+          const auto native_type = struct_attribs.Lookup("native_type");
           if (native_type && field.native_inline) {
             code += "::flatbuffers::Pack";
             const auto pack_name =
-                EffectiveNativeTypePackName(field, *field.value.type.struct_def);
+                struct_attribs.Lookup("native_type_pack_name");
             if (pack_name) {
               code += pack_name->constant;
             }
@@ -4054,8 +3940,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";
@@ -4203,7 +4091,8 @@ class CppGenerator : public BaseGenerator {
           if (field->value.type.base_type == BASE_TYPE_STRUCT) {
             if (IsStruct(field->value.type)) {
               auto native_type =
-                  EffectiveNativeType(*field, *field->value.type.struct_def);
+                  field->value.type.struct_def->attributes.Lookup(
+                      "native_type");
               auto native_inline = field->attributes.Lookup("native_inline");
               if (native_type) {
                 pass_by_address = true;
@@ -4558,141 +4447,6 @@ class CppGenerator : public BaseGenerator {
     }
   }
 
-  // Split a "::"-qualified C++ name into namespace components + final name.
-  static std::vector<std::string> SplitQualifiedName(const std::string& qualified) {
-    std::vector<std::string> parts;
-    size_t start = qualified.compare(0, 2, "::") == 0 ? 2 : 0;
-    for (;;) {
-      const auto pos = qualified.find("::", start);
-      if (pos == std::string::npos) {
-        parts.push_back(qualified.substr(start));
-        break;
-      }
-      parts.push_back(qualified.substr(start, pos - start));
-      start = pos + 2;
-    }
-    return parts;
-  }
-
-  // Bigfoot: for every field annotated `bigfoot_ref: "::Ns::AssetX"` (see
-  // idl_parser.cpp), forward-declare AssetX plus prototype the Pack/UnPack
-  // functions for its reference wrapper. Called early (alongside the
-  // regular struct/table forward declarations), since these prototypes -
-  // unlike their definitions in GenerateBigfootRefImpls() - only need
-  // AssetX and the wrapper struct forward-declared, not complete.
-  void GenerateBigfootRefForwardDecls() {
-    std::unordered_set<std::string> declared_assets;
-    for (const auto& struct_def : parser_.structs_.vec) {
-      if (struct_def->generated) continue;
-      for (const auto& field : struct_def->fields.vec) {
-        const auto* bigfoot_ref = field->attributes.Lookup("bigfoot_ref");
-        if (!bigfoot_ref) continue;
-        if (!declared_assets.insert(bigfoot_ref->constant).second) continue;
-
-        auto parts = SplitQualifiedName(bigfoot_ref->constant);
-        const std::string class_name = parts.back();
-        parts.pop_back();
-
-        SetNameSpace(nullptr);
-        for (const auto& ns_part : parts) code_ += "namespace " + ns_part + " {";
-        code_ += "class " + class_name + ";";
-        for (auto it = parts.rbegin(); it != parts.rend(); ++it)
-          code_ += "}  // namespace " + *it;
-        code_ += "";
-      }
-    }
-
-    std::unordered_set<std::string> declared_pairs;
-    bool opened_flatbuffers_ns = false;
-    for (const auto& struct_def : parser_.structs_.vec) {
-      if (struct_def->generated) continue;
-      for (const auto& field : struct_def->fields.vec) {
-        const auto* bigfoot_ref = field->attributes.Lookup("bigfoot_ref");
-        if (!bigfoot_ref) continue;
-
-        const auto* pack_name = field->attributes.Lookup("native_type_pack_name");
-        if (!declared_pairs.insert(pack_name->constant).second) continue;
-
-        if (!opened_flatbuffers_ns) {
-          SetNameSpace(nullptr);
-          code_ += "namespace flatbuffers {";
-          opened_flatbuffers_ns = true;
-        }
-
-        const auto* native_type = field->attributes.Lookup("native_type");
-        const std::string flat_wrapper =
-            WrapInNameSpace(*field->value.type.struct_def);
-
-        code_ += flat_wrapper + " Pack" + pack_name->constant +
-                 "(const " + native_type->constant + "& p_asset);";
-        code_ += native_type->constant + " UnPack" + pack_name->constant +
-                 "(const " + flat_wrapper + "& p_asset);";
-      }
-    }
-
-    if (opened_flatbuffers_ns) {
-      code_ += "}  // namespace flatbuffers";
-      code_ += "";
-    }
-  }
-
-  // Bigfoot: defines the Pack/UnPack functions prototyped by
-  // GenerateBigfootRefForwardDecls(). Called late (after every struct/table
-  // in this file has been fully defined), since a wrapper struct (e.g.
-  // HardReference/SoftReference) may be defined in this same generated file
-  // rather than one it includes, and these definitions construct it by
-  // value - they need it complete, unlike the earlier prototypes.
-  void GenerateBigfootRefImpls() {
-    std::unordered_set<std::string> declared_pairs;
-    bool opened_flatbuffers_ns = false;
-    for (const auto& struct_def : parser_.structs_.vec) {
-      if (struct_def->generated) continue;
-      for (const auto& field : struct_def->fields.vec) {
-        const auto* bigfoot_ref = field->attributes.Lookup("bigfoot_ref");
-        if (!bigfoot_ref) continue;
-
-        const auto* pack_name = field->attributes.Lookup("native_type_pack_name");
-        if (!declared_pairs.insert(pack_name->constant).second) continue;
-
-        if (!opened_flatbuffers_ns) {
-          SetNameSpace(nullptr);
-          code_ += "namespace flatbuffers {";
-          opened_flatbuffers_ns = true;
-        }
-
-        const auto* native_type = field->attributes.Lookup("native_type");
-        const std::string flat_wrapper =
-            WrapInNameSpace(*field->value.type.struct_def);
-
-        // A single translation unit can end up including two different
-        // generated headers that both reference the same asset type (e.g.
-        // AssetB references AssetA, and some other TU includes both
-        // AssetA_generated.hpp and AssetB_generated.hpp directly) - each
-        // would otherwise emit an identical, independent definition of these
-        // functions. `inline` only allows identical definitions to repeat
-        // across *different* translation units, not twice within the same
-        // one, so guard against that with a plain macro guard.
-        std::string guard_name = pack_name->constant;
-        std::transform(guard_name.begin(), guard_name.end(), guard_name.begin(), CharToUpper);
-        const std::string guard = "FLATBUFFERS_BIGFOOT_REF_" + guard_name;
-        code_ += "#ifndef " + guard;
-        code_ += "#define " + guard;
-        code_ += "inline " + flat_wrapper + " Pack" + pack_name->constant +
-                 "(const " + native_type->constant +
-                 "& p_asset) { return {Pack(p_asset.GetUUID())}; }";
-        code_ += "inline " + native_type->constant + " UnPack" +
-                 pack_name->constant + "(const " + flat_wrapper +
-                 "& p_asset) { return {UnPack(p_asset.uuid())}; }";
-        code_ += "#endif  // " + guard;
-      }
-    }
-
-    if (opened_flatbuffers_ns) {
-      code_ += "}  // namespace flatbuffers";
-      code_ += "";
-    }
-  }
-
   // Set up the correct namespace. Only open a namespace if the existing one is
   // different (closing/opening only what is necessary).
   //

src/idl_gen_python.cpp

@@ -1528,7 +1528,7 @@ class PythonGenerator : public BaseGenerator {
       } else {
         code += "def Create" + field_method + "Vector(builder, data):\n";
       }
-      code += Indent + helper_name + "(builder, data)\n\n";
+      code += Indent + "return " + helper_name + "(builder, data)\n\n";
     }
   }
 

src/idl_gen_swift.cpp

@@ -164,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";
@@ -282,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 + ">";
 
@@ -518,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) {
@@ -528,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_ += "";
@@ -620,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 + "\\";
@@ -699,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)
@@ -719,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));
@@ -730,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 +
@@ -747,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();
@@ -860,7 +867,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:
@@ -894,7 +901,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}}) }";
     }
 
@@ -911,7 +918,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;
@@ -920,7 +927,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 "
@@ -954,24 +962,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) {
@@ -1093,14 +1098,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);
+
+    if (coding_keys.empty() == false) {
+      code_ += "enum CodingKeys: String, CodingKey {";
+      Indent();
+      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 {";
-    Indent();
+
-    if (struct_def.fields.vec.empty() == false) GenerateEncoderBody(struct_def);
+    if (coding_keys.empty() == false) {
-    Outdent();
+      Indent();
+      GenerateEncoderBody(struct_def);
+      Outdent();
+    }
+
     code_ += "}";
+
     Outdent();
     code_ += "}";
     code_ += "";
@@ -1130,7 +1152,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)";
     }
@@ -1150,8 +1172,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();
@@ -1893,7 +1916,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

@@ -324,9 +324,10 @@ 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);
+      }
     }
   }
 
@@ -521,7 +522,16 @@ 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 {
+          return "\"" + value.constant + "\"";
+        }
+      }
       case BASE_TYPE_UNION:
       case BASE_TYPE_STRUCT: {
         return null_keyword_;
@@ -647,7 +657,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;
@@ -655,11 +666,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());
       }
     }
@@ -921,6 +932,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) {
@@ -948,26 +1001,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;
@@ -1172,9 +1231,10 @@ class TsGenerator : public BaseGenerator {
 
   std::string GenNullCheckConditional(const std::string& nullCheckVar,
                                       const std::string& trueVal,
-                                      const std::string& falseVal) {
+                                      const std::string& falseVal = "") {
+    std::string false_val = falseVal.empty() ? null_keyword_ : falseVal;
     return "(" + nullCheckVar + " !== " + null_keyword_ + " ? " + trueVal +
-           " : " + falseVal + ")";
+           " : " + false_val + ")";
   }
 
   std::string GenStructMemberValueTS(const StructDef& struct_def,
@@ -1283,10 +1343,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) {
@@ -1632,11 +1691,12 @@ 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_keyword_ + " = " +
             null_keyword_ + ";\n";
     code += "  bb_pos = 0;\n";
@@ -1679,21 +1739,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_keyword_ + "\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 {
@@ -1722,9 +1783,16 @@ class TsGenerator : public BaseGenerator {
           if (is_string) {
             index += ", optionalEncoding";
           }
-          code +=
+          if (field.IsRequired()) {
-              offset_prefix + GenGetter(field.value.type, "(" + index + ")");
+            code +=
-          if (field.value.type.base_type != BASE_TYPE_ARRAY) {
+                offset_prefix + GenGetter(field.value.type, "(" + index + ")");
+            ;
+          } 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";
@@ -1749,8 +1817,8 @@ 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)";
@@ -1908,7 +1976,7 @@ class TsGenerator : public BaseGenerator {
             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
@@ -1921,7 +1989,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) {
@@ -1953,7 +2022,7 @@ class TsGenerator : public BaseGenerator {
                     " "
                     "{\n";
 
-            code += offset_prefix +
+            code += offset_prefix + "offset ? " +
                     GenGetter(field.value.type, "(obj, this.bb_pos + offset)") +
                     " : " + null_keyword_ + ";\n";
             break;
@@ -2006,7 +2075,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";
@@ -2017,15 +2086,30 @@ class TsGenerator : public BaseGenerator {
           GenDocComment(code_ptr);
 
           code += namer_.Method(field, "Array");
-          code += "():" + GenType(vectorType) + "Array|" + null_keyword_ +
-                  " {\n" + offset_prefix;
 
-          code += "new " + GenType(vectorType) + "Array(" + GenBBAccess() +
+          std::string return_type =
-                  ".bytes().buffer, " + GenBBAccess() +
+              (field.IsRequired() || HasDefaultValue(field))
-                  ".bytes().byteOffset + " + GenBBAccess() +
+                  ? "Array"
-                  ".__vector(this.bb_pos + offset), " + GenBBAccess() +
+                  : ("Array|" + null_keyword_);
-                  ".__vector_len(this.bb_pos + offset)) : " + null_keyword_ +
+          if (field.IsRequired()) {
-                  ";\n}\n\n";
+            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));\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";
+          }
         }
       }
     }
@@ -2054,7 +2138,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) +
@@ -2256,6 +2340,34 @@ class TsGenerator : public BaseGenerator {
     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

@@ -1286,55 +1286,6 @@ CheckedError Parser::ParseField(StructDef& struct_def) {
         "'native_inline' can only be defined on structs, vector of structs or "
         "vector of tables");
 
-  // `bigfoot_ref` is Bigfoot's single-purpose replacement for the old,
-  // general-purpose `native_type_template`/`native_type_template_arg` pair:
-  // a field typed as a `bigfoot_ref_wrapper`-tagged struct (HardReference or
-  // SoftReference) and annotated `bigfoot_ref: "::Bigfoot::AssetX"` gets its
-  // native type instantiated as `<wrapper><::Bigfoot::AssetX>`, plus (unlike
-  // the old mechanism) a forward declaration of AssetX and inline Pack/UnPack
-  // definitions are emitted directly into the generated header - see
-  // GenerateBigfootRefDecls in idl_gen_cpp.cpp.
-  auto bigfoot_ref = field->attributes.Lookup("bigfoot_ref");
-  if (bigfoot_ref) {
-    if (!IsStruct(field->value.type) && !IsVectorOfStruct(field->value.type))
-      return Error(
-          "'bigfoot_ref' can only be defined on struct-typed fields or "
-          "vectors of structs");
-    const auto* target_struct = field->value.type.struct_def;
-    const auto* wrapper = target_struct->attributes.Lookup("bigfoot_ref_wrapper");
-    if (!wrapper)
-      return Error(
-          "'bigfoot_ref' requires the field's type ('" + target_struct->name +
-          "') to declare a 'bigfoot_ref_wrapper' attribute");
-    if (field->attributes.Lookup("native_type"))
-      return Error(
-          "'bigfoot_ref' cannot be combined with an explicit 'native_type' "
-          "on the same field");
-
-    const auto b = bigfoot_ref->constant.find_first_not_of(" \t");
-    const auto e = bigfoot_ref->constant.find_last_not_of(" \t");
-    const std::string asset_type =
-        b == std::string::npos ? "" : bigfoot_ref->constant.substr(b, e - b + 1);
-    if (asset_type.empty())
-      return Error("'bigfoot_ref' cannot be empty");
-
-    auto native_type_val = new Value();
-    native_type_val->type = bigfoot_ref->type;
-    native_type_val->constant = wrapper->constant + "<" + asset_type + ">";
-    field->attributes.Add("native_type", native_type_val);
-
-    if (!field->attributes.Lookup("native_type_pack_name")) {
-      const auto last_colon = asset_type.find_last_of(':');
-      const std::string asset_short_name =
-          last_colon == std::string::npos ? asset_type
-                                          : asset_type.substr(last_colon + 1);
-      auto pack_name_val = new Value();
-      pack_name_val->type = bigfoot_ref->type;
-      pack_name_val->constant = target_struct->name + asset_short_name;
-      field->attributes.Add("native_type_pack_name", pack_name_val);
-    }
-  }
-
   auto nested = field->attributes.Lookup("nested_flatbuffer");
   if (nested) {
     if (nested->type.base_type != BASE_TYPE_STRING)
@@ -2858,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);
 }
 
@@ -3220,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 {

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",
@@ -78,9 +79,6 @@ cc_test(
         "vector_table_naked_ptr/vector_table_naked_ptr_generated.h",
         "vector_table_naked_ptr_test.h",
         "vector_table_naked_ptr_test.cpp",
-        "test_vector_type.h",
-        "cpp_vector_type_test.h",
-        "cpp_vector_type_test.cpp",
     ],
     copts = [
         "-DFLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE",
@@ -139,7 +137,7 @@ cc_test(
     deps = [
         ":alignment_test_cc_fbs",
         ":arrays_test_cc_fbs",
-        ":cpp_vector_type_cc_fbs",
+        ":cross_namespace_pack_test_cc_fbs",
         ":default_vectors_strings_test_cc_fbs",
         ":monster_extra_cc_fbs",
         ":monster_test_cc_fbs",
@@ -265,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"],
@@ -275,19 +284,6 @@ flatbuffer_cc_library(
     ],
 )
 
-flatbuffer_cc_library(
-    name = "cpp_vector_type_cc_fbs",
-    srcs = ["cpp_vector_type.fbs"],
-    flatc_args = [
-        "--gen-compare",
-        "--gen-mutable",
-        "--gen-object-api",
-        "--reflect-names",
-        "--cpp-include test_vector_type.h",
-        "--cpp-vector-type ::flatbuffers::tests::CustomVector",
-    ],
-)
-
 flatbuffer_cc_library(
     name = "alignment_test_cc_fbs",
     srcs = ["alignment_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/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.py

@@ -922,7 +922,7 @@ def MonsterCreateInventoryVector(builder, data):
     return builder.EndVector()
 
 def CreateInventoryVector(builder, data):
-    MonsterCreateInventoryVector(builder, data)
+    return MonsterCreateInventoryVector(builder, data)
 
 def MonsterAddColor(builder, color):
     builder.PrependUint8Slot(6, color, 8)
@@ -962,7 +962,7 @@ def MonsterCreateTest4Vector(builder, data):
     return builder.EndVector()
 
 def CreateTest4Vector(builder, data):
-    MonsterCreateTest4Vector(builder, data)
+    return MonsterCreateTest4Vector(builder, data)
 
 def MonsterAddTestarrayofstring(builder, testarrayofstring):
     builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
@@ -980,7 +980,7 @@ def MonsterCreateTestarrayofstringVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateTestarrayofstringVector(builder, data):
-    MonsterCreateTestarrayofstringVector(builder, data)
+    return MonsterCreateTestarrayofstringVector(builder, data)
 
 def MonsterAddTestarrayoftables(builder, testarrayoftables):
     builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
@@ -998,7 +998,7 @@ def MonsterCreateTestarrayoftablesVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateTestarrayoftablesVector(builder, data):
-    MonsterCreateTestarrayoftablesVector(builder, data)
+    return MonsterCreateTestarrayoftablesVector(builder, data)
 
 def MonsterAddEnemy(builder, enemy):
     builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
@@ -1026,7 +1026,7 @@ def MonsterCreateTestnestedflatbufferVector(builder, data):
     return builder.EndVector()
 
 def CreateTestnestedflatbufferVector(builder, data):
-    MonsterCreateTestnestedflatbufferVector(builder, data)
+    return MonsterCreateTestnestedflatbufferVector(builder, data)
 
 def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes):
     builder.StartVector(1, len(bytes), 1)
@@ -1115,7 +1115,7 @@ def MonsterCreateTestarrayofboolsVector(builder, data):
     return builder.EndVector()
 
 def CreateTestarrayofboolsVector(builder, data):
-    MonsterCreateTestarrayofboolsVector(builder, data)
+    return MonsterCreateTestarrayofboolsVector(builder, data)
 
 def MonsterAddTestf(builder, testf):
     builder.PrependFloat32Slot(25, testf, 3.14159)
@@ -1151,7 +1151,7 @@ def MonsterCreateTestarrayofstring2Vector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateTestarrayofstring2Vector(builder, data):
-    MonsterCreateTestarrayofstring2Vector(builder, data)
+    return MonsterCreateTestarrayofstring2Vector(builder, data)
 
 def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
     builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
@@ -1173,7 +1173,7 @@ def MonsterCreateTestarrayofsortedstructVector(builder, data):
     return builder.EndVector()
 
 def CreateTestarrayofsortedstructVector(builder, data):
-    MonsterCreateTestarrayofsortedstructVector(builder, data)
+    return MonsterCreateTestarrayofsortedstructVector(builder, data)
 
 def MonsterAddFlex(builder, flex):
     builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
@@ -1195,7 +1195,7 @@ def MonsterCreateFlexVector(builder, data):
     return builder.EndVector()
 
 def CreateFlexVector(builder, data):
-    MonsterCreateFlexVector(builder, data)
+    return MonsterCreateFlexVector(builder, data)
 
 def MonsterAddTest5(builder, test5):
     builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
@@ -1217,7 +1217,7 @@ def MonsterCreateTest5Vector(builder, data):
     return builder.EndVector()
 
 def CreateTest5Vector(builder, data):
-    MonsterCreateTest5Vector(builder, data)
+    return MonsterCreateTest5Vector(builder, data)
 
 def MonsterAddVectorOfLongs(builder, vectorOfLongs):
     builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
@@ -1239,7 +1239,7 @@ def MonsterCreateVectorOfLongsVector(builder, data):
     return builder.EndVector()
 
 def CreateVectorOfLongsVector(builder, data):
-    MonsterCreateVectorOfLongsVector(builder, data)
+    return MonsterCreateVectorOfLongsVector(builder, data)
 
 def MonsterAddVectorOfDoubles(builder, vectorOfDoubles):
     builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
@@ -1261,7 +1261,7 @@ def MonsterCreateVectorOfDoublesVector(builder, data):
     return builder.EndVector()
 
 def CreateVectorOfDoublesVector(builder, data):
-    MonsterCreateVectorOfDoublesVector(builder, data)
+    return MonsterCreateVectorOfDoublesVector(builder, data)
 
 def MonsterAddParentNamespaceTest(builder, parentNamespaceTest):
     builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
@@ -1285,7 +1285,7 @@ def MonsterCreateVectorOfReferrablesVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateVectorOfReferrablesVector(builder, data):
-    MonsterCreateVectorOfReferrablesVector(builder, data)
+    return MonsterCreateVectorOfReferrablesVector(builder, data)
 
 def MonsterAddSingleWeakReference(builder, singleWeakReference):
     builder.PrependUint64Slot(36, singleWeakReference, 0)
@@ -1313,7 +1313,7 @@ def MonsterCreateVectorOfWeakReferencesVector(builder, data):
     return builder.EndVector()
 
 def CreateVectorOfWeakReferencesVector(builder, data):
-    MonsterCreateVectorOfWeakReferencesVector(builder, data)
+    return MonsterCreateVectorOfWeakReferencesVector(builder, data)
 
 def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
     builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
@@ -1331,7 +1331,7 @@ def MonsterCreateVectorOfStrongReferrablesVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateVectorOfStrongReferrablesVector(builder, data):
-    MonsterCreateVectorOfStrongReferrablesVector(builder, data)
+    return MonsterCreateVectorOfStrongReferrablesVector(builder, data)
 
 def MonsterAddCoOwningReference(builder, coOwningReference):
     builder.PrependUint64Slot(39, coOwningReference, 0)
@@ -1359,7 +1359,7 @@ def MonsterCreateVectorOfCoOwningReferencesVector(builder, data):
     return builder.EndVector()
 
 def CreateVectorOfCoOwningReferencesVector(builder, data):
-    MonsterCreateVectorOfCoOwningReferencesVector(builder, data)
+    return MonsterCreateVectorOfCoOwningReferencesVector(builder, data)
 
 def MonsterAddNonOwningReference(builder, nonOwningReference):
     builder.PrependUint64Slot(41, nonOwningReference, 0)
@@ -1387,7 +1387,7 @@ def MonsterCreateVectorOfNonOwningReferencesVector(builder, data):
     return builder.EndVector()
 
 def CreateVectorOfNonOwningReferencesVector(builder, data):
-    MonsterCreateVectorOfNonOwningReferencesVector(builder, data)
+    return MonsterCreateVectorOfNonOwningReferencesVector(builder, data)
 
 def MonsterAddAnyUniqueType(builder, anyUniqueType):
     builder.PrependUint8Slot(43, anyUniqueType, 0)
@@ -1433,7 +1433,7 @@ def MonsterCreateVectorOfEnumsVector(builder, data):
     return builder.EndVector()
 
 def CreateVectorOfEnumsVector(builder, data):
-    MonsterCreateVectorOfEnumsVector(builder, data)
+    return MonsterCreateVectorOfEnumsVector(builder, data)
 
 def MonsterAddSignedEnum(builder, signedEnum):
     builder.PrependInt8Slot(48, signedEnum, -1)
@@ -1461,7 +1461,7 @@ def MonsterCreateTestrequirednestedflatbufferVector(builder, data):
     return builder.EndVector()
 
 def CreateTestrequirednestedflatbufferVector(builder, data):
-    MonsterCreateTestrequirednestedflatbufferVector(builder, data)
+    return MonsterCreateTestrequirednestedflatbufferVector(builder, data)
 
 def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
     builder.StartVector(1, len(bytes), 1)
@@ -1486,7 +1486,7 @@ def MonsterCreateScalarKeySortedTablesVector(builder, data):
     return builder.CreateVectorOfTables(data)
 
 def CreateScalarKeySortedTablesVector(builder, data):
-    MonsterCreateScalarKeySortedTablesVector(builder, data)
+    return MonsterCreateScalarKeySortedTablesVector(builder, data)
 
 def MonsterAddNativeInline(builder, nativeInline):
     builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)

tests/MyGame/Example/TypeAliases.py

@@ -238,7 +238,7 @@ def TypeAliasesCreateV8Vector(builder, data):
     return builder.EndVector()
 
 def CreateV8Vector(builder, data):
-    TypeAliasesCreateV8Vector(builder, data)
+    return TypeAliasesCreateV8Vector(builder, data)
 
 def TypeAliasesAddVf64(builder, vf64):
     builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
@@ -260,7 +260,7 @@ def TypeAliasesCreateVf64Vector(builder, data):
     return builder.EndVector()
 
 def CreateVf64Vector(builder, data):
-    TypeAliasesCreateVf64Vector(builder, data)
+    return TypeAliasesCreateVf64Vector(builder, data)
 
 def TypeAliasesEnd(builder):
     return builder.EndObject()

tests/MyGame/MonsterExtra.py

@@ -214,7 +214,7 @@ def MonsterExtraCreateDvecVector(builder: flatbuffers.Builder, data: Iterable[An
     return builder.EndVector()
 
 def CreateDvecVector(builder: flatbuffers.Builder, data: Iterable[Any]) -> int:
-    MonsterExtraCreateDvecVector(builder, data)
+    return MonsterExtraCreateDvecVector(builder, data)
 
 def MonsterExtraAddFvec(builder: flatbuffers.Builder, fvec: int):
     builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(fvec), 0)
@@ -236,7 +236,7 @@ def MonsterExtraCreateFvecVector(builder: flatbuffers.Builder, data: Iterable[An
     return builder.EndVector()
 
 def CreateFvecVector(builder: flatbuffers.Builder, data: Iterable[Any]) -> int:
-    MonsterExtraCreateFvecVector(builder, data)
+    return MonsterExtraCreateFvecVector(builder, data)
 
 def MonsterExtraEnd(builder: flatbuffers.Builder) -> int:
     return builder.EndObject()

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

@@ -1,16 +1,18 @@
 // Automatically generated by the Flatbuffers compiler. Do not modify.
 // @generated
 pub mod my_game {
-  use super::*;
-  pub mod example {
     use super::*;
-    mod test_enum_generated;
+    pub mod example {
-    pub use self::test_enum_generated::*;
+        use super::*;
-    mod nested_struct_generated;
+        mod test_enum_generated;
-    pub use self::nested_struct_generated::*;
+        pub use self::test_enum_generated::*;
-    mod array_struct_generated;
+        mod nested_struct_generated;
-    pub use self::array_struct_generated::*;
+        pub use self::nested_struct_generated::*;
-    mod array_table_generated;
+        mod array_struct_generated;
-    pub use self::array_table_generated::*;
+        pub use self::array_struct_generated::*;
-  } // example
+        mod large_array_struct_generated;
+        pub use self::large_array_struct_generated::*;
+        mod array_table_generated;
+        pub use self::array_table_generated::*;
+    } // example
 } // my_game

tests/arrays_test/my_game/example/array_struct_generated.rs

@@ -2,50 +2,60 @@
 // @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 { 
+    fn default() -> Self {
-    Self([0; 160])
+        Self([0; 160])
-  }
+    }
 }
+
 impl ::core::fmt::Debug for ArrayStruct {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-    f.debug_struct("ArrayStruct")
+        f.debug_struct("ArrayStruct")
-      .field("a", &self.a())
+            .field("a", &self.a())
-      .field("b", &self.b())
+            .field("b", &self.b())
-      .field("c", &self.c())
+            .field("c", &self.c())
-      .field("d", &self.d())
+            .field("d", &self.d())
-      .field("e", &self.e())
+            .field("e", &self.e())
-      .field("f", &self.f())
+            .field("f", &self.f())
-      .finish()
+            .finish()
-  }
+    }
 }
 
 impl ::flatbuffers::SimpleToVerifyInSlice for ArrayStruct {}
+
 impl<'a> ::flatbuffers::Follow<'a> for ArrayStruct {
-  type Inner = &'a ArrayStruct;
+    type Inner = &'a ArrayStruct;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    unsafe { <&'a ArrayStruct>::follow(buf, loc) }
+    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;
+    type Inner = &'a ArrayStruct;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    unsafe { ::flatbuffers::follow_cast_ref::<ArrayStruct>(buf, loc) }
+    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)
@@ -53,207 +63,219 @@ impl<'b> ::flatbuffers::Push for ArrayStruct {
 }
 
 impl<'a> ::flatbuffers::Verifiable for ArrayStruct {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    v.in_buffer::<Self>(pos)
+        v.in_buffer::<Self>(pos)
-  }
+    }
 }
 
 impl<'a> ArrayStruct {
-  #[allow(clippy::too_many_arguments)]
+    #[allow(clippy::too_many_arguments)]
-  pub fn new(
+    pub fn new(
-    a: f32,
+        a: f32,
-    b: &[i32; 15],
+        b: &[i32; 15],
-    c: i8,
+        c: i8,
-    d: &[NestedStruct; 2],
+        d: &[NestedStruct; 2],
-    e: i32,
+        e: i32,
-    f: &[i64; 2],
+        f: &[i64; 2],
-  ) -> Self {
+    ) -> Self {
-    let mut s = Self([0; 160]);
+        let mut s = Self([0; 160]);
-    s.set_a(a);
+        s.set_a(a);
-    s.set_b(b);
+        s.set_b(b);
-    s.set_c(c);
+        s.set_c(c);
-    s.set_d(d);
+        s.set_d(d);
-    s.set_e(e);
+        s.set_e(e);
-    s.set_f(f);
+        s.set_f(f);
-    s
+        s
-  }
-
-  pub const fn get_fully_qualified_name() -> &'static str {
-    "MyGame.Example.ArrayStruct"
-  }
-
-  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> {
+    pub const fn get_fully_qualified_name() -> &'static str {
-    // Safety:
+        "MyGame.Example.ArrayStruct"
-    // 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> {
+    pub fn a(&self) -> f32 {
-    // Safety:
+        let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
-    // Created from a valid Table for this object
+        // Safety:
-    // Which contains a valid array in this slot
+        // Created from a valid Table for this object
-    use ::flatbuffers::Follow;
+        // Which contains a valid value in this slot
-    unsafe { ::flatbuffers::Array::follow(&self.0, 72) }
+        ::flatbuffers::EndianScalar::from_little_endian(unsafe {
-  }
+            ::core::ptr::copy_nonoverlapping(
-
+                self.0[0..].as_ptr(),
-  pub fn set_d(&mut self, x: &[NestedStruct; 2]) {
+                mem.as_mut_ptr() as *mut u8,
-    // Safety:
+                ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
-    // Created from a valid Table for this object
+            );
-    // Which contains a valid array in this slot
+            mem.assume_init()
-    unsafe {
+        })
-      ::core::ptr::copy(
-        x.as_ptr() as *const u8,
-        self.0.as_mut_ptr().add(72),
-        64,
-      );
     }
-  }
 
-  pub fn e(&self) -> i32 {
+    pub fn set_a(&mut self, x: f32) {
-    let mut mem = ::core::mem::MaybeUninit::<<i32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
+        let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
-    // Safety:
+        // Safety:
-    // Created from a valid Table for this object
+        // Created from a valid Table for this object
-    // Which contains a valid value in this slot
+        // Which contains a valid value in this slot
-    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
+        unsafe {
-      ::core::ptr::copy_nonoverlapping(
+            ::core::ptr::copy_nonoverlapping(
-        self.0[136..].as_ptr(),
+                &x_le as *const _ as *const u8,
-        mem.as_mut_ptr() as *mut u8,
+                self.0[0..].as_mut_ptr(),
-        ::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
+                ::core::mem::size_of::<<f32 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> {
+    pub fn b(&'a self) -> ::flatbuffers::Array<'a, i32, 15> {
-    // Safety:
+        // Safety:
-    // Created from a valid Table for this object
+        // Created from a valid Table for this object
-    // Which contains a valid array in this slot
+        // Which contains a valid array in this slot
-    use ::flatbuffers::Follow;
+        use ::flatbuffers::Follow;
-    unsafe { ::flatbuffers::Array::follow(&self.0, 144) }
+        unsafe { ::flatbuffers::Array::follow(&self.0, 4) }
-  }
+    }
-
+
-  pub fn set_f(&mut self, items: &[i64; 2]) {
+    pub fn set_b(&mut self, items: &[i32; 15]) {
-    // Safety:
+        // Safety:
-    // Created from a valid Table for this object
+        // Created from a valid Table for this object
-    // Which contains a valid array in this slot
+        // Which contains a valid array in this slot
-    unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 144, items) };
+        unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 4, items) };
-  }
+    }
-
+
-  pub fn unpack(&self) -> ArrayStructT {
+    pub fn c(&self) -> i8 {
-    ArrayStructT {
+        let mut mem = ::core::mem::MaybeUninit::<<i8 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
-      a: self.a(),
+        // Safety:
-      b: self.b().into(),
+        // Created from a valid Table for this object
-      c: self.c(),
+        // Which contains a valid value in this slot
-      d: { let d = self.d(); ::flatbuffers::array_init(|i| d.get(i).unpack()) },
+        ::flatbuffers::EndianScalar::from_little_endian(unsafe {
-      e: self.e(),
+            ::core::ptr::copy_nonoverlapping(
-      f: self.f().into(),
+                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, Default)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct ArrayStructT {
-  pub a: f32,
+    pub a: f32,
-  pub b: [i32; 15],
+    pub b: [i32; 15],
-  pub c: i8,
+    pub c: i8,
-  pub d: [NestedStructT; 2],
+    pub d: [NestedStructT; 2],
-  pub e: i32,
+    pub e: i32,
-  pub f: [i64; 2],
+    pub f: [i64; 2],
 }
-impl ArrayStructT {
+impl Default for ArrayStructT {
-  pub fn pack(&self) -> ArrayStruct {
+    fn default() -> Self {
-    ArrayStruct::new(
+        Self {
-      self.a,
+            a: 0.0,
-      &self.b,
+            b: [0; 15],
-      self.c,
+            c: 0,
-      &::flatbuffers::array_init(|i| self.d[i].pack()),
+            d: ::flatbuffers::array_init(|_| Default::default()),
-      self.e,
+            e: 0,
-      &self.f,
+            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,
+        )
+    }
+}

tests/arrays_test/my_game/example/array_table_generated.rs

@@ -2,208 +2,226 @@
 // @generated
 extern crate alloc;
 use super::*;
-pub enum ArrayTableOffset {}
-#[derive(Copy, Clone, PartialEq)]
 
+pub enum ArrayTableOffset {}
+
+#[derive(Copy, Clone, PartialEq)]
 pub struct ArrayTable<'a> {
-  pub _tab: ::flatbuffers::Table<'a>,
+    pub _tab: ::flatbuffers::Table<'a>,
 }
 
 impl<'a> ::flatbuffers::Follow<'a> for ArrayTable<'a> {
-  type Inner = ArrayTable<'a>;
+    type Inner = ArrayTable<'a>;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    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;
+    pub const VT_A: ::flatbuffers::VOffsetT = 4;
 
-  pub const fn get_fully_qualified_name() -> &'static str {
+    pub const fn get_fully_qualified_name() -> &'static str {
-    "MyGame.Example.ArrayTable"
+        "MyGame.Example.ArrayTable"
-  }
-
-  #[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]
+    #[inline]
-  pub fn a(&self) -> Option<&'a ArrayStruct> {
+    pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-    // Safety:
+        ArrayTable { _tab: table }
-    // Created from valid Table for this object
+    }
-    // which contains a valid value in this slot
+
-    unsafe { self._tab.get::<ArrayStruct>(ArrayTable::VT_A, None)}
+    #[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]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    v.visit_table(pos)?
+        v.visit_table(pos)?
-     .visit_field::<ArrayStruct>("a", Self::VT_A, false)?
+            .visit_field::<ArrayStruct>("a", Self::VT_A, false)?
-     .finish();
+            .finish();
-    Ok(())
+        Ok(())
-  }
+    }
 }
+
 pub struct ArrayTableArgs<'a> {
     pub a: Option<&'a ArrayStruct>,
 }
+
 impl<'a> Default for ArrayTableArgs<'a> {
-  #[inline]
+    #[inline]
-  fn default() -> Self {
+    fn default() -> Self {
-    ArrayTableArgs {
+        ArrayTableArgs {
-      a: None,
+            a: None,
+        }
     }
-  }
 }
 
 pub struct ArrayTableBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
-  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+    fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+    start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
 }
+
 impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ArrayTableBuilder<'a, 'b, A> {
-  #[inline]
+    #[inline]
-  pub fn add_a(&mut self, a: &ArrayStruct) {
+    pub fn add_a(&mut self, a: &ArrayStruct) {
-    self.fbb_.push_slot_always::<&ArrayStruct>(ArrayTable::VT_A, a);
+        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> {
+    #[inline]
-    let start = _fbb.start_table();
+    pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ArrayTableBuilder<'a, 'b, A> {
-    ArrayTableBuilder {
+        let start = _fbb.start_table();
-      fbb_: _fbb,
+        ArrayTableBuilder {
-      start_: start,
+            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())
     }
-  }
-  #[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 {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-    let mut ds = f.debug_struct("ArrayTable");
+        let mut ds = f.debug_struct("ArrayTable");
-      ds.field("a", &self.a());
+        ds.field("a", &self.a());
-      ds.finish()
+        ds.finish()
-  }
+    }
 }
+
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub struct ArrayTableT {
-  pub a: Option<ArrayStructT>,
+    pub a: Option<ArrayStructT>,
 }
+
 impl Default for ArrayTableT {
-  fn default() -> Self {
+    fn default() -> Self {
-    Self {
+        Self {
-      a: None,
+            a: None,
+        }
     }
-  }
 }
+
 impl ArrayTableT {
-  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
+    pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
-    &self,
+        &self,
-    _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
+        _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
-  ) -> ::flatbuffers::WIPOffset<ArrayTable<'b>> {
+    ) -> ::flatbuffers::WIPOffset<ArrayTable<'b>> {
-    let a_tmp = self.a.as_ref().map(|x| x.pack());
+        let a_tmp = self.a.as_ref().map(|x| x.pack());
-    let a = a_tmp.as_ref();
+        let a = a_tmp.as_ref();
-    ArrayTable::create(_fbb, &ArrayTableArgs{
+        ArrayTable::create(_fbb, &ArrayTableArgs{
-      a,
+            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]
+pub fn root_as_array_table(buf: &[u8]) -> Result<ArrayTable<'_>, ::flatbuffers::InvalidFlatbuffer> {
+    ::flatbuffers::root::<ArrayTable>(buf)
+}
+
 /// 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]
+pub fn size_prefixed_root_as_array_table(buf: &[u8]) -> Result<ArrayTable<'_>, ::flatbuffers::InvalidFlatbuffer> {
+    ::flatbuffers::size_prefixed_root::<ArrayTable>(buf)
+}
+
 /// 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]
+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)
+}
+
 /// 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]
+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)
+}
+
 /// 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]
+pub unsafe fn root_as_array_table_unchecked(buf: &[u8]) -> ArrayTable<'_> {
+    unsafe { ::flatbuffers::root_unchecked::<ArrayTable>(buf) }
+}
+
 /// 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`.
+#[inline]
 pub unsafe fn size_prefixed_root_as_array_table_unchecked(buf: &[u8]) -> ArrayTable<'_> {
-  unsafe { ::flatbuffers::size_prefixed_root_unchecked::<ArrayTable>(buf) }
+    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)
+    ::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)
+    ::flatbuffers::buffer_has_identifier(buf, ARRAY_TABLE_IDENTIFIER, true)
 }
 
 pub const ARRAY_TABLE_EXTENSION: &str = "mon";
@@ -211,11 +229,15 @@ 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>>) {
+    root: ::flatbuffers::WIPOffset<ArrayTable<'a>>
-  fbb.finish(root, Some(ARRAY_TABLE_IDENTIFIER));
+) {
+    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>>) {
+pub fn finish_size_prefixed_array_table_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
-  fbb.finish_size_prefixed(root, Some(ARRAY_TABLE_IDENTIFIER));
+    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+    root: ::flatbuffers::WIPOffset<ArrayTable<'a>>
+) {
+    fbb.finish_size_prefixed(root, Some(ARRAY_TABLE_IDENTIFIER));
 }

tests/arrays_test/my_game/example/large_array_struct_generated.rs

@@ -0,0 +1,223 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// @generated
+extern crate alloc;
+use super::*;
+
+// struct LargeArrayStruct, aligned to 8
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq)]
+pub struct LargeArrayStruct(pub [u8; 2496]);
+
+impl Default for LargeArrayStruct {
+    fn default() -> Self {
+        Self([0; 2496])
+    }
+}
+
+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())
+            .field("g", &self.g())
+            .field("h", &self.h())
+            .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(8)
+    }
+}
+
+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],
+        g: &[NestedStruct; 64],
+        h: &[TestEnum; 64],
+    ) -> Self {
+        let mut s = Self([0; 2496]);
+        s.set_d(d);
+        s.set_e(e);
+        s.set_f(f);
+        s.set_g(g);
+        s.set_h(h);
+        s
+    }
+
+    pub const fn get_fully_qualified_name() -> &'static str {
+        "MyGame.Example.LargeArrayStruct"
+    }
+
+    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 g(&'a self) -> ::flatbuffers::Array<'a, NestedStruct, 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, 384) }
+    }
+
+    pub fn set_g(&mut self, x: &[NestedStruct; 64]) {
+        // 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(384),
+                2048,
+            );
+        }
+    }
+
+    pub fn h(&'a self) -> ::flatbuffers::Array<'a, TestEnum, 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, 2432) }
+    }
+
+    pub fn set_h(&mut self, x: &[TestEnum; 64]) {
+        // 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(2432),
+                64,
+            );
+        }
+    }
+
+    pub fn unpack(&self) -> LargeArrayStructT {
+        LargeArrayStructT {
+            d: self.d().into(),
+            e: self.e().into(),
+            f: self.f().into(),
+        g: { let g = self.g(); ::flatbuffers::array_init(|i| g.get(i).unpack()) },
+            h: self.h().into(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct LargeArrayStructT {
+    pub d: [u8; 64],
+    pub e: [f32; 64],
+    pub f: [bool; 64],
+    pub g: [NestedStructT; 64],
+    pub h: [TestEnum; 64],
+}
+impl Default for LargeArrayStructT {
+    fn default() -> Self {
+        Self {
+            d: [0; 64],
+            e: [0.0; 64],
+            f: [false; 64],
+            g: ::flatbuffers::array_init(|_| Default::default()),
+            h: ::flatbuffers::array_init(|_| Default::default()),
+        }
+    }
+}
+
+impl LargeArrayStructT {
+    pub fn pack(&self) -> LargeArrayStruct {
+        LargeArrayStruct::new(
+            &self.d,
+            &self.e,
+            &self.f,
+            &::flatbuffers::array_init(|i| self.g[i].pack()),
+            &self.h,
+        )
+    }
+}

tests/arrays_test/my_game/example/nested_struct_generated.rs

@@ -2,48 +2,58 @@
 // @generated
 extern crate alloc;
 use super::*;
+
 // struct NestedStruct, aligned to 8
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq)]
 pub struct NestedStruct(pub [u8; 32]);
+
 impl Default for NestedStruct {
-  fn default() -> Self { 
+    fn default() -> Self {
-    Self([0; 32])
+        Self([0; 32])
-  }
+    }
 }
+
 impl ::core::fmt::Debug for NestedStruct {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-    f.debug_struct("NestedStruct")
+        f.debug_struct("NestedStruct")
-      .field("a", &self.a())
+            .field("a", &self.a())
-      .field("b", &self.b())
+            .field("b", &self.b())
-      .field("c", &self.c())
+            .field("c", &self.c())
-      .field("d", &self.d())
+            .field("d", &self.d())
-      .finish()
+            .finish()
-  }
+    }
 }
 
 impl ::flatbuffers::SimpleToVerifyInSlice for NestedStruct {}
+
 impl<'a> ::flatbuffers::Follow<'a> for NestedStruct {
-  type Inner = &'a NestedStruct;
+    type Inner = &'a NestedStruct;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    unsafe { <&'a NestedStruct>::follow(buf, loc) }
+    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;
+    type Inner = &'a NestedStruct;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    unsafe { ::flatbuffers::follow_cast_ref::<NestedStruct>(buf, loc) }
+    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)
@@ -51,139 +61,149 @@ impl<'b> ::flatbuffers::Push for NestedStruct {
 }
 
 impl<'a> ::flatbuffers::Verifiable for NestedStruct {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    v.in_buffer::<Self>(pos)
+        v.in_buffer::<Self>(pos)
-  }
+    }
 }
 
 impl<'a> NestedStruct {
-  #[allow(clippy::too_many_arguments)]
+    #[allow(clippy::too_many_arguments)]
-  pub fn new(
+    pub fn new(
-    a: &[i32; 2],
+        a: &[i32; 2],
-    b: TestEnum,
+        b: TestEnum,
-    c: &[TestEnum; 2],
+        c: &[TestEnum; 2],
-    d: &[i64; 2],
+        d: &[i64; 2],
-  ) -> Self {
+    ) -> Self {
-    let mut s = Self([0; 32]);
+        let mut s = Self([0; 32]);
-    s.set_a(a);
+        s.set_a(a);
-    s.set_b(b);
+        s.set_b(b);
-    s.set_c(c);
+        s.set_c(c);
-    s.set_d(d);
+        s.set_d(d);
-    s
+        s
-  }
-
-  pub const fn get_fully_qualified_name() -> &'static str {
-    "MyGame.Example.NestedStruct"
-  }
-
-  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> {
+    pub const fn get_fully_qualified_name() -> &'static str {
-    // Safety:
+        "MyGame.Example.NestedStruct"
-    // 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> {
+    pub fn a(&'a self) -> ::flatbuffers::Array<'a, i32, 2> {
-    // Safety:
+        // Safety:
-    // Created from a valid Table for this object
+        // Created from a valid Table for this object
-    // Which contains a valid array in this slot
+        // Which contains a valid array in this slot
-    use ::flatbuffers::Follow;
+        use ::flatbuffers::Follow;
-    unsafe { ::flatbuffers::Array::follow(&self.0, 16) }
+        unsafe { ::flatbuffers::Array::follow(&self.0, 0) }
-  }
+    }
-
+
-  pub fn set_d(&mut self, items: &[i64; 2]) {
+    pub fn set_a(&mut self, items: &[i32; 2]) {
-    // Safety:
+        // Safety:
-    // Created from a valid Table for this object
+        // Created from a valid Table for this object
-    // Which contains a valid array in this slot
+        // Which contains a valid array in this slot
-    unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 16, items) };
+        unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 0, items) };
-  }
+    }
-
+
-  pub fn unpack(&self) -> NestedStructT {
+    pub fn b(&self) -> TestEnum {
-    NestedStructT {
+        let mut mem = ::core::mem::MaybeUninit::<<TestEnum as ::flatbuffers::EndianScalar>::Scalar>::uninit();
-      a: self.a().into(),
+        // Safety:
-      b: self.b(),
+        // Created from a valid Table for this object
-      c: self.c().into(),
+        // Which contains a valid value in this slot
-      d: self.d().into(),
+        ::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, Default)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct NestedStructT {
-  pub a: [i32; 2],
+    pub a: [i32; 2],
-  pub b: TestEnum,
+    pub b: TestEnum,
-  pub c: [TestEnum; 2],
+    pub c: [TestEnum; 2],
-  pub d: [i64; 2],
+    pub d: [i64; 2],
 }
-impl NestedStructT {
+impl Default for NestedStructT {
-  pub fn pack(&self) -> NestedStruct {
+    fn default() -> Self {
-    NestedStruct::new(
+        Self {
-      &self.a,
+            a: [0; 2],
-      self.b,
+            b: TestEnum::A,
-      &self.c,
+            c: ::flatbuffers::array_init(|_| Default::default()),
-      &self.d,
+            d: [0; 2],
-    )
+        }
-  }
+    }
 }
 
+impl NestedStructT {
+    pub fn pack(&self) -> NestedStruct {
+        NestedStruct::new(
+            &self.a,
+            self.b,
+            &self.c,
+            &self.d,
+        )
+    }
+}

tests/arrays_test/my_game/example/test_enum_generated.rs

@@ -2,64 +2,73 @@
 // @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_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::A,
-  TestEnum::B,
+    TestEnum::B,
-  TestEnum::C,
+    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 A: Self = Self(0);
-  pub const B: Self = Self(1);
+    pub const B: Self = Self(1);
-  pub const C: Self = Self(2);
+    pub const C: Self = Self(2);
 
-  pub const ENUM_MIN: i8 = 0;
+    pub const ENUM_MIN: i8 = 0;
-  pub const ENUM_MAX: i8 = 2;
+    pub const ENUM_MAX: i8 = 2;
-  pub const ENUM_VALUES: &'static [Self] = &[
+    pub const ENUM_VALUES: &'static [Self] = &[
-    Self::A,
+        Self::A,
-    Self::B,
+        Self::B,
-    Self::C,
+        Self::C,
-  ];
+    ];
-  /// Returns the variant's name or "" if unknown.
+
-  pub fn variant_name(self) -> Option<&'static str> {
+    /// Returns the variant's name or "" if unknown.
-    match self {
+    pub fn variant_name(self) -> Option<&'static str> {
-      Self::A => Some("A"),
+        match self {
-      Self::B => Some("B"),
+            Self::A => Some("A"),
-      Self::C => Some("C"),
+            Self::B => Some("B"),
-      _ => None,
+            Self::C => Some("C"),
+            _ => None,
+        }
     }
-  }
 }
+
 impl ::core::fmt::Debug for TestEnum {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-    if let Some(name) = self.variant_name() {
+        if let Some(name) = self.variant_name() {
-      f.write_str(name)
+            f.write_str(name)
-    } else {
+        } else {
-      f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
+            f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
+        }
     }
-  }
 }
+
 impl<'a> ::flatbuffers::Follow<'a> for TestEnum {
-  type Inner = Self;
+    type Inner = Self;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    let b = unsafe { ::flatbuffers::read_scalar_at::<i8>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-    Self(b)
+        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) };
@@ -67,26 +76,28 @@ impl ::flatbuffers::Push for TestEnum {
 }
 
 impl ::flatbuffers::EndianScalar for TestEnum {
-  type Scalar = i8;
+    type Scalar = i8;
-  #[inline]
+
-  fn to_little_endian(self) -> i8 {
+    #[inline]
-    self.0.to_le()
+    fn to_little_endian(self) -> i8 {
-  }
+        self.0.to_le()
-  #[inline]
+    }
-  #[allow(clippy::wrong_self_convention)]
+
-  fn from_little_endian(v: i8) -> Self {
+    #[inline]
-    let b = i8::from_le(v);
+    #[allow(clippy::wrong_self_convention)]
-    Self(b)
+    fn from_little_endian(v: i8) -> Self {
-  }
+        let b = i8::from_le(v);
+        Self(b)
+    }
 }
 
 impl<'a> ::flatbuffers::Verifiable for TestEnum {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    i8::run_verifier(v, pos)
+        i8::run_verifier(v, pos)
-  }
+    }
 }
 
 impl ::flatbuffers::SimpleToVerifyInSlice for TestEnum {}

tests/bigfoot_ref_test.fbs

@@ -1,31 +0,0 @@
-native_include "bigfoot_ref_test_impl.h";
-
-namespace BigfootRefTestNS;
-
-// Stands in for Bigfoot's real UUID - a `native_type` struct so RefId has a
-// distinct native/flat representation, matching the shape `bigfoot_ref`
-// requires of a wrapper's payload field.
-struct RefId (native_type: "Native::RefId") {
-  value: uint64;
-}
-
-// The reference-wrapper template itself. `bigfoot_ref_wrapper` marks Ref as
-// instantiable per referenced type via `bigfoot_ref` below.
-struct Ref (bigfoot_ref_wrapper: "Native::Ref") {
-  uuid: RefId;
-}
-
-// RefHolder references two distinct C++ types (Thing, OtherThing) that are
-// *never defined anywhere in this test* - only ever forward-declared, by
-// flatc itself, directly into the generated header. This is the property
-// `bigfoot_ref` exists to provide: a reference field never requires the
-// referenced type to be complete. It also references `Thing` twice (once as
-// a plain field, once in a vector), exercising the include-guard dedup for
-// two fields that resolve to the identical Pack/UnPack pair.
-table RefHolder {
-  ref_a: Ref (native_inline, bigfoot_ref: "Native::Thing");
-  ref_a_again: [Ref] (native_inline, bigfoot_ref: "Native::Thing");
-  ref_b: Ref (native_inline, bigfoot_ref: "Native::OtherThing");
-}
-
-root_type RefHolder;

tests/bigfoot_ref_test_impl.cpp

@@ -1,47 +0,0 @@
-#include "bigfoot_ref_test_impl.h"
-
-#include "bigfoot_ref_test_generated.h"
-#include "test_assert.h"
-
-namespace flatbuffers {
-BigfootRefTestNS::RefId Pack(const Native::RefId& obj) {
-  return BigfootRefTestNS::RefId(obj.value);
-}
-
-const Native::RefId UnPack(const BigfootRefTestNS::RefId& obj) {
-  return Native::RefId(obj.value());
-}
-}  // namespace flatbuffers
-
-namespace flatbuffers {
-namespace tests {
-
-// Exercises the --bigfoot_ref/--bigfoot_ref_wrapper flatc attributes (see
-// tests/bigfoot_ref_test.fbs): a reference field never requires the
-// referenced native type to be complete, and the generated header supplies
-// its own forward declaration plus inline Pack/UnPack definitions, with no
-// hand-written boilerplate anywhere in this file for `Thing`/`OtherThing`.
-void BigfootRefTest() {
-  using BigfootRefTestNS::RefHolder;
-  using BigfootRefTestNS::RefHolderT;
-
-  RefHolderT src;
-  src.ref_a = Native::Ref<Native::Thing>(Native::RefId(1));
-  src.ref_a_again.push_back(Native::Ref<Native::Thing>(Native::RefId(2)));
-  src.ref_a_again.push_back(Native::Ref<Native::Thing>(Native::RefId(3)));
-  src.ref_b = Native::Ref<Native::OtherThing>(Native::RefId(4));
-
-  flatbuffers::FlatBufferBuilder fbb;
-  fbb.Finish(RefHolder::Pack(fbb, &src));
-
-  auto dst = BigfootRefTestNS::UnPackRefHolder(fbb.GetBufferPointer());
-
-  TEST_EQ(dst->ref_a.uuid.value, 1u);
-  TEST_EQ(dst->ref_a_again.size(), 2u);
-  TEST_EQ(dst->ref_a_again[0].uuid.value, 2u);
-  TEST_EQ(dst->ref_a_again[1].uuid.value, 3u);
-  TEST_EQ(dst->ref_b.uuid.value, 4u);
-}
-
-}  // namespace tests
-}  // namespace flatbuffers

tests/bigfoot_ref_test_impl.h

@@ -1,55 +0,0 @@
-#ifndef BIGFOOT_REF_TEST_IMPL_H
-#define BIGFOOT_REF_TEST_IMPL_H
-
-#include <cstdint>
-
-namespace Native {
-// Stands in for Bigfoot's real UUID.
-struct RefId {
-  uint64_t value;
-
-  RefId() : value(0) {}
-  explicit RefId(uint64_t _value) : value(_value) {}
-
-  bool operator==(const RefId& other) const { return value == other.value; }
-};
-
-// `Thing`/`OtherThing` are intentionally *never* defined anywhere in this
-// test (see bigfoot_ref_test.fbs) - Ref<T> must compile and round-trip
-// without T ever being a complete type, exactly like Bigfoot's
-// HardReference<T>/SoftReference<T>. Their forward declarations are emitted
-// automatically by flatc (GenerateBigfootRefForwardDecls in
-// idl_gen_cpp.cpp) directly into bigfoot_ref_test_generated.h - no manual
-// forward declaration belongs here.
-
-// The reference-wrapper template `bigfoot_ref_wrapper`/`bigfoot_ref` (see
-// idl_parser.cpp/idl_gen_cpp.cpp) instantiate per referenced type. Only
-// needs a `GetUUID()` accessor and a constructor from RefId - never needs T
-// complete.
-template <typename T>
-struct Ref {
-  RefId uuid;
-
-  Ref() : uuid() {}
-  Ref(const RefId& _uuid) : uuid(_uuid) {}
-
-  const RefId& GetUUID() const { return uuid; }
-
-  bool operator==(const Ref& other) const { return uuid == other.uuid; }
-};
-}  // namespace Native
-
-namespace BigfootRefTestNS {
-struct RefId;
-}  // namespace BigfootRefTestNS
-
-namespace flatbuffers {
-BigfootRefTestNS::RefId Pack(const Native::RefId& obj);
-const Native::RefId UnPack(const BigfootRefTestNS::RefId& obj);
-
-namespace tests {
-void BigfootRefTest();
-}  // namespace tests
-}  // namespace flatbuffers
-
-#endif  // BIGFOOT_REF_TEST_IMPL_H

tests/cpp17/generated_cpp17/monster_test_generated.h

@@ -3276,10 +3276,10 @@ inline ::flatbuffers::Offset<Monster> Monster::Pack(::flatbuffers::FlatBufferBui
   auto _test = _o->test.Pack(_fbb);
   auto _test4 = _o->test4.size() ? _fbb.CreateVectorOfStructs(_o->test4) : 0;
   auto _testarrayofstring = _o->testarrayofstring.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring) : 0;
-  auto _testarrayoftables = _o->testarrayoftables.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Example::Monster>> (_o->testarrayoftables.size(), [](size_t i, _VectorArgs *__va) { return CreateMonster(*__va->__fbb, __va->__o->testarrayoftables[i].get(), __va->__rehasher); }, &_va ) : 0;
+  auto _testarrayoftables = _o->testarrayoftables.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Example::Monster>> (_o->testarrayoftables.size(), [](size_t i, _VectorArgs *__va) { return MyGame::Example::CreateMonster(*__va->__fbb, __va->__o->testarrayoftables[i].get(), __va->__rehasher); }, &_va ) : 0;
-  auto _enemy = _o->enemy ? CreateMonster(_fbb, _o->enemy.get(), _rehasher) : 0;
+  auto _enemy = _o->enemy ? MyGame::Example::CreateMonster(_fbb, _o->enemy.get(), _rehasher) : 0;
   auto _testnestedflatbuffer = _o->testnestedflatbuffer.size() ? _fbb.CreateVector(_o->testnestedflatbuffer) : 0;
-  auto _testempty = _o->testempty ? CreateStat(_fbb, _o->testempty.get(), _rehasher) : 0;
+  auto _testempty = _o->testempty ? MyGame::Example::CreateStat(_fbb, _o->testempty.get(), _rehasher) : 0;
   auto _testbool = _o->testbool;
   auto _testhashs32_fnv1 = _o->testhashs32_fnv1;
   auto _testhashu32_fnv1 = _o->testhashu32_fnv1;
@@ -3299,11 +3299,11 @@ inline ::flatbuffers::Offset<Monster> Monster::Pack(::flatbuffers::FlatBufferBui
   auto _test5 = _o->test5.size() ? _fbb.CreateVectorOfStructs(_o->test5) : 0;
   auto _vector_of_longs = _o->vector_of_longs.size() ? _fbb.CreateVector(_o->vector_of_longs) : 0;
   auto _vector_of_doubles = _o->vector_of_doubles.size() ? _fbb.CreateVector(_o->vector_of_doubles) : 0;
-  auto _parent_namespace_test = _o->parent_namespace_test ? CreateInParentNamespace(_fbb, _o->parent_namespace_test.get(), _rehasher) : 0;
+  auto _parent_namespace_test = _o->parent_namespace_test ? MyGame::CreateInParentNamespace(_fbb, _o->parent_namespace_test.get(), _rehasher) : 0;
-  auto _vector_of_referrables = _o->vector_of_referrables.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Example::Referrable>> (_o->vector_of_referrables.size(), [](size_t i, _VectorArgs *__va) { return CreateReferrable(*__va->__fbb, __va->__o->vector_of_referrables[i].get(), __va->__rehasher); }, &_va ) : 0;
+  auto _vector_of_referrables = _o->vector_of_referrables.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Example::Referrable>> (_o->vector_of_referrables.size(), [](size_t i, _VectorArgs *__va) { return MyGame::Example::CreateReferrable(*__va->__fbb, __va->__o->vector_of_referrables[i].get(), __va->__rehasher); }, &_va ) : 0;
   auto _single_weak_reference = _rehasher ? static_cast<uint64_t>((*_rehasher)(_o->single_weak_reference)) : 0;
   auto _vector_of_weak_references = _o->vector_of_weak_references.size() ? _fbb.CreateVector<uint64_t>(_o->vector_of_weak_references.size(), [](size_t i, _VectorArgs *__va) { return __va->__rehasher ? static_cast<uint64_t>((*__va->__rehasher)(__va->__o->vector_of_weak_references[i])) : 0; }, &_va ) : 0;
-  auto _vector_of_strong_referrables = _o->vector_of_strong_referrables.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Example::Referrable>> (_o->vector_of_strong_referrables.size(), [](size_t i, _VectorArgs *__va) { return CreateReferrable(*__va->__fbb, __va->__o->vector_of_strong_referrables[i].get(), __va->__rehasher); }, &_va ) : 0;
+  auto _vector_of_strong_referrables = _o->vector_of_strong_referrables.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Example::Referrable>> (_o->vector_of_strong_referrables.size(), [](size_t i, _VectorArgs *__va) { return MyGame::Example::CreateReferrable(*__va->__fbb, __va->__o->vector_of_strong_referrables[i].get(), __va->__rehasher); }, &_va ) : 0;
   auto _co_owning_reference = _rehasher ? static_cast<uint64_t>((*_rehasher)(_o->co_owning_reference)) : 0;
   auto _vector_of_co_owning_references = _o->vector_of_co_owning_references.size() ? _fbb.CreateVector<uint64_t>(_o->vector_of_co_owning_references.size(), [](size_t i, _VectorArgs *__va) { return __va->__rehasher ? static_cast<uint64_t>((*__va->__rehasher)(__va->__o->vector_of_co_owning_references[i].get())) : 0; }, &_va ) : 0;
   auto _non_owning_reference = _rehasher ? static_cast<uint64_t>((*_rehasher)(_o->non_owning_reference)) : 0;
@@ -3315,7 +3315,7 @@ inline ::flatbuffers::Offset<Monster> Monster::Pack(::flatbuffers::FlatBufferBui
   auto _vector_of_enums = _o->vector_of_enums.size() ? _fbb.CreateVector(_o->vector_of_enums) : 0;
   auto _signed_enum = _o->signed_enum;
   auto _testrequirednestedflatbuffer = _o->testrequirednestedflatbuffer.size() ? _fbb.CreateVector(_o->testrequirednestedflatbuffer) : 0;
-  auto _scalar_key_sorted_tables = _o->scalar_key_sorted_tables.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Example::Stat>> (_o->scalar_key_sorted_tables.size(), [](size_t i, _VectorArgs *__va) { return CreateStat(*__va->__fbb, __va->__o->scalar_key_sorted_tables[i].get(), __va->__rehasher); }, &_va ) : 0;
+  auto _scalar_key_sorted_tables = _o->scalar_key_sorted_tables.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Example::Stat>> (_o->scalar_key_sorted_tables.size(), [](size_t i, _VectorArgs *__va) { return MyGame::Example::CreateStat(*__va->__fbb, __va->__o->scalar_key_sorted_tables[i].get(), __va->__rehasher); }, &_va ) : 0;
   auto _native_inline = &_o->native_inline;
   auto _long_enum_non_enum_default = _o->long_enum_non_enum_default;
   auto _long_enum_normal_default = _o->long_enum_normal_default;

tests/cpp_vector_type.fbs

@@ -1,29 +0,0 @@
-// Schema used to test the --cpp-vector-type flatc option, which lets the
-// generated Object API use a custom vector-like container (e.g.
-// eastl::vector) instead of std::vector. See tests/test_vector_type.h for
-// the stand-in container used by the test, and
-// tests/cpp_vector_type_test.cpp for the test itself.
-
-namespace CppVectorTypeNS;
-
-enum CppVectorTypeColor : byte { Red = 0, Green, Blue }
-
-struct CppVectorTypeVec2 {
-  x: float;
-  y: float;
-}
-
-table CppVectorTypeMonster {
-  id: int32;
-}
-
-table CppVectorTypeTest {
-  ints: [int32];
-  flags: [bool];
-  colors: [CppVectorTypeColor];
-  strings: [string];
-  positions: [CppVectorTypeVec2];
-  monsters: [CppVectorTypeMonster];
-}
-
-root_type CppVectorTypeTest;

tests/cpp_vector_type_test.cpp

@@ -1,143 +0,0 @@
-#include "cpp_vector_type_test.h"
-
-#include "cpp_vector_type_generated.h"
-#include "test_assert.h"
-
-namespace flatbuffers {
-namespace tests {
-
-// Exercises the --cpp-vector-type flatc option (see
-// tests/cpp_vector_type.fbs and tests/test_vector_type.h), which replaces
-// std::vector with a custom vector-like container in the generated Object
-// API. This covers every CreateVector*-family code path in Pack(): plain
-// scalars, bool, enum-cast, vector-of-string, vector-of-struct and
-// vector-of-table, then round-trips everything back through UnPackTo().
-void CppVectorTypeTest() {
-  using CppVectorTypeNS::CppVectorTypeColor_Blue;
-  using CppVectorTypeNS::CppVectorTypeColor_Green;
-  using CppVectorTypeNS::CppVectorTypeColor_Red;
-  using CppVectorTypeNS::CppVectorTypeMonsterT;
-  using CppVectorTypeNS::CppVectorTypeTest;
-  using CppVectorTypeNS::CppVectorTypeTestT;
-  using CppVectorTypeNS::CppVectorTypeVec2;
-
-  // ---------------------------------------
-  // 1) Build a native object using the custom vector container for every
-  //    vector field (scalars, bools, enums, strings, structs and tables).
-  // ---------------------------------------
-  CppVectorTypeTestT src;
-  src.ints.push_back(1);
-  src.ints.push_back(2);
-  src.ints.push_back(3);
-
-  src.flags.push_back(true);
-  src.flags.push_back(false);
-  src.flags.push_back(true);
-
-  src.colors.push_back(CppVectorTypeColor_Red);
-  src.colors.push_back(CppVectorTypeColor_Green);
-  src.colors.push_back(CppVectorTypeColor_Blue);
-
-  src.strings.push_back("hello");
-  src.strings.push_back("world");
-
-  src.positions.push_back(CppVectorTypeVec2(1.0f, 2.0f));
-  src.positions.push_back(CppVectorTypeVec2(3.0f, 4.0f));
-
-  src.monsters.emplace_back(new CppVectorTypeMonsterT());
-  src.monsters[0]->id = 111;
-  src.monsters.emplace_back(new CppVectorTypeMonsterT());
-  src.monsters[1]->id = 222;
-
-  // ---------------------------------------
-  // 2) Exercise the copy constructor / copy assignment operator generated
-  //    for object-API types (--gen-compare requires these too), which rely
-  //    on the custom vector's own copy ctor plus reserve()/emplace_back()
-  //    for the vector-of-pointer (table) field.
-  // ---------------------------------------
-  CppVectorTypeTestT copy_of_src(src);
-  TEST_EQ(copy_of_src == src, true);
-  TEST_ASSERT(copy_of_src.monsters[0].get() != src.monsters[0].get());
-  TEST_EQ(copy_of_src.monsters[0]->id, 111);
-
-  // ---------------------------------------
-  // 3) Pack into a FlatBuffer and verify the wire-format contents.
-  // ---------------------------------------
-  flatbuffers::FlatBufferBuilder fbb;
-  fbb.Finish(CppVectorTypeTest::Pack(fbb, &src));
-
-  const auto* fb =
-      flatbuffers::GetRoot<CppVectorTypeTest>(fbb.GetBufferPointer());
-
-  TEST_EQ(fb->ints()->size(), 3u);
-  TEST_EQ(fb->ints()->Get(0), 1);
-  TEST_EQ(fb->ints()->Get(1), 2);
-  TEST_EQ(fb->ints()->Get(2), 3);
-
-  TEST_EQ(fb->flags()->size(), 3u);
-  TEST_EQ(fb->flags()->Get(0) != 0, true);
-  TEST_EQ(fb->flags()->Get(1) != 0, false);
-  TEST_EQ(fb->flags()->Get(2) != 0, true);
-
-  TEST_EQ(fb->colors()->size(), 3u);
-  TEST_EQ(fb->colors()->Get(0), CppVectorTypeColor_Red);
-  TEST_EQ(fb->colors()->Get(1), CppVectorTypeColor_Green);
-  TEST_EQ(fb->colors()->Get(2), CppVectorTypeColor_Blue);
-
-  TEST_EQ(fb->strings()->size(), 2u);
-  TEST_EQ_STR(fb->strings()->Get(0)->c_str(), "hello");
-  TEST_EQ_STR(fb->strings()->Get(1)->c_str(), "world");
-
-  TEST_EQ(fb->positions()->size(), 2u);
-  TEST_EQ(fb->positions()->Get(0)->x(), 1.0f);
-  TEST_EQ(fb->positions()->Get(0)->y(), 2.0f);
-  TEST_EQ(fb->positions()->Get(1)->x(), 3.0f);
-  TEST_EQ(fb->positions()->Get(1)->y(), 4.0f);
-
-  TEST_EQ(fb->monsters()->size(), 2u);
-  TEST_EQ(fb->monsters()->Get(0)->id(), 111);
-  TEST_EQ(fb->monsters()->Get(1)->id(), 222);
-
-  // ---------------------------------------
-  // 4) Unpack back into a fresh native object and verify a full round-trip
-  //    through the custom vector container.
-  // ---------------------------------------
-  CppVectorTypeTestT dst;
-  fb->UnPackTo(&dst);
-
-  TEST_EQ(dst == src, true);
-
-  TEST_EQ(dst.ints.size(), 3u);
-  TEST_EQ(dst.ints[0], 1);
-  TEST_EQ(dst.ints[1], 2);
-  TEST_EQ(dst.ints[2], 3);
-
-  TEST_EQ(dst.flags.size(), 3u);
-  TEST_EQ(dst.flags[0], true);
-  TEST_EQ(dst.flags[1], false);
-  TEST_EQ(dst.flags[2], true);
-
-  TEST_EQ(dst.colors.size(), 3u);
-  TEST_EQ(dst.colors[0], CppVectorTypeColor_Red);
-  TEST_EQ(dst.colors[1], CppVectorTypeColor_Green);
-  TEST_EQ(dst.colors[2], CppVectorTypeColor_Blue);
-
-  TEST_EQ(dst.strings.size(), 2u);
-  TEST_EQ_STR(dst.strings[0].c_str(), "hello");
-  TEST_EQ_STR(dst.strings[1].c_str(), "world");
-
-  TEST_EQ(dst.positions.size(), 2u);
-  TEST_EQ(dst.positions[0].x(), 1.0f);
-  TEST_EQ(dst.positions[0].y(), 2.0f);
-  TEST_EQ(dst.positions[1].x(), 3.0f);
-  TEST_EQ(dst.positions[1].y(), 4.0f);
-
-  TEST_EQ(dst.monsters.size(), 2u);
-  TEST_ASSERT(dst.monsters[0] != nullptr);
-  TEST_ASSERT(dst.monsters[1] != nullptr);
-  TEST_EQ(dst.monsters[0]->id, 111);
-  TEST_EQ(dst.monsters[1]->id, 222);
-}
-
-}  // namespace tests
-}  // namespace flatbuffers

tests/cpp_vector_type_test.h

@@ -1,12 +0,0 @@
-#ifndef TESTS_CPP_VECTOR_TYPE_TEST_H
-#define TESTS_CPP_VECTOR_TYPE_TEST_H
-
-namespace flatbuffers {
-namespace tests {
-
-void CppVectorTypeTest();
-
-}  // namespace tests
-}  // namespace flatbuffers
-
-#endif  // TESTS_CPP_VECTOR_TYPE_TEST_H

tests/cross_namespace_pack_test.fbs

@@ -0,0 +1,18 @@
+// Test for cross-namespace Pack() code generation (issue #8948).
+// Verifies that Create* calls in Pack() are properly namespace-qualified
+// when referencing tables from different namespaces.
+
+namespace native;
+
+table TableWithNative {
+  value: int;
+}
+
+namespace foo;
+
+table Consumer {
+  c1: native.TableWithNative;
+  c2: [native.TableWithNative];
+}
+
+root_type Consumer;

tests/even_more_defaults.fbs

@@ -0,0 +1,23 @@
+
+enum ABC: int { A, B, C }
+
+struct EvenMoreStruct {
+  g:[int64:2];
+}
+
+table EvenMoreDefaults {
+  str: EvenMoreStruct;
+  ints: [int] = [];
+  floats: [float] = [     ];
+  float_optional: [float];
+  bytes_optional: [ubyte];
+  floats_required: [float] (required);
+  empty_string: string = "";
+  some_string: string = "some";
+  zero_string: string = "0";
+  a_string:string (key);
+  required_string: string (required);
+  abcs: [ABC] = [];
+  bools: [bool] = [];
+  one_bool: bool = true;
+}

tests/include_test1/mod.rs

@@ -1,16 +1,16 @@
 // Automatically generated by the Flatbuffers compiler. Do not modify.
 // @generated
 pub mod my_game {
-  use super::*;
-  pub mod other_name_space {
     use super::*;
-    mod from_include_generated;
+    pub mod other_name_space {
-    pub use self::from_include_generated::*;
+        use super::*;
-    mod unused_generated;
+        mod from_include_generated;
-    pub use self::unused_generated::*;
+        pub use self::from_include_generated::*;
-    mod table_b_generated;
+        mod unused_generated;
-    pub use self::table_b_generated::*;
+        pub use self::unused_generated::*;
-  } // other_name_space
+        mod table_b_generated;
+        pub use self::table_b_generated::*;
+    } // other_name_space
 } // my_game
 mod table_a_generated;
 pub use self::table_a_generated::*;

tests/include_test1/my_game/other_name_space/from_include_generated.rs

@@ -2,56 +2,65 @@
 // @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_FROM_INCLUDE: i64 = 0;
+
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 pub const ENUM_MAX_FROM_INCLUDE: i64 = 0;
+
 #[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_FROM_INCLUDE: [FromInclude; 1] = [
-  FromInclude::IncludeVal,
+    FromInclude::IncludeVal,
 ];
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct FromInclude(pub i64);
+
 #[allow(non_upper_case_globals)]
 impl FromInclude {
-  pub const IncludeVal: Self = Self(0);
+    pub const IncludeVal: Self = Self(0);
 
-  pub const ENUM_MIN: i64 = 0;
+    pub const ENUM_MIN: i64 = 0;
-  pub const ENUM_MAX: i64 = 0;
+    pub const ENUM_MAX: i64 = 0;
-  pub const ENUM_VALUES: &'static [Self] = &[
+    pub const ENUM_VALUES: &'static [Self] = &[
-    Self::IncludeVal,
+        Self::IncludeVal,
-  ];
+    ];
-  /// Returns the variant's name or "" if unknown.
+
-  pub fn variant_name(self) -> Option<&'static str> {
+    /// Returns the variant's name or "" if unknown.
-    match self {
+    pub fn variant_name(self) -> Option<&'static str> {
-      Self::IncludeVal => Some("IncludeVal"),
+        match self {
-      _ => None,
+            Self::IncludeVal => Some("IncludeVal"),
+            _ => None,
+        }
     }
-  }
 }
+
 impl ::core::fmt::Debug for FromInclude {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-    if let Some(name) = self.variant_name() {
+        if let Some(name) = self.variant_name() {
-      f.write_str(name)
+            f.write_str(name)
-    } else {
+        } else {
-      f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
+            f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
+        }
     }
-  }
 }
+
 impl<'a> ::flatbuffers::Follow<'a> for FromInclude {
-  type Inner = Self;
+    type Inner = Self;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    let b = unsafe { ::flatbuffers::read_scalar_at::<i64>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-    Self(b)
+        let b = unsafe { ::flatbuffers::read_scalar_at::<i64>(buf, loc) };
-  }
+        Self(b)
+    }
 }
 
 impl ::flatbuffers::Push for FromInclude {
     type Output = FromInclude;
+
     #[inline]
     unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
         unsafe { ::flatbuffers::emplace_scalar::<i64>(dst, self.0) };
@@ -59,26 +68,28 @@ impl ::flatbuffers::Push for FromInclude {
 }
 
 impl ::flatbuffers::EndianScalar for FromInclude {
-  type Scalar = i64;
+    type Scalar = i64;
-  #[inline]
+
-  fn to_little_endian(self) -> i64 {
+    #[inline]
-    self.0.to_le()
+    fn to_little_endian(self) -> i64 {
-  }
+        self.0.to_le()
-  #[inline]
+    }
-  #[allow(clippy::wrong_self_convention)]
+
-  fn from_little_endian(v: i64) -> Self {
+    #[inline]
-    let b = i64::from_le(v);
+    #[allow(clippy::wrong_self_convention)]
-    Self(b)
+    fn from_little_endian(v: i64) -> Self {
-  }
+        let b = i64::from_le(v);
+        Self(b)
+    }
 }
 
 impl<'a> ::flatbuffers::Verifiable for FromInclude {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    i64::run_verifier(v, pos)
+        i64::run_verifier(v, pos)
-  }
+    }
 }
 
 impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {}

tests/include_test1/my_game/other_name_space/table_b_generated.rs

@@ -2,136 +2,147 @@
 // @generated
 extern crate alloc;
 use super::*;
-pub enum TableBOffset {}
-#[derive(Copy, Clone, PartialEq)]
 
+pub enum TableBOffset {}
+
+#[derive(Copy, Clone, PartialEq)]
 pub struct TableB<'a> {
-  pub _tab: ::flatbuffers::Table<'a>,
+    pub _tab: ::flatbuffers::Table<'a>,
 }
 
 impl<'a> ::flatbuffers::Follow<'a> for TableB<'a> {
-  type Inner = TableB<'a>;
+    type Inner = TableB<'a>;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-  }
+        Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    }
 }
 
 impl<'a> TableB<'a> {
-  pub const VT_A: ::flatbuffers::VOffsetT = 4;
+    pub const VT_A: ::flatbuffers::VOffsetT = 4;
 
-  pub const fn get_fully_qualified_name() -> &'static str {
+    pub const fn get_fully_qualified_name() -> &'static str {
-    "MyGame.OtherNameSpace.TableB"
+        "MyGame.OtherNameSpace.TableB"
-  }
-
-  #[inline]
-  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-    TableB { _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 TableBArgs<'args>
-  ) -> ::flatbuffers::WIPOffset<TableB<'bldr>> {
-    let mut builder = TableBBuilder::new(_fbb);
-    if let Some(x) = args.a { builder.add_a(x); }
-    builder.finish()
-  }
-
-  pub fn unpack(&self) -> TableBT {
-    let a = self.a().map(|x| {
-      alloc::boxed::Box::new(x.unpack())
-    });
-    TableBT {
-      a,
     }
-  }
 
-  #[inline]
+    #[inline]
-  pub fn a(&self) -> Option<super::super::TableA<'a>> {
+    pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-    // Safety:
+        TableB { _tab: table }
-    // Created from valid Table for this object
+    }
-    // which contains a valid value in this slot
+
-    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<super::super::TableA>>(TableB::VT_A, None)}
+    #[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 TableBArgs<'args>
+    ) -> ::flatbuffers::WIPOffset<TableB<'bldr>> {
+        let mut builder = TableBBuilder::new(_fbb);
+        if let Some(x) = args.a { builder.add_a(x); }
+        builder.finish()
+    }
+
+    pub fn unpack(&self) -> TableBT {
+        let a = self.a().map(|x| {
+            alloc::boxed::Box::new(x.unpack())
+        });
+        TableBT {
+            a,
+        }
+    }
+
+    #[inline]
+    pub fn a(&self) -> Option<super::super::TableA<'a>> {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<super::super::TableA>>(TableB::VT_A, None)}
+    }
 }
 
 impl ::flatbuffers::Verifiable for TableB<'_> {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    v.visit_table(pos)?
+        v.visit_table(pos)?
-     .visit_field::<::flatbuffers::ForwardsUOffset<super::super::TableA>>("a", Self::VT_A, false)?
+            .visit_field::<::flatbuffers::ForwardsUOffset<super::super::TableA>>("a", Self::VT_A, false)?
-     .finish();
+            .finish();
-    Ok(())
+        Ok(())
-  }
+    }
 }
+
 pub struct TableBArgs<'a> {
     pub a: Option<::flatbuffers::WIPOffset<super::super::TableA<'a>>>,
 }
+
 impl<'a> Default for TableBArgs<'a> {
-  #[inline]
+    #[inline]
-  fn default() -> Self {
+    fn default() -> Self {
-    TableBArgs {
+        TableBArgs {
-      a: None,
+            a: None,
+        }
     }
-  }
 }
 
 pub struct TableBBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
-  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+    fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+    start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
 }
+
 impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> {
-  #[inline]
+    #[inline]
-  pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset<super::super::TableA<'b >>) {
+    pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset<super::super::TableA<'b >>) {
-    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a);
+        self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a);
-  }
+    }
-  #[inline]
+
-  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> {
+    #[inline]
-    let start = _fbb.start_table();
+    pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> {
-    TableBBuilder {
+        let start = _fbb.start_table();
-      fbb_: _fbb,
+        TableBBuilder {
-      start_: start,
+            fbb_: _fbb,
+            start_: start,
+        }
+    }
+
+    #[inline]
+    pub fn finish(self) -> ::flatbuffers::WIPOffset<TableB<'a>> {
+        let o = self.fbb_.end_table(self.start_);
+        ::flatbuffers::WIPOffset::new(o.value())
     }
-  }
-  #[inline]
-  pub fn finish(self) -> ::flatbuffers::WIPOffset<TableB<'a>> {
-    let o = self.fbb_.end_table(self.start_);
-    ::flatbuffers::WIPOffset::new(o.value())
-  }
 }
 
 impl ::core::fmt::Debug for TableB<'_> {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-    let mut ds = f.debug_struct("TableB");
+        let mut ds = f.debug_struct("TableB");
-      ds.field("a", &self.a());
+        ds.field("a", &self.a());
-      ds.finish()
+        ds.finish()
-  }
+    }
 }
+
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub struct TableBT {
-  pub a: Option<alloc::boxed::Box<super::super::TableAT>>,
+    pub a: Option<alloc::boxed::Box<super::super::TableAT>>,
 }
+
 impl Default for TableBT {
-  fn default() -> Self {
+    fn default() -> Self {
-    Self {
+        Self {
-      a: None,
+            a: None,
+        }
     }
-  }
 }
+
 impl TableBT {
-  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
+    pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
-    &self,
+        &self,
-    _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
+        _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
-  ) -> ::flatbuffers::WIPOffset<TableB<'b>> {
+    ) -> ::flatbuffers::WIPOffset<TableB<'b>> {
-    let a = self.a.as_ref().map(|x|{
+        let a = self.a.as_ref().map(|x|{
-      x.pack(_fbb)
+            x.pack(_fbb)
-    });
+        });
-    TableB::create(_fbb, &TableBArgs{
+        TableB::create(_fbb, &TableBArgs{
-      a,
+            a,
-    })
+        })
-  }
+    }
 }

tests/include_test1/my_game/other_name_space/unused_generated.rs

@@ -2,45 +2,55 @@
 // @generated
 extern crate alloc;
 use super::*;
+
 // struct Unused, aligned to 4
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq)]
 pub struct Unused(pub [u8; 4]);
+
 impl Default for Unused {
-  fn default() -> Self { 
+    fn default() -> Self {
-    Self([0; 4])
+        Self([0; 4])
-  }
+    }
 }
+
 impl ::core::fmt::Debug for Unused {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-    f.debug_struct("Unused")
+        f.debug_struct("Unused")
-      .field("a", &self.a())
+            .field("a", &self.a())
-      .finish()
+            .finish()
-  }
+    }
 }
 
 impl ::flatbuffers::SimpleToVerifyInSlice for Unused {}
+
 impl<'a> ::flatbuffers::Follow<'a> for Unused {
-  type Inner = &'a Unused;
+    type Inner = &'a Unused;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    unsafe { <&'a Unused>::follow(buf, loc) }
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-  }
+        unsafe { <&'a Unused>::follow(buf, loc) }
+    }
 }
+
 impl<'a> ::flatbuffers::Follow<'a> for &'a Unused {
-  type Inner = &'a Unused;
+    type Inner = &'a Unused;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    unsafe { ::flatbuffers::follow_cast_ref::<Unused>(buf, loc) }
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-  }
+        unsafe { ::flatbuffers::follow_cast_ref::<Unused>(buf, loc) }
+    }
 }
+
 impl<'b> ::flatbuffers::Push for Unused {
     type Output = Unused;
+
     #[inline]
     unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
         let src = unsafe { ::core::slice::from_raw_parts(self as *const Unused as *const u8, <Self as ::flatbuffers::Push>::size()) };
         dst.copy_from_slice(src);
     }
+
     #[inline]
     fn alignment() -> ::flatbuffers::PushAlignment {
         ::flatbuffers::PushAlignment::new(4)
@@ -48,73 +58,80 @@ impl<'b> ::flatbuffers::Push for Unused {
 }
 
 impl<'a> ::flatbuffers::Verifiable for Unused {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    v.in_buffer::<Self>(pos)
+        v.in_buffer::<Self>(pos)
-  }
+    }
 }
 
 impl<'a> Unused {
-  #[allow(clippy::too_many_arguments)]
+    #[allow(clippy::too_many_arguments)]
-  pub fn new(
+    pub fn new(
-    a: i32,
+        a: i32,
-  ) -> Self {
+    ) -> Self {
-    let mut s = Self([0; 4]);
+        let mut s = Self([0; 4]);
-    s.set_a(a);
+        s.set_a(a);
-    s
+        s
-  }
-
-  pub const fn get_fully_qualified_name() -> &'static str {
-    "MyGame.OtherNameSpace.Unused"
-  }
-
-  pub fn a(&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[0..].as_ptr(),
-        mem.as_mut_ptr() as *mut u8,
-        ::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
-      );
-      mem.assume_init()
-    })
-  }
-
-  pub fn set_a(&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[0..].as_mut_ptr(),
-        ::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
-      );
     }
-  }
 
-  pub fn unpack(&self) -> UnusedT {
+    pub const fn get_fully_qualified_name() -> &'static str {
-    UnusedT {
+        "MyGame.OtherNameSpace.Unused"
-      a: self.a(),
+    }
+
+    pub fn a(&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[0..].as_ptr(),
+                mem.as_mut_ptr() as *mut u8,
+                ::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
+            );
+            mem.assume_init()
+        })
+    }
+
+    pub fn set_a(&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[0..].as_mut_ptr(),
+                ::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
+            );
+        }
+    }
+
+    pub fn unpack(&self) -> UnusedT {
+        UnusedT {
+            a: self.a(),
+        }
     }
-  }
 }
 
-#[derive(Debug, Clone, PartialEq, Default)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct UnusedT {
-  pub a: i32,
+    pub a: i32,
 }
-impl UnusedT {
+impl Default for UnusedT {
-  pub fn pack(&self) -> Unused {
+    fn default() -> Self {
-    Unused::new(
+        Self {
-      self.a,
+            a: 0,
-    )
+        }
-  }
+    }
 }
 
+impl UnusedT {
+    pub fn pack(&self) -> Unused {
+        Unused::new(
+            self.a,
+        )
+    }
+}

tests/include_test1/table_a_generated.rs

@@ -2,136 +2,147 @@
 // @generated
 extern crate alloc;
 use super::*;
-pub enum TableAOffset {}
-#[derive(Copy, Clone, PartialEq)]
 
+pub enum TableAOffset {}
+
+#[derive(Copy, Clone, PartialEq)]
 pub struct TableA<'a> {
-  pub _tab: ::flatbuffers::Table<'a>,
+    pub _tab: ::flatbuffers::Table<'a>,
 }
 
 impl<'a> ::flatbuffers::Follow<'a> for TableA<'a> {
-  type Inner = TableA<'a>;
+    type Inner = TableA<'a>;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-  }
+        Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    }
 }
 
 impl<'a> TableA<'a> {
-  pub const VT_B: ::flatbuffers::VOffsetT = 4;
+    pub const VT_B: ::flatbuffers::VOffsetT = 4;
 
-  pub const fn get_fully_qualified_name() -> &'static str {
+    pub const fn get_fully_qualified_name() -> &'static str {
-    "TableA"
+        "TableA"
-  }
-
-  #[inline]
-  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-    TableA { _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 TableAArgs<'args>
-  ) -> ::flatbuffers::WIPOffset<TableA<'bldr>> {
-    let mut builder = TableABuilder::new(_fbb);
-    if let Some(x) = args.b { builder.add_b(x); }
-    builder.finish()
-  }
-
-  pub fn unpack(&self) -> TableAT {
-    let b = self.b().map(|x| {
-      alloc::boxed::Box::new(x.unpack())
-    });
-    TableAT {
-      b,
     }
-  }
 
-  #[inline]
+    #[inline]
-  pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> {
+    pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-    // Safety:
+        TableA { _tab: table }
-    // Created from valid Table for this object
+    }
-    // which contains a valid value in this slot
+
-    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>(TableA::VT_B, None)}
+    #[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 TableAArgs<'args>
+    ) -> ::flatbuffers::WIPOffset<TableA<'bldr>> {
+        let mut builder = TableABuilder::new(_fbb);
+        if let Some(x) = args.b { builder.add_b(x); }
+        builder.finish()
+    }
+
+    pub fn unpack(&self) -> TableAT {
+        let b = self.b().map(|x| {
+            alloc::boxed::Box::new(x.unpack())
+        });
+        TableAT {
+            b,
+        }
+    }
+
+    #[inline]
+    pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>(TableA::VT_B, None)}
+    }
 }
 
 impl ::flatbuffers::Verifiable for TableA<'_> {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    v.visit_table(pos)?
+        v.visit_table(pos)?
-     .visit_field::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>("b", Self::VT_B, false)?
+            .visit_field::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>("b", Self::VT_B, false)?
-     .finish();
+            .finish();
-    Ok(())
+        Ok(())
-  }
+    }
 }
+
 pub struct TableAArgs<'a> {
     pub b: Option<::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'a>>>,
 }
+
 impl<'a> Default for TableAArgs<'a> {
-  #[inline]
+    #[inline]
-  fn default() -> Self {
+    fn default() -> Self {
-    TableAArgs {
+        TableAArgs {
-      b: None,
+            b: None,
+        }
     }
-  }
 }
 
 pub struct TableABuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
-  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+    fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+    start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
 }
+
 impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableABuilder<'a, 'b, A> {
-  #[inline]
+    #[inline]
-  pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) {
+    pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) {
-    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b);
+        self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b);
-  }
+    }
-  #[inline]
+
-  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
+    #[inline]
-    let start = _fbb.start_table();
+    pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
-    TableABuilder {
+        let start = _fbb.start_table();
-      fbb_: _fbb,
+        TableABuilder {
-      start_: start,
+            fbb_: _fbb,
+            start_: start,
+        }
+    }
+
+    #[inline]
+    pub fn finish(self) -> ::flatbuffers::WIPOffset<TableA<'a>> {
+        let o = self.fbb_.end_table(self.start_);
+        ::flatbuffers::WIPOffset::new(o.value())
     }
-  }
-  #[inline]
-  pub fn finish(self) -> ::flatbuffers::WIPOffset<TableA<'a>> {
-    let o = self.fbb_.end_table(self.start_);
-    ::flatbuffers::WIPOffset::new(o.value())
-  }
 }
 
 impl ::core::fmt::Debug for TableA<'_> {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-    let mut ds = f.debug_struct("TableA");
+        let mut ds = f.debug_struct("TableA");
-      ds.field("b", &self.b());
+        ds.field("b", &self.b());
-      ds.finish()
+        ds.finish()
-  }
+    }
 }
+
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub struct TableAT {
-  pub b: Option<alloc::boxed::Box<my_game::other_name_space::TableBT>>,
+    pub b: Option<alloc::boxed::Box<my_game::other_name_space::TableBT>>,
 }
+
 impl Default for TableAT {
-  fn default() -> Self {
+    fn default() -> Self {
-    Self {
+        Self {
-      b: None,
+            b: None,
+        }
     }
-  }
 }
+
 impl TableAT {
-  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
+    pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
-    &self,
+        &self,
-    _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
+        _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
-  ) -> ::flatbuffers::WIPOffset<TableA<'b>> {
+    ) -> ::flatbuffers::WIPOffset<TableA<'b>> {
-    let b = self.b.as_ref().map(|x|{
+        let b = self.b.as_ref().map(|x|{
-      x.pack(_fbb)
+            x.pack(_fbb)
-    });
+        });
-    TableA::create(_fbb, &TableAArgs{
+        TableA::create(_fbb, &TableAArgs{
-      b,
+            b,
-    })
+        })
-  }
+    }
 }

tests/include_test1_generated.rs

@@ -1,479 +1,525 @@
 // automatically generated by the FlatBuffers compiler, do not modify
 // @generated
-
 extern crate alloc;
 
 pub enum TableAOffset {}
-#[derive(Copy, Clone, PartialEq)]
 
+#[derive(Copy, Clone, PartialEq)]
 pub struct TableA<'a> {
-  pub _tab: ::flatbuffers::Table<'a>,
+    pub _tab: ::flatbuffers::Table<'a>,
 }
 
 impl<'a> ::flatbuffers::Follow<'a> for TableA<'a> {
-  type Inner = TableA<'a>;
+    type Inner = TableA<'a>;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-  }
+        Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    }
 }
 
 impl<'a> TableA<'a> {
-  pub const VT_B: ::flatbuffers::VOffsetT = 4;
+    pub const VT_B: ::flatbuffers::VOffsetT = 4;
 
-  pub const fn get_fully_qualified_name() -> &'static str {
+    pub const fn get_fully_qualified_name() -> &'static str {
-    "TableA"
+        "TableA"
-  }
-
-  #[inline]
-  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-    TableA { _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 TableAArgs<'args>
-  ) -> ::flatbuffers::WIPOffset<TableA<'bldr>> {
-    let mut builder = TableABuilder::new(_fbb);
-    if let Some(x) = args.b { builder.add_b(x); }
-    builder.finish()
-  }
-
-  pub fn unpack(&self) -> TableAT {
-    let b = self.b().map(|x| {
-      alloc::boxed::Box::new(x.unpack())
-    });
-    TableAT {
-      b,
     }
-  }
 
-  #[inline]
+    #[inline]
-  pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> {
+    pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-    // Safety:
+        TableA { _tab: table }
-    // Created from valid Table for this object
+    }
-    // which contains a valid value in this slot
+
-    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>(TableA::VT_B, None)}
+    #[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 TableAArgs<'args>
+    ) -> ::flatbuffers::WIPOffset<TableA<'bldr>> {
+        let mut builder = TableABuilder::new(_fbb);
+        if let Some(x) = args.b { builder.add_b(x); }
+        builder.finish()
+    }
+
+    pub fn unpack(&self) -> TableAT {
+        let b = self.b().map(|x| {
+            alloc::boxed::Box::new(x.unpack())
+        });
+        TableAT {
+            b,
+        }
+    }
+
+    #[inline]
+    pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>(TableA::VT_B, None)}
+    }
 }
 
 impl ::flatbuffers::Verifiable for TableA<'_> {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    v.visit_table(pos)?
+        v.visit_table(pos)?
-     .visit_field::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>("b", Self::VT_B, false)?
+            .visit_field::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>("b", Self::VT_B, false)?
-     .finish();
+            .finish();
-    Ok(())
+        Ok(())
-  }
+    }
 }
+
 pub struct TableAArgs<'a> {
     pub b: Option<::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'a>>>,
 }
+
 impl<'a> Default for TableAArgs<'a> {
-  #[inline]
+    #[inline]
-  fn default() -> Self {
+    fn default() -> Self {
-    TableAArgs {
+        TableAArgs {
-      b: None,
+            b: None,
+        }
     }
-  }
 }
 
 pub struct TableABuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
-  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+    fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+    start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
 }
+
 impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableABuilder<'a, 'b, A> {
-  #[inline]
+    #[inline]
-  pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) {
+    pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) {
-    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b);
+        self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b);
-  }
+    }
-  #[inline]
+
-  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
+    #[inline]
-    let start = _fbb.start_table();
+    pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
-    TableABuilder {
+        let start = _fbb.start_table();
-      fbb_: _fbb,
+        TableABuilder {
-      start_: start,
+            fbb_: _fbb,
+            start_: start,
+        }
+    }
+
+    #[inline]
+    pub fn finish(self) -> ::flatbuffers::WIPOffset<TableA<'a>> {
+        let o = self.fbb_.end_table(self.start_);
+        ::flatbuffers::WIPOffset::new(o.value())
     }
-  }
-  #[inline]
-  pub fn finish(self) -> ::flatbuffers::WIPOffset<TableA<'a>> {
-    let o = self.fbb_.end_table(self.start_);
-    ::flatbuffers::WIPOffset::new(o.value())
-  }
 }
 
 impl ::core::fmt::Debug for TableA<'_> {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-    let mut ds = f.debug_struct("TableA");
+        let mut ds = f.debug_struct("TableA");
-      ds.field("b", &self.b());
+        ds.field("b", &self.b());
-      ds.finish()
+        ds.finish()
-  }
+    }
 }
+
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub struct TableAT {
-  pub b: Option<alloc::boxed::Box<my_game::other_name_space::TableBT>>,
+    pub b: Option<alloc::boxed::Box<my_game::other_name_space::TableBT>>,
 }
+
 impl Default for TableAT {
-  fn default() -> Self {
+    fn default() -> Self {
-    Self {
+        Self {
-      b: None,
+            b: None,
+        }
     }
-  }
 }
+
 impl TableAT {
-  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
+    pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
-    &self,
+        &self,
-    _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
+        _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
-  ) -> ::flatbuffers::WIPOffset<TableA<'b>> {
+    ) -> ::flatbuffers::WIPOffset<TableA<'b>> {
-    let b = self.b.as_ref().map(|x|{
+        let b = self.b.as_ref().map(|x|{
-      x.pack(_fbb)
+            x.pack(_fbb)
-    });
+        });
-    TableA::create(_fbb, &TableAArgs{
+        TableA::create(_fbb, &TableAArgs{
-      b,
+            b,
-    })
+        })
-  }
+    }
 }
+
 #[allow(unused_imports, dead_code)]
 pub mod my_game {
+    extern crate alloc;
 
-extern crate alloc;
+    #[allow(unused_imports, dead_code)]
-#[allow(unused_imports, dead_code)]
+    pub mod other_name_space {
-pub mod other_name_space {
+        extern crate alloc;
 
-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_FROM_INCLUDE: i64 = 0;
 
-#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
+        #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
-pub const ENUM_MIN_FROM_INCLUDE: i64 = 0;
+        pub const ENUM_MAX_FROM_INCLUDE: i64 = 0;
-#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
-pub const ENUM_MAX_FROM_INCLUDE: i64 = 0;
-#[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_FROM_INCLUDE: [FromInclude; 1] = [
-  FromInclude::IncludeVal,
-];
 
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+        #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
-#[repr(transparent)]
+        #[allow(non_camel_case_types)]
-pub struct FromInclude(pub i64);
+        pub const ENUM_VALUES_FROM_INCLUDE: [FromInclude; 1] = [
-#[allow(non_upper_case_globals)]
+            FromInclude::IncludeVal,
-impl FromInclude {
+        ];
-  pub const IncludeVal: Self = Self(0);
 
-  pub const ENUM_MIN: i64 = 0;
+        #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-  pub const ENUM_MAX: i64 = 0;
+        #[repr(transparent)]
-  pub const ENUM_VALUES: &'static [Self] = &[
+        pub struct FromInclude(pub i64);
-    Self::IncludeVal,
-  ];
-  /// Returns the variant's name or "" if unknown.
-  pub fn variant_name(self) -> Option<&'static str> {
-    match self {
-      Self::IncludeVal => Some("IncludeVal"),
-      _ => None,
-    }
-  }
-}
-impl ::core::fmt::Debug for FromInclude {
-  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 FromInclude {
-  type Inner = Self;
-  #[inline]
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-    let b = unsafe { ::flatbuffers::read_scalar_at::<i64>(buf, loc) };
-    Self(b)
-  }
-}
 
-impl ::flatbuffers::Push for FromInclude {
+        #[allow(non_upper_case_globals)]
-    type Output = FromInclude;
+        impl FromInclude {
-    #[inline]
+            pub const IncludeVal: Self = Self(0);
-    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-        unsafe { ::flatbuffers::emplace_scalar::<i64>(dst, self.0) };
-    }
-}
 
-impl ::flatbuffers::EndianScalar for FromInclude {
+            pub const ENUM_MIN: i64 = 0;
-  type Scalar = i64;
+            pub const ENUM_MAX: i64 = 0;
-  #[inline]
+            pub const ENUM_VALUES: &'static [Self] = &[
-  fn to_little_endian(self) -> i64 {
+                Self::IncludeVal,
-    self.0.to_le()
+            ];
-  }
-  #[inline]
-  #[allow(clippy::wrong_self_convention)]
-  fn from_little_endian(v: i64) -> Self {
-    let b = i64::from_le(v);
-    Self(b)
-  }
-}
 
-impl<'a> ::flatbuffers::Verifiable for FromInclude {
+            /// Returns the variant's name or "" if unknown.
-  #[inline]
+            pub fn variant_name(self) -> Option<&'static str> {
-  fn run_verifier(
+                match self {
-    v: &mut ::flatbuffers::Verifier, pos: usize
+                    Self::IncludeVal => Some("IncludeVal"),
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+                    _ => None,
-    i64::run_verifier(v, pos)
+                }
-  }
+            }
-}
+        }
 
-impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {}
+        impl ::core::fmt::Debug for FromInclude {
-// struct Unused, aligned to 4
+            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-#[repr(transparent)]
+                if let Some(name) = self.variant_name() {
-#[derive(Clone, Copy, PartialEq)]
+                    f.write_str(name)
-pub struct Unused(pub [u8; 4]);
+                } else {
-impl Default for Unused { 
+                    f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
-  fn default() -> Self { 
+                }
-    Self([0; 4])
+            }
-  }
+        }
-}
-impl ::core::fmt::Debug for Unused {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-    f.debug_struct("Unused")
-      .field("a", &self.a())
-      .finish()
-  }
-}
 
-impl ::flatbuffers::SimpleToVerifyInSlice for Unused {}
+        impl<'a> ::flatbuffers::Follow<'a> for FromInclude {
-impl<'a> ::flatbuffers::Follow<'a> for Unused {
+            type Inner = Self;
-  type Inner = &'a Unused;
-  #[inline]
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-    unsafe { <&'a Unused>::follow(buf, loc) }
-  }
-}
-impl<'a> ::flatbuffers::Follow<'a> for &'a Unused {
-  type Inner = &'a Unused;
-  #[inline]
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-    unsafe { ::flatbuffers::follow_cast_ref::<Unused>(buf, loc) }
-  }
-}
-impl<'b> ::flatbuffers::Push for Unused {
-    type Output = Unused;
-    #[inline]
-    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-        let src = unsafe { ::core::slice::from_raw_parts(self as *const Unused 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 Unused {
+            #[inline]
-  #[inline]
+            unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-  fn run_verifier(
+                let b = unsafe { ::flatbuffers::read_scalar_at::<i64>(buf, loc) };
-    v: &mut ::flatbuffers::Verifier, pos: usize
+                Self(b)
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+            }
-    v.in_buffer::<Self>(pos)
+        }
-  }
-}
 
-impl<'a> Unused {
+        impl ::flatbuffers::Push for FromInclude {
-  #[allow(clippy::too_many_arguments)]
+            type Output = FromInclude;
-  pub fn new(
-    a: i32,
-  ) -> Self {
-    let mut s = Self([0; 4]);
-    s.set_a(a);
-    s
-  }
 
-  pub const fn get_fully_qualified_name() -> &'static str {
+            #[inline]
-    "MyGame.OtherNameSpace.Unused"
+            unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-  }
+                unsafe { ::flatbuffers::emplace_scalar::<i64>(dst, self.0) };
+            }
+        }
 
-  pub fn a(&self) -> i32 {
+        impl ::flatbuffers::EndianScalar for FromInclude {
-    let mut mem = ::core::mem::MaybeUninit::<<i32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
+            type Scalar = i64;
-    // 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::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
-      );
-      mem.assume_init()
-    })
-  }
 
-  pub fn set_a(&mut self, x: i32) {
+            #[inline]
-    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
+            fn to_little_endian(self) -> i64 {
-    // Safety:
+                self.0.to_le()
-    // 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::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
-      );
-    }
-  }
 
-  pub fn unpack(&self) -> UnusedT {
+            #[inline]
-    UnusedT {
+            #[allow(clippy::wrong_self_convention)]
-      a: self.a(),
+            fn from_little_endian(v: i64) -> Self {
-    }
+                let b = i64::from_le(v);
-  }
+                Self(b)
-}
+            }
+        }
 
-#[derive(Debug, Clone, PartialEq, Default)]
+        impl<'a> ::flatbuffers::Verifiable for FromInclude {
-pub struct UnusedT {
+            #[inline]
-  pub a: i32,
+            fn run_verifier(
-}
+                v: &mut ::flatbuffers::Verifier, pos: usize
-impl UnusedT {
+            ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-  pub fn pack(&self) -> Unused {
+                i64::run_verifier(v, pos)
-    Unused::new(
+            }
-      self.a,
+        }
-    )
-  }
-}
 
-pub enum TableBOffset {}
+        impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {}
-#[derive(Copy, Clone, PartialEq)]
 
-pub struct TableB<'a> {
+        // struct Unused, aligned to 4
-  pub _tab: ::flatbuffers::Table<'a>,
+        #[repr(transparent)]
-}
+        #[derive(Clone, Copy, PartialEq)]
+        pub struct Unused(pub [u8; 4]);
 
-impl<'a> ::flatbuffers::Follow<'a> for TableB<'a> {
+        impl Default for Unused {
-  type Inner = TableB<'a>;
+            fn default() -> Self {
-  #[inline]
+                Self([0; 4])
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+            }
-    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+        }
-  }
-}
 
-impl<'a> TableB<'a> {
+        impl ::core::fmt::Debug for Unused {
-  pub const VT_A: ::flatbuffers::VOffsetT = 4;
+            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+                f.debug_struct("Unused")
+                    .field("a", &self.a())
+                    .finish()
+            }
+        }
 
-  pub const fn get_fully_qualified_name() -> &'static str {
+        impl ::flatbuffers::SimpleToVerifyInSlice for Unused {}
-    "MyGame.OtherNameSpace.TableB"
-  }
 
-  #[inline]
+        impl<'a> ::flatbuffers::Follow<'a> for Unused {
-  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+            type Inner = &'a Unused;
-    TableB { _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 TableBArgs<'args>
-  ) -> ::flatbuffers::WIPOffset<TableB<'bldr>> {
-    let mut builder = TableBBuilder::new(_fbb);
-    if let Some(x) = args.a { builder.add_a(x); }
-    builder.finish()
-  }
 
-  pub fn unpack(&self) -> TableBT {
+            #[inline]
-    let a = self.a().map(|x| {
+            unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-      alloc::boxed::Box::new(x.unpack())
+                unsafe { <&'a Unused>::follow(buf, loc) }
-    });
+            }
-    TableBT {
+        }
-      a,
-    }
-  }
 
-  #[inline]
+        impl<'a> ::flatbuffers::Follow<'a> for &'a Unused {
-  pub fn a(&self) -> Option<super::super::TableA<'a>> {
+            type Inner = &'a Unused;
-    // Safety:
-    // Created from valid Table for this object
-    // which contains a valid value in this slot
-    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<super::super::TableA>>(TableB::VT_A, None)}
-  }
-}
 
-impl ::flatbuffers::Verifiable for TableB<'_> {
+            #[inline]
-  #[inline]
+            unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-  fn run_verifier(
+                unsafe { ::flatbuffers::follow_cast_ref::<Unused>(buf, loc) }
-    v: &mut ::flatbuffers::Verifier, pos: usize
+            }
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+        }
-    v.visit_table(pos)?
-     .visit_field::<::flatbuffers::ForwardsUOffset<super::super::TableA>>("a", Self::VT_A, false)?
-     .finish();
-    Ok(())
-  }
-}
-pub struct TableBArgs<'a> {
-    pub a: Option<::flatbuffers::WIPOffset<super::super::TableA<'a>>>,
-}
-impl<'a> Default for TableBArgs<'a> {
-  #[inline]
-  fn default() -> Self {
-    TableBArgs {
-      a: None,
-    }
-  }
-}
 
-pub struct TableBBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
+        impl<'b> ::flatbuffers::Push for Unused {
-  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+            type Output = Unused;
-  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
-}
-impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> {
-  #[inline]
-  pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset<super::super::TableA<'b >>) {
-    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a);
-  }
-  #[inline]
-  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> {
-    let start = _fbb.start_table();
-    TableBBuilder {
-      fbb_: _fbb,
-      start_: start,
-    }
-  }
-  #[inline]
-  pub fn finish(self) -> ::flatbuffers::WIPOffset<TableB<'a>> {
-    let o = self.fbb_.end_table(self.start_);
-    ::flatbuffers::WIPOffset::new(o.value())
-  }
-}
 
-impl ::core::fmt::Debug for TableB<'_> {
+            #[inline]
-  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-    let mut ds = f.debug_struct("TableB");
+                let src = unsafe { ::core::slice::from_raw_parts(self as *const Unused as *const u8, <Self as ::flatbuffers::Push>::size()) };
-      ds.field("a", &self.a());
+                dst.copy_from_slice(src);
-      ds.finish()
+            }
-  }
-}
-#[non_exhaustive]
-#[derive(Debug, Clone, PartialEq)]
-pub struct TableBT {
-  pub a: Option<alloc::boxed::Box<super::super::TableAT>>,
-}
-impl Default for TableBT {
-  fn default() -> Self {
-    Self {
-      a: None,
-    }
-  }
-}
-impl TableBT {
-  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
-    &self,
-    _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
-  ) -> ::flatbuffers::WIPOffset<TableB<'b>> {
-    let a = self.a.as_ref().map(|x|{
-      x.pack(_fbb)
-    });
-    TableB::create(_fbb, &TableBArgs{
-      a,
-    })
-  }
-}
-}  // pub mod OtherNameSpace
-}  // pub mod MyGame
 
+            #[inline]
+            fn alignment() -> ::flatbuffers::PushAlignment {
+                ::flatbuffers::PushAlignment::new(4)
+            }
+        }
+
+        impl<'a> ::flatbuffers::Verifiable for Unused {
+            #[inline]
+            fn run_verifier(
+                v: &mut ::flatbuffers::Verifier, pos: usize
+            ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+                v.in_buffer::<Self>(pos)
+            }
+        }
+
+        impl<'a> Unused {
+            #[allow(clippy::too_many_arguments)]
+            pub fn new(
+                a: i32,
+            ) -> Self {
+                let mut s = Self([0; 4]);
+                s.set_a(a);
+                s
+            }
+
+            pub const fn get_fully_qualified_name() -> &'static str {
+                "MyGame.OtherNameSpace.Unused"
+            }
+
+            pub fn a(&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[0..].as_ptr(),
+                        mem.as_mut_ptr() as *mut u8,
+                        ::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
+                    );
+                    mem.assume_init()
+                })
+            }
+
+            pub fn set_a(&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[0..].as_mut_ptr(),
+                        ::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
+                    );
+                }
+            }
+
+            pub fn unpack(&self) -> UnusedT {
+                UnusedT {
+                    a: self.a(),
+                }
+            }
+        }
+
+        #[derive(Debug, Clone, PartialEq)]
+        pub struct UnusedT {
+            pub a: i32,
+        }
+        impl Default for UnusedT {
+            fn default() -> Self {
+                Self {
+                    a: 0,
+                }
+            }
+        }
+
+        impl UnusedT {
+            pub fn pack(&self) -> Unused {
+                Unused::new(
+                    self.a,
+                )
+            }
+        }
+
+        pub enum TableBOffset {}
+
+        #[derive(Copy, Clone, PartialEq)]
+        pub struct TableB<'a> {
+            pub _tab: ::flatbuffers::Table<'a>,
+        }
+
+        impl<'a> ::flatbuffers::Follow<'a> for TableB<'a> {
+            type Inner = TableB<'a>;
+
+            #[inline]
+            unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+                Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+            }
+        }
+
+        impl<'a> TableB<'a> {
+            pub const VT_A: ::flatbuffers::VOffsetT = 4;
+
+            pub const fn get_fully_qualified_name() -> &'static str {
+                "MyGame.OtherNameSpace.TableB"
+            }
+
+            #[inline]
+            pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+                TableB { _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 TableBArgs<'args>
+            ) -> ::flatbuffers::WIPOffset<TableB<'bldr>> {
+                let mut builder = TableBBuilder::new(_fbb);
+                if let Some(x) = args.a { builder.add_a(x); }
+                builder.finish()
+            }
+
+            pub fn unpack(&self) -> TableBT {
+                let a = self.a().map(|x| {
+                    alloc::boxed::Box::new(x.unpack())
+                });
+                TableBT {
+                    a,
+                }
+            }
+
+            #[inline]
+            pub fn a(&self) -> Option<super::super::TableA<'a>> {
+                // Safety:
+                // Created from valid Table for this object
+                // which contains a valid value in this slot
+                unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<super::super::TableA>>(TableB::VT_A, None)}
+            }
+        }
+
+        impl ::flatbuffers::Verifiable for TableB<'_> {
+            #[inline]
+            fn run_verifier(
+                v: &mut ::flatbuffers::Verifier, pos: usize
+            ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+                v.visit_table(pos)?
+                    .visit_field::<::flatbuffers::ForwardsUOffset<super::super::TableA>>("a", Self::VT_A, false)?
+                    .finish();
+                Ok(())
+            }
+        }
+
+        pub struct TableBArgs<'a> {
+            pub a: Option<::flatbuffers::WIPOffset<super::super::TableA<'a>>>,
+        }
+
+        impl<'a> Default for TableBArgs<'a> {
+            #[inline]
+            fn default() -> Self {
+                TableBArgs {
+                    a: None,
+                }
+            }
+        }
+
+        pub struct TableBBuilder<'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> TableBBuilder<'a, 'b, A> {
+            #[inline]
+            pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset<super::super::TableA<'b >>) {
+                self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a);
+            }
+
+            #[inline]
+            pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> {
+                let start = _fbb.start_table();
+                TableBBuilder {
+                    fbb_: _fbb,
+                    start_: start,
+                }
+            }
+
+            #[inline]
+            pub fn finish(self) -> ::flatbuffers::WIPOffset<TableB<'a>> {
+                let o = self.fbb_.end_table(self.start_);
+                ::flatbuffers::WIPOffset::new(o.value())
+            }
+        }
+
+        impl ::core::fmt::Debug for TableB<'_> {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+                let mut ds = f.debug_struct("TableB");
+                ds.field("a", &self.a());
+                ds.finish()
+            }
+        }
+
+        #[non_exhaustive]
+        #[derive(Debug, Clone, PartialEq)]
+        pub struct TableBT {
+            pub a: Option<alloc::boxed::Box<super::super::TableAT>>,
+        }
+
+        impl Default for TableBT {
+            fn default() -> Self {
+                Self {
+                    a: None,
+                }
+            }
+        }
+
+        impl TableBT {
+            pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
+                &self,
+                _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
+            ) -> ::flatbuffers::WIPOffset<TableB<'b>> {
+                let a = self.a.as_ref().map(|x|{
+                    x.pack(_fbb)
+                });
+                TableB::create(_fbb, &TableBArgs{
+                    a,
+                })
+            }
+        }
+    } // pub mod OtherNameSpace
+} // pub mod MyGame

tests/include_test2/mod.rs

@@ -1,16 +1,16 @@
 // Automatically generated by the Flatbuffers compiler. Do not modify.
 // @generated
 pub mod my_game {
-  use super::*;
-  pub mod other_name_space {
     use super::*;
-    mod from_include_generated;
+    pub mod other_name_space {
-    pub use self::from_include_generated::*;
+        use super::*;
-    mod unused_generated;
+        mod from_include_generated;
-    pub use self::unused_generated::*;
+        pub use self::from_include_generated::*;
-    mod table_b_generated;
+        mod unused_generated;
-    pub use self::table_b_generated::*;
+        pub use self::unused_generated::*;
-  } // other_name_space
+        mod table_b_generated;
+        pub use self::table_b_generated::*;
+    } // other_name_space
 } // my_game
 mod table_a_generated;
 pub use self::table_a_generated::*;

tests/include_test2/my_game/other_name_space/from_include_generated.rs

@@ -2,56 +2,65 @@
 // @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_FROM_INCLUDE: i64 = 0;
+
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 pub const ENUM_MAX_FROM_INCLUDE: i64 = 0;
+
 #[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_FROM_INCLUDE: [FromInclude; 1] = [
-  FromInclude::IncludeVal,
+    FromInclude::IncludeVal,
 ];
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct FromInclude(pub i64);
+
 #[allow(non_upper_case_globals)]
 impl FromInclude {
-  pub const IncludeVal: Self = Self(0);
+    pub const IncludeVal: Self = Self(0);
 
-  pub const ENUM_MIN: i64 = 0;
+    pub const ENUM_MIN: i64 = 0;
-  pub const ENUM_MAX: i64 = 0;
+    pub const ENUM_MAX: i64 = 0;
-  pub const ENUM_VALUES: &'static [Self] = &[
+    pub const ENUM_VALUES: &'static [Self] = &[
-    Self::IncludeVal,
+        Self::IncludeVal,
-  ];
+    ];
-  /// Returns the variant's name or "" if unknown.
+
-  pub fn variant_name(self) -> Option<&'static str> {
+    /// Returns the variant's name or "" if unknown.
-    match self {
+    pub fn variant_name(self) -> Option<&'static str> {
-      Self::IncludeVal => Some("IncludeVal"),
+        match self {
-      _ => None,
+            Self::IncludeVal => Some("IncludeVal"),
+            _ => None,
+        }
     }
-  }
 }
+
 impl ::core::fmt::Debug for FromInclude {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-    if let Some(name) = self.variant_name() {
+        if let Some(name) = self.variant_name() {
-      f.write_str(name)
+            f.write_str(name)
-    } else {
+        } else {
-      f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
+            f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
+        }
     }
-  }
 }
+
 impl<'a> ::flatbuffers::Follow<'a> for FromInclude {
-  type Inner = Self;
+    type Inner = Self;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    let b = unsafe { ::flatbuffers::read_scalar_at::<i64>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-    Self(b)
+        let b = unsafe { ::flatbuffers::read_scalar_at::<i64>(buf, loc) };
-  }
+        Self(b)
+    }
 }
 
 impl ::flatbuffers::Push for FromInclude {
     type Output = FromInclude;
+
     #[inline]
     unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
         unsafe { ::flatbuffers::emplace_scalar::<i64>(dst, self.0) };
@@ -59,26 +68,28 @@ impl ::flatbuffers::Push for FromInclude {
 }
 
 impl ::flatbuffers::EndianScalar for FromInclude {
-  type Scalar = i64;
+    type Scalar = i64;
-  #[inline]
+
-  fn to_little_endian(self) -> i64 {
+    #[inline]
-    self.0.to_le()
+    fn to_little_endian(self) -> i64 {
-  }
+        self.0.to_le()
-  #[inline]
+    }
-  #[allow(clippy::wrong_self_convention)]
+
-  fn from_little_endian(v: i64) -> Self {
+    #[inline]
-    let b = i64::from_le(v);
+    #[allow(clippy::wrong_self_convention)]
-    Self(b)
+    fn from_little_endian(v: i64) -> Self {
-  }
+        let b = i64::from_le(v);
+        Self(b)
+    }
 }
 
 impl<'a> ::flatbuffers::Verifiable for FromInclude {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    i64::run_verifier(v, pos)
+        i64::run_verifier(v, pos)
-  }
+    }
 }
 
 impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {}

tests/include_test2/my_game/other_name_space/table_b_generated.rs

@@ -2,136 +2,147 @@
 // @generated
 extern crate alloc;
 use super::*;
-pub enum TableBOffset {}
-#[derive(Copy, Clone, PartialEq)]
 
+pub enum TableBOffset {}
+
+#[derive(Copy, Clone, PartialEq)]
 pub struct TableB<'a> {
-  pub _tab: ::flatbuffers::Table<'a>,
+    pub _tab: ::flatbuffers::Table<'a>,
 }
 
 impl<'a> ::flatbuffers::Follow<'a> for TableB<'a> {
-  type Inner = TableB<'a>;
+    type Inner = TableB<'a>;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-  }
+        Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    }
 }
 
 impl<'a> TableB<'a> {
-  pub const VT_A: ::flatbuffers::VOffsetT = 4;
+    pub const VT_A: ::flatbuffers::VOffsetT = 4;
 
-  pub const fn get_fully_qualified_name() -> &'static str {
+    pub const fn get_fully_qualified_name() -> &'static str {
-    "MyGame.OtherNameSpace.TableB"
+        "MyGame.OtherNameSpace.TableB"
-  }
-
-  #[inline]
-  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-    TableB { _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 TableBArgs<'args>
-  ) -> ::flatbuffers::WIPOffset<TableB<'bldr>> {
-    let mut builder = TableBBuilder::new(_fbb);
-    if let Some(x) = args.a { builder.add_a(x); }
-    builder.finish()
-  }
-
-  pub fn unpack(&self) -> TableBT {
-    let a = self.a().map(|x| {
-      alloc::boxed::Box::new(x.unpack())
-    });
-    TableBT {
-      a,
     }
-  }
 
-  #[inline]
+    #[inline]
-  pub fn a(&self) -> Option<super::super::TableA<'a>> {
+    pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-    // Safety:
+        TableB { _tab: table }
-    // Created from valid Table for this object
+    }
-    // which contains a valid value in this slot
+
-    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<super::super::TableA>>(TableB::VT_A, None)}
+    #[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 TableBArgs<'args>
+    ) -> ::flatbuffers::WIPOffset<TableB<'bldr>> {
+        let mut builder = TableBBuilder::new(_fbb);
+        if let Some(x) = args.a { builder.add_a(x); }
+        builder.finish()
+    }
+
+    pub fn unpack(&self) -> TableBT {
+        let a = self.a().map(|x| {
+            alloc::boxed::Box::new(x.unpack())
+        });
+        TableBT {
+            a,
+        }
+    }
+
+    #[inline]
+    pub fn a(&self) -> Option<super::super::TableA<'a>> {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<super::super::TableA>>(TableB::VT_A, None)}
+    }
 }
 
 impl ::flatbuffers::Verifiable for TableB<'_> {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    v.visit_table(pos)?
+        v.visit_table(pos)?
-     .visit_field::<::flatbuffers::ForwardsUOffset<super::super::TableA>>("a", Self::VT_A, false)?
+            .visit_field::<::flatbuffers::ForwardsUOffset<super::super::TableA>>("a", Self::VT_A, false)?
-     .finish();
+            .finish();
-    Ok(())
+        Ok(())
-  }
+    }
 }
+
 pub struct TableBArgs<'a> {
     pub a: Option<::flatbuffers::WIPOffset<super::super::TableA<'a>>>,
 }
+
 impl<'a> Default for TableBArgs<'a> {
-  #[inline]
+    #[inline]
-  fn default() -> Self {
+    fn default() -> Self {
-    TableBArgs {
+        TableBArgs {
-      a: None,
+            a: None,
+        }
     }
-  }
 }
 
 pub struct TableBBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
-  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+    fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+    start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
 }
+
 impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> {
-  #[inline]
+    #[inline]
-  pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset<super::super::TableA<'b >>) {
+    pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset<super::super::TableA<'b >>) {
-    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a);
+        self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a);
-  }
+    }
-  #[inline]
+
-  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> {
+    #[inline]
-    let start = _fbb.start_table();
+    pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> {
-    TableBBuilder {
+        let start = _fbb.start_table();
-      fbb_: _fbb,
+        TableBBuilder {
-      start_: start,
+            fbb_: _fbb,
+            start_: start,
+        }
+    }
+
+    #[inline]
+    pub fn finish(self) -> ::flatbuffers::WIPOffset<TableB<'a>> {
+        let o = self.fbb_.end_table(self.start_);
+        ::flatbuffers::WIPOffset::new(o.value())
     }
-  }
-  #[inline]
-  pub fn finish(self) -> ::flatbuffers::WIPOffset<TableB<'a>> {
-    let o = self.fbb_.end_table(self.start_);
-    ::flatbuffers::WIPOffset::new(o.value())
-  }
 }
 
 impl ::core::fmt::Debug for TableB<'_> {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-    let mut ds = f.debug_struct("TableB");
+        let mut ds = f.debug_struct("TableB");
-      ds.field("a", &self.a());
+        ds.field("a", &self.a());
-      ds.finish()
+        ds.finish()
-  }
+    }
 }
+
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub struct TableBT {
-  pub a: Option<alloc::boxed::Box<super::super::TableAT>>,
+    pub a: Option<alloc::boxed::Box<super::super::TableAT>>,
 }
+
 impl Default for TableBT {
-  fn default() -> Self {
+    fn default() -> Self {
-    Self {
+        Self {
-      a: None,
+            a: None,
+        }
     }
-  }
 }
+
 impl TableBT {
-  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
+    pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
-    &self,
+        &self,
-    _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
+        _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
-  ) -> ::flatbuffers::WIPOffset<TableB<'b>> {
+    ) -> ::flatbuffers::WIPOffset<TableB<'b>> {
-    let a = self.a.as_ref().map(|x|{
+        let a = self.a.as_ref().map(|x|{
-      x.pack(_fbb)
+            x.pack(_fbb)
-    });
+        });
-    TableB::create(_fbb, &TableBArgs{
+        TableB::create(_fbb, &TableBArgs{
-      a,
+            a,
-    })
+        })
-  }
+    }
 }

tests/include_test2/my_game/other_name_space/unused_generated.rs

@@ -2,45 +2,55 @@
 // @generated
 extern crate alloc;
 use super::*;
+
 // struct Unused, aligned to 4
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq)]
 pub struct Unused(pub [u8; 4]);
+
 impl Default for Unused {
-  fn default() -> Self { 
+    fn default() -> Self {
-    Self([0; 4])
+        Self([0; 4])
-  }
+    }
 }
+
 impl ::core::fmt::Debug for Unused {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-    f.debug_struct("Unused")
+        f.debug_struct("Unused")
-      .field("a", &self.a())
+            .field("a", &self.a())
-      .finish()
+            .finish()
-  }
+    }
 }
 
 impl ::flatbuffers::SimpleToVerifyInSlice for Unused {}
+
 impl<'a> ::flatbuffers::Follow<'a> for Unused {
-  type Inner = &'a Unused;
+    type Inner = &'a Unused;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    unsafe { <&'a Unused>::follow(buf, loc) }
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-  }
+        unsafe { <&'a Unused>::follow(buf, loc) }
+    }
 }
+
 impl<'a> ::flatbuffers::Follow<'a> for &'a Unused {
-  type Inner = &'a Unused;
+    type Inner = &'a Unused;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    unsafe { ::flatbuffers::follow_cast_ref::<Unused>(buf, loc) }
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-  }
+        unsafe { ::flatbuffers::follow_cast_ref::<Unused>(buf, loc) }
+    }
 }
+
 impl<'b> ::flatbuffers::Push for Unused {
     type Output = Unused;
+
     #[inline]
     unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
         let src = unsafe { ::core::slice::from_raw_parts(self as *const Unused as *const u8, <Self as ::flatbuffers::Push>::size()) };
         dst.copy_from_slice(src);
     }
+
     #[inline]
     fn alignment() -> ::flatbuffers::PushAlignment {
         ::flatbuffers::PushAlignment::new(4)
@@ -48,73 +58,80 @@ impl<'b> ::flatbuffers::Push for Unused {
 }
 
 impl<'a> ::flatbuffers::Verifiable for Unused {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    v.in_buffer::<Self>(pos)
+        v.in_buffer::<Self>(pos)
-  }
+    }
 }
 
 impl<'a> Unused {
-  #[allow(clippy::too_many_arguments)]
+    #[allow(clippy::too_many_arguments)]
-  pub fn new(
+    pub fn new(
-    a: i32,
+        a: i32,
-  ) -> Self {
+    ) -> Self {
-    let mut s = Self([0; 4]);
+        let mut s = Self([0; 4]);
-    s.set_a(a);
+        s.set_a(a);
-    s
+        s
-  }
-
-  pub const fn get_fully_qualified_name() -> &'static str {
-    "MyGame.OtherNameSpace.Unused"
-  }
-
-  pub fn a(&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[0..].as_ptr(),
-        mem.as_mut_ptr() as *mut u8,
-        ::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
-      );
-      mem.assume_init()
-    })
-  }
-
-  pub fn set_a(&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[0..].as_mut_ptr(),
-        ::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
-      );
     }
-  }
 
-  pub fn unpack(&self) -> UnusedT {
+    pub const fn get_fully_qualified_name() -> &'static str {
-    UnusedT {
+        "MyGame.OtherNameSpace.Unused"
-      a: self.a(),
+    }
+
+    pub fn a(&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[0..].as_ptr(),
+                mem.as_mut_ptr() as *mut u8,
+                ::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
+            );
+            mem.assume_init()
+        })
+    }
+
+    pub fn set_a(&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[0..].as_mut_ptr(),
+                ::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
+            );
+        }
+    }
+
+    pub fn unpack(&self) -> UnusedT {
+        UnusedT {
+            a: self.a(),
+        }
     }
-  }
 }
 
-#[derive(Debug, Clone, PartialEq, Default)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct UnusedT {
-  pub a: i32,
+    pub a: i32,
 }
-impl UnusedT {
+impl Default for UnusedT {
-  pub fn pack(&self) -> Unused {
+    fn default() -> Self {
-    Unused::new(
+        Self {
-      self.a,
+            a: 0,
-    )
+        }
-  }
+    }
 }
 
+impl UnusedT {
+    pub fn pack(&self) -> Unused {
+        Unused::new(
+            self.a,
+        )
+    }
+}

tests/include_test2/table_a_generated.rs

@@ -2,136 +2,147 @@
 // @generated
 extern crate alloc;
 use super::*;
-pub enum TableAOffset {}
-#[derive(Copy, Clone, PartialEq)]
 
+pub enum TableAOffset {}
+
+#[derive(Copy, Clone, PartialEq)]
 pub struct TableA<'a> {
-  pub _tab: ::flatbuffers::Table<'a>,
+    pub _tab: ::flatbuffers::Table<'a>,
 }
 
 impl<'a> ::flatbuffers::Follow<'a> for TableA<'a> {
-  type Inner = TableA<'a>;
+    type Inner = TableA<'a>;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-  }
+        Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    }
 }
 
 impl<'a> TableA<'a> {
-  pub const VT_B: ::flatbuffers::VOffsetT = 4;
+    pub const VT_B: ::flatbuffers::VOffsetT = 4;
 
-  pub const fn get_fully_qualified_name() -> &'static str {
+    pub const fn get_fully_qualified_name() -> &'static str {
-    "TableA"
+        "TableA"
-  }
-
-  #[inline]
-  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-    TableA { _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 TableAArgs<'args>
-  ) -> ::flatbuffers::WIPOffset<TableA<'bldr>> {
-    let mut builder = TableABuilder::new(_fbb);
-    if let Some(x) = args.b { builder.add_b(x); }
-    builder.finish()
-  }
-
-  pub fn unpack(&self) -> TableAT {
-    let b = self.b().map(|x| {
-      alloc::boxed::Box::new(x.unpack())
-    });
-    TableAT {
-      b,
     }
-  }
 
-  #[inline]
+    #[inline]
-  pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> {
+    pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-    // Safety:
+        TableA { _tab: table }
-    // Created from valid Table for this object
+    }
-    // which contains a valid value in this slot
+
-    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>(TableA::VT_B, None)}
+    #[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 TableAArgs<'args>
+    ) -> ::flatbuffers::WIPOffset<TableA<'bldr>> {
+        let mut builder = TableABuilder::new(_fbb);
+        if let Some(x) = args.b { builder.add_b(x); }
+        builder.finish()
+    }
+
+    pub fn unpack(&self) -> TableAT {
+        let b = self.b().map(|x| {
+            alloc::boxed::Box::new(x.unpack())
+        });
+        TableAT {
+            b,
+        }
+    }
+
+    #[inline]
+    pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>(TableA::VT_B, None)}
+    }
 }
 
 impl ::flatbuffers::Verifiable for TableA<'_> {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    v.visit_table(pos)?
+        v.visit_table(pos)?
-     .visit_field::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>("b", Self::VT_B, false)?
+            .visit_field::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>("b", Self::VT_B, false)?
-     .finish();
+            .finish();
-    Ok(())
+        Ok(())
-  }
+    }
 }
+
 pub struct TableAArgs<'a> {
     pub b: Option<::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'a>>>,
 }
+
 impl<'a> Default for TableAArgs<'a> {
-  #[inline]
+    #[inline]
-  fn default() -> Self {
+    fn default() -> Self {
-    TableAArgs {
+        TableAArgs {
-      b: None,
+            b: None,
+        }
     }
-  }
 }
 
 pub struct TableABuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
-  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+    fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+    start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
 }
+
 impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableABuilder<'a, 'b, A> {
-  #[inline]
+    #[inline]
-  pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) {
+    pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) {
-    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b);
+        self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b);
-  }
+    }
-  #[inline]
+
-  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
+    #[inline]
-    let start = _fbb.start_table();
+    pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
-    TableABuilder {
+        let start = _fbb.start_table();
-      fbb_: _fbb,
+        TableABuilder {
-      start_: start,
+            fbb_: _fbb,
+            start_: start,
+        }
+    }
+
+    #[inline]
+    pub fn finish(self) -> ::flatbuffers::WIPOffset<TableA<'a>> {
+        let o = self.fbb_.end_table(self.start_);
+        ::flatbuffers::WIPOffset::new(o.value())
     }
-  }
-  #[inline]
-  pub fn finish(self) -> ::flatbuffers::WIPOffset<TableA<'a>> {
-    let o = self.fbb_.end_table(self.start_);
-    ::flatbuffers::WIPOffset::new(o.value())
-  }
 }
 
 impl ::core::fmt::Debug for TableA<'_> {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-    let mut ds = f.debug_struct("TableA");
+        let mut ds = f.debug_struct("TableA");
-      ds.field("b", &self.b());
+        ds.field("b", &self.b());
-      ds.finish()
+        ds.finish()
-  }
+    }
 }
+
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub struct TableAT {
-  pub b: Option<alloc::boxed::Box<my_game::other_name_space::TableBT>>,
+    pub b: Option<alloc::boxed::Box<my_game::other_name_space::TableBT>>,
 }
+
 impl Default for TableAT {
-  fn default() -> Self {
+    fn default() -> Self {
-    Self {
+        Self {
-      b: None,
+            b: None,
+        }
     }
-  }
 }
+
 impl TableAT {
-  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
+    pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
-    &self,
+        &self,
-    _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
+        _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
-  ) -> ::flatbuffers::WIPOffset<TableA<'b>> {
+    ) -> ::flatbuffers::WIPOffset<TableA<'b>> {
-    let b = self.b.as_ref().map(|x|{
+        let b = self.b.as_ref().map(|x|{
-      x.pack(_fbb)
+            x.pack(_fbb)
-    });
+        });
-    TableA::create(_fbb, &TableAArgs{
+        TableA::create(_fbb, &TableAArgs{
-      b,
+            b,
-    })
+        })
-  }
+    }
 }

tests/include_test2_generated.rs

@@ -1,479 +1,525 @@
 // automatically generated by the FlatBuffers compiler, do not modify
 // @generated
-
 extern crate alloc;
 
 pub enum TableAOffset {}
-#[derive(Copy, Clone, PartialEq)]
 
+#[derive(Copy, Clone, PartialEq)]
 pub struct TableA<'a> {
-  pub _tab: ::flatbuffers::Table<'a>,
+    pub _tab: ::flatbuffers::Table<'a>,
 }
 
 impl<'a> ::flatbuffers::Follow<'a> for TableA<'a> {
-  type Inner = TableA<'a>;
+    type Inner = TableA<'a>;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-  }
+        Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    }
 }
 
 impl<'a> TableA<'a> {
-  pub const VT_B: ::flatbuffers::VOffsetT = 4;
+    pub const VT_B: ::flatbuffers::VOffsetT = 4;
 
-  pub const fn get_fully_qualified_name() -> &'static str {
+    pub const fn get_fully_qualified_name() -> &'static str {
-    "TableA"
+        "TableA"
-  }
-
-  #[inline]
-  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-    TableA { _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 TableAArgs<'args>
-  ) -> ::flatbuffers::WIPOffset<TableA<'bldr>> {
-    let mut builder = TableABuilder::new(_fbb);
-    if let Some(x) = args.b { builder.add_b(x); }
-    builder.finish()
-  }
-
-  pub fn unpack(&self) -> TableAT {
-    let b = self.b().map(|x| {
-      alloc::boxed::Box::new(x.unpack())
-    });
-    TableAT {
-      b,
     }
-  }
 
-  #[inline]
+    #[inline]
-  pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> {
+    pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-    // Safety:
+        TableA { _tab: table }
-    // Created from valid Table for this object
+    }
-    // which contains a valid value in this slot
+
-    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>(TableA::VT_B, None)}
+    #[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 TableAArgs<'args>
+    ) -> ::flatbuffers::WIPOffset<TableA<'bldr>> {
+        let mut builder = TableABuilder::new(_fbb);
+        if let Some(x) = args.b { builder.add_b(x); }
+        builder.finish()
+    }
+
+    pub fn unpack(&self) -> TableAT {
+        let b = self.b().map(|x| {
+            alloc::boxed::Box::new(x.unpack())
+        });
+        TableAT {
+            b,
+        }
+    }
+
+    #[inline]
+    pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>(TableA::VT_B, None)}
+    }
 }
 
 impl ::flatbuffers::Verifiable for TableA<'_> {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    v.visit_table(pos)?
+        v.visit_table(pos)?
-     .visit_field::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>("b", Self::VT_B, false)?
+            .visit_field::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>("b", Self::VT_B, false)?
-     .finish();
+            .finish();
-    Ok(())
+        Ok(())
-  }
+    }
 }
+
 pub struct TableAArgs<'a> {
     pub b: Option<::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'a>>>,
 }
+
 impl<'a> Default for TableAArgs<'a> {
-  #[inline]
+    #[inline]
-  fn default() -> Self {
+    fn default() -> Self {
-    TableAArgs {
+        TableAArgs {
-      b: None,
+            b: None,
+        }
     }
-  }
 }
 
 pub struct TableABuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
-  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+    fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+    start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
 }
+
 impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableABuilder<'a, 'b, A> {
-  #[inline]
+    #[inline]
-  pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) {
+    pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) {
-    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b);
+        self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b);
-  }
+    }
-  #[inline]
+
-  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
+    #[inline]
-    let start = _fbb.start_table();
+    pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
-    TableABuilder {
+        let start = _fbb.start_table();
-      fbb_: _fbb,
+        TableABuilder {
-      start_: start,
+            fbb_: _fbb,
+            start_: start,
+        }
+    }
+
+    #[inline]
+    pub fn finish(self) -> ::flatbuffers::WIPOffset<TableA<'a>> {
+        let o = self.fbb_.end_table(self.start_);
+        ::flatbuffers::WIPOffset::new(o.value())
     }
-  }
-  #[inline]
-  pub fn finish(self) -> ::flatbuffers::WIPOffset<TableA<'a>> {
-    let o = self.fbb_.end_table(self.start_);
-    ::flatbuffers::WIPOffset::new(o.value())
-  }
 }
 
 impl ::core::fmt::Debug for TableA<'_> {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-    let mut ds = f.debug_struct("TableA");
+        let mut ds = f.debug_struct("TableA");
-      ds.field("b", &self.b());
+        ds.field("b", &self.b());
-      ds.finish()
+        ds.finish()
-  }
+    }
 }
+
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub struct TableAT {
-  pub b: Option<alloc::boxed::Box<my_game::other_name_space::TableBT>>,
+    pub b: Option<alloc::boxed::Box<my_game::other_name_space::TableBT>>,
 }
+
 impl Default for TableAT {
-  fn default() -> Self {
+    fn default() -> Self {
-    Self {
+        Self {
-      b: None,
+            b: None,
+        }
     }
-  }
 }
+
 impl TableAT {
-  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
+    pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
-    &self,
+        &self,
-    _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
+        _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
-  ) -> ::flatbuffers::WIPOffset<TableA<'b>> {
+    ) -> ::flatbuffers::WIPOffset<TableA<'b>> {
-    let b = self.b.as_ref().map(|x|{
+        let b = self.b.as_ref().map(|x|{
-      x.pack(_fbb)
+            x.pack(_fbb)
-    });
+        });
-    TableA::create(_fbb, &TableAArgs{
+        TableA::create(_fbb, &TableAArgs{
-      b,
+            b,
-    })
+        })
-  }
+    }
 }
+
 #[allow(unused_imports, dead_code)]
 pub mod my_game {
+    extern crate alloc;
 
-extern crate alloc;
+    #[allow(unused_imports, dead_code)]
-#[allow(unused_imports, dead_code)]
+    pub mod other_name_space {
-pub mod other_name_space {
+        extern crate alloc;
 
-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_FROM_INCLUDE: i64 = 0;
 
-#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
+        #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
-pub const ENUM_MIN_FROM_INCLUDE: i64 = 0;
+        pub const ENUM_MAX_FROM_INCLUDE: i64 = 0;
-#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
-pub const ENUM_MAX_FROM_INCLUDE: i64 = 0;
-#[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_FROM_INCLUDE: [FromInclude; 1] = [
-  FromInclude::IncludeVal,
-];
 
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+        #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
-#[repr(transparent)]
+        #[allow(non_camel_case_types)]
-pub struct FromInclude(pub i64);
+        pub const ENUM_VALUES_FROM_INCLUDE: [FromInclude; 1] = [
-#[allow(non_upper_case_globals)]
+            FromInclude::IncludeVal,
-impl FromInclude {
+        ];
-  pub const IncludeVal: Self = Self(0);
 
-  pub const ENUM_MIN: i64 = 0;
+        #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-  pub const ENUM_MAX: i64 = 0;
+        #[repr(transparent)]
-  pub const ENUM_VALUES: &'static [Self] = &[
+        pub struct FromInclude(pub i64);
-    Self::IncludeVal,
-  ];
-  /// Returns the variant's name or "" if unknown.
-  pub fn variant_name(self) -> Option<&'static str> {
-    match self {
-      Self::IncludeVal => Some("IncludeVal"),
-      _ => None,
-    }
-  }
-}
-impl ::core::fmt::Debug for FromInclude {
-  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 FromInclude {
-  type Inner = Self;
-  #[inline]
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-    let b = unsafe { ::flatbuffers::read_scalar_at::<i64>(buf, loc) };
-    Self(b)
-  }
-}
 
-impl ::flatbuffers::Push for FromInclude {
+        #[allow(non_upper_case_globals)]
-    type Output = FromInclude;
+        impl FromInclude {
-    #[inline]
+            pub const IncludeVal: Self = Self(0);
-    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-        unsafe { ::flatbuffers::emplace_scalar::<i64>(dst, self.0) };
-    }
-}
 
-impl ::flatbuffers::EndianScalar for FromInclude {
+            pub const ENUM_MIN: i64 = 0;
-  type Scalar = i64;
+            pub const ENUM_MAX: i64 = 0;
-  #[inline]
+            pub const ENUM_VALUES: &'static [Self] = &[
-  fn to_little_endian(self) -> i64 {
+                Self::IncludeVal,
-    self.0.to_le()
+            ];
-  }
-  #[inline]
-  #[allow(clippy::wrong_self_convention)]
-  fn from_little_endian(v: i64) -> Self {
-    let b = i64::from_le(v);
-    Self(b)
-  }
-}
 
-impl<'a> ::flatbuffers::Verifiable for FromInclude {
+            /// Returns the variant's name or "" if unknown.
-  #[inline]
+            pub fn variant_name(self) -> Option<&'static str> {
-  fn run_verifier(
+                match self {
-    v: &mut ::flatbuffers::Verifier, pos: usize
+                    Self::IncludeVal => Some("IncludeVal"),
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+                    _ => None,
-    i64::run_verifier(v, pos)
+                }
-  }
+            }
-}
+        }
 
-impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {}
+        impl ::core::fmt::Debug for FromInclude {
-// struct Unused, aligned to 4
+            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-#[repr(transparent)]
+                if let Some(name) = self.variant_name() {
-#[derive(Clone, Copy, PartialEq)]
+                    f.write_str(name)
-pub struct Unused(pub [u8; 4]);
+                } else {
-impl Default for Unused { 
+                    f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
-  fn default() -> Self { 
+                }
-    Self([0; 4])
+            }
-  }
+        }
-}
-impl ::core::fmt::Debug for Unused {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-    f.debug_struct("Unused")
-      .field("a", &self.a())
-      .finish()
-  }
-}
 
-impl ::flatbuffers::SimpleToVerifyInSlice for Unused {}
+        impl<'a> ::flatbuffers::Follow<'a> for FromInclude {
-impl<'a> ::flatbuffers::Follow<'a> for Unused {
+            type Inner = Self;
-  type Inner = &'a Unused;
-  #[inline]
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-    unsafe { <&'a Unused>::follow(buf, loc) }
-  }
-}
-impl<'a> ::flatbuffers::Follow<'a> for &'a Unused {
-  type Inner = &'a Unused;
-  #[inline]
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-    unsafe { ::flatbuffers::follow_cast_ref::<Unused>(buf, loc) }
-  }
-}
-impl<'b> ::flatbuffers::Push for Unused {
-    type Output = Unused;
-    #[inline]
-    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-        let src = unsafe { ::core::slice::from_raw_parts(self as *const Unused 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 Unused {
+            #[inline]
-  #[inline]
+            unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-  fn run_verifier(
+                let b = unsafe { ::flatbuffers::read_scalar_at::<i64>(buf, loc) };
-    v: &mut ::flatbuffers::Verifier, pos: usize
+                Self(b)
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+            }
-    v.in_buffer::<Self>(pos)
+        }
-  }
-}
 
-impl<'a> Unused {
+        impl ::flatbuffers::Push for FromInclude {
-  #[allow(clippy::too_many_arguments)]
+            type Output = FromInclude;
-  pub fn new(
-    a: i32,
-  ) -> Self {
-    let mut s = Self([0; 4]);
-    s.set_a(a);
-    s
-  }
 
-  pub const fn get_fully_qualified_name() -> &'static str {
+            #[inline]
-    "MyGame.OtherNameSpace.Unused"
+            unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-  }
+                unsafe { ::flatbuffers::emplace_scalar::<i64>(dst, self.0) };
+            }
+        }
 
-  pub fn a(&self) -> i32 {
+        impl ::flatbuffers::EndianScalar for FromInclude {
-    let mut mem = ::core::mem::MaybeUninit::<<i32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
+            type Scalar = i64;
-    // 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::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
-      );
-      mem.assume_init()
-    })
-  }
 
-  pub fn set_a(&mut self, x: i32) {
+            #[inline]
-    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
+            fn to_little_endian(self) -> i64 {
-    // Safety:
+                self.0.to_le()
-    // 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::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
-      );
-    }
-  }
 
-  pub fn unpack(&self) -> UnusedT {
+            #[inline]
-    UnusedT {
+            #[allow(clippy::wrong_self_convention)]
-      a: self.a(),
+            fn from_little_endian(v: i64) -> Self {
-    }
+                let b = i64::from_le(v);
-  }
+                Self(b)
-}
+            }
+        }
 
-#[derive(Debug, Clone, PartialEq, Default)]
+        impl<'a> ::flatbuffers::Verifiable for FromInclude {
-pub struct UnusedT {
+            #[inline]
-  pub a: i32,
+            fn run_verifier(
-}
+                v: &mut ::flatbuffers::Verifier, pos: usize
-impl UnusedT {
+            ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-  pub fn pack(&self) -> Unused {
+                i64::run_verifier(v, pos)
-    Unused::new(
+            }
-      self.a,
+        }
-    )
-  }
-}
 
-pub enum TableBOffset {}
+        impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {}
-#[derive(Copy, Clone, PartialEq)]
 
-pub struct TableB<'a> {
+        // struct Unused, aligned to 4
-  pub _tab: ::flatbuffers::Table<'a>,
+        #[repr(transparent)]
-}
+        #[derive(Clone, Copy, PartialEq)]
+        pub struct Unused(pub [u8; 4]);
 
-impl<'a> ::flatbuffers::Follow<'a> for TableB<'a> {
+        impl Default for Unused {
-  type Inner = TableB<'a>;
+            fn default() -> Self {
-  #[inline]
+                Self([0; 4])
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+            }
-    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+        }
-  }
-}
 
-impl<'a> TableB<'a> {
+        impl ::core::fmt::Debug for Unused {
-  pub const VT_A: ::flatbuffers::VOffsetT = 4;
+            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+                f.debug_struct("Unused")
+                    .field("a", &self.a())
+                    .finish()
+            }
+        }
 
-  pub const fn get_fully_qualified_name() -> &'static str {
+        impl ::flatbuffers::SimpleToVerifyInSlice for Unused {}
-    "MyGame.OtherNameSpace.TableB"
-  }
 
-  #[inline]
+        impl<'a> ::flatbuffers::Follow<'a> for Unused {
-  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+            type Inner = &'a Unused;
-    TableB { _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 TableBArgs<'args>
-  ) -> ::flatbuffers::WIPOffset<TableB<'bldr>> {
-    let mut builder = TableBBuilder::new(_fbb);
-    if let Some(x) = args.a { builder.add_a(x); }
-    builder.finish()
-  }
 
-  pub fn unpack(&self) -> TableBT {
+            #[inline]
-    let a = self.a().map(|x| {
+            unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-      alloc::boxed::Box::new(x.unpack())
+                unsafe { <&'a Unused>::follow(buf, loc) }
-    });
+            }
-    TableBT {
+        }
-      a,
-    }
-  }
 
-  #[inline]
+        impl<'a> ::flatbuffers::Follow<'a> for &'a Unused {
-  pub fn a(&self) -> Option<super::super::TableA<'a>> {
+            type Inner = &'a Unused;
-    // Safety:
-    // Created from valid Table for this object
-    // which contains a valid value in this slot
-    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<super::super::TableA>>(TableB::VT_A, None)}
-  }
-}
 
-impl ::flatbuffers::Verifiable for TableB<'_> {
+            #[inline]
-  #[inline]
+            unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-  fn run_verifier(
+                unsafe { ::flatbuffers::follow_cast_ref::<Unused>(buf, loc) }
-    v: &mut ::flatbuffers::Verifier, pos: usize
+            }
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+        }
-    v.visit_table(pos)?
-     .visit_field::<::flatbuffers::ForwardsUOffset<super::super::TableA>>("a", Self::VT_A, false)?
-     .finish();
-    Ok(())
-  }
-}
-pub struct TableBArgs<'a> {
-    pub a: Option<::flatbuffers::WIPOffset<super::super::TableA<'a>>>,
-}
-impl<'a> Default for TableBArgs<'a> {
-  #[inline]
-  fn default() -> Self {
-    TableBArgs {
-      a: None,
-    }
-  }
-}
 
-pub struct TableBBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
+        impl<'b> ::flatbuffers::Push for Unused {
-  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+            type Output = Unused;
-  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
-}
-impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> {
-  #[inline]
-  pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset<super::super::TableA<'b >>) {
-    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a);
-  }
-  #[inline]
-  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> {
-    let start = _fbb.start_table();
-    TableBBuilder {
-      fbb_: _fbb,
-      start_: start,
-    }
-  }
-  #[inline]
-  pub fn finish(self) -> ::flatbuffers::WIPOffset<TableB<'a>> {
-    let o = self.fbb_.end_table(self.start_);
-    ::flatbuffers::WIPOffset::new(o.value())
-  }
-}
 
-impl ::core::fmt::Debug for TableB<'_> {
+            #[inline]
-  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+            unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-    let mut ds = f.debug_struct("TableB");
+                let src = unsafe { ::core::slice::from_raw_parts(self as *const Unused as *const u8, <Self as ::flatbuffers::Push>::size()) };
-      ds.field("a", &self.a());
+                dst.copy_from_slice(src);
-      ds.finish()
+            }
-  }
-}
-#[non_exhaustive]
-#[derive(Debug, Clone, PartialEq)]
-pub struct TableBT {
-  pub a: Option<alloc::boxed::Box<super::super::TableAT>>,
-}
-impl Default for TableBT {
-  fn default() -> Self {
-    Self {
-      a: None,
-    }
-  }
-}
-impl TableBT {
-  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
-    &self,
-    _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
-  ) -> ::flatbuffers::WIPOffset<TableB<'b>> {
-    let a = self.a.as_ref().map(|x|{
-      x.pack(_fbb)
-    });
-    TableB::create(_fbb, &TableBArgs{
-      a,
-    })
-  }
-}
-}  // pub mod OtherNameSpace
-}  // pub mod MyGame
 
+            #[inline]
+            fn alignment() -> ::flatbuffers::PushAlignment {
+                ::flatbuffers::PushAlignment::new(4)
+            }
+        }
+
+        impl<'a> ::flatbuffers::Verifiable for Unused {
+            #[inline]
+            fn run_verifier(
+                v: &mut ::flatbuffers::Verifier, pos: usize
+            ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+                v.in_buffer::<Self>(pos)
+            }
+        }
+
+        impl<'a> Unused {
+            #[allow(clippy::too_many_arguments)]
+            pub fn new(
+                a: i32,
+            ) -> Self {
+                let mut s = Self([0; 4]);
+                s.set_a(a);
+                s
+            }
+
+            pub const fn get_fully_qualified_name() -> &'static str {
+                "MyGame.OtherNameSpace.Unused"
+            }
+
+            pub fn a(&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[0..].as_ptr(),
+                        mem.as_mut_ptr() as *mut u8,
+                        ::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
+                    );
+                    mem.assume_init()
+                })
+            }
+
+            pub fn set_a(&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[0..].as_mut_ptr(),
+                        ::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
+                    );
+                }
+            }
+
+            pub fn unpack(&self) -> UnusedT {
+                UnusedT {
+                    a: self.a(),
+                }
+            }
+        }
+
+        #[derive(Debug, Clone, PartialEq)]
+        pub struct UnusedT {
+            pub a: i32,
+        }
+        impl Default for UnusedT {
+            fn default() -> Self {
+                Self {
+                    a: 0,
+                }
+            }
+        }
+
+        impl UnusedT {
+            pub fn pack(&self) -> Unused {
+                Unused::new(
+                    self.a,
+                )
+            }
+        }
+
+        pub enum TableBOffset {}
+
+        #[derive(Copy, Clone, PartialEq)]
+        pub struct TableB<'a> {
+            pub _tab: ::flatbuffers::Table<'a>,
+        }
+
+        impl<'a> ::flatbuffers::Follow<'a> for TableB<'a> {
+            type Inner = TableB<'a>;
+
+            #[inline]
+            unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+                Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+            }
+        }
+
+        impl<'a> TableB<'a> {
+            pub const VT_A: ::flatbuffers::VOffsetT = 4;
+
+            pub const fn get_fully_qualified_name() -> &'static str {
+                "MyGame.OtherNameSpace.TableB"
+            }
+
+            #[inline]
+            pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+                TableB { _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 TableBArgs<'args>
+            ) -> ::flatbuffers::WIPOffset<TableB<'bldr>> {
+                let mut builder = TableBBuilder::new(_fbb);
+                if let Some(x) = args.a { builder.add_a(x); }
+                builder.finish()
+            }
+
+            pub fn unpack(&self) -> TableBT {
+                let a = self.a().map(|x| {
+                    alloc::boxed::Box::new(x.unpack())
+                });
+                TableBT {
+                    a,
+                }
+            }
+
+            #[inline]
+            pub fn a(&self) -> Option<super::super::TableA<'a>> {
+                // Safety:
+                // Created from valid Table for this object
+                // which contains a valid value in this slot
+                unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<super::super::TableA>>(TableB::VT_A, None)}
+            }
+        }
+
+        impl ::flatbuffers::Verifiable for TableB<'_> {
+            #[inline]
+            fn run_verifier(
+                v: &mut ::flatbuffers::Verifier, pos: usize
+            ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+                v.visit_table(pos)?
+                    .visit_field::<::flatbuffers::ForwardsUOffset<super::super::TableA>>("a", Self::VT_A, false)?
+                    .finish();
+                Ok(())
+            }
+        }
+
+        pub struct TableBArgs<'a> {
+            pub a: Option<::flatbuffers::WIPOffset<super::super::TableA<'a>>>,
+        }
+
+        impl<'a> Default for TableBArgs<'a> {
+            #[inline]
+            fn default() -> Self {
+                TableBArgs {
+                    a: None,
+                }
+            }
+        }
+
+        pub struct TableBBuilder<'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> TableBBuilder<'a, 'b, A> {
+            #[inline]
+            pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset<super::super::TableA<'b >>) {
+                self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a);
+            }
+
+            #[inline]
+            pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> {
+                let start = _fbb.start_table();
+                TableBBuilder {
+                    fbb_: _fbb,
+                    start_: start,
+                }
+            }
+
+            #[inline]
+            pub fn finish(self) -> ::flatbuffers::WIPOffset<TableB<'a>> {
+                let o = self.fbb_.end_table(self.start_);
+                ::flatbuffers::WIPOffset::new(o.value())
+            }
+        }
+
+        impl ::core::fmt::Debug for TableB<'_> {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+                let mut ds = f.debug_struct("TableB");
+                ds.field("a", &self.a());
+                ds.finish()
+            }
+        }
+
+        #[non_exhaustive]
+        #[derive(Debug, Clone, PartialEq)]
+        pub struct TableBT {
+            pub a: Option<alloc::boxed::Box<super::super::TableAT>>,
+        }
+
+        impl Default for TableBT {
+            fn default() -> Self {
+                Self {
+                    a: None,
+                }
+            }
+        }
+
+        impl TableBT {
+            pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
+                &self,
+                _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
+            ) -> ::flatbuffers::WIPOffset<TableB<'b>> {
+                let a = self.a.as_ref().map(|x|{
+                    x.pack(_fbb)
+                });
+                TableB::create(_fbb, &TableBArgs{
+                    a,
+                })
+            }
+        }
+    } // pub mod OtherNameSpace
+} // pub mod MyGame

tests/keyword_test/keyword_test/abc_generated.rs

@@ -2,64 +2,73 @@
 // @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_ABC: i32 = 0;
+
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 pub const ENUM_MAX_ABC: i32 = 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_ABC: [ABC; 3] = [
-  ABC::void,
+    ABC::void,
-  ABC::where_,
+    ABC::where_,
-  ABC::stackalloc,
+    ABC::stackalloc,
 ];
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct ABC(pub i32);
+
 #[allow(non_upper_case_globals)]
 impl ABC {
-  pub const void: Self = Self(0);
+    pub const void: Self = Self(0);
-  pub const where_: Self = Self(1);
+    pub const where_: Self = Self(1);
-  pub const stackalloc: Self = Self(2);
+    pub const stackalloc: Self = Self(2);
 
-  pub const ENUM_MIN: i32 = 0;
+    pub const ENUM_MIN: i32 = 0;
-  pub const ENUM_MAX: i32 = 2;
+    pub const ENUM_MAX: i32 = 2;
-  pub const ENUM_VALUES: &'static [Self] = &[
+    pub const ENUM_VALUES: &'static [Self] = &[
-    Self::void,
+        Self::void,
-    Self::where_,
+        Self::where_,
-    Self::stackalloc,
+        Self::stackalloc,
-  ];
+    ];
-  /// Returns the variant's name or "" if unknown.
+
-  pub fn variant_name(self) -> Option<&'static str> {
+    /// Returns the variant's name or "" if unknown.
-    match self {
+    pub fn variant_name(self) -> Option<&'static str> {
-      Self::void => Some("void"),
+        match self {
-      Self::where_ => Some("where_"),
+            Self::void => Some("void"),
-      Self::stackalloc => Some("stackalloc"),
+            Self::where_ => Some("where_"),
-      _ => None,
+            Self::stackalloc => Some("stackalloc"),
+            _ => None,
+        }
     }
-  }
 }
+
 impl ::core::fmt::Debug for ABC {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-    if let Some(name) = self.variant_name() {
+        if let Some(name) = self.variant_name() {
-      f.write_str(name)
+            f.write_str(name)
-    } else {
+        } else {
-      f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
+            f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
+        }
     }
-  }
 }
+
 impl<'a> ::flatbuffers::Follow<'a> for ABC {
-  type Inner = Self;
+    type Inner = Self;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    let b = unsafe { ::flatbuffers::read_scalar_at::<i32>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-    Self(b)
+        let b = unsafe { ::flatbuffers::read_scalar_at::<i32>(buf, loc) };
-  }
+        Self(b)
+    }
 }
 
 impl ::flatbuffers::Push for ABC {
     type Output = ABC;
+
     #[inline]
     unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
         unsafe { ::flatbuffers::emplace_scalar::<i32>(dst, self.0) };
@@ -67,26 +76,28 @@ impl ::flatbuffers::Push for ABC {
 }
 
 impl ::flatbuffers::EndianScalar for ABC {
-  type Scalar = i32;
+    type Scalar = i32;
-  #[inline]
+
-  fn to_little_endian(self) -> i32 {
+    #[inline]
-    self.0.to_le()
+    fn to_little_endian(self) -> i32 {
-  }
+        self.0.to_le()
-  #[inline]
+    }
-  #[allow(clippy::wrong_self_convention)]
+
-  fn from_little_endian(v: i32) -> Self {
+    #[inline]
-    let b = i32::from_le(v);
+    #[allow(clippy::wrong_self_convention)]
-    Self(b)
+    fn from_little_endian(v: i32) -> Self {
-  }
+        let b = i32::from_le(v);
+        Self(b)
+    }
 }
 
 impl<'a> ::flatbuffers::Verifiable for ABC {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    i32::run_verifier(v, pos)
+        i32::run_verifier(v, pos)
-  }
+    }
 }
 
 impl ::flatbuffers::SimpleToVerifyInSlice for ABC {}

tests/keyword_test/keyword_test/keywords_in_table_generated.rs

@@ -2,201 +2,218 @@
 // @generated
 extern crate alloc;
 use super::*;
-pub enum KeywordsInTableOffset {}
-#[derive(Copy, Clone, PartialEq)]
 
+pub enum KeywordsInTableOffset {}
+
+#[derive(Copy, Clone, PartialEq)]
 pub struct KeywordsInTable<'a> {
-  pub _tab: ::flatbuffers::Table<'a>,
+    pub _tab: ::flatbuffers::Table<'a>,
 }
 
 impl<'a> ::flatbuffers::Follow<'a> for KeywordsInTable<'a> {
-  type Inner = KeywordsInTable<'a>;
+    type Inner = KeywordsInTable<'a>;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-  }
+        Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    }
 }
 
 impl<'a> KeywordsInTable<'a> {
-  pub const VT_IS: ::flatbuffers::VOffsetT = 4;
+    pub const VT_IS: ::flatbuffers::VOffsetT = 4;
-  pub const VT_PRIVATE: ::flatbuffers::VOffsetT = 6;
+    pub const VT_PRIVATE: ::flatbuffers::VOffsetT = 6;
-  pub const VT_TYPE_: ::flatbuffers::VOffsetT = 8;
+    pub const VT_TYPE_: ::flatbuffers::VOffsetT = 8;
-  pub const VT_DEFAULT: ::flatbuffers::VOffsetT = 10;
+    pub const VT_DEFAULT: ::flatbuffers::VOffsetT = 10;
 
-  pub const fn get_fully_qualified_name() -> &'static str {
+    pub const fn get_fully_qualified_name() -> &'static str {
-    "KeywordTest.KeywordsInTable"
+        "KeywordTest.KeywordsInTable"
-  }
-
-  #[inline]
-  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-    KeywordsInTable { _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 KeywordsInTableArgs
-  ) -> ::flatbuffers::WIPOffset<KeywordsInTable<'bldr>> {
-    let mut builder = KeywordsInTableBuilder::new(_fbb);
-    builder.add_type_(args.type_);
-    builder.add_private(args.private);
-    builder.add_is(args.is);
-    builder.add_default(args.default);
-    builder.finish()
-  }
-
-  pub fn unpack(&self) -> KeywordsInTableT {
-    let is = self.is();
-    let private = self.private();
-    let type_ = self.type_();
-    let default = self.default();
-    KeywordsInTableT {
-      is,
-      private,
-      type_,
-      default,
     }
-  }
 
-  #[inline]
+    #[inline]
-  pub fn is(&self) -> ABC {
+    pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-    // Safety:
+        KeywordsInTable { _tab: table }
-    // Created from valid Table for this object
+    }
-    // which contains a valid value in this slot
+
-    unsafe { self._tab.get::<ABC>(KeywordsInTable::VT_IS, Some(ABC::void)).unwrap()}
+    #[allow(unused_mut)]
-  }
+    pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
-  #[inline]
+        _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
-  pub fn private(&self) -> public {
+        args: &'args KeywordsInTableArgs
-    // Safety:
+    ) -> ::flatbuffers::WIPOffset<KeywordsInTable<'bldr>> {
-    // Created from valid Table for this object
+        let mut builder = KeywordsInTableBuilder::new(_fbb);
-    // which contains a valid value in this slot
+        builder.add_type_(args.type_);
-    unsafe { self._tab.get::<public>(KeywordsInTable::VT_PRIVATE, Some(public::NONE)).unwrap()}
+        builder.add_private(args.private);
-  }
+        builder.add_is(args.is);
-  #[inline]
+        builder.add_default(args.default);
-  pub fn type_(&self) -> i32 {
+        builder.finish()
-    // Safety:
+    }
-    // Created from valid Table for this object
+
-    // which contains a valid value in this slot
+    pub fn unpack(&self) -> KeywordsInTableT {
-    unsafe { self._tab.get::<i32>(KeywordsInTable::VT_TYPE_, Some(0)).unwrap()}
+        let is = self.is();
-  }
+        let private = self.private();
-  #[inline]
+        let type_ = self.type_();
-  pub fn default(&self) -> bool {
+        let default = self.default();
-    // Safety:
+        KeywordsInTableT {
-    // Created from valid Table for this object
+            is,
-    // which contains a valid value in this slot
+            private,
-    unsafe { self._tab.get::<bool>(KeywordsInTable::VT_DEFAULT, Some(false)).unwrap()}
+            type_,
-  }
+            default,
+        }
+    }
+
+    #[inline]
+    pub fn is(&self) -> ABC {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe { self._tab.get::<ABC>(KeywordsInTable::VT_IS, Some(ABC::void)).unwrap()}
+    }
+
+    #[inline]
+    pub fn private(&self) -> public {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe { self._tab.get::<public>(KeywordsInTable::VT_PRIVATE, Some(public::NONE)).unwrap()}
+    }
+
+    #[inline]
+    pub fn type_(&self) -> i32 {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe { self._tab.get::<i32>(KeywordsInTable::VT_TYPE_, Some(0)).unwrap()}
+    }
+
+    #[inline]
+    pub fn default(&self) -> bool {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe { self._tab.get::<bool>(KeywordsInTable::VT_DEFAULT, Some(false)).unwrap()}
+    }
 }
 
 impl ::flatbuffers::Verifiable for KeywordsInTable<'_> {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    v.visit_table(pos)?
+        v.visit_table(pos)?
-     .visit_field::<ABC>("is", Self::VT_IS, false)?
+            .visit_field::<ABC>("is", Self::VT_IS, false)?
-     .visit_field::<public>("private", Self::VT_PRIVATE, false)?
+            .visit_field::<public>("private", Self::VT_PRIVATE, false)?
-     .visit_field::<i32>("type_", Self::VT_TYPE_, false)?
+            .visit_field::<i32>("type_", Self::VT_TYPE_, false)?
-     .visit_field::<bool>("default", Self::VT_DEFAULT, false)?
+            .visit_field::<bool>("default", Self::VT_DEFAULT, false)?
-     .finish();
+            .finish();
-    Ok(())
+        Ok(())
-  }
+    }
 }
+
 pub struct KeywordsInTableArgs {
     pub is: ABC,
     pub private: public,
     pub type_: i32,
     pub default: bool,
 }
+
 impl<'a> Default for KeywordsInTableArgs {
-  #[inline]
+    #[inline]
-  fn default() -> Self {
+    fn default() -> Self {
-    KeywordsInTableArgs {
+        KeywordsInTableArgs {
-      is: ABC::void,
+            is: ABC::void,
-      private: public::NONE,
+            private: public::NONE,
-      type_: 0,
+            type_: 0,
-      default: false,
+            default: false,
+        }
     }
-  }
 }
 
 pub struct KeywordsInTableBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
-  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+    fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+    start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
 }
+
 impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> KeywordsInTableBuilder<'a, 'b, A> {
-  #[inline]
+    #[inline]
-  pub fn add_is(&mut self, is: ABC) {
+    pub fn add_is(&mut self, is: ABC) {
-    self.fbb_.push_slot::<ABC>(KeywordsInTable::VT_IS, is, ABC::void);
+        self.fbb_.push_slot::<ABC>(KeywordsInTable::VT_IS, is, ABC::void);
-  }
+    }
-  #[inline]
+
-  pub fn add_private(&mut self, private: public) {
+    #[inline]
-    self.fbb_.push_slot::<public>(KeywordsInTable::VT_PRIVATE, private, public::NONE);
+    pub fn add_private(&mut self, private: public) {
-  }
+        self.fbb_.push_slot::<public>(KeywordsInTable::VT_PRIVATE, private, public::NONE);
-  #[inline]
+    }
-  pub fn add_type_(&mut self, type_: i32) {
+
-    self.fbb_.push_slot::<i32>(KeywordsInTable::VT_TYPE_, type_, 0);
+    #[inline]
-  }
+    pub fn add_type_(&mut self, type_: i32) {
-  #[inline]
+        self.fbb_.push_slot::<i32>(KeywordsInTable::VT_TYPE_, type_, 0);
-  pub fn add_default(&mut self, default: bool) {
+    }
-    self.fbb_.push_slot::<bool>(KeywordsInTable::VT_DEFAULT, default, false);
+
-  }
+    #[inline]
-  #[inline]
+    pub fn add_default(&mut self, default: bool) {
-  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> KeywordsInTableBuilder<'a, 'b, A> {
+        self.fbb_.push_slot::<bool>(KeywordsInTable::VT_DEFAULT, default, false);
-    let start = _fbb.start_table();
+    }
-    KeywordsInTableBuilder {
+
-      fbb_: _fbb,
+    #[inline]
-      start_: start,
+    pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> KeywordsInTableBuilder<'a, 'b, A> {
+        let start = _fbb.start_table();
+        KeywordsInTableBuilder {
+            fbb_: _fbb,
+            start_: start,
+        }
+    }
+
+    #[inline]
+    pub fn finish(self) -> ::flatbuffers::WIPOffset<KeywordsInTable<'a>> {
+        let o = self.fbb_.end_table(self.start_);
+        ::flatbuffers::WIPOffset::new(o.value())
     }
-  }
-  #[inline]
-  pub fn finish(self) -> ::flatbuffers::WIPOffset<KeywordsInTable<'a>> {
-    let o = self.fbb_.end_table(self.start_);
-    ::flatbuffers::WIPOffset::new(o.value())
-  }
 }
 
 impl ::core::fmt::Debug for KeywordsInTable<'_> {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-    let mut ds = f.debug_struct("KeywordsInTable");
+        let mut ds = f.debug_struct("KeywordsInTable");
-      ds.field("is", &self.is());
+        ds.field("is", &self.is());
-      ds.field("private", &self.private());
+        ds.field("private", &self.private());
-      ds.field("type_", &self.type_());
+        ds.field("type_", &self.type_());
-      ds.field("default", &self.default());
+        ds.field("default", &self.default());
-      ds.finish()
+        ds.finish()
-  }
+    }
 }
+
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub struct KeywordsInTableT {
-  pub is: ABC,
+    pub is: ABC,
-  pub private: public,
+    pub private: public,
-  pub type_: i32,
+    pub type_: i32,
-  pub default: bool,
+    pub default: bool,
 }
+
 impl Default for KeywordsInTableT {
-  fn default() -> Self {
+    fn default() -> Self {
-    Self {
+        Self {
-      is: ABC::void,
+            is: ABC::void,
-      private: public::NONE,
+            private: public::NONE,
-      type_: 0,
+            type_: 0,
-      default: false,
+            default: false,
+        }
     }
-  }
 }
+
 impl KeywordsInTableT {
-  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
+    pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
-    &self,
+        &self,
-    _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
+        _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
-  ) -> ::flatbuffers::WIPOffset<KeywordsInTable<'b>> {
+    ) -> ::flatbuffers::WIPOffset<KeywordsInTable<'b>> {
-    let is = self.is;
+        let is = self.is;
-    let private = self.private;
+        let private = self.private;
-    let type_ = self.type_;
+        let type_ = self.type_;
-    let default = self.default;
+        let default = self.default;
-    KeywordsInTable::create(_fbb, &KeywordsInTableArgs{
+        KeywordsInTable::create(_fbb, &KeywordsInTableArgs{
-      is,
+            is,
-      private,
+            private,
-      type_,
+            type_,
-      default,
+            default,
-    })
+        })
-  }
+    }
 }

tests/keyword_test/keyword_test/keywords_in_union_generated.rs

@@ -2,64 +2,73 @@
 // @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_KEYWORDS_IN_UNION: u8 = 0;
+
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 pub const ENUM_MAX_KEYWORDS_IN_UNION: u8 = 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_KEYWORDS_IN_UNION: [KeywordsInUnion; 3] = [
-  KeywordsInUnion::NONE,
+    KeywordsInUnion::NONE,
-  KeywordsInUnion::static_,
+    KeywordsInUnion::static_,
-  KeywordsInUnion::internal,
+    KeywordsInUnion::internal,
 ];
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct KeywordsInUnion(pub u8);
+
 #[allow(non_upper_case_globals)]
 impl KeywordsInUnion {
-  pub const NONE: Self = Self(0);
+    pub const NONE: Self = Self(0);
-  pub const static_: Self = Self(1);
+    pub const static_: Self = Self(1);
-  pub const internal: Self = Self(2);
+    pub const internal: Self = Self(2);
 
-  pub const ENUM_MIN: u8 = 0;
+    pub const ENUM_MIN: u8 = 0;
-  pub const ENUM_MAX: u8 = 2;
+    pub const ENUM_MAX: u8 = 2;
-  pub const ENUM_VALUES: &'static [Self] = &[
+    pub const ENUM_VALUES: &'static [Self] = &[
-    Self::NONE,
+        Self::NONE,
-    Self::static_,
+        Self::static_,
-    Self::internal,
+        Self::internal,
-  ];
+    ];
-  /// Returns the variant's name or "" if unknown.
+
-  pub fn variant_name(self) -> Option<&'static str> {
+    /// Returns the variant's name or "" if unknown.
-    match self {
+    pub fn variant_name(self) -> Option<&'static str> {
-      Self::NONE => Some("NONE"),
+        match self {
-      Self::static_ => Some("static_"),
+            Self::NONE => Some("NONE"),
-      Self::internal => Some("internal"),
+            Self::static_ => Some("static_"),
-      _ => None,
+            Self::internal => Some("internal"),
+            _ => None,
+        }
     }
-  }
 }
+
 impl ::core::fmt::Debug for KeywordsInUnion {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-    if let Some(name) = self.variant_name() {
+        if let Some(name) = self.variant_name() {
-      f.write_str(name)
+            f.write_str(name)
-    } else {
+        } else {
-      f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
+            f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
+        }
     }
-  }
 }
+
 impl<'a> ::flatbuffers::Follow<'a> for KeywordsInUnion {
-  type Inner = Self;
+    type Inner = Self;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-    Self(b)
+        let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
-  }
+        Self(b)
+    }
 }
 
 impl ::flatbuffers::Push for KeywordsInUnion {
     type Output = KeywordsInUnion;
+
     #[inline]
     unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
         unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
@@ -67,99 +76,112 @@ impl ::flatbuffers::Push for KeywordsInUnion {
 }
 
 impl ::flatbuffers::EndianScalar for KeywordsInUnion {
-  type Scalar = u8;
+    type Scalar = u8;
-  #[inline]
+
-  fn to_little_endian(self) -> u8 {
+    #[inline]
-    self.0.to_le()
+    fn to_little_endian(self) -> u8 {
-  }
+        self.0.to_le()
-  #[inline]
+    }
-  #[allow(clippy::wrong_self_convention)]
+
-  fn from_little_endian(v: u8) -> Self {
+    #[inline]
-    let b = u8::from_le(v);
+    #[allow(clippy::wrong_self_convention)]
-    Self(b)
+    fn from_little_endian(v: u8) -> Self {
-  }
+        let b = u8::from_le(v);
+        Self(b)
+    }
 }
 
 impl<'a> ::flatbuffers::Verifiable for KeywordsInUnion {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    u8::run_verifier(v, pos)
+        u8::run_verifier(v, pos)
-  }
+    }
 }
 
 impl ::flatbuffers::SimpleToVerifyInSlice for KeywordsInUnion {}
+
 pub struct KeywordsInUnionUnionTableOffset {}
 
 #[allow(clippy::upper_case_acronyms)]
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub enum KeywordsInUnionT {
-  NONE,
+    NONE,
-  Static_(alloc::boxed::Box<KeywordsInTableT>),
+    Static_(alloc::boxed::Box<KeywordsInTableT>),
-  Internal(alloc::boxed::Box<KeywordsInTableT>),
+    Internal(alloc::boxed::Box<KeywordsInTableT>),
 }
+
 impl Default for KeywordsInUnionT {
-  fn default() -> Self {
+    fn default() -> Self {
-    Self::NONE
+        Self::NONE
-  }
+    }
 }
+
 impl KeywordsInUnionT {
-  pub fn keywords_in_union_type(&self) -> KeywordsInUnion {
+    pub fn keywords_in_union_type(&self) -> KeywordsInUnion {
-    match self {
+        match self {
-      Self::NONE => KeywordsInUnion::NONE,
+            Self::NONE => KeywordsInUnion::NONE,
-      Self::Static_(_) => KeywordsInUnion::static_,
+            Self::Static_(_) => KeywordsInUnion::static_,
-      Self::Internal(_) => KeywordsInUnion::internal,
+            Self::Internal(_) => KeywordsInUnion::internal,
+        }
     }
-  }
+
-  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> {
+    pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> {
-    match self {
+        match self {
-      Self::NONE => None,
+            Self::NONE => None,
-      Self::Static_(v) => Some(v.pack(fbb).as_union_value()),
+            Self::Static_(v) => Some(v.pack(fbb).as_union_value()),
-      Self::Internal(v) => Some(v.pack(fbb).as_union_value()),
+            Self::Internal(v) => Some(v.pack(fbb).as_union_value()),
+        }
     }
-  }
+
-  /// If the union variant matches, return the owned KeywordsInTableT, setting the union to NONE.
+    /// If the union variant matches, return the owned KeywordsInTableT, setting the union to NONE.
-  pub fn take_static_(&mut self) -> Option<alloc::boxed::Box<KeywordsInTableT>> {
+    pub fn take_static_(&mut self) -> Option<alloc::boxed::Box<KeywordsInTableT>> {
-    if let Self::Static_(_) = self {
+        if let Self::Static_(_) = self {
-      let v = ::core::mem::replace(self, Self::NONE);
+            let v = ::core::mem::replace(self, Self::NONE);
-      if let Self::Static_(w) = v {
+            if let Self::Static_(w) = v {
-        Some(w)
+                Some(w)
-      } else {
+            } else {
-        unreachable!()
+                unreachable!()
-      }
+            }
-    } else {
+        } else {
-      None
+            None
+        }
     }
-  }
+
-  /// If the union variant matches, return a reference to the KeywordsInTableT.
+    /// If the union variant matches, return a reference to the KeywordsInTableT.
-  pub fn as_static_(&self) -> Option<&KeywordsInTableT> {
+    pub fn as_static_(&self) -> Option<&KeywordsInTableT> {
-    if let Self::Static_(v) = self { Some(v.as_ref()) } else { None }
+        if let Self::Static_(v) = self { Some(v.as_ref()) } else { None }
-  }
+    }
-  /// If the union variant matches, return a mutable reference to the KeywordsInTableT.
+
-  pub fn as_static__mut(&mut self) -> Option<&mut KeywordsInTableT> {
+    /// If the union variant matches, return a mutable reference to the KeywordsInTableT.
-    if let Self::Static_(v) = self { Some(v.as_mut()) } else { None }
+    pub fn as_static__mut(&mut self) -> Option<&mut KeywordsInTableT> {
-  }
+        if let Self::Static_(v) = self { Some(v.as_mut()) } else { None }
-  /// If the union variant matches, return the owned KeywordsInTableT, setting the union to NONE.
+    }
-  pub fn take_internal(&mut self) -> Option<alloc::boxed::Box<KeywordsInTableT>> {
+
-    if let Self::Internal(_) = self {
+    /// If the union variant matches, return the owned KeywordsInTableT, setting the union to NONE.
-      let v = ::core::mem::replace(self, Self::NONE);
+    pub fn take_internal(&mut self) -> Option<alloc::boxed::Box<KeywordsInTableT>> {
-      if let Self::Internal(w) = v {
+        if let Self::Internal(_) = self {
-        Some(w)
+            let v = ::core::mem::replace(self, Self::NONE);
-      } else {
+            if let Self::Internal(w) = v {
-        unreachable!()
+                Some(w)
-      }
+            } else {
-    } else {
+                unreachable!()
-      None
+            }
+        } else {
+            None
+        }
+    }
+
+    /// If the union variant matches, return a reference to the KeywordsInTableT.
+    pub fn as_internal(&self) -> Option<&KeywordsInTableT> {
+        if let Self::Internal(v) = self { Some(v.as_ref()) } else { None }
+    }
+
+    /// If the union variant matches, return a mutable reference to the KeywordsInTableT.
+    pub fn as_internal_mut(&mut self) -> Option<&mut KeywordsInTableT> {
+        if let Self::Internal(v) = self { Some(v.as_mut()) } else { None }
     }
-  }
-  /// If the union variant matches, return a reference to the KeywordsInTableT.
-  pub fn as_internal(&self) -> Option<&KeywordsInTableT> {
-    if let Self::Internal(v) = self { Some(v.as_ref()) } else { None }
-  }
-  /// If the union variant matches, return a mutable reference to the KeywordsInTableT.
-  pub fn as_internal_mut(&mut self) -> Option<&mut KeywordsInTableT> {
-    if let Self::Internal(v) = self { Some(v.as_mut()) } else { None }
-  }
 }
+

tests/keyword_test/keyword_test/public_generated.rs

@@ -2,56 +2,65 @@
 // @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_PUBLIC: i32 = 0;
+
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 pub const ENUM_MAX_PUBLIC: i32 = 0;
+
 #[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_PUBLIC: [public; 1] = [
-  public::NONE,
+    public::NONE,
 ];
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct public(pub i32);
+
 #[allow(non_upper_case_globals)]
 impl public {
-  pub const NONE: Self = Self(0);
+    pub const NONE: Self = Self(0);
 
-  pub const ENUM_MIN: i32 = 0;
+    pub const ENUM_MIN: i32 = 0;
-  pub const ENUM_MAX: i32 = 0;
+    pub const ENUM_MAX: i32 = 0;
-  pub const ENUM_VALUES: &'static [Self] = &[
+    pub const ENUM_VALUES: &'static [Self] = &[
-    Self::NONE,
+        Self::NONE,
-  ];
+    ];
-  /// Returns the variant's name or "" if unknown.
+
-  pub fn variant_name(self) -> Option<&'static str> {
+    /// Returns the variant's name or "" if unknown.
-    match self {
+    pub fn variant_name(self) -> Option<&'static str> {
-      Self::NONE => Some("NONE"),
+        match self {
-      _ => None,
+            Self::NONE => Some("NONE"),
+            _ => None,
+        }
     }
-  }
 }
+
 impl ::core::fmt::Debug for public {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-    if let Some(name) = self.variant_name() {
+        if let Some(name) = self.variant_name() {
-      f.write_str(name)
+            f.write_str(name)
-    } else {
+        } else {
-      f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
+            f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
+        }
     }
-  }
 }
+
 impl<'a> ::flatbuffers::Follow<'a> for public {
-  type Inner = Self;
+    type Inner = Self;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    let b = unsafe { ::flatbuffers::read_scalar_at::<i32>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-    Self(b)
+        let b = unsafe { ::flatbuffers::read_scalar_at::<i32>(buf, loc) };
-  }
+        Self(b)
+    }
 }
 
 impl ::flatbuffers::Push for public {
     type Output = public;
+
     #[inline]
     unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
         unsafe { ::flatbuffers::emplace_scalar::<i32>(dst, self.0) };
@@ -59,26 +68,28 @@ impl ::flatbuffers::Push for public {
 }
 
 impl ::flatbuffers::EndianScalar for public {
-  type Scalar = i32;
+    type Scalar = i32;
-  #[inline]
+
-  fn to_little_endian(self) -> i32 {
+    #[inline]
-    self.0.to_le()
+    fn to_little_endian(self) -> i32 {
-  }
+        self.0.to_le()
-  #[inline]
+    }
-  #[allow(clippy::wrong_self_convention)]
+
-  fn from_little_endian(v: i32) -> Self {
+    #[inline]
-    let b = i32::from_le(v);
+    #[allow(clippy::wrong_self_convention)]
-    Self(b)
+    fn from_little_endian(v: i32) -> Self {
-  }
+        let b = i32::from_le(v);
+        Self(b)
+    }
 }
 
 impl<'a> ::flatbuffers::Verifiable for public {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    i32::run_verifier(v, pos)
+        i32::run_verifier(v, pos)
-  }
+    }
 }
 
 impl ::flatbuffers::SimpleToVerifyInSlice for public {}

tests/keyword_test/keyword_test/table_2_generated.rs

@@ -2,218 +2,231 @@
 // @generated
 extern crate alloc;
 use super::*;
-pub enum Table2Offset {}
-#[derive(Copy, Clone, PartialEq)]
 
+pub enum Table2Offset {}
+
+#[derive(Copy, Clone, PartialEq)]
 pub struct Table2<'a> {
-  pub _tab: ::flatbuffers::Table<'a>,
+    pub _tab: ::flatbuffers::Table<'a>,
 }
 
 impl<'a> ::flatbuffers::Follow<'a> for Table2<'a> {
-  type Inner = Table2<'a>;
+    type Inner = Table2<'a>;
-  #[inline]
+
-  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    #[inline]
-    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-  }
+        Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+    }
 }
 
 impl<'a> Table2<'a> {
-  pub const VT_TYPE_TYPE: ::flatbuffers::VOffsetT = 4;
+    pub const VT_TYPE_TYPE: ::flatbuffers::VOffsetT = 4;
-  pub const VT_TYPE_: ::flatbuffers::VOffsetT = 6;
+    pub const VT_TYPE_: ::flatbuffers::VOffsetT = 6;
 
-  pub const fn get_fully_qualified_name() -> &'static str {
+    pub const fn get_fully_qualified_name() -> &'static str {
-    "KeywordTest.Table2"
+        "KeywordTest.Table2"
-  }
-
-  #[inline]
-  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-    Table2 { _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 Table2Args
-  ) -> ::flatbuffers::WIPOffset<Table2<'bldr>> {
-    let mut builder = Table2Builder::new(_fbb);
-    if let Some(x) = args.type_ { builder.add_type_(x); }
-    builder.add_type_type(args.type_type);
-    builder.finish()
-  }
-
-  pub fn unpack(&self) -> Table2T {
-    let type_ = match self.type_type() {
-      KeywordsInUnion::NONE => KeywordsInUnionT::NONE,
-      KeywordsInUnion::static_ => KeywordsInUnionT::Static_(alloc::boxed::Box::new(
-        self.type__as_static_()
-            .expect("Invalid union table, expected `KeywordsInUnion::static_`.")
-            .unpack()
-      )),
-      KeywordsInUnion::internal => KeywordsInUnionT::Internal(alloc::boxed::Box::new(
-        self.type__as_internal()
-            .expect("Invalid union table, expected `KeywordsInUnion::internal`.")
-            .unpack()
-      )),
-      _ => KeywordsInUnionT::NONE,
-    };
-    Table2T {
-      type_,
     }
-  }
 
-  #[inline]
+    #[inline]
-  pub fn type_type(&self) -> KeywordsInUnion {
+    pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-    // Safety:
+        Table2 { _tab: table }
-    // Created from valid Table for this object
-    // which contains a valid value in this slot
-    unsafe { self._tab.get::<KeywordsInUnion>(Table2::VT_TYPE_TYPE, Some(KeywordsInUnion::NONE)).unwrap()}
-  }
-  #[inline]
-  pub fn type_(&self) -> Option<::flatbuffers::Table<'a>> {
-    // Safety:
-    // Created from valid Table for this object
-    // which contains a valid value in this slot
-    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Table2::VT_TYPE_, None)}
-  }
-  #[inline]
-  #[allow(non_snake_case)]
-  pub fn type__as_static_(&self) -> Option<KeywordsInTable<'a>> {
-    if self.type_type() == KeywordsInUnion::static_ {
-      self.type_().map(|t| {
-       // Safety:
-       // Created from a valid Table for this object
-       // Which contains a valid union in this slot
-       unsafe { KeywordsInTable::init_from_table(t) }
-     })
-    } else {
-      None
     }
-  }
 
-  #[inline]
+    #[allow(unused_mut)]
-  #[allow(non_snake_case)]
+    pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
-  pub fn type__as_internal(&self) -> Option<KeywordsInTable<'a>> {
+        _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
-    if self.type_type() == KeywordsInUnion::internal {
+        args: &'args Table2Args
-      self.type_().map(|t| {
+    ) -> ::flatbuffers::WIPOffset<Table2<'bldr>> {
-       // Safety:
+        let mut builder = Table2Builder::new(_fbb);
-       // Created from a valid Table for this object
+        if let Some(x) = args.type_ { builder.add_type_(x); }
-       // Which contains a valid union in this slot
+        builder.add_type_type(args.type_type);
-       unsafe { KeywordsInTable::init_from_table(t) }
+        builder.finish()
-     })
-    } else {
-      None
     }
-  }
 
+    pub fn unpack(&self) -> Table2T {
+        let type_ = match self.type_type() {
+            KeywordsInUnion::NONE => KeywordsInUnionT::NONE,
+            KeywordsInUnion::static_ => KeywordsInUnionT::Static_(alloc::boxed::Box::new(
+                self.type__as_static_()
+                    .expect("Invalid union table, expected `KeywordsInUnion::static_`.")
+                    .unpack()
+            )),
+            KeywordsInUnion::internal => KeywordsInUnionT::Internal(alloc::boxed::Box::new(
+                self.type__as_internal()
+                    .expect("Invalid union table, expected `KeywordsInUnion::internal`.")
+                    .unpack()
+            )),
+            _ => KeywordsInUnionT::NONE,
+        };
+        Table2T {
+            type_,
+        }
+    }
+
+    #[inline]
+    pub fn type_type(&self) -> KeywordsInUnion {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe { self._tab.get::<KeywordsInUnion>(Table2::VT_TYPE_TYPE, Some(KeywordsInUnion::NONE)).unwrap()}
+    }
+
+    #[inline]
+    pub fn type_(&self) -> Option<::flatbuffers::Table<'a>> {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Table2::VT_TYPE_, None)}
+    }
+
+    #[inline]
+    #[allow(non_snake_case)]
+    pub fn type__as_static_(&self) -> Option<KeywordsInTable<'a>> {
+        if self.type_type() == KeywordsInUnion::static_ {
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { KeywordsInTable::init_from_table(t) }
+            })
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    #[allow(non_snake_case)]
+    pub fn type__as_internal(&self) -> Option<KeywordsInTable<'a>> {
+        if self.type_type() == KeywordsInUnion::internal {
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { KeywordsInTable::init_from_table(t) }
+            })
+        } else {
+            None
+        }
+    }
 }
 
 impl ::flatbuffers::Verifiable for Table2<'_> {
-  #[inline]
+    #[inline]
-  fn run_verifier(
+    fn run_verifier(
-    v: &mut ::flatbuffers::Verifier, pos: usize
+        v: &mut ::flatbuffers::Verifier, pos: usize
-  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-    v.visit_table(pos)?
+        v.visit_table(pos)?
-     .visit_union::<KeywordsInUnion, _>("type_type", Self::VT_TYPE_TYPE, "type_", Self::VT_TYPE_, false, |key, v, pos| {
+            .visit_union::<KeywordsInUnion, _>("type_type", Self::VT_TYPE_TYPE, "type_", Self::VT_TYPE_, false, |key, v, pos| {
-        match key {
+                match key {
-          KeywordsInUnion::static_ => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<KeywordsInTable>>("KeywordsInUnion::static_", pos),
+                    KeywordsInUnion::static_ => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<KeywordsInTable>>("KeywordsInUnion::static_", pos),
-          KeywordsInUnion::internal => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<KeywordsInTable>>("KeywordsInUnion::internal", pos),
+                    KeywordsInUnion::internal => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<KeywordsInTable>>("KeywordsInUnion::internal", pos),
-          _ => Ok(()),
+                    _ => Ok(()),
-        }
+                }
-     })?
+            })?
-     .finish();
+            .finish();
-    Ok(())
+        Ok(())
-  }
+    }
 }
+
 pub struct Table2Args {
     pub type_type: KeywordsInUnion,
     pub type_: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
 }
+
 impl<'a> Default for Table2Args {
-  #[inline]
+    #[inline]
-  fn default() -> Self {
+    fn default() -> Self {
-    Table2Args {
+        Table2Args {
-      type_type: KeywordsInUnion::NONE,
+            type_type: KeywordsInUnion::NONE,
-      type_: None,
+            type_: None,
+        }
     }
-  }
 }
 
 pub struct Table2Builder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
-  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+    fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+    start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
 }
+
 impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> Table2Builder<'a, 'b, A> {
-  #[inline]
+    #[inline]
-  pub fn add_type_type(&mut self, type_type: KeywordsInUnion) {
+    pub fn add_type_type(&mut self, type_type: KeywordsInUnion) {
-    self.fbb_.push_slot::<KeywordsInUnion>(Table2::VT_TYPE_TYPE, type_type, KeywordsInUnion::NONE);
+        self.fbb_.push_slot::<KeywordsInUnion>(Table2::VT_TYPE_TYPE, type_type, KeywordsInUnion::NONE);
-  }
+    }
-  #[inline]
+
-  pub fn add_type_(&mut self, type_: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
+    #[inline]
-    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Table2::VT_TYPE_, type_);
+    pub fn add_type_(&mut self, type_: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
-  }
+        self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Table2::VT_TYPE_, type_);
-  #[inline]
+    }
-  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> Table2Builder<'a, 'b, A> {
+
-    let start = _fbb.start_table();
+    #[inline]
-    Table2Builder {
+    pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> Table2Builder<'a, 'b, A> {
-      fbb_: _fbb,
+        let start = _fbb.start_table();
-      start_: start,
+        Table2Builder {
+            fbb_: _fbb,
+            start_: start,
+        }
+    }
+
+    #[inline]
+    pub fn finish(self) -> ::flatbuffers::WIPOffset<Table2<'a>> {
+        let o = self.fbb_.end_table(self.start_);
+        ::flatbuffers::WIPOffset::new(o.value())
     }
-  }
-  #[inline]
-  pub fn finish(self) -> ::flatbuffers::WIPOffset<Table2<'a>> {
-    let o = self.fbb_.end_table(self.start_);
-    ::flatbuffers::WIPOffset::new(o.value())
-  }
 }
 
 impl ::core::fmt::Debug for Table2<'_> {
-  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-    let mut ds = f.debug_struct("Table2");
+        let mut ds = f.debug_struct("Table2");
-      ds.field("type_type", &self.type_type());
+        ds.field("type_type", &self.type_type());
-      match self.type_type() {
+        match self.type_type() {
-        KeywordsInUnion::static_ => {
+            KeywordsInUnion::static_ => {
-          if let Some(x) = self.type__as_static_() {
+                if let Some(x) = self.type__as_static_() {
-            ds.field("type_", &x)
+                    ds.field("type_", &x)
-          } else {
+                } else {
-            ds.field("type_", &"InvalidFlatbuffer: Union discriminant does not match value.")
+                    ds.field("type_", &"InvalidFlatbuffer: Union discriminant does not match value.")
-          }
+                }
-        },
+            },
-        KeywordsInUnion::internal => {
+            KeywordsInUnion::internal => {
-          if let Some(x) = self.type__as_internal() {
+                if let Some(x) = self.type__as_internal() {
-            ds.field("type_", &x)
+                    ds.field("type_", &x)
-          } else {
+                } else {
-            ds.field("type_", &"InvalidFlatbuffer: Union discriminant does not match value.")
+                    ds.field("type_", &"InvalidFlatbuffer: Union discriminant does not match value.")
-          }
+                }
-        },
+            },
-        _ => {
+            _ => {
-          let x: Option<()> = None;
+                let x: Option<()> = None;
-          ds.field("type_", &x)
+                ds.field("type_", &x)
-        },
+            },
-      };
+        };
-      ds.finish()
+        ds.finish()
-  }
+    }
 }
+
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub struct Table2T {
-  pub type_: KeywordsInUnionT,
+    pub type_: KeywordsInUnionT,
 }
+
 impl Default for Table2T {
-  fn default() -> Self {
+    fn default() -> Self {
-    Self {
+        Self {
-      type_: KeywordsInUnionT::NONE,
+            type_: KeywordsInUnionT::NONE,
+        }
     }
-  }
 }
+
 impl Table2T {
-  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
+    pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
-    &self,
+        &self,
-    _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
+        _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
-  ) -> ::flatbuffers::WIPOffset<Table2<'b>> {
+    ) -> ::flatbuffers::WIPOffset<Table2<'b>> {
-    let type_type = self.type_.keywords_in_union_type();
+        let type_type = self.type_.keywords_in_union_type();
-    let type_ = self.type_.pack(_fbb);
+        let type_ = self.type_.pack(_fbb);
-    Table2::create(_fbb, &Table2Args{
+        Table2::create(_fbb, &Table2Args{
-      type_type,
+            type_type,
-      type_,
+            type_,
-    })
+        })
-  }
+    }
 }