allocate immediately required fields (#1)

Reviewed-on: #1
Co-authored-by: Romain BOULLARD <romain.boullard@protonmail.com>

.github/CODEOWNERS

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

.github/dependabot.yml

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

.github/workflows/build.yml

@@ -197,8 +197,7 @@ jobs:
         configuration: [
           '',
           '-p:UnsafeByteBuffer=true',
-          # Fails two tests currently.
-          #'-p:EnableSpanT=true,UnsafeByteBuffer=true'
+          '-p:EnableSpanT=true,UnsafeByteBuffer=true'
           ]
     steps:
     - uses: actions/checkout@v6
@@ -209,7 +208,7 @@ jobs:
     - name: Build
       run: |
         cd tests\FlatBuffers.Test
-        dotnet new sln --force --name FlatBuffers.Test
+        dotnet new sln --force --name FlatBuffers.Test --format sln
         dotnet sln FlatBuffers.Test.sln add FlatBuffers.Test.csproj
         dotnet build -c Release ${{matrix.configuration}} FlatBuffers.Test.sln
     - name: Run net6.0
@@ -592,11 +591,16 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v6
+      # Explicitly use 8.5.1 until we can update or https://github.com/actions/runner-images/issues/13564 is fixed.
+      - name: Set env
+        run: >
+          echo "USE_BAZEL_VERSION=8.5.1" >> $GITHUB_ENV
       - name: bazel build
         run: >
           bazel build
           //:flatc
           //:flatbuffers
+          //tests:flatbuffers_test
       - name: bazel test
         run: >
           bazel test
@@ -633,8 +637,7 @@ jobs:
       actions: read   # To read the workflow path.
       id-token: write # To sign the provenance.
       contents: write # To add assets to a release.
-    uses: slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@v1.2.1
+    uses: slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@v2.1.0
     with:
       base64-subjects: "${{ needs.release-digests.outputs.digests }}"
       upload-assets: true # Optional: Upload to a new release
-      compile-generator: true # Workaround for https://github.com/slsa-framework/slsa-github-generator/issues/1163

CMake/BuildFlatBuffers.cmake

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

CMakeLists.txt

@@ -238,8 +238,15 @@ 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/required_table_default_test.h
+  tests/required_table_default_test.cpp
   tests/alignment_test.h
   tests/alignment_test.cpp
   tests/64bit/offset64_test.h
@@ -548,17 +555,21 @@ 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/required_table_default_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}")
 
   if(FLATBUFFERS_CODE_SANITIZE)
     add_fsanitize_to_target(flattests ${FLATBUFFERS_CODE_SANITIZE})

MODULE.bazel

@@ -7,7 +7,7 @@ module(
 
 bazel_dep(
     name = "aspect_bazel_lib",
-    version = "2.11.0",
+    version = "2.14.0",
 )
 bazel_dep(
     name = "aspect_rules_esbuild",
@@ -28,11 +28,11 @@ bazel_dep(
 )
 bazel_dep(
     name = "platforms",
-    version = "0.0.10",
+    version = "0.0.11",
 )
 bazel_dep(
     name = "rules_cc",
-    version = "0.0.16",
+    version = "0.1.1",
 )
 bazel_dep(
     name = "rules_go",
@@ -50,6 +50,7 @@ bazel_dep(
 bazel_dep(
     name = "rules_swift",
     version = "2.1.1",
+    max_compatibility_level = 3,
     repo_name = "build_bazel_rules_swift",
 )
 bazel_dep(

benchmarks/swift/Benchmarks/FlexBuffersBenchmarks/FlexBuffersBenchmarks.swift

@@ -0,0 +1,174 @@
+/*
+ * Copyright 2024 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Benchmark
+import FlexBuffers
+import Foundation
+
+let benchmarks = {
+  let data = {
+    var array = [8888.88, 8888.88]
+    var data = Data()
+    array.withUnsafeBytes { ptr in
+      data.append(contentsOf: ptr)
+    }
+    return data
+  }()
+  let ints: [Int32] = Array(repeating: 42, count: 100)
+  let str10 = (0...9).map { _ -> String in "x" }.joined()
+  let str100 = (0...99).map { _ -> String in "x" }.joined()
+
+  // A representative map: 50 keyed scalars, a keyed string and a keyed vector
+  // of 100 scalars. Used for the realistic decode benchmarks.
+  let mapBuffer: ByteBuffer = {
+    var fbx = FlexBuffersWriter(initialSize: 1 << 16)
+    fbx.map {
+      for i in 0..<50 { $0.add(int: i, key: "i\(i)") }
+      $0.add(string: "hello world", key: "s")
+      $0.vector(key: "v") { v in
+        for x in 0..<100 { v.add(int: x) }
+      }
+    }
+    fbx.finish()
+    return fbx.sizedByteBuffer
+  }()
+
+  let metrics: [BenchmarkMetric] = [
+    .cpuTotal,
+    .wallClock,
+    .mallocCountTotal,
+    .releaseCount,
+    .peakMemoryResident,
+  ]
+  let maxIterations = 1_000_000
+  let maxDuration: Duration = .seconds(3)
+  let megaConfiguration: Benchmark.Configuration = .init(
+    metrics: metrics,
+    warmupIterations: 1,
+    scalingFactor: .mega,
+    maxDuration: maxDuration,
+    maxIterations: maxIterations)
+
+  Benchmark.defaultConfiguration = megaConfiguration
+
+  // Decode (read path)
+
+  // Raw scalar read: isolates `read<T: BitwiseCopyable>` and the `let` blob.
+  Benchmark("Reading Doubles") { benchmark in
+    let byteBuffer = ByteBuffer(data: data)
+    benchmark.startMeasurement()
+    for _ in benchmark.scaledIterations {
+      blackHole(byteBuffer.read(def: Double.self, position: 0))
+    }
+    benchmark.stopMeasurement()
+  }
+
+  // Realistic decode: resolve root map and read a keyed scalar.
+  Benchmark("Decode Map Scalar") { benchmark in
+    benchmark.startMeasurement()
+    for _ in benchmark.scaledIterations {
+      let map = try! getRoot(buffer: mapBuffer)!.map!
+      blackHole(map["i25"]?.int)
+    }
+    benchmark.stopMeasurement()
+  }
+
+  // Realistic decode: resolve root map and read a keyed string.
+  Benchmark("Decode Map String") { benchmark in
+    benchmark.startMeasurement()
+    for _ in benchmark.scaledIterations {
+      let map = try! getRoot(buffer: mapBuffer)!.map!
+      blackHole(map["s"]?.string())
+    }
+    benchmark.stopMeasurement()
+  }
+
+  // Realistic decode: resolve a nested vector and sum its scalars.
+  Benchmark("Decode Vector") { benchmark in
+    benchmark.startMeasurement()
+    for _ in benchmark.scaledIterations {
+      let map = try! getRoot(buffer: mapBuffer)!.map!
+      let vector = map["v"]!.vector!
+      var sum: Int64 = 0
+      for i in 0..<vector.count {
+        sum &+= vector[i]?.int ?? 0
+      }
+      blackHole(sum)
+    }
+    benchmark.stopMeasurement()
+  }
+
+  // Encode (write path)
+  // Writers are reused with `reset(keepingCapacity:)` so per-iteration
+  // allocation does not dominate and mask the write-path cost (which is what
+  // the `@exclusivity(unchecked)` storage pointer affects).
+
+  Benchmark("Strings 10") { benchmark in
+    var fbx = FlexBuffersWriter(initialSize: 1 << 20)
+    benchmark.startMeasurement()
+    for _ in benchmark.scaledIterations {
+      fbx.add(string: str10)
+      fbx.finish()
+      blackHole(fbx.sizedByteBuffer)
+      fbx.reset(keepingCapacity: true)
+    }
+    benchmark.stopMeasurement()
+  }
+
+  Benchmark("Strings 100") { benchmark in
+    var fbx = FlexBuffersWriter(initialSize: 1 << 20)
+    benchmark.startMeasurement()
+    for _ in benchmark.scaledIterations {
+      fbx.add(string: str100)
+      fbx.finish()
+      blackHole(fbx.sizedByteBuffer)
+      fbx.reset(keepingCapacity: true)
+    }
+    benchmark.stopMeasurement()
+  }
+
+  Benchmark("Encoding Vector Of Ints") { benchmark in
+    var fbx = FlexBuffersWriter(initialSize: 1 << 20)
+    benchmark.startMeasurement()
+    for _ in benchmark.scaledIterations {
+      fbx.vector {
+        $0.create(vector: ints)
+      }
+      fbx.finish()
+      blackHole(fbx.sizedByteBuffer)
+      fbx.reset(keepingCapacity: true)
+    }
+    benchmark.stopMeasurement()
+  }
+
+  Benchmark("Encoding Map") { benchmark in
+    var fbx = FlexBuffersWriter(initialSize: 1 << 20)
+    benchmark.startMeasurement()
+    for _ in benchmark.scaledIterations {
+      fbx.map {
+        for i in 0..<50 { $0.add(int: i, key: "i\(i)") }
+        $0.add(string: "hello world", key: "s")
+        $0.vector(key: "v") { v in
+          for x in 0..<100 { v.add(int: x) }
+        }
+      }
+      fbx.finish()
+      blackHole(fbx.sizedByteBuffer)
+      fbx.reset(keepingCapacity: true)
+    }
+    benchmark.stopMeasurement()
+  }
+}

docs/source/flatc.md

@@ -79,11 +79,12 @@ list of `FILES...`.
     `myschema.fbs` to JSON:
 
     ```sh
-    flatc --json myschema.fbs mydata.bin
+    flatc --json myschema.fbs -- mydata.bin
     ```
 
-    This will generate a `mydata.json` file.
-
+    This will generate a `mydata.json` file. If there is no
+    [`file_identifier`](schema.md/#file-identification-and-extension) defined
+    for this schema, you will need to use the `--raw-binary` option.
 
 ### Additional options
 
@@ -167,6 +168,12 @@ 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,6 +242,42 @@ 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:
 
@@ -337,6 +373,27 @@ 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/tutorial.md

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

go/table.go

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

goldens/py/flatbuffers/goldens/Universe.py

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

goldens/rust/basic_generated.rs

@@ -1,14 +1,16 @@
 // automatically generated by the FlatBuffers compiler, do not modify
 // @generated
-extern crate alloc;
 
+extern crate alloc;
 
 #[allow(unused_imports, dead_code)]
 pub mod flatbuffers {
 
+extern crate alloc;
 #[allow(unused_imports, dead_code)]
 pub mod goldens {
 
+extern crate alloc;
 
 pub enum GalaxyOffset {}
 #[derive(Copy, Clone, PartialEq)]

grpc/examples/greeter_v2.fbs

@@ -0,0 +1,16 @@
+namespace models;
+
+table HelloResponse {
+  message:string;
+}
+
+table HelloRequest {
+  name:string;
+}
+
+rpc_service Greeter {
+  Get(HelloRequest):HelloResponse;
+  Collect(HelloRequest):HelloResponse (streaming: "client");
+  Expand(HelloRequest):HelloResponse (streaming: "server");
+  Update(HelloRequest):HelloResponse (streaming: "bidi");
+}

grpc/examples/swift/Greeter/Sources/Commands/Commands.swift

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2024 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import ArgumentParser
+
+let port = 3000
+
+@main
+struct GreeterCommand: AsyncParsableCommand {
+  static let configuration = CommandConfiguration(
+    commandName: "greeter",
+    abstract: "A multi-tool to run an echo server and execute RPCs against it.",
+    subcommands: [ServerCommand.self, ClientCommand.self])
+}
+

grpc/examples/swift/Greeter/Sources/Commands/Services/GreeterService.swift

@@ -0,0 +1,121 @@
+/*
+ * Copyright 2024 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import FlatBuffers
+import GRPCCore
+import Models
+
+struct GreeterService: models_Greeter.SimpleServiceProtocol {
+  func Get(
+    request: GRPCMessage<models_HelloResponse>,
+    context: GRPCCore
+      .ServerContext) async throws -> GRPCMessage<models_HelloResponse>
+  {
+    let model = try request.decode()
+    print("## GreeterService.Get: \(model.message)")
+
+    var builder = FlatBufferBuilder(initialSize: 128)
+    let off = builder.create(string: "Hello \(model.message ?? "Unknown")")
+    let root = models_HelloResponse.createHelloResponse(
+      &builder,
+      messageOffset: off)
+    builder.finish(offset: root)
+    return try GRPCMessage<models_HelloResponse>(builder: &builder)
+  }
+
+  func Collect(
+    request: GRPCCore.RPCAsyncSequence<
+      GRPCMessage<models_HelloResponse>,
+      any Swift.Error
+    >,
+    context: GRPCCore
+      .ServerContext) async throws -> GRPCMessage<models_HelloResponse>
+  {
+    let messages: [String] = try await request
+      .reduce(into: []) { array, message in
+        let model = try message.decode()
+        return array.append(model.message ?? "Unknown")
+      }
+
+    let joined = messages.joined(separator: ", ")
+    print("## GreeterService.Collect: \(joined)")
+
+    var builder = FlatBufferBuilder(initialSize: 128)
+    let off = builder.create(string: "Hello \(joined)")
+    let root = models_HelloResponse.createHelloResponse(
+      &builder,
+      messageOffset: off)
+    builder.finish(offset: root)
+    return try GRPCMessage<models_HelloResponse>(builder: &builder)
+  }
+
+  func Expand(
+    request: GRPCMessage<models_HelloResponse>,
+    response: GRPCCore.RPCWriter<GRPCMessage<models_HelloResponse>>,
+    context: GRPCCore.ServerContext) async throws
+  {
+
+    let model = try request.decode()
+    print("## GreeterService.Expand: \(model.message)")
+
+    let message = model.message ?? "Unknown"
+    let stream = AsyncThrowingStream<
+      GRPCMessage<models_HelloResponse>,
+      Error
+    > { continuation in
+      var builder = FlatBufferBuilder(initialSize: 128)
+      for char in message {
+        let off = builder.create(string: "\(char)")
+        let root = models_HelloResponse.createHelloResponse(
+          &builder,
+          messageOffset: off)
+        builder.finish(offset: root)
+
+        do {
+          continuation
+            .yield(try GRPCMessage<models_HelloResponse>(builder: &builder))
+        } catch {
+          continuation.finish(throwing: error)
+        }
+      }
+
+      continuation.finish()
+    }
+    try await response.write(contentsOf: stream)
+  }
+
+  func Update(
+    request: GRPCCore.RPCAsyncSequence<
+      GRPCMessage<models_HelloResponse>,
+      any Swift.Error
+    >,
+    response: GRPCCore.RPCWriter<GRPCMessage<models_HelloResponse>>,
+    context: GRPCCore.ServerContext) async throws
+  {
+    for try await message in request {
+      let model = try message.decode()
+      print("## GreeterService.Update: \(model.message)")
+      var builder = FlatBufferBuilder(initialSize: 128)
+      let off = builder.create(string: "Hello \(model.message ?? "Unknown")")
+      let root = models_HelloResponse.createHelloResponse(
+        &builder,
+        messageOffset: off)
+      builder.finish(offset: root)
+      try await response
+        .write(try GRPCMessage<models_HelloResponse>(builder: &builder))
+    }
+  }
+}

grpc/examples/swift/Greeter/Sources/Commands/Subcommands/ClientCommand.swift

@@ -0,0 +1,140 @@
+/*
+ * Copyright 2024 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import ArgumentParser
+import FlatBuffers
+import GRPCCore
+import GRPCNIOTransportHTTP2
+import Models
+
+enum ClientRequest: String, ExpressibleByArgument {
+  case get, expand, collect, update
+}
+
+struct ClientCommand: AsyncParsableCommand {
+  static let configuration = CommandConfiguration(
+    commandName: "client")
+
+  @Option(help: "Name to send to the server")
+  var name: String
+
+  @Option(help: "request type")
+  var request: ClientRequest
+
+  func run() async throws {
+    try await withGRPCClient(
+      transport: .http2NIOPosix(
+        target: .dns(host: "localhost", port: port),
+        transportSecurity: .plaintext))
+    {
+      let client = models_Greeter.Client(wrapping: $0)
+
+      switch request {
+      case .get: try await get(client: client)
+      case .expand: try await expand(client: client)
+      case .collect: try await collect(client: client)
+      case .update: try await update(client: client)
+      }
+    }
+  }
+
+  func get(
+    client: models_Greeter
+      .Client<HTTP2ClientTransport.Posix>) async throws
+  {
+    for _ in 0..<3 {
+      var builder = FlatBufferBuilder(initialSize: 64)
+      let off = builder.create(string: name)
+      let root = models_HelloRequest.createHelloRequest(
+        &builder,
+        nameOffset: off)
+      builder.finish(offset: root)
+
+      let response = try await client
+        .Get(GRPCMessage(builder: &builder))
+      let message = try? response.decode().message
+      print("get message: \(message ?? "nil")")
+    }
+  }
+
+  func expand(
+    client: models_Greeter
+      .Client<HTTP2ClientTransport.Posix>) async throws
+  {
+    for _ in 0..<3 {
+      var builder = FlatBufferBuilder(initialSize: 64)
+      let off = builder.create(string: name)
+      let root = models_HelloRequest.createHelloRequest(
+        &builder,
+        nameOffset: off)
+      builder.finish(offset: root)
+      try await client.Expand(GRPCMessage(builder: &builder)) { response in
+        for try await message in response.messages {
+          let message = try? message.decode().message
+          print("expand message: \(message ?? "nil")")
+        }
+      }
+    }
+  }
+
+  func collect(
+    client: models_Greeter
+      .Client<HTTP2ClientTransport.Posix>) async throws
+  {
+    for _ in 0..<3 {
+      let response = try await client.Collect { writer in
+        for part in name {
+          print("collect sending: \(part)")
+          var builder = FlatBufferBuilder(initialSize: 64)
+          let off = builder.create(string: String(part))
+          let root = models_HelloRequest.createHelloRequest(
+            &builder,
+            nameOffset: off)
+          builder.finish(offset: root)
+          try await writer.write(GRPCMessage(builder: &builder))
+        }
+      }
+
+      let message = try response.decode().message
+      print("collect message: \(message ?? "nil")")
+    }
+  }
+
+  func update(
+    client: models_Greeter
+      .Client<HTTP2ClientTransport.Posix>) async throws
+  {
+    for _ in 0..<3 {
+      try await client.Update { writer in
+        for part in name {
+          print("update sending: \(part)")
+          var builder = FlatBufferBuilder(initialSize: 64)
+          let off = builder.create(string: String(part))
+          let root = models_HelloRequest.createHelloRequest(
+            &builder,
+            nameOffset: off)
+          builder.finish(offset: root)
+          try await writer.write(GRPCMessage(builder: &builder))
+        }
+      } onResponse: { response in
+        for try await message in response.messages {
+          let message = try message.decode().message
+          print("collect message: \(message ?? "nil")")
+        }
+      }
+    }
+  }
+}

grpc/examples/swift/Greeter/Sources/Commands/Subcommands/ServerCommand.swift

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2024 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import ArgumentParser
+import GRPCCore
+import GRPCNIOTransportHTTP2
+
+struct ServerCommand: AsyncParsableCommand {
+  static let configuration = CommandConfiguration(
+    commandName: "serve")
+
+  func run() async throws {
+    let server = GRPCServer(
+      transport: .http2NIOPosix(
+        address: .ipv4(host: "127.0.0.1", port: port),
+        transportSecurity: .plaintext),
+      services: [GreeterService()])
+
+    try await withThrowingDiscardingTaskGroup { group in
+      group.addTask { try await server.serve() }
+      if let address = try await server.listeningAddress {
+        print("Echo listening on \(address)")
+      }
+    }
+  }
+}

grpc/examples/swift/Greeter/Sources/Models/greeter_v2.grpc.swift

@@ -0,0 +1,572 @@
+// Generated GRPC code for FlatBuffers swift!
+/// The following code is generated by the Flatbuffers library which might not be in sync with grpc-swift
+/// in case of an issue please open github issue, though it would be maintained
+
+// swiftlint:disable all
+// swiftformat:disable all
+
+#if !os(Windows) && compiler(>=6.0)
+import FlatBuffers
+import Foundation
+import GRPCCore
+import GRPCNIOTransportCore
+
+
+/// Usage: instantiate models.GreeterServiceClient, then call methods of this protocol to make API calls.
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension FlatBuffersMessageSerializer: MessageSerializer {
+  public func serialize<Bytes>(_ message: Message) throws -> Bytes where Bytes : GRPCCore.GRPCContiguousBytes {
+    do {
+      return try self.serialize(message: message) { GRPCNIOTransportBytes($0) } as! Bytes
+    } catch let error {
+      throw RPCError(
+        code: .invalidArgument,
+        message: "Can't serialize message",
+        cause: error
+      )
+    }
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension FlatBuffersMessageDeserializer: MessageDeserializer {
+  public func deserialize<Bytes>(_ serializedMessageBytes: Bytes) throws -> Message where Bytes : GRPCCore.GRPCContiguousBytes {
+    do {
+      return try serializedMessageBytes.withUnsafeBytes {
+        try self.deserialize(pointer: $0)
+      }
+    } catch let error {
+      throw RPCError(
+        code: .invalidArgument,
+        message: "Can't Decode message of type \(Message.self)",
+        cause: error
+      )
+    }
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+public enum models_Greeter: Sendable {
+  public static let descriptor = GRPCCore.ServiceDescriptor(fullyQualifiedService: "models.Greeter")
+  public enum Method: Sendable {
+    public enum Get: Sendable {
+      public typealias Input = FlatBufferBuilder
+      public typealias Output = models_HelloResponse
+      public static let descriptor = GRPCCore.MethodDescriptor(
+        service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "models.Greeter"),
+        method: "Get"
+      )
+    }
+    public enum Collect: Sendable {
+      public typealias Input = FlatBufferBuilder
+      public typealias Output = models_HelloResponse
+      public static let descriptor = GRPCCore.MethodDescriptor(
+        service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "models.Greeter"),
+        method: "Collect"
+      )
+    }
+    public enum Expand: Sendable {
+      public typealias Input = FlatBufferBuilder
+      public typealias Output = models_HelloResponse
+      public static let descriptor = GRPCCore.MethodDescriptor(
+        service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "models.Greeter"),
+        method: "Expand"
+      )
+    }
+    public enum Update: Sendable {
+      public typealias Input = FlatBufferBuilder
+      public typealias Output = models_HelloResponse
+      public static let descriptor = GRPCCore.MethodDescriptor(
+        service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "models.Greeter"),
+        method: "Update"
+      )
+    }
+    public static let descriptors: [GRPCCore.MethodDescriptor] = [
+      Get.descriptor,
+      Collect.descriptor,
+      Expand.descriptor,
+      Update.descriptor,
+    ]
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension GRPCCore.ServiceDescriptor {
+  public static let models_Greeter = GRPCCore.ServiceDescriptor(fullyQualifiedService: "models.Greeter")
+}
+
+// MARK: models.Greeter Server
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension models_Greeter {
+  public protocol StreamingServiceProtocol: GRPCCore.RegistrableRPCService {
+    func Get(
+      request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>
+    
+    func Collect(
+      request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>
+    
+    func Expand(
+      request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>
+    
+    func Update(
+      request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>
+    
+  }
+  
+  public protocol ServiceProtocol: models_Greeter.StreamingServiceProtocol {
+    func Get(
+      request: GRPCCore.ServerRequest<GRPCMessage<models_HelloResponse>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.ServerResponse<GRPCMessage<models_HelloResponse>>
+    
+    func Collect(
+      request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.ServerResponse<GRPCMessage<models_HelloResponse>>
+    
+    func Expand(
+      request: GRPCCore.ServerRequest<GRPCMessage<models_HelloResponse>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>
+    
+    func Update(
+      request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>
+    
+  }
+  
+  public protocol SimpleServiceProtocol: models_Greeter.ServiceProtocol {
+    func Get(
+      request: GRPCMessage<models_HelloResponse>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCMessage<models_HelloResponse>
+    
+    func Collect(
+      request: GRPCCore.RPCAsyncSequence<GRPCMessage<models_HelloResponse>, any Swift.Error>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCMessage<models_HelloResponse>
+    
+    func Expand(
+      request: GRPCMessage<models_HelloResponse>,
+      response: GRPCCore.RPCWriter<GRPCMessage<models_HelloResponse>>,
+      context: GRPCCore.ServerContext
+    ) async throws
+    
+    func Update(
+      request: GRPCCore.RPCAsyncSequence<GRPCMessage<models_HelloResponse>, any Swift.Error>,
+      response: GRPCCore.RPCWriter<GRPCMessage<models_HelloResponse>>,
+      context: GRPCCore.ServerContext
+    ) async throws
+    
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension models_Greeter.StreamingServiceProtocol {
+  public func registerMethods<Transport>(with router: inout GRPCCore.RPCRouter<Transport>) where Transport: GRPCCore.ServerTransport {
+    router.registerHandler(
+      forMethod: models_Greeter.Method.Get.descriptor,
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
+      handler: { request, context in
+        try await self.Get(
+          request: request,
+          context: context
+        )
+      }
+    )
+    router.registerHandler(
+      forMethod: models_Greeter.Method.Collect.descriptor,
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
+      handler: { request, context in
+        try await self.Collect(
+          request: request,
+          context: context
+        )
+      }
+    )
+    router.registerHandler(
+      forMethod: models_Greeter.Method.Expand.descriptor,
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
+      handler: { request, context in
+        try await self.Expand(
+          request: request,
+          context: context
+        )
+      }
+    )
+    router.registerHandler(
+      forMethod: models_Greeter.Method.Update.descriptor,
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
+      handler: { request, context in
+        try await self.Update(
+          request: request,
+          context: context
+        )
+      }
+    )
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension models_Greeter.ServiceProtocol {
+  public func Get(
+    request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>> {
+    let response = try await self.Get(
+      request: GRPCCore.ServerRequest(stream: request),
+      context: context
+    )
+    return GRPCCore.StreamingServerResponse(single: response)
+  }
+  public func Collect(
+    request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>> {
+    let response = try await self.Collect(
+      request: request,
+      context: context
+    )
+    return GRPCCore.StreamingServerResponse(single: response)
+  }
+  public func Expand(
+    request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>> {
+    let response = try await self.Expand(
+      request: GRPCCore.ServerRequest(stream: request),
+      context: context
+    )
+    return response
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension models_Greeter.SimpleServiceProtocol {
+  public func Get(
+    request: GRPCCore.ServerRequest<GRPCMessage<models_HelloResponse>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.ServerResponse<GRPCMessage<models_HelloResponse>> {
+    return GRPCCore.ServerResponse<GRPCMessage<models_HelloResponse>>(
+      message: try await self.Get(
+        request: request.message,
+        context: context
+      ),
+      metadata: [:]
+    )
+  }
+  public func Collect(
+    request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.ServerResponse<GRPCMessage<models_HelloResponse>> {
+    return GRPCCore.ServerResponse<GRPCMessage<models_HelloResponse>>(
+      message: try await self.Collect(
+        request: request.messages,
+        context: context
+      ),
+      metadata: [:]
+    )
+  }
+  public func Expand(
+    request: GRPCCore.ServerRequest<GRPCMessage<models_HelloResponse>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>> {
+    return GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>(
+      metadata: [:],
+      producer: { writer in
+        try await self.Expand(
+          request: request.message,
+          response: writer,
+          context: context
+        )
+        return [:]
+      }
+    )
+  }
+  public func Update(
+    request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>> {
+    return GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>(
+      metadata: [:],
+      producer: { writer in
+        try await self.Update(
+          request: request.messages,
+          response: writer,
+          context: context
+        )
+        return [:]
+      }
+    )
+  }
+}
+
+
+// MARK: models.Greeter Client
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension models_Greeter {
+  public protocol ClientProtocol: Sendable {
+    func Get<Result>(
+      request: GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
+      options: GRPCCore.CallOptions,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
+    ) async throws -> Result where Result: Sendable
+    
+    func Collect<Result>(
+      request: GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
+      options: GRPCCore.CallOptions,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
+    ) async throws -> Result where Result: Sendable
+    
+    func Expand<Result>(
+      request: GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
+      options: GRPCCore.CallOptions,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
+    ) async throws -> Result where Result: Sendable
+    
+    func Update<Result>(
+      request: GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
+      options: GRPCCore.CallOptions,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
+    ) async throws -> Result where Result: Sendable
+    
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension models_Greeter {
+  public struct Client<Transport>: ClientProtocol where Transport: GRPCCore.ClientTransport {
+    private let client: GRPCCore.GRPCClient<Transport>
+    
+    public init(wrapping client: GRPCCore.GRPCClient<Transport>) {
+      self.client = client
+    }
+    
+    public func Get<Result>(
+      request: GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
+      options: GRPCCore.CallOptions = .defaults,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result = { response in try response.message }
+    ) async throws -> Result where Result: Sendable {
+      try await self.client.unary(
+        request: request,
+        descriptor: models_Greeter.Method.Get.descriptor,
+        serializer: serializer,
+        deserializer: deserializer,
+        options: options,
+        onResponse: handleResponse
+      )
+    }
+    
+    public func Collect<Result>(
+      request: GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
+      options: GRPCCore.CallOptions = .defaults,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result = { response in try response.message }
+    ) async throws -> Result where Result: Sendable {
+      try await self.client.clientStreaming(
+        request: request,
+        descriptor: models_Greeter.Method.Collect.descriptor,
+        serializer: serializer,
+        deserializer: deserializer,
+        options: options,
+        onResponse: handleResponse
+      )
+    }
+    
+    public func Expand<Result>(
+      request: GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
+      options: GRPCCore.CallOptions = .defaults,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
+    ) async throws -> Result where Result: Sendable {
+      try await self.client.serverStreaming(
+        request: request,
+        descriptor: models_Greeter.Method.Expand.descriptor,
+        serializer: serializer,
+        deserializer: deserializer,
+        options: options,
+        onResponse: handleResponse
+      )
+    }
+    
+    public func Update<Result>(
+      request: GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
+      options: GRPCCore.CallOptions = .defaults,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
+    ) async throws -> Result where Result: Sendable {
+      try await self.client.bidirectionalStreaming(
+        request: request,
+        descriptor: models_Greeter.Method.Update.descriptor,
+        serializer: serializer,
+        deserializer: deserializer,
+        options: options,
+        onResponse: handleResponse
+      )
+    }
+    
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension models_Greeter.ClientProtocol {
+  public func Get<Result>(
+    request: GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>,
+    options: GRPCCore.CallOptions = .defaults,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result = { response in try response.message }
+  ) async throws -> Result where Result: Sendable {
+    try await self.Get(
+      request: request,
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+  public func Collect<Result>(
+    request: GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>,
+    options: GRPCCore.CallOptions = .defaults,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result = { response in try response.message }
+  ) async throws -> Result where Result: Sendable {
+    try await self.Collect(
+      request: request,
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+  public func Expand<Result>(
+    request: GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>,
+    options: GRPCCore.CallOptions = .defaults,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
+  ) async throws -> Result where Result: Sendable {
+    try await self.Expand(
+      request: request,
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+  public func Update<Result>(
+    request: GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>,
+    options: GRPCCore.CallOptions = .defaults,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
+  ) async throws -> Result where Result: Sendable {
+    try await self.Update(
+      request: request,
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension models_Greeter.ClientProtocol {
+  public func Get<Result>(
+    _ message: GRPCMessage<models_HelloResponse>,
+    metadata: GRPCCore.Metadata = [:],
+    options: GRPCCore.CallOptions = .defaults,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result = { try $0.message }
+  ) async throws -> Result where Result: Sendable {
+    let request = GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>(
+      message: message,
+      metadata: metadata
+    )
+    return try await self.Get(
+      request: request,
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+  public func Collect<Result>(
+    metadata: GRPCCore.Metadata = [:],
+    options: GRPCCore.CallOptions = .defaults,
+    requestProducer producer: @Sendable @escaping (GRPCCore.RPCWriter<GRPCMessage<models_HelloResponse>>) async throws -> Void,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result = { try $0.message }
+  ) async throws -> Result where Result: Sendable {
+    let request = GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>(
+      metadata: metadata,
+      producer: producer
+    )
+    return try await self.Collect(
+      request: request,
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+  public func Expand<Result>(
+    _ message: GRPCMessage<models_HelloResponse>,
+    metadata: GRPCCore.Metadata = [:],
+    options: GRPCCore.CallOptions = .defaults,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
+  ) async throws -> Result where Result: Sendable {
+    let request = GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>(
+      message: message,
+      metadata: metadata
+    )
+    return try await self.Expand(
+      request: request,
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+  public func Update<Result>(
+    metadata: GRPCCore.Metadata = [:],
+    options: GRPCCore.CallOptions = .defaults,
+    requestProducer producer: @Sendable @escaping (GRPCCore.RPCWriter<GRPCMessage<models_HelloResponse>>) async throws -> Void,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
+  ) async throws -> Result where Result: Sendable {
+    let request = GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>(
+      metadata: metadata,
+      producer: producer
+    )
+    return try await self.Update(
+      request: request,
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+}
+
+#endif
+

grpc/examples/swift/Greeter/Sources/Models/greeter_v2_generated.swift

@@ -0,0 +1,100 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// swiftlint:disable all
+// swiftformat:disable all
+
+#if canImport(Common)
+import Common
+#endif
+
+import FlatBuffers
+
+public struct models_HelloResponse: FlatBufferVerifiableTable, FlatbuffersVectorInitializable {
+
+  static func validateVersion() { FlatBuffersVersion_25_12_19() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Table
+
+  private init(_ t: Table) { _accessor = t }
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+  private struct VT {
+    static let message: VOffset = 4
+  }
+
+  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: VT.message) }
+  public static func startHelloResponse(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
+  public static func add(message: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: message, at: VT.message) }
+  public static func endHelloResponse(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
+  public static func createHelloResponse(
+    _ fbb: inout FlatBufferBuilder,
+    messageOffset message: Offset = Offset()
+  ) -> Offset {
+    let __start = models_HelloResponse.startHelloResponse(&fbb)
+    models_HelloResponse.add(message: message, &fbb)
+    return models_HelloResponse.endHelloResponse(&fbb, start: __start)
+  }
+
+  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: VT.message, fieldName: "message", required: false, type: ForwardOffset<String>.self)
+    _v.finish()
+  }
+}
+
+extension models_HelloResponse: 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)
+  }
+}
+
+public struct models_HelloRequest: FlatBufferVerifiableTable, FlatbuffersVectorInitializable {
+
+  static func validateVersion() { FlatBuffersVersion_25_12_19() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Table
+
+  private init(_ t: Table) { _accessor = t }
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+  private struct VT {
+    static let name: VOffset = 4
+  }
+
+  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: 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: 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,
+    nameOffset name: Offset = Offset()
+  ) -> Offset {
+    let __start = models_HelloRequest.startHelloRequest(&fbb)
+    models_HelloRequest.add(name: name, &fbb)
+    return models_HelloRequest.endHelloRequest(&fbb, start: __start)
+  }
+
+  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: VT.name, fieldName: "name", required: false, type: ForwardOffset<String>.self)
+    _v.finish()
+  }
+}
+
+extension models_HelloRequest: Encodable {
+  enum CodingKeys: String, CodingKey {
+    case name = "name"
+  }
+
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encodeIfPresent(name, forKey: .name)
+  }
+}
+

include/codegen/namer.h

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

include/codegen/python.h

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

include/flatbuffers/base.h

@@ -142,6 +142,19 @@
 #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/flatbuffers.h

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

include/flatbuffers/idl.h

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

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

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

lua/flatbuffers/builder.lua

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

net/FlatBuffers/Table.cs

@@ -150,7 +150,7 @@ namespace Google.FlatBuffers
 
             var pos = this.__vector(o);
             var len = this.__vector_len(o);
-            return bb.ToArray<T>(pos, len);
+            return bb.ToArray<T>(pos, len * ByteBuffer.SizeOf<T>());
         }
 
         // Initialize any Table-derived type to point to the union at the given offset.

pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+packages:
+  - tests/ts

python/flatbuffers/builder.py

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

python/flatbuffers/reflection/Enum.py

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

python/flatbuffers/reflection/EnumVal.py

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

python/flatbuffers/reflection/Field.py

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

python/flatbuffers/reflection/Object.py

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

python/flatbuffers/reflection/RPCCall.py

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

python/flatbuffers/reflection/Schema.py

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

python/flatbuffers/reflection/SchemaFile.py

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

python/flatbuffers/reflection/Service.py

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

rust/flatbuffers/src/builder.rs

@@ -611,6 +611,8 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
         // Write the VTable (we may delete it afterwards, if it is a duplicate):
         let vt_start_pos = self.head;
         let vt_end_pos = self.head + vtable_byte_len;
+        // Zero out the vtable space - make_space only reserves but doesn't initialize
+        self.allocator[vt_start_pos.range_to(vt_end_pos)].fill(0);
         {
             // write the vtable header:
             let vtfw =

rust/flexbuffers/src/builder/ser.rs

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

samples/monster_generated.h

@@ -328,6 +328,10 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const MyGame::Sample::Weapon *equipped_as_Weapon() const {
     return equipped_type() == MyGame::Sample::Equipment_Weapon ? static_cast<const MyGame::Sample::Weapon *>(equipped()) : nullptr;
   }
+  template<typename T> T *mutable_equipped_as();
+  MyGame::Sample::Weapon *mutable_equipped_as_Weapon() {
+    return equipped_type() == MyGame::Sample::Equipment_Weapon ? static_cast<MyGame::Sample::Weapon *>(mutable_equipped()) : nullptr;
+  }
   void *mutable_equipped() {
     return GetPointer<void *>(VT_EQUIPPED);
   }
@@ -367,6 +371,10 @@ template<> inline const MyGame::Sample::Weapon *Monster::equipped_as<MyGame::Sam
   return equipped_as_Weapon();
 }
 
+template<> inline MyGame::Sample::Weapon *Monster::mutable_equipped_as<MyGame::Sample::Weapon>() {
+  return mutable_equipped_as_Weapon();
+}
+
 struct MonsterBuilder {
   typedef Monster Table;
   ::flatbuffers::FlatBufferBuilder &fbb_;

scripts/check_generate_code.py

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

scripts/generate_code.py

@@ -85,6 +85,11 @@ RUST_OPTS = BASE_OPTS + [
     "--gen-name-strings",
     "--rust-module-root-file",
 ]
+RUST_STANDALONE_OPTS = BASE_OPTS + [
+    "--rust",
+    "--gen-all",
+    "--gen-name-strings",
+]
 RUST_SERIALIZE_OPTS = BASE_OPTS + [
     "--rust",
     "--gen-all",
@@ -246,6 +251,21 @@ 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",
@@ -288,6 +308,12 @@ flatc(
     schema="include_test/include_test1.fbs",
 )
 
+flatc(
+    RUST_STANDALONE_OPTS,
+    include="include_test",
+    schema="include_test/include_test1.fbs",
+)
+
 flatc(
     RUST_OPTS,
     prefix="include_test2",
@@ -295,6 +321,12 @@ flatc(
     schema="include_test/sub/include_test2.fbs",
 )
 
+flatc(
+    RUST_STANDALONE_OPTS,
+    include="include_test",
+    schema="include_test/sub/include_test2.fbs",
+)
+
 flatc(
     BINARY_OPTS + ["--bfbs-filenames", str(tests_path)],
     include="include_test",

src/bfbs_gen_lua.cpp

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

src/bfbs_gen_nim.cpp

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

src/flatc.cpp

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

src/idl_gen_cpp.cpp

@@ -257,6 +257,19 @@ 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() {
@@ -529,6 +542,8 @@ 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.
@@ -758,6 +773,8 @@ class CppGenerator : public BaseGenerator {
 
     if (cur_name_space_) SetNameSpace(nullptr);
 
+    GenerateBigfootRefImpls();
+
     // Close the include guard.
     code_ += "#endif  // " + include_guard;
 
@@ -892,6 +909,24 @@ 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.
@@ -937,6 +972,23 @@ 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);
@@ -974,20 +1026,21 @@ class CppGenerator : public BaseGenerator {
       case BASE_TYPE_VECTOR64:
       case BASE_TYPE_VECTOR: {
         const auto type_name = GenTypeNative(type.VectorType(), true, field);
-        if (type.struct_def &&
+        const auto vector_type = NativeVectorType(&field);
+        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 "std::vector<" + type_name + ">";
+          return vector_type + "<" + type_name + ">";
         }
       }
       case BASE_TYPE_STRUCT: {
         auto type_name = WrapInNameSpace(*type.struct_def);
         if (IsStruct(type)) {
-          auto native_type = type.struct_def->attributes.Lookup("native_type");
+          auto native_type = EffectiveNativeType(field, *type.struct_def);
           if (native_type) {
             type_name = native_type->constant;
           }
@@ -1979,7 +2032,7 @@ class CppGenerator : public BaseGenerator {
       const std::string& full_type =
           (cpp_type
                ? (IsVector(field.value.type)
-                      ? "std::vector<" +
+                      ? NativeVectorType(&field) + "<" +
                             GenTypeNativePtr(cpp_type->constant, &field,
                                              false) +
                             "> "
@@ -1996,8 +2049,19 @@ class CppGenerator : public BaseGenerator {
               " = " + (native_default ? std::string(native_default->constant)
                                       : GetDefaultScalarValue(field, true));
         } else if (field.value.type.base_type == BASE_TYPE_STRUCT) {
-          if (IsStruct(field.value.type) && native_default) {
-            field_di = " = " + native_default->constant;
+          if (IsStruct(field.value.type)) {
+            if (native_default) {
+              field_di = " = " + native_default->constant;
+            }
+          } else if (!cpp_type && !field.native_inline && field.IsRequired() &&
+                     PtrType(&field) != "naked") {
+            // A required table field can never legally be absent once
+            // Verify()/Pack() succeed, so default-construct it here instead
+            // of leaving every hand-written native constructor to remember
+            // to allocate it before the first Pack().
+            const auto nn = WrapNativeNameInNameSpace(
+                *field.value.type.struct_def, opts_);
+            field_di = "{new " + nn + "()}";
           }
         }
       }
@@ -2685,14 +2749,18 @@ class CppGenerator : public BaseGenerator {
     code_ += "  }";
   }
 
-  void GenTableUnionAsGetters(const FieldDef& field) {
+  void GenTableUnionAsGetters(const FieldDef& field, bool is_mutable) {
     const auto& type = field.value.type;
     auto u = type.enum_def;
 
+    code_.SetValue("MUTABLE_EXT", is_mutable ? "" : " const");
+    code_.SetValue("MUTABLE", is_mutable ? "mutable_" : "");
+
     if (!type.enum_def->uses_multiple_type_instances)
       code_ +=
-          "  template<typename T> "
-          "const T *{{NULLABLE_EXT}}{{FIELD_NAME}}_as() const;";
+          "  template<typename T>"
+          "{{MUTABLE_EXT}} T *{{MUTABLE}}{{NULLABLE_EXT}}{{FIELD_NAME}}_as()"
+          "{{MUTABLE_EXT}};";
 
     for (auto u_it = u->Vals().begin(); u_it != u->Vals().end(); ++u_it) {
       auto& ev = **u_it;
@@ -2706,15 +2774,19 @@ class CppGenerator : public BaseGenerator {
                      EscapeKeyword(Name(field) + UnionTypeFieldSuffix()));
       code_.SetValue("U_ELEMENT_TYPE", WrapInNameSpace(u->defined_namespace,
                                                        GetEnumValUse(*u, ev)));
-      code_.SetValue("U_FIELD_TYPE", "const " + full_struct_name + " *");
+      code_.SetValue("U_FIELD_TYPE",
+                     (is_mutable ? "" : "const ") + full_struct_name + " *");
       code_.SetValue("U_FIELD_NAME", Name(field) + "_as_" + Name(ev));
       code_.SetValue("U_NULLABLE", NullableExtension());
 
       // `const Type *union_name_asType() const` accessor.
-      code_ += "  {{U_FIELD_TYPE}}{{U_NULLABLE}}{{U_FIELD_NAME}}() const {";
+      // and `Type *mutable_union_name_asType()` accessor.
+      code_ +=
+          "  {{U_FIELD_TYPE}}{{U_NULLABLE}}{{MUTABLE}}{{U_FIELD_NAME}}()"
+          "{{MUTABLE_EXT}} {";
       code_ +=
           "    return {{U_GET_TYPE}}() == {{U_ELEMENT_TYPE}} ? "
-          "static_cast<{{U_FIELD_TYPE}}>({{FIELD_NAME}}()) "
+          "static_cast<{{U_FIELD_TYPE}}>({{MUTABLE}}{{FIELD_NAME}}()) "
           ": nullptr;";
       code_ += "  }";
     }
@@ -2755,7 +2827,7 @@ class CppGenerator : public BaseGenerator {
       code_.SetValue("FIELD_VALUE", GenUnderlyingCast(field, true, call));
       code_.SetValue("NULLABLE_EXT", NullableExtension());
       code_ += "  {{FIELD_TYPE}}{{FIELD_NAME}}() const {";
-            if (IsVector(type) && field.value.constant == "[]") {
+      if (IsVector(type) && field.value.constant == "[]") {
         const auto& vec_type = type.VectorType();
         const std::string vtype_wire = GenTypeWire(
             vec_type, "", VectorElementUserFacing(vec_type), field.offset64);
@@ -2799,7 +2871,7 @@ class CppGenerator : public BaseGenerator {
     }
 
     if (type.base_type == BASE_TYPE_UNION) {
-      GenTableUnionAsGetters(field);
+      GenTableUnionAsGetters(field, false);
     }
   }
 
@@ -2974,6 +3046,11 @@ class CppGenerator : public BaseGenerator {
       auto wire_type = GenTypeGet(type, " ", "", postptr.c_str(), true);
       code_.SetValue("FIELD_TYPE", wire_type);
 
+      // mutable union accessors
+      if (type.base_type == BASE_TYPE_UNION) {
+        GenTableUnionAsGetters(field, true);
+      }
+
       if (IsVector(type) && field.value.constant == "[]") {
         const auto& vec_type = type.VectorType();
         const std::string vtype_wire = GenTypeWire(
@@ -3185,6 +3262,7 @@ class CppGenerator : public BaseGenerator {
         code_.SetValue("U_FIELD_NAME", Name(*field) + "_as_" + Name(ev));
 
         // `template<> const T *union_name_as<T>() const` accessor.
+        // and `template<> T *mutable_union_name_as<T>()` accessor.
         code_ +=
             "template<> "
             "inline {{U_FIELD_TYPE}}{{STRUCT_NAME}}::{{FIELD_NAME}}_as"
@@ -3192,6 +3270,20 @@ class CppGenerator : public BaseGenerator {
         code_ += "  return {{U_FIELD_NAME}}();";
         code_ += "}";
         code_ += "";
+
+        if (opts_.mutable_buffer) {
+          code_.SetValue("U_FIELD_TYPE", full_struct_name + " *");
+          code_.SetValue("U_FIELD_NAME",
+                         "mutable_" + Name(*field) + "_as_" + Name(ev));
+          code_ +=
+              "template<> "
+              "inline {{U_FIELD_TYPE}}"
+              "{{STRUCT_NAME}}::mutable_{{FIELD_NAME}}_as"
+              "<{{U_ELEMENT_NAME}}>() {";
+          code_ += "  return {{U_FIELD_NAME}}();";
+          code_ += "}";
+          code_ += "";
+        }
       }
     }
 
@@ -3487,11 +3579,11 @@ class CppGenerator : public BaseGenerator {
       }
       case BASE_TYPE_STRUCT: {
         if (IsStruct(type)) {
-          const auto& struct_attrs = type.struct_def->attributes;
-          const auto native_type = struct_attrs.Lookup("native_type");
+          const auto native_type = EffectiveNativeType(afield, *type.struct_def);
           if (native_type) {
             std::string unpack_call = "::flatbuffers::UnPack";
-            const auto pack_name = struct_attrs.Lookup("native_type_pack_name");
+            const auto pack_name =
+                EffectiveNativeTypePackName(afield, *type.struct_def);
             if (pack_name) {
               unpack_call += pack_name->constant;
             }
@@ -3744,13 +3836,22 @@ 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 (NativeString(&field) == "std::string") {
+            if (!custom_vector && 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>>"
@@ -3765,20 +3866,37 @@ class CppGenerator : public BaseGenerator {
           }
           case BASE_TYPE_STRUCT: {
             if (IsStruct(vector_type)) {
-              const auto& struct_attrs =
-                  field.value.type.struct_def->attributes;
-              const auto native_type = struct_attrs.Lookup("native_type");
+              const auto native_type =
+                  EffectiveNativeType(field, *field.value.type.struct_def);
               if (native_type) {
                 code += "_fbb.CreateVectorOfNativeStructs<";
                 code += WrapInNameSpace(*vector_type.struct_def) + ", " +
                         native_type->constant + ">";
-                code += "(" + value;
-                const auto pack_name =
-                    struct_attrs.Lookup("native_type_pack_name");
+                if (custom_vector) {
+                  code += "(" + value + ".data(), " + value + ".size()";
+                } else {
+                  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) {
@@ -3790,7 +3908,11 @@ class CppGenerator : public BaseGenerator {
                     code += "64<::flatbuffers::Vector>";
                   }
                 }
-                code += "(" + value + ")";
+                if (custom_vector) {
+                  code += "(" + value + ".data(), " + value + ".size())";
+                } else {
+                  code += "(" + value + ")";
+                }
               }
             } else {
               code += "_fbb.CreateVector<::flatbuffers::Offset<";
@@ -3809,7 +3931,17 @@ class CppGenerator : public BaseGenerator {
             break;
           }
           case BASE_TYPE_BOOL: {
-            code += "_fbb.CreateVector(" + value + ")";
+            if (custom_vector) {
+              // 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: {
@@ -3845,9 +3977,11 @@ class CppGenerator : public BaseGenerator {
               // the underlying storage type (eg. uint8_t).
               const auto basetype = GenTypeBasic(
                   field.value.type.enum_def->underlying_type, false);
-              code += "_fbb.CreateVectorScalarCast<" + basetype +
-                      ">(::flatbuffers::data(" + value + "), " + value +
-                      ".size())";
+              const std::string data_ptr =
+                  custom_vector ? value + ".data()"
+                                : "::flatbuffers::data(" + value + ")";
+              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(), ";
@@ -3856,6 +3990,27 @@ 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) {
@@ -3889,12 +4044,12 @@ class CppGenerator : public BaseGenerator {
       }
       case BASE_TYPE_STRUCT: {
         if (IsStruct(field.value.type)) {
-          const auto& struct_attribs = field.value.type.struct_def->attributes;
-          const auto native_type = struct_attribs.Lookup("native_type");
+          const auto native_type =
+              EffectiveNativeType(field, *field.value.type.struct_def);
           if (native_type && field.native_inline) {
             code += "::flatbuffers::Pack";
             const auto pack_name =
-                struct_attribs.Lookup("native_type_pack_name");
+                EffectiveNativeTypePackName(field, *field.value.type.struct_def);
             if (pack_name) {
               code += pack_name->constant;
             }
@@ -4059,8 +4214,7 @@ class CppGenerator : public BaseGenerator {
           if (field->value.type.base_type == BASE_TYPE_STRUCT) {
             if (IsStruct(field->value.type)) {
               auto native_type =
-                  field->value.type.struct_def->attributes.Lookup(
-                      "native_type");
+                  EffectiveNativeType(*field, *field->value.type.struct_def);
               auto native_inline = field->attributes.Lookup("native_inline");
               if (native_type) {
                 pass_by_address = true;
@@ -4415,6 +4569,141 @@ 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_csharp.cpp

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

src/idl_gen_dart.cpp

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

src/idl_gen_go.cpp

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

src/idl_gen_java.cpp

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

src/idl_gen_kotlin.cpp

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

src/idl_gen_kotlin_kmp.cpp

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

src/idl_gen_python.cpp

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

src/idl_gen_rust.cpp

@@ -49,6 +49,7 @@ static Namer::Config RustDefaultConfig() {
           /*object_suffix=*/"T",
           /*keyword_prefix=*/"",
           /*keyword_suffix=*/"_",
+          /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
           /*filenames=*/Case::kSnake,
           /*directories=*/Case::kSnake,
           /*output_path=*/"",
@@ -423,7 +424,6 @@ class RustGenerator : public BaseGenerator {
     code_.Clear();
     code_ += "// " + std::string(FlatBuffersGeneratedWarning());
     code_ += "// @generated";
-    code_ += "extern crate alloc;";
 
     assert(!cur_name_space_);
 
@@ -3005,6 +3005,7 @@ class RustGenerator : public BaseGenerator {
           "use self::serde::ser::{Serialize, Serializer, SerializeStruct};";
       code_ += "";
     }
+    code_ += "extern crate alloc;";
   }
 
   // Set up the correct namespace. This opens a namespace if the current

src/idl_gen_swift.cpp

@@ -47,6 +47,7 @@ static Namer::Config SwiftDefaultConfig() {
           /*object_suffix=*/"T",
           /*keyword_prefix=*/"",
           /*keyword_suffix=*/"_",
+          /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
           /*filenames=*/Case::kKeep,
           /*directories=*/Case::kKeep,
           /*output_path=*/"",
@@ -1962,7 +1963,7 @@ class SwiftGenerator : public BaseGenerator {
   std::string GenType(const Type& type,
                       const bool should_consider_suffix = false) const {
     return IsScalar(type.base_type) ? GenTypeBasic(type)
-           : IsArray(type) ? GenType(type.VectorType())
+           : IsArray(type)          ? GenType(type.VectorType())
                            : GenTypePointer(type, should_consider_suffix);
   }
 

src/idl_gen_ts.cpp

@@ -67,6 +67,7 @@ Namer::Config TypeScriptDefaultConfig() {
           /*object_suffix=*/"T",
           /*keyword_prefix=*/"",
           /*keyword_suffix=*/"_",
+          /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
           /*filenames=*/Case::kDasher,
           /*directories=*/Case::kDasher,
           /*output_path=*/"",
@@ -86,6 +87,7 @@ std::set<std::string> TypescriptKeywords() {
       "throw",     "true",     "try",       "typeof",     "var",        "void",
       "while",     "with",     "as",        "implements", "interface",  "let",
       "package",   "private",  "protected", "public",     "static",     "yield",
+      "undefined"  // Used with --ts-undefined-for-optionals
   };
 }
 
@@ -110,7 +112,9 @@ class TsGenerator : public BaseGenerator {
               const std::string& file_name)
       : BaseGenerator(parser, path, file_name, "", "_", "ts"),
         namer_(WithFlagOptions(TypeScriptDefaultConfig(), parser.opts, path),
-               TypescriptKeywords()) {}
+               TypescriptKeywords()),
+        null_keyword_(parser_.opts.ts_undefined_for_optionals ? "undefined"
+                                                              : "null") {}
 
   bool generate() {
     generateEnums();
@@ -214,6 +218,8 @@ class TsGenerator : public BaseGenerator {
 
   std::map<std::string, NsDefinition> ns_defs_;
 
+  std::string null_keyword_;
+
   // Generate code for all enums.
   void generateEnums() {
     for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
@@ -467,7 +473,7 @@ class TsGenerator : public BaseGenerator {
 
   std::string GenDefaultValue(const FieldDef& field, import_set& imports) {
     if (field.IsScalarOptional()) {
-      return "null";
+      return null_keyword_;
     }
 
     const auto& value = field.value;
@@ -518,7 +524,7 @@ class TsGenerator : public BaseGenerator {
       case BASE_TYPE_STRING:
       case BASE_TYPE_UNION:
       case BASE_TYPE_STRUCT: {
-        return "null";
+        return null_keyword_;
       }
 
       case BASE_TYPE_ARRAY:
@@ -554,16 +560,16 @@ class TsGenerator : public BaseGenerator {
         } else {
           name = AddImport(imports, owner, *type.struct_def).name;
         }
-        return allowNull ? (name + "|null") : name;
+        return allowNull ? (name + "|" + null_keyword_) : name;
       }
     }
 
     switch (type.base_type) {
       case BASE_TYPE_BOOL:
-        return allowNull ? "boolean|null" : "boolean";
+        return allowNull ? ("boolean|" + null_keyword_) : "boolean";
       case BASE_TYPE_LONG:
       case BASE_TYPE_ULONG:
-        return allowNull ? "bigint|null" : "bigint";
+        return allowNull ? ("bigint|" + null_keyword_) : "bigint";
       case BASE_TYPE_ARRAY: {
         std::string name;
         if (type.element == BASE_TYPE_LONG || type.element == BASE_TYPE_ULONG) {
@@ -578,16 +584,16 @@ class TsGenerator : public BaseGenerator {
           }
         }
 
-        return name + (allowNull ? "|null" : "");
+        return name + (allowNull ? ("|" + null_keyword_) : "");
       }
       default:
         if (IsScalar(type.base_type)) {
           if (type.enum_def) {
             const auto enum_name =
                 AddImport(imports, owner, *type.enum_def).name;
-            return allowNull ? (enum_name + "|null") : enum_name;
+            return allowNull ? (enum_name + "|" + null_keyword_) : enum_name;
           }
-          return allowNull ? "number|null" : "number";
+          return allowNull ? ("number|" + null_keyword_) : "number";
         }
         return "flatbuffers.Offset";
     }
@@ -1039,7 +1045,8 @@ class TsGenerator : public BaseGenerator {
       const auto& enum_def = *union_type.enum_def;
 
       const auto valid_union_type = GenUnionTypeTS(enum_def, imports);
-      const auto valid_union_type_with_null = valid_union_type + "|null";
+      const auto valid_union_type_with_null =
+          valid_union_type + "|" + null_keyword_;
 
       auto ret = "\n\nexport function " + GenUnionConvFuncName(enum_def) +
                  "(\n  type: " + GetTypeName(enum_def) +
@@ -1051,7 +1058,7 @@ class TsGenerator : public BaseGenerator {
 
       const auto union_enum_loop = [&](const std::string& accessor_str) {
         ret += "  switch(" + enum_type + "[type]) {\n";
-        ret += "    case 'NONE': return null; \n";
+        ret += "    case 'NONE': return " + null_keyword_ + "; \n";
 
         for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end();
              ++it) {
@@ -1075,7 +1082,7 @@ class TsGenerator : public BaseGenerator {
           ret += "\n";
         }
 
-        ret += "    default: return null;\n";
+        ret += "    default: return " + null_keyword_ + ";\n";
         ret += "  }\n";
       };
 
@@ -1120,7 +1127,8 @@ class TsGenerator : public BaseGenerator {
         ret += "      const temp = " + conversion_function + "(this." +
                namer_.Method(field_name, "Type") + "(), " +
                field_binded_method + ");\n";
-        ret += "      if(temp === null) { return null; }\n";
+        ret += "      if(temp === " + null_keyword_ + ") { return " +
+               null_keyword_ + "; }\n";
         ret += union_has_string
                    ? "      if(typeof temp === 'string') { return temp; }\n"
                    : "";
@@ -1140,12 +1148,12 @@ class TsGenerator : public BaseGenerator {
                "++targetEnumIndex) {\n";
         ret += "      const targetEnum = this." +
                namer_.Method(field_name, "Type") + "(targetEnumIndex);\n";
-        ret += "      if(targetEnum === null || " + enum_type +
+        ret += "      if(targetEnum === " + null_keyword_ + " || " + enum_type +
                "[targetEnum!] === 'NONE') { "
                "continue; }\n\n";
         ret += "      const temp = " + conversion_function + "(targetEnum, " +
                field_binded_method + ", targetEnumIndex);\n";
-        ret += "      if(temp === null) { continue; }\n";
+        ret += "      if(temp === " + null_keyword_ + ") { continue; }\n";
         ret += union_has_string ? "      if(typeof temp === 'string') { "
                                   "ret.push(temp); continue; }\n"
                                 : "";
@@ -1162,11 +1170,11 @@ class TsGenerator : public BaseGenerator {
     return "";
   }
 
-  static std::string GenNullCheckConditional(
-      const std::string& nullCheckVar, const std::string& trueVal,
-      const std::string& falseVal = "null") {
-    return "(" + nullCheckVar + " !== null ? " + trueVal + " : " + falseVal +
-           ")";
+  std::string GenNullCheckConditional(const std::string& nullCheckVar,
+                                      const std::string& trueVal,
+                                      const std::string& falseVal) {
+    return "(" + nullCheckVar + " !== " + null_keyword_ + " ? " + trueVal +
+           " : " + falseVal + ")";
   }
 
   std::string GenStructMemberValueTS(const StructDef& struct_def,
@@ -1300,8 +1308,8 @@ class TsGenerator : public BaseGenerator {
 
             const std::string field_accessor =
                 "this." + namer_.Method(field) + "()";
-            field_val = GenNullCheckConditional(field_accessor,
-                                                field_accessor + "!.unpack()");
+            field_val = GenNullCheckConditional(
+                field_accessor, field_accessor + "!.unpack()", null_keyword_);
             auto packing = GenNullCheckConditional(
                 "this." + field_field,
                 "this." + field_field + "!.pack(builder)", "0");
@@ -1509,8 +1517,8 @@ class TsGenerator : public BaseGenerator {
             break;
         }
 
-        // length 0 vector is simply empty instead of null
-        field_type += is_vector ? "" : "|null";
+        // length 0 vector is simply empty instead of null/undefined.
+        field_type += is_vector ? "" : ("|" + null_keyword_);
       }
 
       if (!field_offset_decl.empty()) {
@@ -1539,7 +1547,7 @@ class TsGenerator : public BaseGenerator {
         } else {
           if (field.IsScalarOptional()) {
             pack_func_create_call +=
-                "  if (" + field_offset_val + " !== null)\n  ";
+                "  if (" + field_offset_val + " !== " + null_keyword_ + ")\n  ";
           }
           pack_func_create_call += "  " + struct_name + "." +
                                    namer_.Method("add", field) + "(builder, " +
@@ -1629,7 +1637,8 @@ class TsGenerator : public BaseGenerator {
               "> {\n";
     else
       code += " {\n";
-    code += "  bb: flatbuffers.ByteBuffer|null = null;\n";
+    code += "  bb: flatbuffers.ByteBuffer|" + null_keyword_ + " = " +
+            null_keyword_ + ";\n";
     code += "  bb_pos = 0;\n";
 
     // Generate the __init method that sets the field in a pre-existing
@@ -1681,7 +1690,7 @@ class TsGenerator : public BaseGenerator {
         GenDocComment(field.doc_comment, code_ptr);
         std::string prefix = namer_.Method(field) + "(";
         if (is_string) {
-          code += prefix + "):string|null\n";
+          code += prefix + "):string|" + null_keyword_ + "\n";
           code +=
               prefix + "optionalEncoding:flatbuffers.Encoding" + "):" +
               GenTypeName(imports, struct_def, field.value.type, false, true) +
@@ -1731,7 +1740,8 @@ class TsGenerator : public BaseGenerator {
                     .name;
             GenDocComment(field.doc_comment, code_ptr);
             code += namer_.Method(field);
-            code += "(obj?:" + type + "):" + type + "|null {\n";
+            code +=
+                "(obj?:" + type + "):" + type + "|" + null_keyword_ + " {\n";
 
             if (struct_def.fixed) {
               code += "  return (obj || " + GenerateNewExpression(type);
@@ -1744,7 +1754,7 @@ class TsGenerator : public BaseGenerator {
               code += field.value.type.struct_def->fixed
                           ? "this.bb_pos + offset"
                           : GenBBAccess() + ".__indirect(this.bb_pos + offset)";
-              code += ", " + GenBBAccess() + ") : null;\n";
+              code += ", " + GenBBAccess() + ") : " + null_keyword_ + ";\n";
             }
 
             break;
@@ -1797,7 +1807,7 @@ class TsGenerator : public BaseGenerator {
             } else {
               code += prefix;
             }
-            code += "):" + vectortypename + "|null {\n";
+            code += "):" + vectortypename + "|" + null_keyword_ + " {\n";
 
             if (vectortype.base_type == BASE_TYPE_STRUCT) {
               code += offset_prefix + "(obj || " +
@@ -1837,7 +1847,7 @@ class TsGenerator : public BaseGenerator {
                     code += " : 0";
                   }
                 } else {
-                  code += ": null";
+                  code += ": " + null_keyword_;
                 }
                 break;
               }
@@ -1895,7 +1905,7 @@ class TsGenerator : public BaseGenerator {
             } else {
               code += prefix;
             }
-            code += "):" + vectortypename + "|null {\n";
+            code += "):" + vectortypename + "|" + null_keyword_ + " {\n";
 
             if (vectortype.base_type == BASE_TYPE_STRUCT) {
               code += offset_prefix + "(obj || " +
@@ -1921,12 +1931,12 @@ class TsGenerator : public BaseGenerator {
               code += "BigInt(0)";
             } else if (IsScalar(field.value.type.element)) {
               if (field.value.type.enum_def) {
-                code += "null";
+                code += null_keyword_;
               } else {
                 code += "0";
               }
             } else {
-              code += "null";
+              code += null_keyword_;
             }
             code += ";\n";
             break;
@@ -1939,13 +1949,13 @@ class TsGenerator : public BaseGenerator {
             const auto& union_enum = *(field.value.type.enum_def);
             const auto union_type = GenUnionGenericTypeTS(union_enum);
             code += "<T extends flatbuffers.Table>(obj:" + union_type +
-                    "):" + union_type +
-                    "|null "
+                    "):" + union_type + "|" + null_keyword_ +
+                    " "
                     "{\n";
 
             code += offset_prefix +
                     GenGetter(field.value.type, "(obj, this.bb_pos + offset)") +
-                    " : null;\n";
+                    " : " + null_keyword_ + ";\n";
             break;
           }
           default:
@@ -2007,14 +2017,15 @@ class TsGenerator : public BaseGenerator {
           GenDocComment(code_ptr);
 
           code += namer_.Method(field, "Array");
-          code +=
-              "():" + GenType(vectorType) + "Array|null {\n" + offset_prefix;
+          code += "():" + GenType(vectorType) + "Array|" + null_keyword_ +
+                  " {\n" + offset_prefix;
 
           code += "new " + GenType(vectorType) + "Array(" + GenBBAccess() +
                   ".bytes().buffer, " + GenBBAccess() +
                   ".bytes().byteOffset + " + GenBBAccess() +
                   ".__vector(this.bb_pos + offset), " + GenBBAccess() +
-                  ".__vector_len(this.bb_pos + offset)) : null;\n}\n\n";
+                  ".__vector_len(this.bb_pos + offset)) : " + null_keyword_ +
+                  ";\n}\n\n";
         }
       }
     }
@@ -2084,7 +2095,7 @@ class TsGenerator : public BaseGenerator {
         if (!IsScalar(field.value.type.base_type)) {
           code += "0";
         } else if (HasNullDefault(field)) {
-          code += "null";
+          code += null_keyword_;
         } else {
           if (field.value.type.base_type == BASE_TYPE_BOOL) {
             code += "+";
@@ -2201,7 +2212,7 @@ class TsGenerator : public BaseGenerator {
           const auto arg_name = GetArgName(field);
 
           if (field.IsScalarOptional()) {
-            code += "  if (" + arg_name + " !== null)\n  ";
+            code += "  if (" + arg_name + " !== " + null_keyword_ + ")\n  ";
           }
 
           code += "  " + methodPrefix + "." + namer_.Method("add", field) + "(";
@@ -2241,7 +2252,7 @@ class TsGenerator : public BaseGenerator {
     }
   }
 
-  static bool HasNullDefault(const FieldDef& field) {
+  bool HasNullDefault(const FieldDef& field) {
     return field.IsOptional() && field.value.constant == "null";
   }
 

src/idl_parser.cpp

@@ -1286,6 +1286,55 @@ 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)
@@ -2755,6 +2804,42 @@ std::vector<IncludedFile> Parser::GetIncludedFiles() const {
   return {it->second.cbegin(), it->second.cend()};
 }
 
+bool Parser::HasCircularStructDependency() {
+  std::function<bool(StructDef*)> visit =
+      [&](StructDef* struct_def) {
+        // Only consider fixed structs and structs we have yet to check
+        if (!struct_def->fixed || struct_def->cycle_status == StructDef::CycleStatus::Checked) {
+          return false;
+        }
+
+        if (struct_def->cycle_status == StructDef::CycleStatus::InProgress) {
+          // cycle found
+          return true;
+        }
+
+        struct_def->cycle_status = StructDef::CycleStatus::InProgress;
+
+        for (const auto& field : struct_def->fields.vec) {
+          if (field->value.type.base_type == BASE_TYPE_STRUCT) {
+            if (visit(field->value.type.struct_def)) {
+              return true;  // Cycle detected in recursion.
+            }
+          }
+        }
+
+        struct_def->cycle_status = StructDef::CycleStatus::Checked;
+        return false;  // No cycle detected.
+      };
+
+  for (const auto& struct_def : structs_.vec) {
+    if (visit(struct_def)) {
+      return true;  // Cycle detected.
+    }
+  }
+
+  return false;  // No cycle detected.
+}
+
 bool Parser::SupportsOptionalScalars(const flatbuffers::IDLOptions& opts) {
   static FLATBUFFERS_CONSTEXPR unsigned long supported_langs =
       IDLOptions::kRust | IDLOptions::kSwift | IDLOptions::kLobster |

src/reflection.cpp

@@ -156,6 +156,7 @@ static bool VerifyVector(flatbuffers::Verifier& v,
       auto type_vec = table.GetPointer<Vector<uint8_t>*>(vec_field.offset() -
                                                          sizeof(voffset_t));
       if (!v.VerifyVector(type_vec)) return false;
+      if (type_vec->size() != vec->size()) return false;
       for (uoffset_t j = 0; j < vec->size(); j++) {
         //  get union type from the prev field
         auto utype = type_vec->Get(j);

swift/BUILD.bazel

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

tests/BUILD.bazel

@@ -78,6 +78,9 @@ 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",
@@ -136,6 +139,7 @@ cc_test(
     deps = [
         ":alignment_test_cc_fbs",
         ":arrays_test_cc_fbs",
+        ":cpp_vector_type_cc_fbs",
         ":default_vectors_strings_test_cc_fbs",
         ":monster_extra_cc_fbs",
         ":monster_test_cc_fbs",
@@ -271,6 +275,19 @@ 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/FlatBuffersExampleTests.cs

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

tests/FlatBuffers.Test/FlatBuffersFixedLengthArrayTests.cs

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

tests/MyGame/Example/ArrayStruct.cs

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

tests/MyGame/Example/LargeArrayStruct.cs

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

tests/MyGame/Example/LargeArrayStruct.java

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

tests/MyGame/Example/LargeArrayStruct.py

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

tests/MyGame/Example/LargeArrayStruct.pyi

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

tests/MyGame/Example/LargeArrayStructT.java

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

tests/MyGame/Example/Monster.lua

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

tests/MyGame/Example/Monster.py

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

tests/MyGame/Example/NestedStruct.cs

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

tests/MyGame/Example/TypeAliases.py

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

tests/MyGame/MonsterExtra.py

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

tests/MyGame/MonsterExtra.pyi

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

tests/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/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/bigfoot_ref_test.fbs

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,47 @@
+#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

@@ -0,0 +1,55 @@
+#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

@@ -1481,6 +1481,16 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const MyGame::Example2::Monster *test_as_MyGame_Example2_Monster() const {
     return test_type() == MyGame::Example::Any::MyGame_Example2_Monster ? static_cast<const MyGame::Example2::Monster *>(test()) : nullptr;
   }
+  template<typename T> T *mutable_test_as();
+  MyGame::Example::Monster *mutable_test_as_Monster() {
+    return test_type() == MyGame::Example::Any::Monster ? static_cast<MyGame::Example::Monster *>(mutable_test()) : nullptr;
+  }
+  MyGame::Example::TestSimpleTableWithEnum *mutable_test_as_TestSimpleTableWithEnum() {
+    return test_type() == MyGame::Example::Any::TestSimpleTableWithEnum ? static_cast<MyGame::Example::TestSimpleTableWithEnum *>(mutable_test()) : nullptr;
+  }
+  MyGame::Example2::Monster *mutable_test_as_MyGame_Example2_Monster() {
+    return test_type() == MyGame::Example::Any::MyGame_Example2_Monster ? static_cast<MyGame::Example2::Monster *>(mutable_test()) : nullptr;
+  }
   void *mutable_test() {
     return GetPointer<void *>(VT_TEST);
   }
@@ -1716,6 +1726,16 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const MyGame::Example2::Monster *any_unique_as_M2() const {
     return any_unique_type() == MyGame::Example::AnyUniqueAliases::M2 ? static_cast<const MyGame::Example2::Monster *>(any_unique()) : nullptr;
   }
+  template<typename T> T *mutable_any_unique_as();
+  MyGame::Example::Monster *mutable_any_unique_as_M() {
+    return any_unique_type() == MyGame::Example::AnyUniqueAliases::M ? static_cast<MyGame::Example::Monster *>(mutable_any_unique()) : nullptr;
+  }
+  MyGame::Example::TestSimpleTableWithEnum *mutable_any_unique_as_TS() {
+    return any_unique_type() == MyGame::Example::AnyUniqueAliases::TS ? static_cast<MyGame::Example::TestSimpleTableWithEnum *>(mutable_any_unique()) : nullptr;
+  }
+  MyGame::Example2::Monster *mutable_any_unique_as_M2() {
+    return any_unique_type() == MyGame::Example::AnyUniqueAliases::M2 ? static_cast<MyGame::Example2::Monster *>(mutable_any_unique()) : nullptr;
+  }
   void *mutable_any_unique() {
     return GetPointer<void *>(VT_ANY_UNIQUE);
   }
@@ -1734,6 +1754,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const MyGame::Example::Monster *any_ambiguous_as_M3() const {
     return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases::M3 ? static_cast<const MyGame::Example::Monster *>(any_ambiguous()) : nullptr;
   }
+  MyGame::Example::Monster *mutable_any_ambiguous_as_M1() {
+    return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases::M1 ? static_cast<MyGame::Example::Monster *>(mutable_any_ambiguous()) : nullptr;
+  }
+  MyGame::Example::Monster *mutable_any_ambiguous_as_M2() {
+    return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases::M2 ? static_cast<MyGame::Example::Monster *>(mutable_any_ambiguous()) : nullptr;
+  }
+  MyGame::Example::Monster *mutable_any_ambiguous_as_M3() {
+    return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases::M3 ? static_cast<MyGame::Example::Monster *>(mutable_any_ambiguous()) : nullptr;
+  }
   void *mutable_any_ambiguous() {
     return GetPointer<void *>(VT_ANY_AMBIGUOUS);
   }
@@ -2008,26 +2037,50 @@ template<> inline const MyGame::Example::Monster *Monster::test_as<MyGame::Examp
   return test_as_Monster();
 }
 
+template<> inline MyGame::Example::Monster *Monster::mutable_test_as<MyGame::Example::Monster>() {
+  return mutable_test_as_Monster();
+}
+
 template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::test_as<MyGame::Example::TestSimpleTableWithEnum>() const {
   return test_as_TestSimpleTableWithEnum();
 }
 
+template<> inline MyGame::Example::TestSimpleTableWithEnum *Monster::mutable_test_as<MyGame::Example::TestSimpleTableWithEnum>() {
+  return mutable_test_as_TestSimpleTableWithEnum();
+}
+
 template<> inline const MyGame::Example2::Monster *Monster::test_as<MyGame::Example2::Monster>() const {
   return test_as_MyGame_Example2_Monster();
 }
 
+template<> inline MyGame::Example2::Monster *Monster::mutable_test_as<MyGame::Example2::Monster>() {
+  return mutable_test_as_MyGame_Example2_Monster();
+}
+
 template<> inline const MyGame::Example::Monster *Monster::any_unique_as<MyGame::Example::Monster>() const {
   return any_unique_as_M();
 }
 
+template<> inline MyGame::Example::Monster *Monster::mutable_any_unique_as<MyGame::Example::Monster>() {
+  return mutable_any_unique_as_M();
+}
+
 template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::any_unique_as<MyGame::Example::TestSimpleTableWithEnum>() const {
   return any_unique_as_TS();
 }
 
+template<> inline MyGame::Example::TestSimpleTableWithEnum *Monster::mutable_any_unique_as<MyGame::Example::TestSimpleTableWithEnum>() {
+  return mutable_any_unique_as_TS();
+}
+
 template<> inline const MyGame::Example2::Monster *Monster::any_unique_as<MyGame::Example2::Monster>() const {
   return any_unique_as_M2();
 }
 
+template<> inline MyGame::Example2::Monster *Monster::mutable_any_unique_as<MyGame::Example2::Monster>() {
+  return mutable_any_unique_as_M2();
+}
+
 struct MonsterBuilder {
   typedef Monster Table;
   ::flatbuffers::FlatBufferBuilder &fbb_;

tests/cpp17/generated_cpp17/union_vector_generated.h

@@ -595,6 +595,24 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::String *main_character_as_Unused() const {
     return main_character_type() == Character::Unused ? static_cast<const ::flatbuffers::String *>(main_character()) : nullptr;
   }
+  Attacker *mutable_main_character_as_MuLan() {
+    return main_character_type() == Character::MuLan ? static_cast<Attacker *>(mutable_main_character()) : nullptr;
+  }
+  Rapunzel *mutable_main_character_as_Rapunzel() {
+    return main_character_type() == Character::Rapunzel ? static_cast<Rapunzel *>(mutable_main_character()) : nullptr;
+  }
+  BookReader *mutable_main_character_as_Belle() {
+    return main_character_type() == Character::Belle ? static_cast<BookReader *>(mutable_main_character()) : nullptr;
+  }
+  BookReader *mutable_main_character_as_BookFan() {
+    return main_character_type() == Character::BookFan ? static_cast<BookReader *>(mutable_main_character()) : nullptr;
+  }
+  ::flatbuffers::String *mutable_main_character_as_Other() {
+    return main_character_type() == Character::Other ? static_cast<::flatbuffers::String *>(mutable_main_character()) : nullptr;
+  }
+  ::flatbuffers::String *mutable_main_character_as_Unused() {
+    return main_character_type() == Character::Unused ? static_cast<::flatbuffers::String *>(mutable_main_character()) : nullptr;
+  }
   void *mutable_main_character() {
     return GetPointer<void *>(VT_MAIN_CHARACTER);
   }

tests/cpp_vector_type.fbs

@@ -0,0 +1,29 @@
+// 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

@@ -0,0 +1,143 @@
+#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

@@ -0,0 +1,12 @@
+#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/flatc/flatc_schema_tests.py

@@ -71,3 +71,12 @@ class SchemaTests:
         schema_json["enums"][0]["values"][2]["attributes"][1]["value"]
         == "Value 3 (deprecated)"
     )
+
+  def CircularStructDependency(self):
+    try:
+      flatc(["-c", "circular_struct_dependency.fbs"])
+      assert False, "Expected flatc to fail on circular struct dependency"
+    except subprocess.CalledProcessError:
+      pass
+    
+    flatc(["-c", "circular_table.fbs"])

tests/go_test.go

@@ -22,8 +22,8 @@ import (
 	pizza "Pizza"
 	"encoding/json"
 	optional_scalars "optional_scalars" // refers to generated code
-	required_strings "required_strings" // refers to generated code
 	order "order"
+	required_strings "required_strings" // refers to generated code
 
 	"bytes"
 	"flag"
@@ -132,6 +132,10 @@ func TestAll(t *testing.T) {
 	CheckByteStringIsNestedError(t.Fatalf)
 	CheckStructIsNotInlineError(t.Fatalf)
 	CheckFinishedBytesError(t.Fatalf)
+
+	// Verify bounds checking
+	CheckByteVectorBoundsChecking(t.Fatalf)
+
 	CheckSharedStrings(t.Fatalf)
 	CheckEmptiedBuilder(t.Fatalf)
 
@@ -2471,6 +2475,52 @@ func CheckByKey(fail func(string, ...interface{})) {
 	expectEq("Mana Count", mpStat.Count(), uint16(0))
 }
 
+// CheckByteVectorBoundsChecking ensures ByteVector handles malformed input safely.
+func CheckByteVectorBoundsChecking(fail func(string, ...interface{})) {
+	// Test case 1: Offset beyond buffer size
+	table := &flatbuffers.Table{
+		Bytes: []byte{0x04, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00}, // Small buffer
+		Pos:   0,
+	}
+	result := table.ByteVector(100) // Offset way beyond buffer
+	if result != nil {
+		fail("ByteVector should return nil for offset beyond buffer")
+	}
+
+	// Test case 2: Malicious length field
+	// Construct: [relative offset: 4] [vector length: 0xFFFFFFFF] [data...]
+	maliciousBytes := make([]byte, 20)
+	// At position 0, set relative offset to point to position 4
+	maliciousBytes[0] = 4
+	maliciousBytes[1] = 0
+	maliciousBytes[2] = 0
+	maliciousBytes[3] = 0
+	// At position 4, set malicious vector length
+	maliciousBytes[4] = 0xFF
+	maliciousBytes[5] = 0xFF
+	maliciousBytes[6] = 0xFF
+	maliciousBytes[7] = 0xFF
+
+	table = &flatbuffers.Table{Bytes: maliciousBytes, Pos: 0}
+	result = table.ByteVector(0)
+	if result != nil {
+		fail("ByteVector should return nil for malicious length field")
+	}
+
+	// Test case 3: Valid case should still work
+	// Construct: [relative offset: 4] [vector length: 3] [data: 'a', 'b', 'c']
+	validBytes := []byte{
+		4, 0, 0, 0, // relative offset to vector data (at position 4)
+		3, 0, 0, 0, // vector length (3 bytes)
+		'a', 'b', 'c', // actual vector data
+	}
+	table = &flatbuffers.Table{Bytes: validBytes, Pos: 0}
+	result = table.ByteVector(0)
+	if result == nil || !bytes.Equal(result, []byte("abc")) {
+		fail("ByteVector should work correctly for valid data")
+	}
+}
+
 // BenchmarkVtableDeduplication measures the speed of vtable deduplication
 // by creating prePop vtables, then populating b.N objects with a
 // different single vtable.

tests/include_test1_generated.rs

@@ -0,0 +1,479 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// @generated
+
+extern crate alloc;
+
+pub enum TableAOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct TableA<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for TableA<'a> {
+  type Inner = TableA<'a>;
+  #[inline]
+  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 fn get_fully_qualified_name() -> &'static str {
+    "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]
+  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]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>("b", Self::VT_B, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct TableAArgs<'a> {
+    pub b: Option<::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'a>>>,
+}
+impl<'a> Default for TableAArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    TableAArgs {
+      b: None,
+    }
+  }
+}
+
+pub struct TableABuilder<'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> TableABuilder<'a, 'b, A> {
+  #[inline]
+  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);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    TableABuilder {
+      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())
+  }
+}
+
+impl ::core::fmt::Debug for TableA<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("TableA");
+      ds.field("b", &self.b());
+      ds.finish()
+  }
+}
+#[non_exhaustive]
+#[derive(Debug, Clone, PartialEq)]
+pub struct TableAT {
+  pub b: Option<alloc::boxed::Box<my_game::other_name_space::TableBT>>,
+}
+impl Default for TableAT {
+  fn default() -> Self {
+    Self {
+      b: None,
+    }
+  }
+}
+impl TableAT {
+  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
+    &self,
+    _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
+  ) -> ::flatbuffers::WIPOffset<TableA<'b>> {
+    let b = self.b.as_ref().map(|x|{
+      x.pack(_fbb)
+    });
+    TableA::create(_fbb, &TableAArgs{
+      b,
+    })
+  }
+}
+#[allow(unused_imports, dead_code)]
+pub mod my_game {
+
+extern crate alloc;
+#[allow(unused_imports, dead_code)]
+pub mod other_name_space {
+
+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.")]
+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)]
+#[repr(transparent)]
+pub struct FromInclude(pub i64);
+#[allow(non_upper_case_globals)]
+impl FromInclude {
+  pub const IncludeVal: Self = Self(0);
+
+  pub const ENUM_MIN: i64 = 0;
+  pub const ENUM_MAX: i64 = 0;
+  pub const ENUM_VALUES: &'static [Self] = &[
+    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 {
+    type Output = FromInclude;
+    #[inline]
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        unsafe { ::flatbuffers::emplace_scalar::<i64>(dst, self.0) };
+    }
+}
+
+impl ::flatbuffers::EndianScalar for FromInclude {
+  type Scalar = i64;
+  #[inline]
+  fn to_little_endian(self) -> i64 {
+    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 {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    i64::run_verifier(v, pos)
+  }
+}
+
+impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {}
+// struct Unused, aligned to 4
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq)]
+pub struct Unused(pub [u8; 4]);
+impl Default for Unused { 
+  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 Unused {
+  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]
+  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, Default)]
+pub struct UnusedT {
+  pub a: i32,
+}
+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_generated.rs

@@ -0,0 +1,479 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// @generated
+
+extern crate alloc;
+
+pub enum TableAOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct TableA<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for TableA<'a> {
+  type Inner = TableA<'a>;
+  #[inline]
+  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 fn get_fully_qualified_name() -> &'static str {
+    "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]
+  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]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>("b", Self::VT_B, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct TableAArgs<'a> {
+    pub b: Option<::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'a>>>,
+}
+impl<'a> Default for TableAArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    TableAArgs {
+      b: None,
+    }
+  }
+}
+
+pub struct TableABuilder<'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> TableABuilder<'a, 'b, A> {
+  #[inline]
+  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);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    TableABuilder {
+      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())
+  }
+}
+
+impl ::core::fmt::Debug for TableA<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("TableA");
+      ds.field("b", &self.b());
+      ds.finish()
+  }
+}
+#[non_exhaustive]
+#[derive(Debug, Clone, PartialEq)]
+pub struct TableAT {
+  pub b: Option<alloc::boxed::Box<my_game::other_name_space::TableBT>>,
+}
+impl Default for TableAT {
+  fn default() -> Self {
+    Self {
+      b: None,
+    }
+  }
+}
+impl TableAT {
+  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
+    &self,
+    _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
+  ) -> ::flatbuffers::WIPOffset<TableA<'b>> {
+    let b = self.b.as_ref().map(|x|{
+      x.pack(_fbb)
+    });
+    TableA::create(_fbb, &TableAArgs{
+      b,
+    })
+  }
+}
+#[allow(unused_imports, dead_code)]
+pub mod my_game {
+
+extern crate alloc;
+#[allow(unused_imports, dead_code)]
+pub mod other_name_space {
+
+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.")]
+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)]
+#[repr(transparent)]
+pub struct FromInclude(pub i64);
+#[allow(non_upper_case_globals)]
+impl FromInclude {
+  pub const IncludeVal: Self = Self(0);
+
+  pub const ENUM_MIN: i64 = 0;
+  pub const ENUM_MAX: i64 = 0;
+  pub const ENUM_VALUES: &'static [Self] = &[
+    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 {
+    type Output = FromInclude;
+    #[inline]
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        unsafe { ::flatbuffers::emplace_scalar::<i64>(dst, self.0) };
+    }
+}
+
+impl ::flatbuffers::EndianScalar for FromInclude {
+  type Scalar = i64;
+  #[inline]
+  fn to_little_endian(self) -> i64 {
+    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 {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    i64::run_verifier(v, pos)
+  }
+}
+
+impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {}
+// struct Unused, aligned to 4
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq)]
+pub struct Unused(pub [u8; 4]);
+impl Default for Unused { 
+  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 Unused {
+  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]
+  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, Default)]
+pub struct UnusedT {
+  pub a: i32,
+}
+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/monster_test_generated.h

@@ -1497,6 +1497,16 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const MyGame::Example2::Monster *test_as_MyGame_Example2_Monster() const {
     return test_type() == MyGame::Example::Any_MyGame_Example2_Monster ? static_cast<const MyGame::Example2::Monster *>(test()) : nullptr;
   }
+  template<typename T> T *mutable_test_as();
+  MyGame::Example::Monster *mutable_test_as_Monster() {
+    return test_type() == MyGame::Example::Any_Monster ? static_cast<MyGame::Example::Monster *>(mutable_test()) : nullptr;
+  }
+  MyGame::Example::TestSimpleTableWithEnum *mutable_test_as_TestSimpleTableWithEnum() {
+    return test_type() == MyGame::Example::Any_TestSimpleTableWithEnum ? static_cast<MyGame::Example::TestSimpleTableWithEnum *>(mutable_test()) : nullptr;
+  }
+  MyGame::Example2::Monster *mutable_test_as_MyGame_Example2_Monster() {
+    return test_type() == MyGame::Example::Any_MyGame_Example2_Monster ? static_cast<MyGame::Example2::Monster *>(mutable_test()) : nullptr;
+  }
   void *mutable_test() {
     return GetPointer<void *>(VT_TEST);
   }
@@ -1732,6 +1742,16 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const MyGame::Example2::Monster *any_unique_as_M2() const {
     return any_unique_type() == MyGame::Example::AnyUniqueAliases_M2 ? static_cast<const MyGame::Example2::Monster *>(any_unique()) : nullptr;
   }
+  template<typename T> T *mutable_any_unique_as();
+  MyGame::Example::Monster *mutable_any_unique_as_M() {
+    return any_unique_type() == MyGame::Example::AnyUniqueAliases_M ? static_cast<MyGame::Example::Monster *>(mutable_any_unique()) : nullptr;
+  }
+  MyGame::Example::TestSimpleTableWithEnum *mutable_any_unique_as_TS() {
+    return any_unique_type() == MyGame::Example::AnyUniqueAliases_TS ? static_cast<MyGame::Example::TestSimpleTableWithEnum *>(mutable_any_unique()) : nullptr;
+  }
+  MyGame::Example2::Monster *mutable_any_unique_as_M2() {
+    return any_unique_type() == MyGame::Example::AnyUniqueAliases_M2 ? static_cast<MyGame::Example2::Monster *>(mutable_any_unique()) : nullptr;
+  }
   void *mutable_any_unique() {
     return GetPointer<void *>(VT_ANY_UNIQUE);
   }
@@ -1750,6 +1770,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const MyGame::Example::Monster *any_ambiguous_as_M3() const {
     return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M3 ? static_cast<const MyGame::Example::Monster *>(any_ambiguous()) : nullptr;
   }
+  MyGame::Example::Monster *mutable_any_ambiguous_as_M1() {
+    return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M1 ? static_cast<MyGame::Example::Monster *>(mutable_any_ambiguous()) : nullptr;
+  }
+  MyGame::Example::Monster *mutable_any_ambiguous_as_M2() {
+    return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M2 ? static_cast<MyGame::Example::Monster *>(mutable_any_ambiguous()) : nullptr;
+  }
+  MyGame::Example::Monster *mutable_any_ambiguous_as_M3() {
+    return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M3 ? static_cast<MyGame::Example::Monster *>(mutable_any_ambiguous()) : nullptr;
+  }
   void *mutable_any_ambiguous() {
     return GetPointer<void *>(VT_ANY_AMBIGUOUS);
   }
@@ -1959,26 +1988,50 @@ template<> inline const MyGame::Example::Monster *Monster::test_as<MyGame::Examp
   return test_as_Monster();
 }
 
+template<> inline MyGame::Example::Monster *Monster::mutable_test_as<MyGame::Example::Monster>() {
+  return mutable_test_as_Monster();
+}
+
 template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::test_as<MyGame::Example::TestSimpleTableWithEnum>() const {
   return test_as_TestSimpleTableWithEnum();
 }
 
+template<> inline MyGame::Example::TestSimpleTableWithEnum *Monster::mutable_test_as<MyGame::Example::TestSimpleTableWithEnum>() {
+  return mutable_test_as_TestSimpleTableWithEnum();
+}
+
 template<> inline const MyGame::Example2::Monster *Monster::test_as<MyGame::Example2::Monster>() const {
   return test_as_MyGame_Example2_Monster();
 }
 
+template<> inline MyGame::Example2::Monster *Monster::mutable_test_as<MyGame::Example2::Monster>() {
+  return mutable_test_as_MyGame_Example2_Monster();
+}
+
 template<> inline const MyGame::Example::Monster *Monster::any_unique_as<MyGame::Example::Monster>() const {
   return any_unique_as_M();
 }
 
+template<> inline MyGame::Example::Monster *Monster::mutable_any_unique_as<MyGame::Example::Monster>() {
+  return mutable_any_unique_as_M();
+}
+
 template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::any_unique_as<MyGame::Example::TestSimpleTableWithEnum>() const {
   return any_unique_as_TS();
 }
 
+template<> inline MyGame::Example::TestSimpleTableWithEnum *Monster::mutable_any_unique_as<MyGame::Example::TestSimpleTableWithEnum>() {
+  return mutable_any_unique_as_TS();
+}
+
 template<> inline const MyGame::Example2::Monster *Monster::any_unique_as<MyGame::Example2::Monster>() const {
   return any_unique_as_M2();
 }
 
+template<> inline MyGame::Example2::Monster *Monster::mutable_any_unique_as<MyGame::Example2::Monster>() {
+  return mutable_any_unique_as_M2();
+}
+
 struct MonsterBuilder {
   typedef Monster Table;
   ::flatbuffers::FlatBufferBuilder &fbb_;

tests/monster_test_generated.py

@@ -1761,6 +1761,13 @@ def MonsterAddInventory(builder, inventory):
 def MonsterStartInventoryVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
+def MonsterCreateInventoryVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependUint8(item)
+    return builder.EndVector()
+
 def MonsterAddColor(builder, color):
     builder.PrependUint8Slot(6, color, 8)
 
@@ -1776,18 +1783,31 @@ def MonsterAddTest4(builder, test4):
 def MonsterStartTest4Vector(builder, numElems):
     return builder.StartVector(4, numElems, 2)
 
+def MonsterCreateTest4Vector(builder, data):
+    data = list(data)
+    builder.StartVector(4, len(data), 2)
+    for item in reversed(data):
+        item.Pack(builder)
+    return builder.EndVector()
+
 def MonsterAddTestarrayofstring(builder, testarrayofstring):
     builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
 
 def MonsterStartTestarrayofstringVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
+def MonsterCreateTestarrayofstringVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
 def MonsterAddTestarrayoftables(builder, testarrayoftables):
     builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
 
 def MonsterStartTestarrayoftablesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
+def MonsterCreateTestarrayoftablesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
 def MonsterAddEnemy(builder, enemy):
     builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
 
@@ -1797,6 +1817,13 @@ def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer):
 def MonsterStartTestnestedflatbufferVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
+def MonsterCreateTestnestedflatbufferVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependUint8(item)
+    return builder.EndVector()
+
 def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes):
     builder.StartVector(1, len(bytes), 1)
     builder.head = builder.head - len(bytes)
@@ -1838,6 +1865,13 @@ def MonsterAddTestarrayofbools(builder, testarrayofbools):
 def MonsterStartTestarrayofboolsVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
+def MonsterCreateTestarrayofboolsVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependBool(item)
+    return builder.EndVector()
+
 def MonsterAddTestf(builder, testf):
     builder.PrependFloat32Slot(25, testf, 3.14159)
 
@@ -1853,36 +1887,74 @@ def MonsterAddTestarrayofstring2(builder, testarrayofstring2):
 def MonsterStartTestarrayofstring2Vector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
+def MonsterCreateTestarrayofstring2Vector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
 def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
     builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
 
 def MonsterStartTestarrayofsortedstructVector(builder, numElems):
     return builder.StartVector(8, numElems, 4)
 
+def MonsterCreateTestarrayofsortedstructVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 4)
+    for item in reversed(data):
+        item.Pack(builder)
+    return builder.EndVector()
+
 def MonsterAddFlex(builder, flex):
     builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
 
 def MonsterStartFlexVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
+def MonsterCreateFlexVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependUint8(item)
+    return builder.EndVector()
+
 def MonsterAddTest5(builder, test5):
     builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
 
 def MonsterStartTest5Vector(builder, numElems):
     return builder.StartVector(4, numElems, 2)
 
+def MonsterCreateTest5Vector(builder, data):
+    data = list(data)
+    builder.StartVector(4, len(data), 2)
+    for item in reversed(data):
+        item.Pack(builder)
+    return builder.EndVector()
+
 def MonsterAddVectorOfLongs(builder, vectorOfLongs):
     builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
 
 def MonsterStartVectorOfLongsVector(builder, numElems):
     return builder.StartVector(8, numElems, 8)
 
+def MonsterCreateVectorOfLongsVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependInt64(item)
+    return builder.EndVector()
+
 def MonsterAddVectorOfDoubles(builder, vectorOfDoubles):
     builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
 
 def MonsterStartVectorOfDoublesVector(builder, numElems):
     return builder.StartVector(8, numElems, 8)
 
+def MonsterCreateVectorOfDoublesVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependFloat64(item)
+    return builder.EndVector()
+
 def MonsterAddParentNamespaceTest(builder, parentNamespaceTest):
     builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
 
@@ -1892,6 +1964,9 @@ def MonsterAddVectorOfReferrables(builder, vectorOfReferrables):
 def MonsterStartVectorOfReferrablesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
+def MonsterCreateVectorOfReferrablesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
 def MonsterAddSingleWeakReference(builder, singleWeakReference):
     builder.PrependUint64Slot(36, singleWeakReference, 0)
 
@@ -1901,12 +1976,22 @@ def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences):
 def MonsterStartVectorOfWeakReferencesVector(builder, numElems):
     return builder.StartVector(8, numElems, 8)
 
+def MonsterCreateVectorOfWeakReferencesVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependUint64(item)
+    return builder.EndVector()
+
 def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
     builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
 
 def MonsterStartVectorOfStrongReferrablesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
+def MonsterCreateVectorOfStrongReferrablesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
 def MonsterAddCoOwningReference(builder, coOwningReference):
     builder.PrependUint64Slot(39, coOwningReference, 0)
 
@@ -1916,6 +2001,13 @@ def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
 def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems):
     return builder.StartVector(8, numElems, 8)
 
+def MonsterCreateVectorOfCoOwningReferencesVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependUint64(item)
+    return builder.EndVector()
+
 def MonsterAddNonOwningReference(builder, nonOwningReference):
     builder.PrependUint64Slot(41, nonOwningReference, 0)
 
@@ -1925,6 +2017,13 @@ def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
 def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems):
     return builder.StartVector(8, numElems, 8)
 
+def MonsterCreateVectorOfNonOwningReferencesVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependUint64(item)
+    return builder.EndVector()
+
 def MonsterAddAnyUniqueType(builder, anyUniqueType):
     builder.PrependUint8Slot(43, anyUniqueType, 0)
 
@@ -1943,6 +2042,13 @@ def MonsterAddVectorOfEnums(builder, vectorOfEnums):
 def MonsterStartVectorOfEnumsVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
+def MonsterCreateVectorOfEnumsVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependUint8(item)
+    return builder.EndVector()
+
 def MonsterAddSignedEnum(builder, signedEnum):
     builder.PrependInt8Slot(48, signedEnum, -1)
 
@@ -1952,6 +2058,13 @@ def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer
 def MonsterStartTestrequirednestedflatbufferVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
+def MonsterCreateTestrequirednestedflatbufferVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependUint8(item)
+    return builder.EndVector()
+
 def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
     builder.StartVector(1, len(bytes), 1)
     builder.head = builder.head - len(bytes)
@@ -1963,6 +2076,9 @@ def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables):
 def MonsterStartScalarKeySortedTablesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
+def MonsterCreateScalarKeySortedTablesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
 def MonsterAddNativeInline(builder, nativeInline):
     builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
 
@@ -2792,12 +2908,26 @@ def TypeAliasesAddV8(builder, v8):
 def TypeAliasesStartV8Vector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
+def TypeAliasesCreateV8Vector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependInt8(item)
+    return builder.EndVector()
+
 def TypeAliasesAddVf64(builder, vf64):
     builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
 
 def TypeAliasesStartVf64Vector(builder, numElems):
     return builder.StartVector(8, numElems, 8)
 
+def TypeAliasesCreateVf64Vector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependFloat64(item)
+    return builder.EndVector()
+
 def TypeAliasesEnd(builder):
     return builder.EndObject()
 

tests/monster_test_suffix/ext_only/monster_test_generated.hpp

@@ -1488,6 +1488,16 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const MyGame::Example2::Monster *test_as_MyGame_Example2_Monster() const {
     return test_type() == MyGame::Example::Any_MyGame_Example2_Monster ? static_cast<const MyGame::Example2::Monster *>(test()) : nullptr;
   }
+  template<typename T> T *mutable_test_as();
+  MyGame::Example::Monster *mutable_test_as_Monster() {
+    return test_type() == MyGame::Example::Any_Monster ? static_cast<MyGame::Example::Monster *>(mutable_test()) : nullptr;
+  }
+  MyGame::Example::TestSimpleTableWithEnum *mutable_test_as_TestSimpleTableWithEnum() {
+    return test_type() == MyGame::Example::Any_TestSimpleTableWithEnum ? static_cast<MyGame::Example::TestSimpleTableWithEnum *>(mutable_test()) : nullptr;
+  }
+  MyGame::Example2::Monster *mutable_test_as_MyGame_Example2_Monster() {
+    return test_type() == MyGame::Example::Any_MyGame_Example2_Monster ? static_cast<MyGame::Example2::Monster *>(mutable_test()) : nullptr;
+  }
   void *mutable_test() {
     return GetPointer<void *>(VT_TEST);
   }
@@ -1723,6 +1733,16 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const MyGame::Example2::Monster *any_unique_as_M2() const {
     return any_unique_type() == MyGame::Example::AnyUniqueAliases_M2 ? static_cast<const MyGame::Example2::Monster *>(any_unique()) : nullptr;
   }
+  template<typename T> T *mutable_any_unique_as();
+  MyGame::Example::Monster *mutable_any_unique_as_M() {
+    return any_unique_type() == MyGame::Example::AnyUniqueAliases_M ? static_cast<MyGame::Example::Monster *>(mutable_any_unique()) : nullptr;
+  }
+  MyGame::Example::TestSimpleTableWithEnum *mutable_any_unique_as_TS() {
+    return any_unique_type() == MyGame::Example::AnyUniqueAliases_TS ? static_cast<MyGame::Example::TestSimpleTableWithEnum *>(mutable_any_unique()) : nullptr;
+  }
+  MyGame::Example2::Monster *mutable_any_unique_as_M2() {
+    return any_unique_type() == MyGame::Example::AnyUniqueAliases_M2 ? static_cast<MyGame::Example2::Monster *>(mutable_any_unique()) : nullptr;
+  }
   void *mutable_any_unique() {
     return GetPointer<void *>(VT_ANY_UNIQUE);
   }
@@ -1741,6 +1761,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const MyGame::Example::Monster *any_ambiguous_as_M3() const {
     return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M3 ? static_cast<const MyGame::Example::Monster *>(any_ambiguous()) : nullptr;
   }
+  MyGame::Example::Monster *mutable_any_ambiguous_as_M1() {
+    return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M1 ? static_cast<MyGame::Example::Monster *>(mutable_any_ambiguous()) : nullptr;
+  }
+  MyGame::Example::Monster *mutable_any_ambiguous_as_M2() {
+    return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M2 ? static_cast<MyGame::Example::Monster *>(mutable_any_ambiguous()) : nullptr;
+  }
+  MyGame::Example::Monster *mutable_any_ambiguous_as_M3() {
+    return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M3 ? static_cast<MyGame::Example::Monster *>(mutable_any_ambiguous()) : nullptr;
+  }
   void *mutable_any_ambiguous() {
     return GetPointer<void *>(VT_ANY_AMBIGUOUS);
   }
@@ -1950,26 +1979,50 @@ template<> inline const MyGame::Example::Monster *Monster::test_as<MyGame::Examp
   return test_as_Monster();
 }
 
+template<> inline MyGame::Example::Monster *Monster::mutable_test_as<MyGame::Example::Monster>() {
+  return mutable_test_as_Monster();
+}
+
 template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::test_as<MyGame::Example::TestSimpleTableWithEnum>() const {
   return test_as_TestSimpleTableWithEnum();
 }
 
+template<> inline MyGame::Example::TestSimpleTableWithEnum *Monster::mutable_test_as<MyGame::Example::TestSimpleTableWithEnum>() {
+  return mutable_test_as_TestSimpleTableWithEnum();
+}
+
 template<> inline const MyGame::Example2::Monster *Monster::test_as<MyGame::Example2::Monster>() const {
   return test_as_MyGame_Example2_Monster();
 }
 
+template<> inline MyGame::Example2::Monster *Monster::mutable_test_as<MyGame::Example2::Monster>() {
+  return mutable_test_as_MyGame_Example2_Monster();
+}
+
 template<> inline const MyGame::Example::Monster *Monster::any_unique_as<MyGame::Example::Monster>() const {
   return any_unique_as_M();
 }
 
+template<> inline MyGame::Example::Monster *Monster::mutable_any_unique_as<MyGame::Example::Monster>() {
+  return mutable_any_unique_as_M();
+}
+
 template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::any_unique_as<MyGame::Example::TestSimpleTableWithEnum>() const {
   return any_unique_as_TS();
 }
 
+template<> inline MyGame::Example::TestSimpleTableWithEnum *Monster::mutable_any_unique_as<MyGame::Example::TestSimpleTableWithEnum>() {
+  return mutable_any_unique_as_TS();
+}
+
 template<> inline const MyGame::Example2::Monster *Monster::any_unique_as<MyGame::Example2::Monster>() const {
   return any_unique_as_M2();
 }
 
+template<> inline MyGame::Example2::Monster *Monster::mutable_any_unique_as<MyGame::Example2::Monster>() {
+  return mutable_any_unique_as_M2();
+}
+
 struct MonsterBuilder {
   typedef Monster Table;
   ::flatbuffers::FlatBufferBuilder &fbb_;

tests/monster_test_suffix/filesuffix_only/monster_test_suffix.h

@@ -1488,6 +1488,16 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const MyGame::Example2::Monster *test_as_MyGame_Example2_Monster() const {
     return test_type() == MyGame::Example::Any_MyGame_Example2_Monster ? static_cast<const MyGame::Example2::Monster *>(test()) : nullptr;
   }
+  template<typename T> T *mutable_test_as();
+  MyGame::Example::Monster *mutable_test_as_Monster() {
+    return test_type() == MyGame::Example::Any_Monster ? static_cast<MyGame::Example::Monster *>(mutable_test()) : nullptr;
+  }
+  MyGame::Example::TestSimpleTableWithEnum *mutable_test_as_TestSimpleTableWithEnum() {
+    return test_type() == MyGame::Example::Any_TestSimpleTableWithEnum ? static_cast<MyGame::Example::TestSimpleTableWithEnum *>(mutable_test()) : nullptr;
+  }
+  MyGame::Example2::Monster *mutable_test_as_MyGame_Example2_Monster() {
+    return test_type() == MyGame::Example::Any_MyGame_Example2_Monster ? static_cast<MyGame::Example2::Monster *>(mutable_test()) : nullptr;
+  }
   void *mutable_test() {
     return GetPointer<void *>(VT_TEST);
   }
@@ -1723,6 +1733,16 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const MyGame::Example2::Monster *any_unique_as_M2() const {
     return any_unique_type() == MyGame::Example::AnyUniqueAliases_M2 ? static_cast<const MyGame::Example2::Monster *>(any_unique()) : nullptr;
   }
+  template<typename T> T *mutable_any_unique_as();
+  MyGame::Example::Monster *mutable_any_unique_as_M() {
+    return any_unique_type() == MyGame::Example::AnyUniqueAliases_M ? static_cast<MyGame::Example::Monster *>(mutable_any_unique()) : nullptr;
+  }
+  MyGame::Example::TestSimpleTableWithEnum *mutable_any_unique_as_TS() {
+    return any_unique_type() == MyGame::Example::AnyUniqueAliases_TS ? static_cast<MyGame::Example::TestSimpleTableWithEnum *>(mutable_any_unique()) : nullptr;
+  }
+  MyGame::Example2::Monster *mutable_any_unique_as_M2() {
+    return any_unique_type() == MyGame::Example::AnyUniqueAliases_M2 ? static_cast<MyGame::Example2::Monster *>(mutable_any_unique()) : nullptr;
+  }
   void *mutable_any_unique() {
     return GetPointer<void *>(VT_ANY_UNIQUE);
   }
@@ -1741,6 +1761,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const MyGame::Example::Monster *any_ambiguous_as_M3() const {
     return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M3 ? static_cast<const MyGame::Example::Monster *>(any_ambiguous()) : nullptr;
   }
+  MyGame::Example::Monster *mutable_any_ambiguous_as_M1() {
+    return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M1 ? static_cast<MyGame::Example::Monster *>(mutable_any_ambiguous()) : nullptr;
+  }
+  MyGame::Example::Monster *mutable_any_ambiguous_as_M2() {
+    return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M2 ? static_cast<MyGame::Example::Monster *>(mutable_any_ambiguous()) : nullptr;
+  }
+  MyGame::Example::Monster *mutable_any_ambiguous_as_M3() {
+    return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M3 ? static_cast<MyGame::Example::Monster *>(mutable_any_ambiguous()) : nullptr;
+  }
   void *mutable_any_ambiguous() {
     return GetPointer<void *>(VT_ANY_AMBIGUOUS);
   }
@@ -1950,26 +1979,50 @@ template<> inline const MyGame::Example::Monster *Monster::test_as<MyGame::Examp
   return test_as_Monster();
 }
 
+template<> inline MyGame::Example::Monster *Monster::mutable_test_as<MyGame::Example::Monster>() {
+  return mutable_test_as_Monster();
+}
+
 template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::test_as<MyGame::Example::TestSimpleTableWithEnum>() const {
   return test_as_TestSimpleTableWithEnum();
 }
 
+template<> inline MyGame::Example::TestSimpleTableWithEnum *Monster::mutable_test_as<MyGame::Example::TestSimpleTableWithEnum>() {
+  return mutable_test_as_TestSimpleTableWithEnum();
+}
+
 template<> inline const MyGame::Example2::Monster *Monster::test_as<MyGame::Example2::Monster>() const {
   return test_as_MyGame_Example2_Monster();
 }
 
+template<> inline MyGame::Example2::Monster *Monster::mutable_test_as<MyGame::Example2::Monster>() {
+  return mutable_test_as_MyGame_Example2_Monster();
+}
+
 template<> inline const MyGame::Example::Monster *Monster::any_unique_as<MyGame::Example::Monster>() const {
   return any_unique_as_M();
 }
 
+template<> inline MyGame::Example::Monster *Monster::mutable_any_unique_as<MyGame::Example::Monster>() {
+  return mutable_any_unique_as_M();
+}
+
 template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::any_unique_as<MyGame::Example::TestSimpleTableWithEnum>() const {
   return any_unique_as_TS();
 }
 
+template<> inline MyGame::Example::TestSimpleTableWithEnum *Monster::mutable_any_unique_as<MyGame::Example::TestSimpleTableWithEnum>() {
+  return mutable_any_unique_as_TS();
+}
+
 template<> inline const MyGame::Example2::Monster *Monster::any_unique_as<MyGame::Example2::Monster>() const {
   return any_unique_as_M2();
 }
 
+template<> inline MyGame::Example2::Monster *Monster::mutable_any_unique_as<MyGame::Example2::Monster>() {
+  return mutable_any_unique_as_M2();
+}
+
 struct MonsterBuilder {
   typedef Monster Table;
   ::flatbuffers::FlatBufferBuilder &fbb_;

tests/monster_test_suffix/monster_test_suffix.hpp

@@ -1488,6 +1488,16 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const MyGame::Example2::Monster *test_as_MyGame_Example2_Monster() const {
     return test_type() == MyGame::Example::Any_MyGame_Example2_Monster ? static_cast<const MyGame::Example2::Monster *>(test()) : nullptr;
   }
+  template<typename T> T *mutable_test_as();
+  MyGame::Example::Monster *mutable_test_as_Monster() {
+    return test_type() == MyGame::Example::Any_Monster ? static_cast<MyGame::Example::Monster *>(mutable_test()) : nullptr;
+  }
+  MyGame::Example::TestSimpleTableWithEnum *mutable_test_as_TestSimpleTableWithEnum() {
+    return test_type() == MyGame::Example::Any_TestSimpleTableWithEnum ? static_cast<MyGame::Example::TestSimpleTableWithEnum *>(mutable_test()) : nullptr;
+  }
+  MyGame::Example2::Monster *mutable_test_as_MyGame_Example2_Monster() {
+    return test_type() == MyGame::Example::Any_MyGame_Example2_Monster ? static_cast<MyGame::Example2::Monster *>(mutable_test()) : nullptr;
+  }
   void *mutable_test() {
     return GetPointer<void *>(VT_TEST);
   }
@@ -1723,6 +1733,16 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const MyGame::Example2::Monster *any_unique_as_M2() const {
     return any_unique_type() == MyGame::Example::AnyUniqueAliases_M2 ? static_cast<const MyGame::Example2::Monster *>(any_unique()) : nullptr;
   }
+  template<typename T> T *mutable_any_unique_as();
+  MyGame::Example::Monster *mutable_any_unique_as_M() {
+    return any_unique_type() == MyGame::Example::AnyUniqueAliases_M ? static_cast<MyGame::Example::Monster *>(mutable_any_unique()) : nullptr;
+  }
+  MyGame::Example::TestSimpleTableWithEnum *mutable_any_unique_as_TS() {
+    return any_unique_type() == MyGame::Example::AnyUniqueAliases_TS ? static_cast<MyGame::Example::TestSimpleTableWithEnum *>(mutable_any_unique()) : nullptr;
+  }
+  MyGame::Example2::Monster *mutable_any_unique_as_M2() {
+    return any_unique_type() == MyGame::Example::AnyUniqueAliases_M2 ? static_cast<MyGame::Example2::Monster *>(mutable_any_unique()) : nullptr;
+  }
   void *mutable_any_unique() {
     return GetPointer<void *>(VT_ANY_UNIQUE);
   }
@@ -1741,6 +1761,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const MyGame::Example::Monster *any_ambiguous_as_M3() const {
     return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M3 ? static_cast<const MyGame::Example::Monster *>(any_ambiguous()) : nullptr;
   }
+  MyGame::Example::Monster *mutable_any_ambiguous_as_M1() {
+    return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M1 ? static_cast<MyGame::Example::Monster *>(mutable_any_ambiguous()) : nullptr;
+  }
+  MyGame::Example::Monster *mutable_any_ambiguous_as_M2() {
+    return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M2 ? static_cast<MyGame::Example::Monster *>(mutable_any_ambiguous()) : nullptr;
+  }
+  MyGame::Example::Monster *mutable_any_ambiguous_as_M3() {
+    return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M3 ? static_cast<MyGame::Example::Monster *>(mutable_any_ambiguous()) : nullptr;
+  }
   void *mutable_any_ambiguous() {
     return GetPointer<void *>(VT_ANY_AMBIGUOUS);
   }
@@ -1950,26 +1979,50 @@ template<> inline const MyGame::Example::Monster *Monster::test_as<MyGame::Examp
   return test_as_Monster();
 }
 
+template<> inline MyGame::Example::Monster *Monster::mutable_test_as<MyGame::Example::Monster>() {
+  return mutable_test_as_Monster();
+}
+
 template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::test_as<MyGame::Example::TestSimpleTableWithEnum>() const {
   return test_as_TestSimpleTableWithEnum();
 }
 
+template<> inline MyGame::Example::TestSimpleTableWithEnum *Monster::mutable_test_as<MyGame::Example::TestSimpleTableWithEnum>() {
+  return mutable_test_as_TestSimpleTableWithEnum();
+}
+
 template<> inline const MyGame::Example2::Monster *Monster::test_as<MyGame::Example2::Monster>() const {
   return test_as_MyGame_Example2_Monster();
 }
 
+template<> inline MyGame::Example2::Monster *Monster::mutable_test_as<MyGame::Example2::Monster>() {
+  return mutable_test_as_MyGame_Example2_Monster();
+}
+
 template<> inline const MyGame::Example::Monster *Monster::any_unique_as<MyGame::Example::Monster>() const {
   return any_unique_as_M();
 }
 
+template<> inline MyGame::Example::Monster *Monster::mutable_any_unique_as<MyGame::Example::Monster>() {
+  return mutable_any_unique_as_M();
+}
+
 template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::any_unique_as<MyGame::Example::TestSimpleTableWithEnum>() const {
   return any_unique_as_TS();
 }
 
+template<> inline MyGame::Example::TestSimpleTableWithEnum *Monster::mutable_any_unique_as<MyGame::Example::TestSimpleTableWithEnum>() {
+  return mutable_any_unique_as_TS();
+}
+
 template<> inline const MyGame::Example2::Monster *Monster::any_unique_as<MyGame::Example2::Monster>() const {
   return any_unique_as_M2();
 }
 
+template<> inline MyGame::Example2::Monster *Monster::mutable_any_unique_as<MyGame::Example2::Monster>() {
+  return mutable_any_unique_as_M2();
+}
+
 struct MonsterBuilder {
   typedef Monster Table;
   ::flatbuffers::FlatBufferBuilder &fbb_;

tests/namespace_test/namespace_test2_generated.h

@@ -117,6 +117,10 @@ struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const NamespaceA::NamespaceB::TableInNestedNS *foo_union_as_TableInNestedNS() const {
     return foo_union_type() == NamespaceA::NamespaceB::UnionInNestedNS_TableInNestedNS ? static_cast<const NamespaceA::NamespaceB::TableInNestedNS *>(foo_union()) : nullptr;
   }
+  template<typename T> T *mutable_foo_union_as();
+  NamespaceA::NamespaceB::TableInNestedNS *mutable_foo_union_as_TableInNestedNS() {
+    return foo_union_type() == NamespaceA::NamespaceB::UnionInNestedNS_TableInNestedNS ? static_cast<NamespaceA::NamespaceB::TableInNestedNS *>(mutable_foo_union()) : nullptr;
+  }
   void *mutable_foo_union() {
     return GetPointer<void *>(VT_FOO_UNION);
   }
@@ -147,6 +151,10 @@ template<> inline const NamespaceA::NamespaceB::TableInNestedNS *TableInFirstNS:
   return foo_union_as_TableInNestedNS();
 }
 
+template<> inline NamespaceA::NamespaceB::TableInNestedNS *TableInFirstNS::mutable_foo_union_as<NamespaceA::NamespaceB::TableInNestedNS>() {
+  return mutable_foo_union_as_TableInNestedNS();
+}
+
 struct TableInFirstNSBuilder {
   typedef TableInFirstNS Table;
   ::flatbuffers::FlatBufferBuilder &fbb_;

tests/native_type_test_generated.h

@@ -31,14 +31,6 @@ struct ApplicationDataT;
 bool operator==(const ApplicationDataT &lhs, const ApplicationDataT &rhs);
 bool operator!=(const ApplicationDataT &lhs, const ApplicationDataT &rhs);
 
-inline const ::flatbuffers::TypeTable *Vector3DTypeTable();
-
-inline const ::flatbuffers::TypeTable *Vector3DAltTypeTable();
-
-inline const ::flatbuffers::TypeTable *MatrixTypeTable();
-
-inline const ::flatbuffers::TypeTable *ApplicationDataTypeTable();
-
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3D FLATBUFFERS_FINAL_CLASS {
  private:
   float x_;
@@ -46,9 +38,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3D FLATBUFFERS_FINAL_CLASS {
   float z_;
 
  public:
-  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
-    return Vector3DTypeTable();
-  }
+  struct Traits;
   Vector3D()
       : x_(0),
         y_(0),
@@ -62,24 +52,19 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3D FLATBUFFERS_FINAL_CLASS {
   float x() const {
     return ::flatbuffers::EndianScalar(x_);
   }
-  void mutate_x(float _x) {
-    ::flatbuffers::WriteScalar(&x_, _x);
-  }
   float y() const {
     return ::flatbuffers::EndianScalar(y_);
   }
-  void mutate_y(float _y) {
-    ::flatbuffers::WriteScalar(&y_, _y);
-  }
   float z() const {
     return ::flatbuffers::EndianScalar(z_);
   }
-  void mutate_z(float _z) {
-    ::flatbuffers::WriteScalar(&z_, _z);
-  }
 };
 FLATBUFFERS_STRUCT_END(Vector3D, 12);
 
+struct Vector3D::Traits {
+  using type = Vector3D;
+};
+
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3DAlt FLATBUFFERS_FINAL_CLASS {
  private:
   float a_;
@@ -87,9 +72,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3DAlt FLATBUFFERS_FINAL_CLASS {
   float c_;
 
  public:
-  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
-    return Vector3DAltTypeTable();
-  }
+  struct Traits;
   Vector3DAlt()
       : a_(0),
         b_(0),
@@ -103,30 +86,23 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3DAlt FLATBUFFERS_FINAL_CLASS {
   float a() const {
     return ::flatbuffers::EndianScalar(a_);
   }
-  void mutate_a(float _a) {
-    ::flatbuffers::WriteScalar(&a_, _a);
-  }
   float b() const {
     return ::flatbuffers::EndianScalar(b_);
   }
-  void mutate_b(float _b) {
-    ::flatbuffers::WriteScalar(&b_, _b);
-  }
   float c() const {
     return ::flatbuffers::EndianScalar(c_);
   }
-  void mutate_c(float _c) {
-    ::flatbuffers::WriteScalar(&c_, _c);
-  }
 };
 FLATBUFFERS_STRUCT_END(Vector3DAlt, 12);
 
+struct Vector3DAlt::Traits {
+  using type = Vector3DAlt;
+};
+
 struct Matrix FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef Native::Matrix NativeTableType;
   typedef MatrixBuilder Builder;
-  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
-    return MatrixTypeTable();
-  }
+  struct Traits;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_ROWS = 4,
     VT_COLUMNS = 6,
@@ -135,21 +111,12 @@ struct Matrix FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int32_t rows() const {
     return GetField<int32_t>(VT_ROWS, 0);
   }
-  bool mutate_rows(int32_t _rows = 0) {
-    return SetField<int32_t>(VT_ROWS, _rows, 0);
-  }
   int32_t columns() const {
     return GetField<int32_t>(VT_COLUMNS, 0);
   }
-  bool mutate_columns(int32_t _columns = 0) {
-    return SetField<int32_t>(VT_COLUMNS, _columns, 0);
-  }
   const ::flatbuffers::Vector<float> *values() const {
     return GetPointer<const ::flatbuffers::Vector<float> *>(VT_VALUES);
   }
-  ::flatbuffers::Vector<float> *mutable_values() {
-    return GetPointer<::flatbuffers::Vector<float> *>(VT_VALUES);
-  }
   template <bool B = false>
   bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
@@ -200,6 +167,11 @@ inline ::flatbuffers::Offset<Matrix> CreateMatrix(
   return builder_.Finish();
 }
 
+struct Matrix::Traits {
+  using type = Matrix;
+  static auto constexpr Create = CreateMatrix;
+};
+
 inline ::flatbuffers::Offset<Matrix> CreateMatrixDirect(
     ::flatbuffers::FlatBufferBuilder &_fbb,
     int32_t rows = 0,
@@ -232,9 +204,7 @@ struct ApplicationDataT : public ::flatbuffers::NativeTable {
 struct ApplicationData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef ApplicationDataT NativeTableType;
   typedef ApplicationDataBuilder Builder;
-  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
-    return ApplicationDataTypeTable();
-  }
+  struct Traits;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_VECTORS = 4,
     VT_VECTORS_ALT = 6,
@@ -246,39 +216,21 @@ struct ApplicationData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::Vector<const Geometry::Vector3D *> *vectors() const {
     return GetPointer<const ::flatbuffers::Vector<const Geometry::Vector3D *> *>(VT_VECTORS);
   }
-  ::flatbuffers::Vector<const Geometry::Vector3D *> *mutable_vectors() {
-    return GetPointer<::flatbuffers::Vector<const Geometry::Vector3D *> *>(VT_VECTORS);
-  }
   const ::flatbuffers::Vector<const Geometry::Vector3DAlt *> *vectors_alt() const {
     return GetPointer<const ::flatbuffers::Vector<const Geometry::Vector3DAlt *> *>(VT_VECTORS_ALT);
   }
-  ::flatbuffers::Vector<const Geometry::Vector3DAlt *> *mutable_vectors_alt() {
-    return GetPointer<::flatbuffers::Vector<const Geometry::Vector3DAlt *> *>(VT_VECTORS_ALT);
-  }
   const Geometry::Vector3D *position() const {
     return GetStruct<const Geometry::Vector3D *>(VT_POSITION);
   }
-  Geometry::Vector3D *mutable_position() {
-    return GetStruct<Geometry::Vector3D *>(VT_POSITION);
-  }
   const Geometry::Vector3D *position_inline() const {
     return GetStruct<const Geometry::Vector3D *>(VT_POSITION_INLINE);
   }
-  Geometry::Vector3D *mutable_position_inline() {
-    return GetStruct<Geometry::Vector3D *>(VT_POSITION_INLINE);
-  }
   const Geometry::Matrix *matrix() const {
     return GetPointer<const Geometry::Matrix *>(VT_MATRIX);
   }
-  Geometry::Matrix *mutable_matrix() {
-    return GetPointer<Geometry::Matrix *>(VT_MATRIX);
-  }
   const ::flatbuffers::Vector<::flatbuffers::Offset<Geometry::Matrix>> *matrices() const {
     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Geometry::Matrix>> *>(VT_MATRICES);
   }
-  ::flatbuffers::Vector<::flatbuffers::Offset<Geometry::Matrix>> *mutable_matrices() {
-    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<Geometry::Matrix>> *>(VT_MATRICES);
-  }
   template <bool B = false>
   bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
@@ -351,6 +303,11 @@ inline ::flatbuffers::Offset<ApplicationData> CreateApplicationData(
   return builder_.Finish();
 }
 
+struct ApplicationData::Traits {
+  using type = ApplicationData;
+  static auto constexpr Create = CreateApplicationData;
+};
+
 inline ::flatbuffers::Offset<ApplicationData> CreateApplicationDataDirect(
     ::flatbuffers::FlatBufferBuilder &_fbb,
     const std::vector<Geometry::Vector3D> *vectors = nullptr,
@@ -375,7 +332,7 @@ inline ::flatbuffers::Offset<ApplicationData> CreateApplicationDataDirect(
 ::flatbuffers::Offset<ApplicationData> CreateApplicationData(::flatbuffers::FlatBufferBuilder &_fbb, const ApplicationDataT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
 
 inline Native::Matrix *Matrix::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
-  auto _o = std::unique_ptr<Native::Matrix>(new Native::Matrix());
+  auto _o = std::make_unique<Native::Matrix>();
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -421,7 +378,7 @@ inline ApplicationDataT &ApplicationDataT::operator=(ApplicationDataT o) FLATBUF
 }
 
 inline ApplicationDataT *ApplicationData::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
-  auto _o = std::unique_ptr<ApplicationDataT>(new ApplicationDataT());
+  auto _o = std::make_unique<ApplicationDataT>();
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -461,87 +418,6 @@ inline ::flatbuffers::Offset<ApplicationData> ApplicationData::Pack(::flatbuffer
       _matrices);
 }
 
-inline const ::flatbuffers::TypeTable *Vector3DTypeTable() {
-  static const ::flatbuffers::TypeCode type_codes[] = {
-    { ::flatbuffers::ET_FLOAT, 0, -1 },
-    { ::flatbuffers::ET_FLOAT, 0, -1 },
-    { ::flatbuffers::ET_FLOAT, 0, -1 }
-  };
-  static const int64_t values[] = { 0, 4, 8, 12 };
-  static const char * const names[] = {
-    "x",
-    "y",
-    "z"
-  };
-  static const ::flatbuffers::TypeTable tt = {
-    ::flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names
-  };
-  return &tt;
-}
-
-inline const ::flatbuffers::TypeTable *Vector3DAltTypeTable() {
-  static const ::flatbuffers::TypeCode type_codes[] = {
-    { ::flatbuffers::ET_FLOAT, 0, -1 },
-    { ::flatbuffers::ET_FLOAT, 0, -1 },
-    { ::flatbuffers::ET_FLOAT, 0, -1 }
-  };
-  static const int64_t values[] = { 0, 4, 8, 12 };
-  static const char * const names[] = {
-    "a",
-    "b",
-    "c"
-  };
-  static const ::flatbuffers::TypeTable tt = {
-    ::flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names
-  };
-  return &tt;
-}
-
-inline const ::flatbuffers::TypeTable *MatrixTypeTable() {
-  static const ::flatbuffers::TypeCode type_codes[] = {
-    { ::flatbuffers::ET_INT, 0, -1 },
-    { ::flatbuffers::ET_INT, 0, -1 },
-    { ::flatbuffers::ET_FLOAT, 1, -1 }
-  };
-  static const char * const names[] = {
-    "rows",
-    "columns",
-    "values"
-  };
-  static const ::flatbuffers::TypeTable tt = {
-    ::flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, nullptr, names
-  };
-  return &tt;
-}
-
-inline const ::flatbuffers::TypeTable *ApplicationDataTypeTable() {
-  static const ::flatbuffers::TypeCode type_codes[] = {
-    { ::flatbuffers::ET_SEQUENCE, 1, 0 },
-    { ::flatbuffers::ET_SEQUENCE, 1, 1 },
-    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
-    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
-    { ::flatbuffers::ET_SEQUENCE, 0, 2 },
-    { ::flatbuffers::ET_SEQUENCE, 1, 2 }
-  };
-  static const ::flatbuffers::TypeFunction type_refs[] = {
-    Geometry::Vector3DTypeTable,
-    Geometry::Vector3DAltTypeTable,
-    Geometry::MatrixTypeTable
-  };
-  static const char * const names[] = {
-    "vectors",
-    "vectors_alt",
-    "position",
-    "position_inline",
-    "matrix",
-    "matrices"
-  };
-  static const ::flatbuffers::TypeTable tt = {
-    ::flatbuffers::ST_TABLE, 6, type_codes, type_refs, nullptr, nullptr, names
-  };
-  return &tt;
-}
-
 inline const Geometry::ApplicationData *GetApplicationData(const void *buf) {
   return ::flatbuffers::GetRoot<Geometry::ApplicationData>(buf);
 }
@@ -550,14 +426,6 @@ inline const Geometry::ApplicationData *GetSizePrefixedApplicationData(const voi
   return ::flatbuffers::GetSizePrefixedRoot<Geometry::ApplicationData>(buf);
 }
 
-inline ApplicationData *GetMutableApplicationData(void *buf) {
-  return ::flatbuffers::GetMutableRoot<ApplicationData>(buf);
-}
-
-inline Geometry::ApplicationData *GetMutableSizePrefixedApplicationData(void *buf) {
-  return ::flatbuffers::GetMutableSizePrefixedRoot<Geometry::ApplicationData>(buf);
-}
-
 template <bool B = false>
 inline bool VerifyApplicationDataBuffer(
     ::flatbuffers::VerifierTemplate<B> &verifier) {
@@ -570,6 +438,10 @@ inline bool VerifySizePrefixedApplicationDataBuffer(
   return verifier.template VerifySizePrefixedBuffer<Geometry::ApplicationData>(nullptr);
 }
 
+inline const char *ApplicationDataExtension() {
+  return "bfbs";
+}
+
 inline void FinishApplicationDataBuffer(
     ::flatbuffers::FlatBufferBuilder &fbb,
     ::flatbuffers::Offset<Geometry::ApplicationData> root) {

tests/native_type_test_impl.h

@@ -43,6 +43,7 @@ struct Matrix {
            (values == other.values);
   }
 };
+
 }  // namespace Native
 
 namespace Geometry {

tests/parser_test.cpp

@@ -97,6 +97,17 @@ void ErrorTest() {
             "datatype already");
   TestError("struct X (force_align: 7) { Y:int; }", "force_align");
   TestError("struct X {}", "size 0");
+  TestError(
+      "struct X { Y:int; } table T { y:X (bigfoot_ref:\"::Foo::Bar\"); "
+      "}",
+      "'bigfoot_ref_wrapper' attribute");
+  TestError(
+      "table T { y:int (bigfoot_ref:\"::Foo::Bar\"); }",
+      "struct-typed fields");
+  TestError(
+      "struct X (bigfoot_ref_wrapper: \"Foo\") { Y:int; } "
+      "table T { y:X (bigfoot_ref:\"\"); }",
+      "cannot be empty");
   TestError("{}", "no root");
   TestError("table X { Y:byte; } root_type X; { Y:1 } { Y:1 }", "end of file");
   TestError("table X { Y:byte; } root_type X; { Y:1 } table Y{ Z:int }",