Merge branch 'master' into master

.github/workflows/build.yml

@@ -9,6 +9,7 @@ on:
       - "*" # new tag version, like `0.8.4` or else
     branches:
       - master
+      - flatbuffers-64
   pull_request:
     branches:
       - master

BUILD.bazel

@@ -47,6 +47,7 @@ filegroup(
         "include/flatbuffers/code_generators.h",
         "include/flatbuffers/default_allocator.h",
         "include/flatbuffers/detached_buffer.h",
+        "include/flatbuffers/file_manager.h",
         "include/flatbuffers/flatbuffer_builder.h",
         "include/flatbuffers/flatbuffers.h",
         "include/flatbuffers/flex_flat_util.h",

CMakeLists.txt

@@ -127,6 +127,7 @@ set(FlatBuffers_Library_SRCS
   include/flatbuffers/default_allocator.h
   include/flatbuffers/detached_buffer.h
   include/flatbuffers/code_generator.h
+  include/flatbuffers/file_manager.h
   include/flatbuffers/flatbuffer_builder.h
   include/flatbuffers/flatbuffers.h
   include/flatbuffers/flexbuffers.h
@@ -171,6 +172,9 @@ set(FlatBuffers_Compiler_SRCS
   src/idl_gen_grpc.cpp
   src/idl_gen_json_schema.cpp
   src/idl_gen_swift.cpp
+  src/file_name_saving_file_manager.cpp
+  src/file_binary_writer.cpp
+  src/file_writer.cpp
   src/idl_namer.h
   src/namer.h
   src/flatc.cpp

README.md

@@ -31,14 +31,14 @@ Code generation and runtime libraries for many popular languages.
 1. C++ - [snapcraft.io](https://snapcraft.io/flatbuffers)
 1. C# - [nuget.org](https://www.nuget.org/packages/Google.FlatBuffers)
 1. Dart - [pub.dev](https://pub.dev/packages/flat_buffers)
-1. Go - [go.dev](https://pkg.go.dev/github.com/google/flatbuffers/go)
+1. Go - [go.dev](https://pkg.go.dev/github.com/google/flatbuffers)
 1. Java - [Maven](https://search.maven.org/artifact/com.google.flatbuffers/flatbuffers-java)
 1. JavaScript - [NPM](https://www.npmjs.com/package/flatbuffers)
 1. Kotlin
 1. Lobster
 1. Lua
 1. PHP
-1. Python - [PyPi](https://pypi.org/project/flatbuffers/)
+1. Python - [PyPI](https://pypi.org/project/flatbuffers/)
 1. Rust - [crates.io](https://crates.io/crates/flatbuffers)
 1. Swift - [swiftpackageindex](https://swiftpackageindex.com/google/flatbuffers)
 1. TypeScript - [NPM](https://www.npmjs.com/package/flatbuffers)

docs/source/CsharpUsage.md

@@ -142,6 +142,47 @@ To use it:
     `ByKey` only works if the vector has been sorted, it will
     likely not find elements if it hasn't been sorted.
 
+## Buffer verification 
+
+As mentioned in [C++ Usage](@ref flatbuffers_guide_use_cpp) buffer
+accessor functions do not verify buffer offsets at run-time. 
+If it is necessary, you can optionally use a buffer verifier before you
+access the data. This verifier will check all offsets, all sizes of
+fields, and null termination of strings to ensure that when a buffer
+is accessed, all reads will end up inside the buffer.
+
+Each root type will have a verification function generated for it,
+e.g. `Monster.VerifyMonster`. This can be called as shown:
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cs}
+    var ok = Monster.VerifyMonster(buf);
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+if `ok` is true, the buffer is safe to read.
+
+For a more detailed control of verification `MonsterVerify.Verify` 
+for `Monster` type can be used: 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cs}
+    # Sequence of calls
+    FlatBuffers.Verifier verifier = new FlatBuffers.Verifier(buf);
+    var ok = verifier.VerifyBuffer("MONS", false, MonsterVerify.Verify);
+    
+    # Or single line call 
+    var ok = new FlatBuffers.Verifier(bb).setStringCheck(true).\
+             VerifyBuffer("MONS", false, MonsterVerify.Verify);
+       
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+if `ok` is true, the buffer is safe to read.
+
+A second parameter of `verifyBuffer` specifies whether buffer content is
+size prefixed or not. In the example above, the buffer is assumed to not include
+size prefix (`false`).
+
+Verifier supports options that can be set using appropriate fluent methods:
+* SetMaxDepth - limit the nesting depth. Default: 1000000
+* SetMaxTables - total amount of tables the verifier may encounter. Default: 64
+* SetAlignmentCheck - check content alignment. Default: True
+* SetStringCheck - check if strings contain termination '0' character. Default: true
+ 
+
 ## Text parsing
 
 There currently is no support for parsing text (Schema's and JSON) directly

docs/source/Tutorial.md

@@ -529,7 +529,7 @@ The first step is to import/include the library, generated files, etc.
   #[allow(dead_code, unused_imports)]
   #[path = "./monster_generated.rs"]
   mod monster_generated;
-  pub use monster_generated::my_game::sample::{get_root_as_monster,
+  pub use monster_generated::my_game::sample::{root_as_monster,
                                                Color, Equipment,
                                                Monster, MonsterArgs,
                                                Vec3,
@@ -652,7 +652,7 @@ which will grow automatically if needed:
 ~~~{.rs}
   // Build up a serialized buffer algorithmically.
   // Initialize it with a capacity of 1024 bytes.
-  let mut builder = flatbuffers::FlatBufferBuilder::new_with_capacity(1024);
+  let mut builder = flatbuffers::FlatBufferBuilder::with_capacity(1024);
 ~~~
 </div>
 <div class="language-swift">
@@ -2309,7 +2309,7 @@ import './monster_my_game.sample_generated.dart' as myGame;
   #[allow(dead_code, unused_imports)]
   #[path = "./monster_generated.rs"]
   mod monster_generated;
-  pub use monster_generated::my_game::sample::{get_root_as_monster,
+  pub use monster_generated::my_game::sample::{root_as_monster,
                                                Color, Equipment,
                                                Monster, MonsterArgs,
                                                Vec3,
@@ -2465,7 +2465,7 @@ myGame.Monster monster = new myGame.Monster(data);
   let buf = /* the data you just read, in a &[u8] */
 
   // Get an accessor to the root object inside the buffer.
-  let monster = get_root_as_monster(buf);
+  let monster = root_as_monster(buf).unwrap();
 ~~~
 </div>
 <div class="language-swift">

docs/source/doxyfile

@@ -779,7 +779,8 @@ INPUT = "FlatBuffers.md" \
         "../../python/flatbuffers/builder.py" \
         "../../js/flatbuffers.js" \
         "../../php/FlatbufferBuilder.php" \
-        "../../net/FlatBuffers/FlatBufferBuilder.cs" \
+        "../../net/FlatBuffers/FlatBufferBuilder.cs"
+        "../../net/FlatBuffers/FlatBufferVerify.cs" \
         "../../include/flatbuffers/flatbuffers.h" \
         "../../go/builder.go" \
         "../../rust/flatbuffers/src/builder.rs"

examples/go-echo/hero/Warrior.go

@@ -12,8 +12,13 @@ type WarriorT struct {
 }
 
 func (t *WarriorT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
-	if t == nil { return 0 }
+	if t == nil {
-	nameOffset := builder.CreateString(t.Name)
+		return 0
+	}
+	nameOffset := flatbuffers.UOffsetT(0)
+	if t.Name != "" {
+		nameOffset = builder.CreateString(t.Name)
+	}
 	WarriorStart(builder)
 	WarriorAddName(builder, nameOffset)
 	WarriorAddHp(builder, t.Hp)
@@ -26,7 +31,9 @@ func (rcv *Warrior) UnPackTo(t *WarriorT) {
 }
 
 func (rcv *Warrior) UnPack() *WarriorT {
-	if rcv == nil { return nil }
+	if rcv == nil {
+		return nil
+	}
 	t := &WarriorT{}
 	rcv.UnPackTo(t)
 	return t

examples/go-echo/net/Request.go

@@ -13,7 +13,9 @@ type RequestT struct {
 }
 
 func (t *RequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
-	if t == nil { return 0 }
+	if t == nil {
+		return 0
+	}
 	playerOffset := t.Player.Pack(builder)
 	RequestStart(builder)
 	RequestAddPlayer(builder, playerOffset)
@@ -25,7 +27,9 @@ func (rcv *Request) UnPackTo(t *RequestT) {
 }
 
 func (rcv *Request) UnPack() *RequestT {
-	if rcv == nil { return nil }
+	if rcv == nil {
+		return nil
+	}
 	t := &RequestT{}
 	rcv.UnPackTo(t)
 	return t

examples/go-echo/net/Response.go

@@ -13,7 +13,9 @@ type ResponseT struct {
 }
 
 func (t *ResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
-	if t == nil { return 0 }
+	if t == nil {
+		return 0
+	}
 	playerOffset := t.Player.Pack(builder)
 	ResponseStart(builder)
 	ResponseAddPlayer(builder, playerOffset)
@@ -25,7 +27,9 @@ func (rcv *Response) UnPackTo(t *ResponseT) {
 }
 
 func (rcv *Response) UnPack() *ResponseT {
-	if rcv == nil { return nil }
+	if rcv == nil {
+		return nil
+	}
 	t := &ResponseT{}
 	rcv.UnPackTo(t)
 	return t

go/lib.go

@@ -28,3 +28,23 @@ func GetSizePrefix(buf []byte, offset UOffsetT) uint32 {
 func GetIndirectOffset(buf []byte, offset UOffsetT) UOffsetT {
 	return offset + GetUOffsetT(buf[offset:])
 }
+
+// GetBufferIdentifier returns the file identifier as string
+func GetBufferIdentifier(buf []byte) string {
+	return string(buf[SizeUOffsetT:][:fileIdentifierLength])
+}
+
+// GetBufferIdentifier returns the file identifier as string for a size-prefixed buffer
+func GetSizePrefixedBufferIdentifier(buf []byte) string {
+	return string(buf[SizeUOffsetT+sizePrefixLength:][:fileIdentifierLength])
+}
+
+// BufferHasIdentifier checks if the identifier in a buffer has the expected value
+func BufferHasIdentifier(buf []byte, identifier string) bool {
+	return GetBufferIdentifier(buf) == identifier
+}
+
+// BufferHasIdentifier checks if the identifier in a buffer has the expected value for a size-prefixed buffer
+func SizePrefixedBufferHasIdentifier(buf []byte, identifier string) bool {
+	return GetSizePrefixedBufferIdentifier(buf) == identifier
+}

grpc/examples/go/greeter/models/HelloReply.go

@@ -17,6 +17,10 @@ func GetRootAsHelloReply(buf []byte, offset flatbuffers.UOffsetT) *HelloReply {
 	return x
 }
 
+func FinishHelloReplyBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
 func GetSizePrefixedRootAsHelloReply(buf []byte, offset flatbuffers.UOffsetT) *HelloReply {
 	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
 	x := &HelloReply{}
@@ -24,6 +28,10 @@ func GetSizePrefixedRootAsHelloReply(buf []byte, offset flatbuffers.UOffsetT) *H
 	return x
 }
 
+func FinishSizePrefixedHelloReplyBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
 func (rcv *HelloReply) Init(buf []byte, i flatbuffers.UOffsetT) {
 	rcv._tab.Bytes = buf
 	rcv._tab.Pos = i

grpc/examples/go/greeter/models/HelloRequest.go

@@ -17,6 +17,10 @@ func GetRootAsHelloRequest(buf []byte, offset flatbuffers.UOffsetT) *HelloReques
 	return x
 }
 
+func FinishHelloRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
 func GetSizePrefixedRootAsHelloRequest(buf []byte, offset flatbuffers.UOffsetT) *HelloRequest {
 	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
 	x := &HelloRequest{}
@@ -24,6 +28,10 @@ func GetSizePrefixedRootAsHelloRequest(buf []byte, offset flatbuffers.UOffsetT)
 	return x
 }
 
+func FinishSizePrefixedHelloRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
 func (rcv *HelloRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
 	rcv._tab.Bytes = buf
 	rcv._tab.Pos = i

grpc/examples/python/greeter/models/HelloReply.py

@@ -31,12 +31,20 @@ class HelloReply(object):
             return self._tab.String(o + self._tab.Pos)
         return None
 
-def HelloReplyStart(builder): builder.StartObject(1)
+def HelloReplyStart(builder):
+    return builder.StartObject(1)
+
 def Start(builder):
     return HelloReplyStart(builder)
-def HelloReplyAddMessage(builder, message): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0)
+
+def HelloReplyAddMessage(builder, message):
+    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0)
+
 def AddMessage(builder, message):
     return HelloReplyAddMessage(builder, message)
-def HelloReplyEnd(builder): return builder.EndObject()
+
+def HelloReplyEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
-    return HelloReplyEnd(builder)
+    return HelloReplyEnd(builder)

grpc/examples/python/greeter/models/HelloRequest.py

@@ -31,12 +31,20 @@ class HelloRequest(object):
             return self._tab.String(o + self._tab.Pos)
         return None
 
-def HelloRequestStart(builder): builder.StartObject(1)
+def HelloRequestStart(builder):
+    return builder.StartObject(1)
+
 def Start(builder):
     return HelloRequestStart(builder)
-def HelloRequestAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
+def HelloRequestAddName(builder, name):
+    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
 def AddName(builder, name):
     return HelloRequestAddName(builder, name)
-def HelloRequestEnd(builder): return builder.EndObject()
+
+def HelloRequestEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
-    return HelloRequestEnd(builder)
+    return HelloRequestEnd(builder)

include/flatbuffers/file_manager.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2023 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.
+ */
+
+#ifndef FLATBUFFERS_FILE_MANAGER_H_
+#define FLATBUFFERS_FILE_MANAGER_H_
+
+#include <set>
+#include <string>
+
+#include "flatbuffers/util.h"
+
+namespace flatbuffers {
+
+// A File interface to write data to file by default or
+// save only file names
+class FileManager {
+ public:
+  FileManager() = default;
+  virtual ~FileManager() = default;
+
+  virtual bool SaveFile(const std::string &absolute_file_name,
+                        const std::string &content) = 0;
+
+  virtual bool LoadFile(const std::string &absolute_file_name,
+                        std::string *buf) = 0;
+
+ private:
+  // Copying is not supported.
+  FileManager(const FileManager &) = delete;
+  FileManager &operator=(const FileManager &) = delete;
+};
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_FILE_MANAGER_H_

include/flatbuffers/flatbuffer_builder.h

@@ -1184,7 +1184,8 @@ class FlatBufferBuilder {
   // Allocates space for a vector of structures.
   // Must be completed with EndVectorOfStructs().
   template<typename T> T *StartVectorOfStructs(size_t vector_size) {
-    StartVector(vector_size * sizeof(T) / AlignOf<T>(), sizeof(T), AlignOf<T>());
+    StartVector(vector_size * sizeof(T) / AlignOf<T>(), sizeof(T),
+                AlignOf<T>());
     return reinterpret_cast<T *>(buf_.make_space(vector_size * sizeof(T)));
   }
 

include/flatbuffers/flatc.h

@@ -56,6 +56,7 @@ struct FlatCOptions {
   bool schema_binary = false;
   bool grpc_enabled = false;
   bool requires_bfbs = false;
+  bool file_names_only = false;
 
   std::vector<std::shared_ptr<CodeGenerator>> generators;
 };

include/flatbuffers/flexbuffers.h

@@ -1424,12 +1424,10 @@ class Builder FLATBUFFERS_FINAL_CLASS {
 
   template<typename T> static Type GetScalarType() {
     static_assert(flatbuffers::is_scalar<T>::value, "Unrelated types");
-    return flatbuffers::is_floating_point<T>::value
+    return flatbuffers::is_floating_point<T>::value ? FBT_FLOAT
-               ? FBT_FLOAT
+           : flatbuffers::is_same<T, bool>::value
-               : flatbuffers::is_same<T, bool>::value
+               ? FBT_BOOL
-                     ? FBT_BOOL
+               : (flatbuffers::is_unsigned<T>::value ? FBT_UINT : FBT_INT);
-                     : (flatbuffers::is_unsigned<T>::value ? FBT_UINT
-                                                           : FBT_INT);
   }
 
  public:

include/flatbuffers/idl.h

@@ -697,6 +697,7 @@ struct IDLOptions {
   bool no_leak_private_annotations;
   bool require_json_eof;
   bool keep_proto_id;
+  bool python_no_type_prefix_suffix;
   ProtoIdGapAction proto_id_gap_action;
 
   // Possible options for the more general generator below.
@@ -806,6 +807,7 @@ struct IDLOptions {
         no_leak_private_annotations(false),
         require_json_eof(true),
         keep_proto_id(false),
+        python_no_type_prefix_suffix(false),
         proto_id_gap_action(ProtoIdGapAction::WARNING),
         mini_reflect(IDLOptions::kNone),
         require_explicit_ids(false),

include/flatbuffers/minireflect.h

@@ -408,7 +408,7 @@ inline std::string FlatBufferToString(const uint8_t *buffer,
                                       const TypeTable *type_table,
                                       bool multi_line = false,
                                       bool vector_delimited = true,
-                                      const std::string& indent = "") {
+                                      const std::string &indent = "") {
   ToStringVisitor tostring_visitor(multi_line ? "\n" : " ", false, indent,
                                    vector_delimited);
   IterateFlatBuffer(buffer, type_table, &tostring_visitor);

include/flatbuffers/util.h

@@ -722,9 +722,10 @@ enum class Case {
   kSnake2 = 9,
 };
 
-// Convert the `input` string of case `input_case` to the specified `output_case`.
+// Convert the `input` string of case `input_case` to the specified
+// `output_case`.
 std::string ConvertCase(const std::string &input, Case output_case,
-                    Case input_case = Case::kSnake);
+                        Case input_case = Case::kSnake);
 
 }  // namespace flatbuffers
 

net/FlatBuffers/FlatBufferBuilder.cs

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

net/FlatBuffers/FlatBufferVerify.cs

@@ -0,0 +1,822 @@
+/*
+ * Copyright 2014 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.Reflection;using System.Collections.Generic;
+using System.IO;
+
+namespace Google.FlatBuffers
+{
+
+  /// <summary>
+  /// The Class of the Verifier Options
+  /// </summary>
+  public class Options
+  {
+    public const int DEFAULT_MAX_DEPTH = 64;
+    public const int DEFAULT_MAX_TABLES = 1000000;
+
+    private int max_depth = 0;
+    private int max_tables = 0;
+    private bool string_end_check = false;
+    private bool alignment_check = false;
+
+    public Options()
+    {
+      max_depth = DEFAULT_MAX_DEPTH;
+      max_tables = DEFAULT_MAX_TABLES;
+      string_end_check = true;
+      alignment_check = true;
+    }
+
+    public Options(int maxDepth, int maxTables, bool stringEndCheck, bool alignmentCheck)
+    {
+      max_depth = maxDepth;
+      max_tables = maxTables;
+      string_end_check = stringEndCheck;
+      alignment_check = alignmentCheck;
+    }
+    /// <summary> Maximum depth of nested tables allowed in a valid flatbuffer. </summary>
+    public int maxDepth
+    {
+      get { return max_depth; }
+      set { max_depth = value; }
+    }
+    /// <summary> Maximum number of tables allowed in a valid flatbuffer. </summary>
+    public int maxTables
+    {
+      get { return max_tables; }
+      set { max_tables = value; }
+    }
+    /// <summary> Check that string contains its null terminator </summary>
+    public bool stringEndCheck
+    {
+      get { return string_end_check; }
+      set { string_end_check = value; }
+    }
+    /// <summary> Check alignment of elements </summary>
+    public bool alignmentCheck
+    {
+      get { return alignment_check; }
+      set { alignment_check = value; }
+    }
+  }
+
+  public struct checkElementStruct
+  {
+    public bool elementValid;
+    public uint elementOffset;
+  }
+
+  public delegate bool VerifyTableAction(Verifier verifier, uint tablePos);
+  public delegate bool VerifyUnionAction(Verifier verifier, byte typeId, uint tablePos);
+
+  /// <summary>
+  /// The Main Class of the FlatBuffer Verifier
+  /// </summary>
+  public class Verifier
+  {
+    private ByteBuffer verifier_buffer = null;
+    private Options verifier_options = null;
+    private int depth_cnt = 0;
+    private int num_tables_cnt = 0;
+
+    public const int SIZE_BYTE = 1;
+    public const int SIZE_INT = 4;
+    public const int SIZE_U_OFFSET = 4;
+    public const int SIZE_S_OFFSET = 4;
+    public const int SIZE_V_OFFSET = 2;
+    public const int SIZE_PREFIX_LENGTH = FlatBufferConstants.SizePrefixLength;         // default size = 4
+    public const int FLATBUFFERS_MAX_BUFFER_SIZE = System.Int32.MaxValue;               // default size = 2147483647
+    public const int FILE_IDENTIFIER_LENGTH = FlatBufferConstants.FileIdentifierLength; // default size = 4
+
+    /// <summary> The Base Constructor of the Verifier object </summary>
+    public Verifier()
+    {
+      // Verifier buffer
+      verifier_buffer = null;
+      // Verifier settings 
+      verifier_options = null;
+      // Depth counter
+      depth_cnt = 0;
+      // Tables counter
+      num_tables_cnt = 0;
+    }
+
+    /// <summary> The Constructor of the Verifier object with input parameters: ByteBuffer and/or Options </summary>
+    /// <param name="buf"> Input flat byte buffer defined as ByteBuffer type</param>
+    /// <param name="options"> Options object with settings for the coniguration the Verifier </param>
+    public Verifier(ByteBuffer buf, Options options = null)
+    {
+      verifier_buffer = buf;
+      verifier_options = options ?? new Options();
+      depth_cnt = 0;
+      num_tables_cnt = 0;
+    }
+
+    /// <summary> Bytes Buffer for Verify</summary>
+    public ByteBuffer Buf
+    {
+      get { return verifier_buffer; }
+      set { verifier_buffer = value; }
+    }
+    /// <summary> Options of the Verifier </summary>
+    public Options options
+    {
+      get { return verifier_options; }
+      set { verifier_options = value; }
+    }
+    /// <summary> Counter of tables depth in a tested flatbuffer  </summary>
+    public int depth
+    {
+      get { return depth_cnt; }
+      set { depth_cnt = value; }
+    }
+    /// <summary> Counter of tables in a tested flatbuffer </summary>
+    public int numTables
+    {
+      get { return num_tables_cnt; }
+      set { num_tables_cnt = value; }
+    }
+
+
+    /// <summary> Method set maximum tables depth of valid structure</summary>
+    /// <param name="value"> Specify Value of the maximum depth of the structure</param>
+    public Verifier SetMaxDepth(int value)
+    {
+      verifier_options.maxDepth = value;
+      return this;
+    }
+    /// <summary> Specify maximum number of tables in structure </summary>
+    /// <param name="value"> Specify Value of the maximum number of the tables in the structure</param>
+    public Verifier SetMaxTables(int value)
+    {
+      verifier_options.maxTables = value;
+      return this;
+    }
+    /// <summary> Enable/disable buffer content alignment check </summary>
+    /// <param name="value"> Value of the State for buffer content alignment check (Enable = true) </param>
+    public Verifier SetAlignmentCheck(bool value)
+    {
+      verifier_options.alignmentCheck = value;
+      return this;
+    }
+    /// <summary> Enable/disable checking of string termination '0' character </summary>
+    /// <param name="value"> Value of the option for string termination '0' character check (Enable = true)</param>
+    public Verifier SetStringCheck(bool value)
+    {
+      verifier_options.stringEndCheck = value;
+      return this;
+    }
+
+    /// <summary> Check if there is identifier in buffer </summary>
+    /// <param name="buf"> Input flat byte buffer defined as ByteBuffer type </param>
+    /// <param name="startPos">Start position of data in the Byte Buffer</param>
+    /// <param name="identifier"> Identifier for the Byte Buffer</param>
+    /// <returns> Return True when the Byte Buffer Identifier is present</returns>
+    private bool BufferHasIdentifier(ByteBuffer buf, uint startPos, string identifier)
+    {
+      if (identifier.Length != FILE_IDENTIFIER_LENGTH)
+      {
+        throw new ArgumentException("FlatBuffers: file identifier must be length" + Convert.ToString(FILE_IDENTIFIER_LENGTH));
+      }
+      for (int i = 0; i < FILE_IDENTIFIER_LENGTH; i++)
+      {
+        if ((sbyte)identifier[i] != verifier_buffer.GetSbyte(Convert.ToInt32(SIZE_S_OFFSET + i + startPos)))
+        {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    /// <summary> Get UOffsetT from buffer at given position - it must be verified before read </summary>
+    /// <param name="buf"> Input flat byte buffer defined as ByteBuffer type </param>
+    /// <param name="pos"> Position of data in the Byte Buffer</param>
+    /// <returns> Return the UOffset Value (Unsigned Integer type - 4 bytes) in pos </returns>
+    private uint ReadUOffsetT(ByteBuffer buf, uint pos)
+    {
+      return buf.GetUint(Convert.ToInt32(pos));
+    }
+    /// <summary> Get SOffsetT from buffer at given position - it must be verified before read </summary>
+    /// <param name="buf"> Input flat byte buffer defined as ByteBuffer type </param>
+    /// <param name="pos"> Position of data in the Byte Buffer</param>
+    /// <returns> Return the SOffset Value (Signed Integer type - 4 bytes) in pos </returns>
+    private int ReadSOffsetT(ByteBuffer buf, int pos)
+    {
+      return buf.GetInt(pos);
+    }
+    /// <summary> Get VOffsetT from buffer at given position - it must be verified before read </summary>
+    /// <param name="buf"> Input flat byte buffer defined as ByteBuffer type </param>
+    /// <param name="pos"> Position of data in the Byte Buffer</param>
+    /// <returns> Return the VOffset Value (Short type - 2 bytes) in pos </returns>
+    private short ReadVOffsetT(ByteBuffer buf, int pos)
+    {
+      return buf.GetShort(pos);
+    }
+
+    /// <summary> Get table data area relative offset from vtable. Result is relative to table start
+    ///           Fields which are deprecated are ignored by checking against the vtable's length. </summary>
+    /// <param name="pos"> Position of data in the Byte Buffer </param>
+    /// <param name="vtableOffset"> offset of value in the Table</param>
+    /// <returns> Return the relative VOffset Value (Short type - 2 bytes) in calculated offset </returns>
+    private short GetVRelOffset(int pos, short vtableOffset)
+    {
+      short VOffset = 0;
+      // Used try/catch because pos typa as int 32bit
+      try
+      {
+        // First, get vtable offset
+        short vtable = Convert.ToInt16(pos - ReadSOffsetT(verifier_buffer, pos));
+        // Check that offset points to vtable area (is smaller than vtable size)
+        if (vtableOffset < ReadVOffsetT(verifier_buffer, vtable))
+        {
+          // Now, we can read offset value - TODO check this value against size of table data
+          VOffset = ReadVOffsetT(verifier_buffer, vtable + vtableOffset);
+        }
+        else
+        {
+          VOffset = 0;
+        }
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine("Exception: {0}", e);
+        return VOffset;
+      }
+      return VOffset;
+
+    }
+    /// <summary> Get table data area absolute offset from vtable. Result is the absolute buffer offset.
+    /// The result value offset cannot be '0' (pointing to itself) so after validation this method returnes '0'
+    /// value as a marker for missing optional entry </summary>
+    /// <param name="tablePos"> Table Position value in the Byte Buffer </param>
+    /// <param name="vtableOffset"> offset value in the Table</param>
+    /// <returns> Return the absolute UOffset Value </returns>
+    private uint GetVOffset(uint tablePos, short vtableOffset)
+    {
+      uint UOffset = 0;
+      // First, get vtable relative offset
+      short relPos = GetVRelOffset(Convert.ToInt32(tablePos), vtableOffset);
+      if (relPos != 0)
+      {
+        // Calculate offset based on table postion
+        UOffset = Convert.ToUInt32(tablePos + relPos);
+      }
+      else
+      {
+        UOffset = 0;
+      }
+      return UOffset;
+    }
+
+    /// <summary> Check flatbuffer complexity (tables depth, elements counter and so on) </summary>
+    /// <returns> If complexity is too high function returns false as verification error </returns>
+    private bool CheckComplexity()
+    {
+      return ((depth <= options.maxDepth) && (numTables <= options.maxTables));
+    }
+
+    /// <summary> Check alignment of element. </summary>
+    /// <returns> Return True when alignment of the element is correct</returns>
+    private bool CheckAlignment(uint element, ulong align)
+    {
+      return (((element & (align - 1)) == 0) || (!options.alignmentCheck));
+    }
+
+    /// <summary> Check if element is valid in buffer area. </summary> 
+    /// <param name="pos"> Value defines the offset/position to element</param>
+    /// <param name="elementSize"> Size of element</param>
+    /// <returns> Return True when Element is correct </returns>
+    private bool CheckElement(uint pos, ulong elementSize)
+    {
+      return ((elementSize < Convert.ToUInt64(verifier_buffer.Length)) && (pos <= (Convert.ToUInt32(verifier_buffer.Length) - elementSize)));
+    }
+    /// <summary> Check if element is a valid scalar. </summary>
+    /// <param name="pos"> Value defines the offset to scalar</param>
+    /// <param name="elementSize"> Size of element</param>
+    /// <returns> Return True when Scalar Element is correct </returns>
+    private bool CheckScalar(uint pos, ulong elementSize)
+    {
+      return ((CheckAlignment(pos, elementSize)) && (CheckElement(pos, elementSize)));
+    }
+    /// <summary> Check offset. It is a scalar with size of UOffsetT. </summary>
+    private bool CheckOffset(uint offset)
+    {
+      return (CheckScalar(offset, SIZE_U_OFFSET));
+    }
+
+    private checkElementStruct CheckVectorOrString(uint pos, ulong elementSize)
+    {
+      var result = new checkElementStruct
+      {
+        elementValid = false,
+        elementOffset = 0
+      };
+
+      uint vectorPos = pos;
+      // Check we can read the vector/string size field (it is of uoffset size)
+      if (!CheckScalar(vectorPos, SIZE_U_OFFSET))
+      {
+        // result.elementValid = false; result.elementOffset = 0;
+        return result;
+      }
+      // Check the whole array. If this is a string, the byte past the array
+      // must be 0.
+      uint size = ReadUOffsetT(verifier_buffer, vectorPos);
+      ulong max_elements = (FLATBUFFERS_MAX_BUFFER_SIZE / elementSize);
+      if (size >= max_elements)
+      {
+        // Protect against byte_size overflowing. 
+        // result.elementValid = false; result.elementOffset = 0;
+        return result;
+      }
+
+      uint bytes_size = SIZE_U_OFFSET + (Convert.ToUInt32(elementSize) * size);
+      uint buffer_end_pos = vectorPos + bytes_size;
+      result.elementValid = CheckElement(vectorPos, bytes_size);
+      result.elementOffset = buffer_end_pos;
+      return (result);
+    }
+
+    /// <summary>Verify a string at given position.</summary>
+    private bool CheckString(uint pos)
+    {
+      var result = CheckVectorOrString(pos, SIZE_BYTE);
+      if (options.stringEndCheck)
+      {
+        result.elementValid = result.elementValid && CheckScalar(result.elementOffset, 1); // Must have terminator
+        result.elementValid = result.elementValid && (verifier_buffer.GetSbyte(Convert.ToInt32(result.elementOffset)) == 0); // Terminating byte must be 0.
+      }
+      return result.elementValid;
+    }
+
+    /// <summary> Verify the vector of elements of given size </summary>
+    private bool CheckVector(uint pos, ulong elementSize)
+    {
+      var result = CheckVectorOrString(pos, elementSize);
+      return result.elementValid;
+    }
+    /// <summary> Verify table content using structure dependent generated function </summary>
+    private bool CheckTable(uint tablePos, VerifyTableAction verifyAction)
+    {
+      return verifyAction(this, tablePos);
+    }
+
+    /// <summary> String check wrapper function to be used in vector of strings check </summary>
+    private bool CheckStringFunc(Verifier verifier, uint pos)
+    {
+      return verifier.CheckString(pos);
+    }
+
+    /// <summary> Check vector of objects. Use generated object verification function </summary>
+    private bool CheckVectorOfObjects(uint pos, VerifyTableAction verifyAction)
+    {
+      if (!CheckVector(pos, SIZE_U_OFFSET))
+      {
+        return false;
+      }
+      uint size = ReadUOffsetT(verifier_buffer, pos);
+      // Vector data starts just after vector size/length
+      uint vecStart = pos + SIZE_U_OFFSET;
+      uint vecOff = 0;
+      // Iterate offsets and verify referenced objects
+      for (uint i = 0; i < size; i++)
+      {
+        vecOff = vecStart + (i * SIZE_U_OFFSET);
+        if (!CheckIndirectOffset(vecOff))
+        {
+          return false;
+        }
+        uint objOffset = GetIndirectOffset(vecOff);
+        if (!verifyAction(this, objOffset))
+        {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    /// <summary> Check if the offset referenced by offsetPos is the valid offset pointing to buffer</summary>
+    //  offsetPos - offset to offset data
+    private bool CheckIndirectOffset(uint pos)
+    {
+      // Check the input offset is valid
+      if(!CheckScalar(pos, SIZE_U_OFFSET))
+      {
+        return false;
+      }
+      // Get indirect offset
+      uint offset = ReadUOffsetT(verifier_buffer, pos);
+      // May not point to itself neither wrap around  (buffers are max 2GB)
+      if ((offset == 0) || (offset >= FLATBUFFERS_MAX_BUFFER_SIZE))
+      {
+        return false;
+      }
+      // Must be inside the buffer
+      return CheckElement(pos + offset, 1);
+    }
+
+    /// <summary> Check flatbuffer content using generated object verification function </summary>
+    private bool CheckBufferFromStart(string identifier, uint startPos, VerifyTableAction verifyAction)
+    {
+      if ((identifier != null) &&
+          (identifier.Length == 0) &&
+          ((verifier_buffer.Length < (SIZE_U_OFFSET + FILE_IDENTIFIER_LENGTH)) || (!BufferHasIdentifier(verifier_buffer, startPos, identifier))))
+      {
+        return false;
+      }
+      if(!CheckIndirectOffset(startPos))
+      {
+        return false;
+      }
+      uint offset = GetIndirectOffset(startPos);
+      return CheckTable(offset, verifyAction); //  && GetComputedSize()
+    }
+
+    /// <summary> Get indirect offset. It is an offset referenced by offset Pos </summary>
+    private uint GetIndirectOffset(uint pos)
+    {
+      // Get indirect offset referenced by offsetPos
+      uint offset = pos + ReadUOffsetT(verifier_buffer, pos);
+      return offset;
+    }
+
+    /// <summary> Verify beginning of table </summary>
+    /// <param name="tablePos"> Position in the Table </param>
+    /// <returns> Return True when the verification of the beginning of the table is passed</returns> 
+    // (this method is used internally by generated verification functions)
+    public bool VerifyTableStart(uint tablePos)
+    {
+      // Starting new table verification increases complexity of structure
+      depth_cnt++;
+      num_tables_cnt++;
+
+      if (!CheckScalar(tablePos, SIZE_S_OFFSET))
+      {
+        return false;
+      }
+      uint vtable = (uint)(tablePos - ReadSOffsetT(verifier_buffer, Convert.ToInt32(tablePos)));
+      return ((CheckComplexity()) && (CheckScalar(vtable, SIZE_V_OFFSET)) && (CheckAlignment(Convert.ToUInt32(ReadVOffsetT(verifier_buffer, Convert.ToInt32(vtable))), SIZE_V_OFFSET)) && (CheckElement(vtable, Convert.ToUInt64(ReadVOffsetT(verifier_buffer, Convert.ToInt32(vtable))))));
+    }
+
+    /// <summary> Verify end of table. In practice, this function does not check buffer but handles
+    /// verification statistics update </summary>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyTableEnd(uint tablePos)
+    {
+      depth--;
+      return true;
+    }
+
+    /// <summary> Verifiy static/inlined data area field </summary>
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="offsetId"> Offset to the static/inlined data element </param>
+    /// <param name="elementSize"> Size of the element </param>
+    /// <param name="align"> Alignment bool value </param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the static/inlined data element is passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyField(uint tablePos, short offsetId, ulong elementSize, ulong align, bool required)
+    {
+      uint offset = GetVOffset(tablePos, offsetId);
+      if (offset != 0)
+      {
+        return ((CheckAlignment(offset, align)) && (CheckElement(offset, elementSize)));
+      }
+      return !required; // it is OK if field is not required
+    }
+
+    /// <summary> Verify string </summary> 
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="vOffset"> Offset to the String element </param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the String is passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyString(uint tablePos, short vOffset, bool required)
+    {
+      var offset = GetVOffset(tablePos, vOffset);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      var strOffset = GetIndirectOffset(offset);
+      return CheckString(strOffset);
+    }
+
+    /// <summary> Verify vector of fixed size structures and scalars </summary>
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="vOffset"> Offset to the Vector of Data </param>
+    /// <param name="elementSize"> Size of the element</param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the Vector of Data passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyVectorOfData(uint tablePos, short vOffset, ulong elementSize, bool required)
+    {
+      var offset = GetVOffset(tablePos, vOffset);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      var vecOffset = GetIndirectOffset(offset);
+      return  CheckVector(vecOffset, elementSize);
+    }
+
+    /// <summary> Verify array of strings </summary>
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="offsetId"> Offset to the Vector of String </param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the Vector of String passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyVectorOfStrings(uint tablePos, short offsetId, bool required)
+    {
+      var offset = GetVOffset(tablePos, offsetId);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      var vecOffset = GetIndirectOffset(offset);
+      return CheckVectorOfObjects(vecOffset, CheckStringFunc); 
+    }
+
+    /// <summary> Verify vector of tables (objects). Tables are verified using generated verifyObjFunc </summary>
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="offsetId"> Offset to the Vector of Table </param>
+    /// <param name="verifyAction"> Method used to the verification Table </param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the Vector of Table passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyVectorOfTables(uint tablePos, short offsetId, VerifyTableAction verifyAction, bool required)
+    {
+      var offset = GetVOffset(tablePos, offsetId);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      var vecOffset = GetIndirectOffset(offset);
+      return CheckVectorOfObjects(vecOffset, verifyAction);
+    }
+
+    /// <summary> Verify table object using generated verification function. </summary>
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="offsetId"> Offset to the Table </param>
+    /// <param name="verifyAction"> Method used to the verification Table </param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the Table passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyTable(uint tablePos, short offsetId, VerifyTableAction verifyAction, bool required)
+    {
+      var offset = GetVOffset(tablePos, offsetId);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      var tabOffset = GetIndirectOffset(offset);
+      return CheckTable(tabOffset, verifyAction);
+    }
+
+    /// <summary> Verify nested buffer object. When verifyObjFunc is provided, it is used to verify object structure. </summary>
+    /// <param name="tablePos"> Position in the Table </param>
+    /// <param name="offsetId"> Offset to the Table </param>
+    /// <param name="verifyAction">  Method used to the verification Table </param>
+    /// <param name="required"> Required Value when the offset == 0  </param>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyNestedBuffer(uint tablePos, short offsetId, VerifyTableAction verifyAction, bool required)
+    {
+      var offset = GetVOffset(tablePos, offsetId);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      uint vecOffset = GetIndirectOffset(offset);
+      if (!CheckVector(vecOffset, SIZE_BYTE))
+      {
+        return false;
+      }
+      if (verifyAction != null)
+      {
+        var vecLength = ReadUOffsetT(verifier_buffer, vecOffset);
+        // Buffer begins after vector length
+        var vecStart = vecOffset + SIZE_U_OFFSET;
+        // Create and Copy nested buffer bytes from part of Verify Buffer
+        var nestedByteBuffer = new ByteBuffer(verifier_buffer.ToArray(Convert.ToInt32(vecStart), Convert.ToInt32(vecLength)));
+        var nestedVerifyier = new Verifier(nestedByteBuffer, options);
+        // There is no internal identifier - use empty one
+        if (!nestedVerifyier.CheckBufferFromStart("", 0, verifyAction))
+        {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    /// <summary> Verifiy static/inlined data area at absolute offset </summary>
+    /// <param name="pos"> Position of static/inlined data area in the Byte Buffer</param>
+    /// <param name="elementSize"> Size of the union data</param>
+    /// <param name="align"> Alignment bool value </param>
+    /// <returns>Return True when the verification of the Union Data is passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyUnionData(uint pos, ulong elementSize, ulong align)
+    {
+      bool result = ((CheckAlignment(pos, align)) && (CheckElement(pos, elementSize)));
+      return result;
+    }
+
+    /// <summary> Verify string referenced by absolute offset value </summary>
+    /// <param name="pos"> Position of Union String in the Byte Buffer</param>
+    /// <returns>Return True when the verification of the Union String is passed</returns> 
+    // (this method is used internally by generated verification functions)
+    public bool VerifyUnionString(uint pos)
+    {
+      bool result = CheckString(pos);
+      return result;
+    }
+
+    /// <summary> Method verifies union object using generated verification function </summary>
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="typeIdVOffset"> Offset in the Table</param>
+    /// <param name="valueVOffset"> Offset to Element</param>
+    /// <param name="verifyAction"> Verification Method used for Union</param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyUnion(uint tablePos, short typeIdVOffset, short valueVOffset, VerifyUnionAction verifyAction, bool required)
+    {
+      // Check the union type index
+      var offset = GetVOffset(tablePos, typeIdVOffset);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!((CheckAlignment(offset, SIZE_BYTE)) && (CheckElement(offset, SIZE_BYTE))))
+      {
+        return false;
+      }
+      // Check union data
+      offset = GetVOffset(tablePos, valueVOffset);
+      // Take type id
+      var typeId = verifier_buffer.Get(Convert.ToInt32(offset));
+      if (offset == 0)
+      {
+        // When value data is not present, allow union verification function to deal with illegal offset
+        return verifyAction(this, typeId, Convert.ToUInt32(verifier_buffer.Length));
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      // Take value offset and validate union structure
+      uint unionOffset = GetIndirectOffset(offset);
+      return verifyAction(this, typeId, unionOffset);
+    }
+
+    /// <summary> Verify vector of unions (objects). Unions are verified using generated verifyObjFunc </summary>
+    /// <param name="tablePos"> Position of the Table</param>
+    /// <param name="typeOffsetId"> Offset in the Table (Union type id)</param>
+    /// <param name="offsetId"> Offset to vector of Data Stucture offset</param>
+    /// <param name="verifyAction"> Verification Method used for Union</param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the Vector of Unions passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyVectorOfUnion(uint tablePos, short typeOffsetId, short offsetId, VerifyUnionAction verifyAction, bool required)
+    {
+      // type id offset must be valid
+      var offset = GetVOffset(tablePos, typeOffsetId);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      // Get type id table absolute offset
+      var typeIdVectorOffset = GetIndirectOffset(offset);
+      // values offset must be valid
+      offset = GetVOffset(tablePos, offsetId);
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      var valueVectorOffset = GetIndirectOffset(offset);
+      // validate referenced vectors
+      if(!CheckVector(typeIdVectorOffset, SIZE_BYTE) ||
+         !CheckVector(valueVectorOffset, SIZE_U_OFFSET))
+      {
+        return false;
+      }
+      // Both vectors should have the same length
+      var typeIdVectorLength = ReadUOffsetT(verifier_buffer, typeIdVectorOffset);
+      var valueVectorLength = ReadUOffsetT(verifier_buffer, valueVectorOffset);
+      if (typeIdVectorLength != valueVectorLength)
+      {
+        return false;
+      }
+      // Verify each union from vectors
+      var typeIdStart = typeIdVectorOffset + SIZE_U_OFFSET;
+      var valueStart = valueVectorOffset + SIZE_U_OFFSET;
+      for (uint i = 0; i < typeIdVectorLength; i++)
+      {
+        // Get type id
+        byte typeId = verifier_buffer.Get(Convert.ToInt32(typeIdStart + i * SIZE_U_OFFSET));
+        // get offset to vector item
+        uint off = valueStart + i * SIZE_U_OFFSET;
+        // Check the vector item has a proper offset
+        if (!CheckIndirectOffset(off))
+        {
+          return false;
+        }
+        uint valueOffset = GetIndirectOffset(off);
+        // Verify object
+        if (!verifyAction(this, typeId, valueOffset))
+        {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    // Method verifies flatbuffer data using generated Table verification function.
+    // The data buffer is already provided when creating [Verifier] object (see [NewVerifier])
+    //
+    //   - identifier - the expected identifier of buffer data.
+    //     When empty identifier is provided the identifier validation is skipped.
+    //   - sizePrefixed - this flag should be true when buffer is prefixed with content size
+    //   - verifyObjFunc - function to be used for verification. This function is generated by compiler and included in each table definition file with name "<Tablename>Verify"
+    //
+    // Example:
+    //
+    //  /* Verify Monster table. Ignore buffer name and assume buffer does not contain data length prefix */
+    //  isValid = verifier.verifyBuffer(bb, false, MonsterVerify)
+    //
+    //  /* Verify Monster table. Buffer name is 'MONS' and contains data length prefix */
+    //  isValid = verifier.verifyBuffer("MONS", true, MonsterVerify)
+    /// <summary> Method verifies flatbuffer data using generated Table verification function </summary>
+    /// 
+    /// <param name="identifier"> The expected identifier of buffer data</param>
+    /// <param name="sizePrefixed"> Flag should be true when buffer is prefixed with content size</param>
+    /// <param name="verifyAction"> Function to be used for verification. This function is generated by compiler and included in each table definition file</param>
+    /// <returns> Return True when verification of FlatBuffer passed</returns>
+    /// <example>
+    /// Example 1. Verify Monster table. Ignore buffer name and assume buffer does not contain data length prefix 
+    /// <code>  isValid = verifier.VerifyBuffer(bb, false, MonsterVerify)</code>
+    /// Example 2. Verify Monster table. Buffer name is 'MONS' and contains data length prefix 
+    /// <code>  isValid = verifier.VerifyBuffer("MONS", true, MonsterVerify)</code>
+    /// </example>
+    public bool VerifyBuffer(string identifier, bool sizePrefixed, VerifyTableAction verifyAction)
+    {
+      // Reset counters - starting verification from beginning
+      depth = 0;
+      numTables = 0;
+
+      var start = (uint)(verifier_buffer.Position);
+      if (sizePrefixed) 
+      {
+        start = (uint)(verifier_buffer.Position) + SIZE_PREFIX_LENGTH;
+        if(!CheckScalar((uint)(verifier_buffer.Position), SIZE_PREFIX_LENGTH))
+        {
+          return false;
+        }
+        uint size = ReadUOffsetT(verifier_buffer, (uint)(verifier_buffer.Position));
+        if (size != ((uint)(verifier_buffer.Length) - start))
+        {
+          return false;
+        }
+      } 
+      return CheckBufferFromStart(identifier, start, verifyAction);
+    }
+  }
+
+}

net/FlatBuffers/FlatBuffers.net35.csproj

@@ -40,9 +40,9 @@
     <Compile Include="ByteBufferUtil.cs" />
     <Compile Include="FlatBufferBuilder.cs" />
     <Compile Include="FlatBufferConstants.cs" />
+    <Compile Include="FlatBufferVerify.cs" />
     <Compile Include="IFlatbufferObject.cs" />
     <Compile Include="Offset.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Struct.cs" />
     <Compile Include="Table.cs" />
   </ItemGroup>

net/FlatBuffers/Table.cs

@@ -65,7 +65,11 @@ namespace Google.FlatBuffers
         // Create a .NET String from UTF-8 data stored inside the flatbuffer.
         public string __string(int offset)
         {
-            offset += bb.GetInt(offset);
+            int stringOffset = bb.GetInt(offset);
+            if (stringOffset == 0)
+                return null;
+
+            offset += stringOffset;
             var len = bb.GetInt(offset);
             var startPos = offset + sizeof(int);
             return bb.GetStringUTF8(startPos, len);

package.json

@@ -37,11 +37,11 @@
   "dependencies": {},
   "devDependencies": {
     "@bazel/typescript": "5.2.0",
-    "@types/node": "18.7.16",
+    "@types/node": "18.15.11",
-    "@typescript-eslint/eslint-plugin": "^5.46.0",
+    "@typescript-eslint/eslint-plugin": "^5.57.0",
-    "@typescript-eslint/parser": "^5.46.0",
+    "@typescript-eslint/parser": "^5.57.0",
-    "esbuild": "^0.16.4",
+    "esbuild": "^0.17.14",
-    "eslint": "^8.29.0",
+    "eslint": "^8.37.0",
-    "typescript": "^4.8.3"
+    "typescript": "^5.0.3"
   }
 }

python/flatbuffers/reflection/Enum.py

@@ -131,39 +131,74 @@ class Enum(object):
             return self._tab.String(o + self._tab.Pos)
         return None
 
-def EnumStart(builder): builder.StartObject(7)
+def EnumStart(builder):
+    return builder.StartObject(7)
+
 def Start(builder):
     return EnumStart(builder)
-def EnumAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
+def EnumAddName(builder, name):
+    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
 def AddName(builder, name):
     return EnumAddName(builder, name)
-def EnumAddValues(builder, values): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0)
+
+def EnumAddValues(builder, values):
+    return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0)
+
 def AddValues(builder, values):
     return EnumAddValues(builder, values)
-def EnumStartValuesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def EnumStartValuesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartValuesVector(builder, numElems):
     return EnumStartValuesVector(builder, numElems)
-def EnumAddIsUnion(builder, isUnion): builder.PrependBoolSlot(2, isUnion, 0)
+
+def EnumAddIsUnion(builder, isUnion):
+    return builder.PrependBoolSlot(2, isUnion, 0)
+
 def AddIsUnion(builder, isUnion):
     return EnumAddIsUnion(builder, isUnion)
-def EnumAddUnderlyingType(builder, underlyingType): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(underlyingType), 0)
+
+def EnumAddUnderlyingType(builder, underlyingType):
+    return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(underlyingType), 0)
+
 def AddUnderlyingType(builder, underlyingType):
     return EnumAddUnderlyingType(builder, underlyingType)
-def EnumAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
+
+def EnumAddAttributes(builder, attributes):
+    return builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
+
 def AddAttributes(builder, attributes):
     return EnumAddAttributes(builder, attributes)
-def EnumStartAttributesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def EnumStartAttributesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartAttributesVector(builder, numElems):
     return EnumStartAttributesVector(builder, numElems)
-def EnumAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
+
+def EnumAddDocumentation(builder, documentation):
+    return builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
+
 def AddDocumentation(builder, documentation):
     return EnumAddDocumentation(builder, documentation)
-def EnumStartDocumentationVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def EnumStartDocumentationVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartDocumentationVector(builder, numElems):
     return EnumStartDocumentationVector(builder, numElems)
-def EnumAddDeclarationFile(builder, declarationFile): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)
+
+def EnumAddDeclarationFile(builder, declarationFile):
+    return builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)
+
 def AddDeclarationFile(builder, declarationFile):
     return EnumAddDeclarationFile(builder, declarationFile)
-def EnumEnd(builder): return builder.EndObject()
+
+def EnumEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
-    return EnumEnd(builder)
+    return EnumEnd(builder)

python/flatbuffers/reflection/EnumVal.py

@@ -98,30 +98,56 @@ class EnumVal(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
         return o == 0
 
-def EnumValStart(builder): builder.StartObject(6)
+def EnumValStart(builder):
+    return builder.StartObject(6)
+
 def Start(builder):
     return EnumValStart(builder)
-def EnumValAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
+def EnumValAddName(builder, name):
+    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
 def AddName(builder, name):
     return EnumValAddName(builder, name)
-def EnumValAddValue(builder, value): builder.PrependInt64Slot(1, value, 0)
+
+def EnumValAddValue(builder, value):
+    return builder.PrependInt64Slot(1, value, 0)
+
 def AddValue(builder, value):
     return EnumValAddValue(builder, value)
-def EnumValAddUnionType(builder, unionType): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(unionType), 0)
+
+def EnumValAddUnionType(builder, unionType):
+    return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(unionType), 0)
+
 def AddUnionType(builder, unionType):
     return EnumValAddUnionType(builder, unionType)
-def EnumValAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
+
+def EnumValAddDocumentation(builder, documentation):
+    return builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
+
 def AddDocumentation(builder, documentation):
     return EnumValAddDocumentation(builder, documentation)
-def EnumValStartDocumentationVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def EnumValStartDocumentationVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartDocumentationVector(builder, numElems):
     return EnumValStartDocumentationVector(builder, numElems)
-def EnumValAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
+
+def EnumValAddAttributes(builder, attributes):
+    return builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
+
 def AddAttributes(builder, attributes):
     return EnumValAddAttributes(builder, attributes)
-def EnumValStartAttributesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def EnumValStartAttributesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartAttributesVector(builder, numElems):
     return EnumValStartAttributesVector(builder, numElems)
-def EnumValEnd(builder): return builder.EndObject()
+
+def EnumValEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
-    return EnumValEnd(builder)
+    return EnumValEnd(builder)

python/flatbuffers/reflection/Field.py

@@ -155,54 +155,104 @@ class Field(object):
             return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
         return 0
 
-def FieldStart(builder): builder.StartObject(13)
+def FieldStart(builder):
+    return builder.StartObject(13)
+
 def Start(builder):
     return FieldStart(builder)
-def FieldAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
+def FieldAddName(builder, name):
+    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
 def AddName(builder, name):
     return FieldAddName(builder, name)
-def FieldAddType(builder, type): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(type), 0)
+
+def FieldAddType(builder, type):
+    return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(type), 0)
+
 def AddType(builder, type):
     return FieldAddType(builder, type)
-def FieldAddId(builder, id): builder.PrependUint16Slot(2, id, 0)
+
+def FieldAddId(builder, id):
+    return builder.PrependUint16Slot(2, id, 0)
+
 def AddId(builder, id):
     return FieldAddId(builder, id)
-def FieldAddOffset(builder, offset): builder.PrependUint16Slot(3, offset, 0)
+
+def FieldAddOffset(builder, offset):
+    return builder.PrependUint16Slot(3, offset, 0)
+
 def AddOffset(builder, offset):
     return FieldAddOffset(builder, offset)
-def FieldAddDefaultInteger(builder, defaultInteger): builder.PrependInt64Slot(4, defaultInteger, 0)
+
+def FieldAddDefaultInteger(builder, defaultInteger):
+    return builder.PrependInt64Slot(4, defaultInteger, 0)
+
 def AddDefaultInteger(builder, defaultInteger):
     return FieldAddDefaultInteger(builder, defaultInteger)
-def FieldAddDefaultReal(builder, defaultReal): builder.PrependFloat64Slot(5, defaultReal, 0.0)
+
+def FieldAddDefaultReal(builder, defaultReal):
+    return builder.PrependFloat64Slot(5, defaultReal, 0.0)
+
 def AddDefaultReal(builder, defaultReal):
     return FieldAddDefaultReal(builder, defaultReal)
-def FieldAddDeprecated(builder, deprecated): builder.PrependBoolSlot(6, deprecated, 0)
+
+def FieldAddDeprecated(builder, deprecated):
+    return builder.PrependBoolSlot(6, deprecated, 0)
+
 def AddDeprecated(builder, deprecated):
     return FieldAddDeprecated(builder, deprecated)
-def FieldAddRequired(builder, required): builder.PrependBoolSlot(7, required, 0)
+
+def FieldAddRequired(builder, required):
+    return builder.PrependBoolSlot(7, required, 0)
+
 def AddRequired(builder, required):
     return FieldAddRequired(builder, required)
-def FieldAddKey(builder, key): builder.PrependBoolSlot(8, key, 0)
+
+def FieldAddKey(builder, key):
+    return builder.PrependBoolSlot(8, key, 0)
+
 def AddKey(builder, key):
     return FieldAddKey(builder, key)
-def FieldAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
+
+def FieldAddAttributes(builder, attributes):
+    return builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
+
 def AddAttributes(builder, attributes):
     return FieldAddAttributes(builder, attributes)
-def FieldStartAttributesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def FieldStartAttributesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartAttributesVector(builder, numElems):
     return FieldStartAttributesVector(builder, numElems)
-def FieldAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
+
+def FieldAddDocumentation(builder, documentation):
+    return builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
+
 def AddDocumentation(builder, documentation):
     return FieldAddDocumentation(builder, documentation)
-def FieldStartDocumentationVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def FieldStartDocumentationVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartDocumentationVector(builder, numElems):
     return FieldStartDocumentationVector(builder, numElems)
-def FieldAddOptional(builder, optional): builder.PrependBoolSlot(11, optional, 0)
+
+def FieldAddOptional(builder, optional):
+    return builder.PrependBoolSlot(11, optional, 0)
+
 def AddOptional(builder, optional):
     return FieldAddOptional(builder, optional)
-def FieldAddPadding(builder, padding): builder.PrependUint16Slot(12, padding, 0)
+
+def FieldAddPadding(builder, padding):
+    return builder.PrependUint16Slot(12, padding, 0)
+
 def AddPadding(builder, padding):
     return FieldAddPadding(builder, padding)
-def FieldEnd(builder): return builder.EndObject()
+
+def FieldEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
-    return FieldEnd(builder)
+    return FieldEnd(builder)

python/flatbuffers/reflection/KeyValue.py

@@ -42,15 +42,26 @@ class KeyValue(object):
             return self._tab.String(o + self._tab.Pos)
         return None
 
-def KeyValueStart(builder): builder.StartObject(2)
+def KeyValueStart(builder):
+    return builder.StartObject(2)
+
 def Start(builder):
     return KeyValueStart(builder)
-def KeyValueAddKey(builder, key): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
+
+def KeyValueAddKey(builder, key):
+    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
+
 def AddKey(builder, key):
     return KeyValueAddKey(builder, key)
-def KeyValueAddValue(builder, value): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(value), 0)
+
+def KeyValueAddValue(builder, value):
+    return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(value), 0)
+
 def AddValue(builder, value):
     return KeyValueAddValue(builder, value)
-def KeyValueEnd(builder): return builder.EndObject()
+
+def KeyValueEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
-    return KeyValueEnd(builder)
+    return KeyValueEnd(builder)

python/flatbuffers/reflection/Object.py

@@ -134,42 +134,80 @@ class Object(object):
             return self._tab.String(o + self._tab.Pos)
         return None
 
-def ObjectStart(builder): builder.StartObject(8)
+def ObjectStart(builder):
+    return builder.StartObject(8)
+
 def Start(builder):
     return ObjectStart(builder)
-def ObjectAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
+def ObjectAddName(builder, name):
+    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
 def AddName(builder, name):
     return ObjectAddName(builder, name)
-def ObjectAddFields(builder, fields): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(fields), 0)
+
+def ObjectAddFields(builder, fields):
+    return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(fields), 0)
+
 def AddFields(builder, fields):
     return ObjectAddFields(builder, fields)
-def ObjectStartFieldsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def ObjectStartFieldsVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartFieldsVector(builder, numElems):
     return ObjectStartFieldsVector(builder, numElems)
-def ObjectAddIsStruct(builder, isStruct): builder.PrependBoolSlot(2, isStruct, 0)
+
+def ObjectAddIsStruct(builder, isStruct):
+    return builder.PrependBoolSlot(2, isStruct, 0)
+
 def AddIsStruct(builder, isStruct):
     return ObjectAddIsStruct(builder, isStruct)
-def ObjectAddMinalign(builder, minalign): builder.PrependInt32Slot(3, minalign, 0)
+
+def ObjectAddMinalign(builder, minalign):
+    return builder.PrependInt32Slot(3, minalign, 0)
+
 def AddMinalign(builder, minalign):
     return ObjectAddMinalign(builder, minalign)
-def ObjectAddBytesize(builder, bytesize): builder.PrependInt32Slot(4, bytesize, 0)
+
+def ObjectAddBytesize(builder, bytesize):
+    return builder.PrependInt32Slot(4, bytesize, 0)
+
 def AddBytesize(builder, bytesize):
     return ObjectAddBytesize(builder, bytesize)
-def ObjectAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
+
+def ObjectAddAttributes(builder, attributes):
+    return builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
+
 def AddAttributes(builder, attributes):
     return ObjectAddAttributes(builder, attributes)
-def ObjectStartAttributesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def ObjectStartAttributesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartAttributesVector(builder, numElems):
     return ObjectStartAttributesVector(builder, numElems)
-def ObjectAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
+
+def ObjectAddDocumentation(builder, documentation):
+    return builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
+
 def AddDocumentation(builder, documentation):
     return ObjectAddDocumentation(builder, documentation)
-def ObjectStartDocumentationVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def ObjectStartDocumentationVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartDocumentationVector(builder, numElems):
     return ObjectStartDocumentationVector(builder, numElems)
-def ObjectAddDeclarationFile(builder, declarationFile): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)
+
+def ObjectAddDeclarationFile(builder, declarationFile):
+    return builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)
+
 def AddDeclarationFile(builder, declarationFile):
     return ObjectAddDeclarationFile(builder, declarationFile)
-def ObjectEnd(builder): return builder.EndObject()
+
+def ObjectEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
-    return ObjectEnd(builder)
+    return ObjectEnd(builder)

python/flatbuffers/reflection/RPCCall.py

@@ -102,30 +102,56 @@ class RPCCall(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
         return o == 0
 
-def RPCCallStart(builder): builder.StartObject(5)
+def RPCCallStart(builder):
+    return builder.StartObject(5)
+
 def Start(builder):
     return RPCCallStart(builder)
-def RPCCallAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
+def RPCCallAddName(builder, name):
+    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
 def AddName(builder, name):
     return RPCCallAddName(builder, name)
-def RPCCallAddRequest(builder, request): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(request), 0)
+
+def RPCCallAddRequest(builder, request):
+    return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(request), 0)
+
 def AddRequest(builder, request):
     return RPCCallAddRequest(builder, request)
-def RPCCallAddResponse(builder, response): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(response), 0)
+
+def RPCCallAddResponse(builder, response):
+    return builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(response), 0)
+
 def AddResponse(builder, response):
     return RPCCallAddResponse(builder, response)
-def RPCCallAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
+
+def RPCCallAddAttributes(builder, attributes):
+    return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
+
 def AddAttributes(builder, attributes):
     return RPCCallAddAttributes(builder, attributes)
-def RPCCallStartAttributesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def RPCCallStartAttributesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartAttributesVector(builder, numElems):
     return RPCCallStartAttributesVector(builder, numElems)
-def RPCCallAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
+
+def RPCCallAddDocumentation(builder, documentation):
+    return builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
+
 def AddDocumentation(builder, documentation):
     return RPCCallAddDocumentation(builder, documentation)
-def RPCCallStartDocumentationVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def RPCCallStartDocumentationVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartDocumentationVector(builder, numElems):
     return RPCCallStartDocumentationVector(builder, numElems)
-def RPCCallEnd(builder): return builder.EndObject()
+
+def RPCCallEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
-    return RPCCallEnd(builder)
+    return RPCCallEnd(builder)

python/flatbuffers/reflection/Schema.py

@@ -162,45 +162,86 @@ class Schema(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
         return o == 0
 
-def SchemaStart(builder): builder.StartObject(8)
+def SchemaStart(builder):
+    return builder.StartObject(8)
+
 def Start(builder):
     return SchemaStart(builder)
-def SchemaAddObjects(builder, objects): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(objects), 0)
+
+def SchemaAddObjects(builder, objects):
+    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(objects), 0)
+
 def AddObjects(builder, objects):
     return SchemaAddObjects(builder, objects)
-def SchemaStartObjectsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def SchemaStartObjectsVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartObjectsVector(builder, numElems):
     return SchemaStartObjectsVector(builder, numElems)
-def SchemaAddEnums(builder, enums): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(enums), 0)
+
+def SchemaAddEnums(builder, enums):
+    return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(enums), 0)
+
 def AddEnums(builder, enums):
     return SchemaAddEnums(builder, enums)
-def SchemaStartEnumsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def SchemaStartEnumsVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartEnumsVector(builder, numElems):
     return SchemaStartEnumsVector(builder, numElems)
-def SchemaAddFileIdent(builder, fileIdent): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(fileIdent), 0)
+
+def SchemaAddFileIdent(builder, fileIdent):
+    return builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(fileIdent), 0)
+
 def AddFileIdent(builder, fileIdent):
     return SchemaAddFileIdent(builder, fileIdent)
-def SchemaAddFileExt(builder, fileExt): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(fileExt), 0)
+
+def SchemaAddFileExt(builder, fileExt):
+    return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(fileExt), 0)
+
 def AddFileExt(builder, fileExt):
     return SchemaAddFileExt(builder, fileExt)
-def SchemaAddRootTable(builder, rootTable): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(rootTable), 0)
+
+def SchemaAddRootTable(builder, rootTable):
+    return builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(rootTable), 0)
+
 def AddRootTable(builder, rootTable):
     return SchemaAddRootTable(builder, rootTable)
-def SchemaAddServices(builder, services): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(services), 0)
+
+def SchemaAddServices(builder, services):
+    return builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(services), 0)
+
 def AddServices(builder, services):
     return SchemaAddServices(builder, services)
-def SchemaStartServicesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def SchemaStartServicesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartServicesVector(builder, numElems):
     return SchemaStartServicesVector(builder, numElems)
-def SchemaAddAdvancedFeatures(builder, advancedFeatures): builder.PrependUint64Slot(6, advancedFeatures, 0)
+
+def SchemaAddAdvancedFeatures(builder, advancedFeatures):
+    return builder.PrependUint64Slot(6, advancedFeatures, 0)
+
 def AddAdvancedFeatures(builder, advancedFeatures):
     return SchemaAddAdvancedFeatures(builder, advancedFeatures)
-def SchemaAddFbsFiles(builder, fbsFiles): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(fbsFiles), 0)
+
+def SchemaAddFbsFiles(builder, fbsFiles):
+    return builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(fbsFiles), 0)
+
 def AddFbsFiles(builder, fbsFiles):
     return SchemaAddFbsFiles(builder, fbsFiles)
-def SchemaStartFbsFilesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def SchemaStartFbsFilesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartFbsFilesVector(builder, numElems):
     return SchemaStartFbsFilesVector(builder, numElems)
-def SchemaEnd(builder): return builder.EndObject()
+
+def SchemaEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
-    return SchemaEnd(builder)
+    return SchemaEnd(builder)

python/flatbuffers/reflection/SchemaFile.py

@@ -60,18 +60,32 @@ class SchemaFile(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         return o == 0
 
-def SchemaFileStart(builder): builder.StartObject(2)
+def SchemaFileStart(builder):
+    return builder.StartObject(2)
+
 def Start(builder):
     return SchemaFileStart(builder)
-def SchemaFileAddFilename(builder, filename): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(filename), 0)
+
+def SchemaFileAddFilename(builder, filename):
+    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(filename), 0)
+
 def AddFilename(builder, filename):
     return SchemaFileAddFilename(builder, filename)
-def SchemaFileAddIncludedFilenames(builder, includedFilenames): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(includedFilenames), 0)
+
+def SchemaFileAddIncludedFilenames(builder, includedFilenames):
+    return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(includedFilenames), 0)
+
 def AddIncludedFilenames(builder, includedFilenames):
     return SchemaFileAddIncludedFilenames(builder, includedFilenames)
-def SchemaFileStartIncludedFilenamesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def SchemaFileStartIncludedFilenamesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartIncludedFilenamesVector(builder, numElems):
     return SchemaFileStartIncludedFilenamesVector(builder, numElems)
-def SchemaFileEnd(builder): return builder.EndObject()
+
+def SchemaFileEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
-    return SchemaFileEnd(builder)
+    return SchemaFileEnd(builder)

python/flatbuffers/reflection/Service.py

@@ -113,33 +113,62 @@ class Service(object):
             return self._tab.String(o + self._tab.Pos)
         return None
 
-def ServiceStart(builder): builder.StartObject(5)
+def ServiceStart(builder):
+    return builder.StartObject(5)
+
 def Start(builder):
     return ServiceStart(builder)
-def ServiceAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
+def ServiceAddName(builder, name):
+    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
 def AddName(builder, name):
     return ServiceAddName(builder, name)
-def ServiceAddCalls(builder, calls): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(calls), 0)
+
+def ServiceAddCalls(builder, calls):
+    return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(calls), 0)
+
 def AddCalls(builder, calls):
     return ServiceAddCalls(builder, calls)
-def ServiceStartCallsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def ServiceStartCallsVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartCallsVector(builder, numElems):
     return ServiceStartCallsVector(builder, numElems)
-def ServiceAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
+
+def ServiceAddAttributes(builder, attributes):
+    return builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
+
 def AddAttributes(builder, attributes):
     return ServiceAddAttributes(builder, attributes)
-def ServiceStartAttributesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def ServiceStartAttributesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartAttributesVector(builder, numElems):
     return ServiceStartAttributesVector(builder, numElems)
-def ServiceAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
+
+def ServiceAddDocumentation(builder, documentation):
+    return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
+
 def AddDocumentation(builder, documentation):
     return ServiceAddDocumentation(builder, documentation)
-def ServiceStartDocumentationVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def ServiceStartDocumentationVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartDocumentationVector(builder, numElems):
     return ServiceStartDocumentationVector(builder, numElems)
-def ServiceAddDeclarationFile(builder, declarationFile): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)
+
+def ServiceAddDeclarationFile(builder, declarationFile):
+    return builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)
+
 def AddDeclarationFile(builder, declarationFile):
     return ServiceAddDeclarationFile(builder, declarationFile)
-def ServiceEnd(builder): return builder.EndObject()
+
+def ServiceEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
-    return ServiceEnd(builder)
+    return ServiceEnd(builder)

python/flatbuffers/reflection/Type.py

@@ -72,27 +72,50 @@ class Type(object):
             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
         return 0
 
-def TypeStart(builder): builder.StartObject(6)
+def TypeStart(builder):
+    return builder.StartObject(6)
+
 def Start(builder):
     return TypeStart(builder)
-def TypeAddBaseType(builder, baseType): builder.PrependInt8Slot(0, baseType, 0)
+
+def TypeAddBaseType(builder, baseType):
+    return builder.PrependInt8Slot(0, baseType, 0)
+
 def AddBaseType(builder, baseType):
     return TypeAddBaseType(builder, baseType)
-def TypeAddElement(builder, element): builder.PrependInt8Slot(1, element, 0)
+
+def TypeAddElement(builder, element):
+    return builder.PrependInt8Slot(1, element, 0)
+
 def AddElement(builder, element):
     return TypeAddElement(builder, element)
-def TypeAddIndex(builder, index): builder.PrependInt32Slot(2, index, -1)
+
+def TypeAddIndex(builder, index):
+    return builder.PrependInt32Slot(2, index, -1)
+
 def AddIndex(builder, index):
     return TypeAddIndex(builder, index)
-def TypeAddFixedLength(builder, fixedLength): builder.PrependUint16Slot(3, fixedLength, 0)
+
+def TypeAddFixedLength(builder, fixedLength):
+    return builder.PrependUint16Slot(3, fixedLength, 0)
+
 def AddFixedLength(builder, fixedLength):
     return TypeAddFixedLength(builder, fixedLength)
-def TypeAddBaseSize(builder, baseSize): builder.PrependUint32Slot(4, baseSize, 4)
+
+def TypeAddBaseSize(builder, baseSize):
+    return builder.PrependUint32Slot(4, baseSize, 4)
+
 def AddBaseSize(builder, baseSize):
     return TypeAddBaseSize(builder, baseSize)
-def TypeAddElementSize(builder, elementSize): builder.PrependUint32Slot(5, elementSize, 0)
+
+def TypeAddElementSize(builder, elementSize):
+    return builder.PrependUint32Slot(5, elementSize, 0)
+
 def AddElementSize(builder, elementSize):
     return TypeAddElementSize(builder, elementSize)
-def TypeEnd(builder): return builder.EndObject()
+
+def TypeEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
-    return TypeEnd(builder)
+    return TypeEnd(builder)

samples/go.mod

@@ -0,0 +1,7 @@
+module github.com/google/flatbuffers/samples
+
+go 1.20
+
+replace github.com/google/flatbuffers/go => ./go_gen
+
+require github.com/google/flatbuffers/go v0.0.0-00010101000000-000000000000

samples/go_sample.sh

@@ -41,23 +41,18 @@ fi
 
 echo Compiling and running the Go sample.
 
-# Go requires a particular layout of files in order to link the necessary
+# Workaround for https://github.com/google/flatbuffers/issues/7780:
-# packages. Copy these files to the respective directores to compile the
+# go mod replace requires a go.mod file in the target directory,
-# sample.
+# but there currently isn't one in the ../go directory.
-mkdir -p ${sampledir}/go_gen/src/MyGame/Sample
+# So we copy the ../go directory to go_gen and manually create go_gen/go.mod
-mkdir -p ${sampledir}/go_gen/src/github.com/google/flatbuffers/go
+mkdir -p ${sampledir}/go_gen
-cp MyGame/Sample/*.go ${sampledir}/go_gen/src/MyGame/Sample/
+cp ${sampledir}/../go/* ${sampledir}/go_gen
-cp ${sampledir}/../go/* ${sampledir}/go_gen/src/github.com/google/flatbuffers/go
+( cd ${sampledir}/go_gen && go mod init github.com/google/flatbuffers/go )
-
-# Export the `GOPATH`, so that `go` will know which directories to search for
-# the libraries.
-export GOPATH=${sampledir}/go_gen/
 
 # Compile and execute the sample.
 go build -o go_sample sample_binary.go
 ./go_sample
 
 # Clean up the temporary files.
-rm -rf MyGame/
 rm -rf ${sampledir}/go_gen/
 rm go_sample

samples/sample_binary.go

@@ -19,7 +19,7 @@
 package main
 
 import (
-	sample "MyGame/Sample"
+	sample "github.com/google/flatbuffers/samples/MyGame/Sample"
 	"fmt"
 	flatbuffers "github.com/google/flatbuffers/go"
 	"strconv"

src/BUILD.bazel

@@ -69,6 +69,9 @@ cc_library(
         "bfbs_gen_nim.cpp",
         "bfbs_gen_nim.h",
         "bfbs_namer.h",
+        "file_binary_writer.cpp",
+        "file_name_saving_file_manager.cpp",
+        "file_writer.cpp",
         "flatc_main.cpp",
         "idl_gen_binary.cpp",
         "idl_gen_binary.h",

src/file_binary_writer.cpp

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2023 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.
+ */
+
+#include <fstream>
+#include <set>
+#include <string>
+
+#include "flatbuffers/file_manager.h"
+
+namespace flatbuffers {
+
+class FileBinaryWriter : public FileManager {
+ public:
+  bool SaveFile(const std::string &absolute_file_name,
+                const std::string &content) override {
+    std::ofstream ofs(absolute_file_name, std::ofstream::binary);
+    if (!ofs.is_open()) return false;
+    ofs.write(content.c_str(), content.size());
+    return !ofs.bad();
+  }
+
+  bool Loadfile(const std::string &absolute_file_name, std::string *output) {
+    if (DirExists(absolute_file_name.c_str())) return false;
+    std::ifstream ifs(absolute_file_name, std::ifstream::binary);
+    if (!ifs.is_open()) return false;
+    // The fastest way to read a file into a string.
+    ifs.seekg(0, std::ios::end);
+    auto size = ifs.tellg();
+    (*output).resize(static_cast<size_t>(size));
+    ifs.seekg(0, std::ios::beg);
+    ifs.read(&(*output)[0], (*output).size());
+    return !ifs.bad();
+  }
+};
+
+}  // namespace flatbuffers

src/file_name_saving_file_manager.cpp

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2023 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.
+ */
+
+#include <fstream>
+#include <set>
+#include <string>
+
+#include "flatbuffers/file_manager.h"
+
+namespace flatbuffers {
+
+class FileNameSavingFileManager : public FileManager {
+ public:
+  FileNameSavingFileManager(std::set<std::string> file_names)
+      : file_names_(file_names) {}
+
+  bool SaveFile(const std::string &absolute_file_name,
+                const std::string &content) override {
+    (void)content;
+    auto pair = file_names_.insert(absolute_file_name);
+    // pair.second indicates whether the insertion is
+    // successful or not.
+    return pair.second;
+  }
+
+  bool Loadfile(const std::string &absolute_file_name, std::string *content) {
+    (void) absolute_file_name;
+    (void) content;
+    return false;
+  }
+
+ private:
+  std::set<std::string> file_names_;
+};
+
+}  // namespace flatbuffers

src/file_writer.cpp

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2023 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.
+ */
+
+#include <fstream>
+#include <set>
+#include <string>
+
+#include "flatbuffers/file_manager.h"
+
+namespace flatbuffers {
+
+class FileWriter : public FileManager {
+ public:
+  bool SaveFile(const std::string &absolute_file_name,
+                const std::string &content) override {
+    std::ofstream ofs(absolute_file_name, std::ofstream::out);
+    if (!ofs.is_open()) return false;
+    ofs.write(content.c_str(), content.size());
+    return !ofs.bad();
+  }
+
+  bool Loadfile(const std::string &absolute_file_name, std::string *output) {
+    if (DirExists(absolute_file_name.c_str())) return false;
+    std::ifstream ifs(absolute_file_name, std::ifstream::in);
+    if (!ifs.is_open()) return false;
+    // This is slower, but works correctly on all platforms for text files.
+    std::ostringstream oss;
+    oss << ifs.rdbuf();
+    *output = oss.str();
+    return !ifs.bad();
+  }
+};
+
+}  // namespace flatbuffers

src/flatc.cpp

@@ -250,6 +250,10 @@ const static FlatCOption flatc_options[] = {
   { "", "no-leak-private-annotation", "",
     "Prevents multiple type of annotations within a Fbs SCHEMA file. "
     "Currently this is required to generate private types in Rust" },
+  { "", "python-no-type-prefix-suffix", "",
+    "Skip emission of Python functions that are prefixed with typenames" },
+  { "", "file-names-only", "",
+    "Print out generated file names without writing to the files"},
 };
 
 auto cmp = [](FlatCOption a, FlatCOption b) { return a.long_opt < b.long_opt; };
@@ -648,11 +652,16 @@ FlatCOptions FlatCompiler::ParseFromCommandLineArguments(int argc,
         opts.ts_no_import_ext = true;
       } else if (arg == "--no-leak-private-annotation") {
         opts.no_leak_private_annotations = true;
-      } else if (arg == "--annotate-sparse-vectors") {
+       } else if (arg == "--python-no-type-prefix-suffix") {
+        opts.python_no_type_prefix_suffix = true;
+     } else if (arg == "--annotate-sparse-vectors") {
         options.annotate_include_vector_contents = false;
       } else if (arg == "--annotate") {
         if (++argi >= argc) Error("missing path following: " + arg, true);
         options.annotate_schema = flatbuffers::PosixPath(argv[argi]);
+      } else if(arg == "--file-names-only") {
+        // TODO (khhn): Provide 2 implementation
+        options.file_names_only = true;
       } else {
         if (arg == "--proto") { opts.proto_mode = true; }
 

src/idl_gen_csharp.cpp

@@ -169,6 +169,7 @@ class CSharpGenerator : public BaseGenerator {
       if (!parser_.opts.one_file)
         cur_name_space_ = struct_def.defined_namespace;
       GenStruct(struct_def, &declcode, parser_.opts);
+      GenStructVerifier(struct_def, &declcode);
       if (parser_.opts.one_file) {
         one_file_code += declcode;
       } else {
@@ -623,6 +624,173 @@ class CSharpGenerator : public BaseGenerator {
            ")";
   }
 
+  // Get the value of a table verification function start
+  void GetStartOfTableVerifier(const StructDef &struct_def, std::string *code_ptr) {
+    std::string &code = *code_ptr;
+    code += "\n";
+    code += "static public class " + struct_def.name + "Verify\n";
+    code += "{\n";
+    code += "  static public bool Verify";
+    code += "(Google.FlatBuffers.Verifier verifier, uint tablePos)\n";
+    code += "  {\n";
+    code += "    return verifier.VerifyTableStart(tablePos)\n";
+  }
+
+  // Get the value of a table verification function end
+  void GetEndOfTableVerifier(std::string *code_ptr) {
+    std::string &code = *code_ptr;
+    code += "      && verifier.VerifyTableEnd(tablePos);\n";
+    code += "  }\n";
+    code += "}\n";
+  }
+
+  std::string GetNestedFlatBufferName(const FieldDef &field) {
+    std::string  name;
+    if (field.nested_flatbuffer) {
+      name = NamespacedName(*field.nested_flatbuffer);
+    } else {
+      name = "";
+    }
+    return name ;
+  }
+
+  // Generate the code to call the appropriate Verify function(s) for a field.
+  void GenVerifyCall(CodeWriter &code_, const FieldDef &field, const char *prefix) {
+    code_.SetValue("PRE", prefix);
+    code_.SetValue("NAME", ConvertCase(field.name, Case::kUpperCamel));
+    code_.SetValue("REQUIRED", field.IsRequired() ? "Required" : "");
+    code_.SetValue("REQUIRED_FLAG", field.IsRequired() ? "true" : "false");
+    code_.SetValue("TYPE", GenTypeGet(field.value.type));
+    code_.SetValue("INLINESIZE", NumToString(InlineSize(field.value.type)));
+    code_.SetValue("OFFSET", NumToString(field.value.offset));
+    
+    if (IsScalar(field.value.type.base_type) || IsStruct(field.value.type)) {
+      code_.SetValue("ALIGN", NumToString(InlineAlignment(field.value.type)));
+      code_ +=
+        "{{PRE}}      && verifier.VerifyField(tablePos, "
+        "{{OFFSET}} /*{{NAME}}*/, {{INLINESIZE}} /*{{TYPE}}*/, {{ALIGN}}, {{REQUIRED_FLAG}})";
+    } else {
+      // TODO - probably code below should go to this 'else' - code_ += "{{PRE}}VerifyOffset{{REQUIRED}}(verifier, {{OFFSET}})\\";
+    }
+
+    switch (field.value.type.base_type) {
+      case BASE_TYPE_UNION: {
+        auto union_name = NamespacedName(*field.value.type.enum_def);
+        code_.SetValue("ENUM_NAME1", field.value.type.enum_def->name);
+        code_.SetValue("ENUM_NAME", union_name);
+        code_.SetValue("SUFFIX", UnionTypeFieldSuffix());
+        // Caution: This construction assumes, that UNION type id element has been created just before union data and
+        // its offset precedes union. Such assumption is common in flatbuffer implementation
+        code_.SetValue("TYPE_ID_OFFSET", NumToString(field.value.offset - sizeof(voffset_t)));
+        code_ += "{{PRE}}      && verifier.VerifyUnion(tablePos, {{TYPE_ID_OFFSET}}, "
+          "{{OFFSET}} /*{{NAME}}*/, {{ENUM_NAME}}Verify.Verify, {{REQUIRED_FLAG}})";
+        break;
+      }
+      case BASE_TYPE_STRUCT: {
+        if (!field.value.type.struct_def->fixed) {
+          code_ += "{{PRE}}      && verifier.VerifyTable(tablePos, "
+            "{{OFFSET}} /*{{NAME}}*/, {{TYPE}}Verify.Verify, {{REQUIRED_FLAG}})";
+        }
+        break;
+      }
+      case BASE_TYPE_STRING: {
+        code_ += "{{PRE}}      && verifier.VerifyString(tablePos, "
+          "{{OFFSET}} /*{{NAME}}*/, {{REQUIRED_FLAG}})";
+        break;
+      }
+      case BASE_TYPE_VECTOR: {
+
+        switch (field.value.type.element) {
+          case BASE_TYPE_STRING: {
+            code_ += "{{PRE}}      && verifier.VerifyVectorOfStrings(tablePos, "
+              "{{OFFSET}} /*{{NAME}}*/, {{REQUIRED_FLAG}})";
+            break;
+          }
+          case BASE_TYPE_STRUCT: {
+            if (!field.value.type.struct_def->fixed) {
+              code_ += "{{PRE}}      && verifier.VerifyVectorOfTables(tablePos, "
+                "{{OFFSET}} /*{{NAME}}*/, {{TYPE}}Verify.Verify, {{REQUIRED_FLAG}})";
+            } else {
+              code_.SetValue(
+                  "VECTOR_ELEM_INLINESIZE",
+                  NumToString(InlineSize(field.value.type.VectorType())));
+              code_ +=
+                  "{{PRE}}      && "
+                  "verifier.VerifyVectorOfData(tablePos, "
+                  "{{OFFSET}} /*{{NAME}}*/, {{VECTOR_ELEM_INLINESIZE}} "
+                  "/*{{TYPE}}*/, {{REQUIRED_FLAG}})";
+            }
+            break;
+          }
+          case BASE_TYPE_UNION: {
+            // Vectors of unions are not yet supported for go
+            break;
+          }
+          default:
+            // Generate verifier for vector of data.
+            // It may be either nested flatbuffer of just vector of bytes
+            auto nfn = GetNestedFlatBufferName(field);
+            if (!nfn.empty()) {
+              code_.SetValue("CPP_NAME", nfn);
+              // FIXME: file_identifier.
+              code_ += "{{PRE}}      && verifier.VerifyNestedBuffer(tablePos, "
+                "{{OFFSET}} /*{{NAME}}*/, {{CPP_NAME}}Verify.Verify, {{REQUIRED_FLAG}})";
+            } else if (field.flexbuffer) {
+              code_ += "{{PRE}}      && verifier.VerifyNestedBuffer(tablePos, "
+                "{{OFFSET}} /*{{NAME}}*/, null, {{REQUIRED_FLAG}})";
+            } else {
+              code_.SetValue("VECTOR_ELEM_INLINESIZE", NumToString(InlineSize(field.value.type.VectorType())));
+              code_ +=
+                "{{PRE}}      && verifier.VerifyVectorOfData(tablePos, "
+                "{{OFFSET}} /*{{NAME}}*/, {{VECTOR_ELEM_INLINESIZE}} /*{{TYPE}}*/, {{REQUIRED_FLAG}})";
+            }
+            break;
+        }
+
+        break;
+      }
+      default: {
+        break;
+      }
+    }
+  }
+
+  // Generate table constructors, conditioned on its members' types.
+  void GenTableVerifier(const StructDef &struct_def, std::string *code_ptr) {
+    CodeWriter code_;
+    
+    GetStartOfTableVerifier(struct_def, code_ptr);
+
+    // Generate struct fields accessors
+    for (auto it = struct_def.fields.vec.begin();
+         it != struct_def.fields.vec.end(); ++it) {
+      auto &field = **it;
+      if (field.deprecated) continue;
+
+      GenVerifyCall(code_, field, "");
+    }
+
+    *code_ptr += code_.ToString();
+    
+    GetEndOfTableVerifier(code_ptr);
+  }
+
+  // Generate struct or table methods.
+  void GenStructVerifier(const StructDef &struct_def, std::string *code_ptr) {
+    if (struct_def.generated) return;
+
+    // cur_name_space_ = struct_def.defined_namespace;
+
+    // Generate verifiers
+    if (struct_def.fixed) {
+      // Fixed size structures do not require table members
+      // verification - instead structure size is verified using VerifyField
+    } else {
+      // Create table verification function
+       GenTableVerifier(struct_def, code_ptr);
+    }
+  }
+
   void GenStruct(StructDef &struct_def, std::string *code_ptr,
                  const IDLOptions &opts) const {
     if (struct_def.generated) return;
@@ -688,8 +856,20 @@ class CSharpGenerator : public BaseGenerator {
           code += parser_.file_identifier_;
           code += "\"); }\n";
         }
+
+        // Generate the Verify method that checks if a ByteBuffer is save to
+        // access
+        code += "  public static ";
+        code += "bool Verify" + struct_def.name + "(ByteBuffer _bb) {";
+        code += "Google.FlatBuffers.Verifier verifier = new ";
+        code += "Google.FlatBuffers.Verifier(_bb); ";
+        code += "return verifier.VerifyBuffer(\"";
+        code += parser_.file_identifier_;
+        code += "\", false, " + struct_def.name + "Verify.Verify);";
+        code += " }\n";
       }
     }
+
     // Generate the __init method that sets the field in a pre-existing
     // accessor object. This is to allow object reuse.
     code += "  public void __init(int _i, ByteBuffer _bb) ";
@@ -1418,6 +1598,67 @@ class CSharpGenerator : public BaseGenerator {
     code += "  }\n";
   }
 
+  std::string GenUnionVerify(const Type &union_type) const {
+    if (union_type.enum_def) {
+      const auto &enum_def = *union_type.enum_def;
+
+      auto ret =
+          "\n\nstatic public class " + enum_def.name + "Verify\n";
+      ret += "{\n";
+      ret +=
+          "  static public bool Verify(Google.FlatBuffers.Verifier verifier, "
+          "byte typeId, uint tablePos)\n";
+      ret += "  {\n";
+      ret += "    bool result = true;\n";
+
+      const auto union_enum_loop = [&]() {
+        ret += "    switch((" + enum_def.name + ")typeId)\n";
+        ret += "    {\n";
+
+        for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
+          const auto &ev = **it;
+          if (ev.IsZero()) { continue; }
+
+          ret += "      case " + Name(enum_def) + "." + Name(ev) + ":\n";
+
+          if (IsString(ev.union_type)) {
+            ret +=
+                "       result = verifier.VerifyUnionString(tablePos);\n";
+            ret += "        break;";
+          } else if (ev.union_type.base_type == BASE_TYPE_STRUCT) {
+            if (! ev.union_type.struct_def->fixed) {
+              auto type = GenTypeGet(ev.union_type);
+              ret += "        result = " + type + "Verify.Verify(verifier, tablePos);\n";
+            } else {
+              ret += "        result = verifier.VerifyUnionData(tablePos, " +
+                  NumToString(InlineSize(ev.union_type)) + ", " +
+                  NumToString(InlineAlignment(ev.union_type)) + 
+                ");\n";;
+            }
+            ret += "        break;";
+          } else {
+            FLATBUFFERS_ASSERT(false);
+          }
+          ret += "\n";
+        }
+
+        ret += "      default: result = true;\n";
+        ret += "        break;\n";
+        ret += "    }\n";
+        ret += "    return result;\n";
+      };
+
+      union_enum_loop();
+      ret += "  }\n";
+      ret += "}\n";
+      ret += "\n";
+
+      return ret;
+    }
+    FLATBUFFERS_ASSERT(0);
+    return "";
+  }
+
   void GenEnum_ObjectAPI(EnumDef &enum_def, std::string *code_ptr,
                          const IDLOptions &opts) const {
     auto &code = *code_ptr;
@@ -1493,6 +1734,9 @@ class CSharpGenerator : public BaseGenerator {
     code += "    }\n";
     code += "  }\n";
     code += "}\n\n";
+
+    code += GenUnionVerify(enum_def.underlying_type);
+    
     // JsonConverter
     if (opts.cs_gen_json_serializer) {
       if (enum_def.attributes.Lookup("private")) {

src/idl_gen_go.cpp

@@ -292,6 +292,14 @@ class GoGenerator : public BaseGenerator {
     const std::string size_prefix[] = { "", "SizePrefixed" };
     const std::string struct_type = namer_.Type(struct_def);
 
+    bool has_file_identifier = (parser_.root_struct_def_ == &struct_def) &&
+                               parser_.file_identifier_.length();
+
+    if (has_file_identifier) {
+      code += "const " + struct_type + "Identifier = \"" +
+              parser_.file_identifier_ + "\"\n\n";
+    }
+
     for (int i = 0; i < 2; i++) {
       code += "func Get" + size_prefix[i] + "RootAs" + struct_type;
       code += "(buf []byte, offset flatbuffers.UOffsetT) ";
@@ -312,6 +320,26 @@ class GoGenerator : public BaseGenerator {
       }
       code += "\treturn x\n";
       code += "}\n\n";
+
+      code += "func Finish" + size_prefix[i] + struct_type +
+              "Buffer(builder *flatbuffers.Builder, offset "
+              "flatbuffers.UOffsetT) {\n";
+      if (has_file_identifier) {
+        code += "\tidentifierBytes := []byte(" + struct_type + "Identifier)\n";
+        code += "\tbuilder.Finish" + size_prefix[i] +
+                "WithFileIdentifier(offset, identifierBytes)\n";
+      } else {
+        code += "\tbuilder.Finish" + size_prefix[i] + "(offset)\n";
+      }
+      code += "}\n\n";
+
+      if (has_file_identifier) {
+        code += "func " + size_prefix[i] + struct_type +
+                "BufferHasIdentifier(buf []byte) bool {\n";
+        code += "\treturn flatbuffers." + size_prefix[i] +
+                "BufferHasIdentifier(buf, " + struct_type + "Identifier)\n";
+        code += "}\n\n";
+      }
     }
   }
 
@@ -513,7 +541,7 @@ class GoGenerator : public BaseGenerator {
     GenReceiver(struct_def, code_ptr);
     code += " " + namer_.Field(field) + "ByKey";
     code += "(obj *" + TypeName(field);
-    code += ", key " + NativeType(key_field.value.type) + ") bool" +
+    code += ", key " + NativeType(key_field.value.type) + ") bool " +
             OffsetPrefix(field);
     code += "\t\tx := rcv._tab.Vector(o)\n";
     code += "\t\treturn ";
@@ -892,8 +920,8 @@ class GoGenerator : public BaseGenerator {
     code += "o1, o2 flatbuffers.UOffsetT, buf []byte) bool {\n";
     code += "\tobj1 := &" + namer_.Type(struct_def) + "{}\n";
     code += "\tobj2 := &" + namer_.Type(struct_def) + "{}\n";
-    code += "\tobj1.Init(buf, flatbuffers.UOffsetT(len(buf)) - o1)\n";
+    code += "\tobj1.Init(buf, flatbuffers.UOffsetT(len(buf))-o1)\n";
-    code += "\tobj2.Init(buf, flatbuffers.UOffsetT(len(buf)) - o2)\n";
+    code += "\tobj2.Init(buf, flatbuffers.UOffsetT(len(buf))-o2)\n";
     if (IsString(field.value.type)) {
       code += "\treturn string(obj1." + namer_.Function(field.name) + "()) < ";
       code += "string(obj2." + namer_.Function(field.name) + "())\n";
@@ -915,13 +943,13 @@ class GoGenerator : public BaseGenerator {
     code += "key " + NativeType(field.value.type) + ", ";
     code += "vectorLocation flatbuffers.UOffsetT, ";
     code += "buf []byte) bool {\n";
-    code += "\tspan := flatbuffers.GetUOffsetT(buf[vectorLocation - 4:])\n";
+    code += "\tspan := flatbuffers.GetUOffsetT(buf[vectorLocation-4:])\n";
     code += "\tstart := flatbuffers.UOffsetT(0)\n";
     if (IsString(field.value.type)) { code += "\tbKey := []byte(key)\n"; }
     code += "\tfor span != 0 {\n";
     code += "\t\tmiddle := span / 2\n";
     code += "\t\ttableOffset := flatbuffers.GetIndirectOffset(buf, ";
-    code += "vectorLocation+ 4 * (start + middle))\n";
+    code += "vectorLocation+4*(start+middle))\n";
 
     code += "\t\tobj := &" + namer_.Type(struct_def) + "{}\n";
     code += "\t\tobj.Init(buf, tableOffset)\n";
@@ -1032,8 +1060,8 @@ class GoGenerator : public BaseGenerator {
 
       code += "\t\treturn &" +
               WrapInNameSpaceAndTrack(&enum_def, NativeName(enum_def)) +
-              "{ Type: " + namer_.EnumVariant(enum_def, ev) +
+              "{Type: " + namer_.EnumVariant(enum_def, ev) +
-              ", Value: x.UnPack() }\n";
+              ", Value: x.UnPack()}\n";
     }
     code += "\t}\n";
     code += "\treturn nil\n";
@@ -1046,7 +1074,7 @@ class GoGenerator : public BaseGenerator {
 
     code += "func (t *" + NativeName(struct_def) +
             ") Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {\n";
-    code += "\tif t == nil { return 0 }\n";
+    code += "\tif t == nil {\n\t\treturn 0\n\t}\n";
     for (auto it = struct_def.fields.vec.begin();
          it != struct_def.fields.vec.end(); ++it) {
       const FieldDef &field = **it;
@@ -1116,8 +1144,7 @@ class GoGenerator : public BaseGenerator {
         if (field.value.type.struct_def->fixed) continue;
         code += "\t" + offset + " := t." + field_field + ".Pack(builder)\n";
       } else if (field.value.type.base_type == BASE_TYPE_UNION) {
-        code += "\t" + offset + " := t." + field_field + ".Pack(builder)\n";
+        code += "\t" + offset + " := t." + field_field + ".Pack(builder)\n\n";
-        code += "\t\n";
       } else {
         FLATBUFFERS_ASSERT(0);
       }
@@ -1233,7 +1260,7 @@ class GoGenerator : public BaseGenerator {
 
     code += "func (rcv *" + struct_type + ") UnPack() *" +
             NativeName(struct_def) + " {\n";
-    code += "\tif rcv == nil { return nil }\n";
+    code += "\tif rcv == nil {\n\t\treturn nil\n\t}\n";
     code += "\tt := &" + NativeName(struct_def) + "{}\n";
     code += "\trcv.UnPackTo(t)\n";
     code += "\treturn t\n";
@@ -1245,7 +1272,7 @@ class GoGenerator : public BaseGenerator {
 
     code += "func (t *" + NativeName(struct_def) +
             ") Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {\n";
-    code += "\tif t == nil { return 0 }\n";
+    code += "\tif t == nil {\n\t\treturn 0\n\t}\n";
     code += "\treturn Create" + namer_.Type(struct_def) + "(builder";
     StructPackArgs(struct_def, "", code_ptr);
     code += ")\n";
@@ -1289,7 +1316,7 @@ class GoGenerator : public BaseGenerator {
 
     code += "func (rcv *" + namer_.Type(struct_def) + ") UnPack() *" +
             NativeName(struct_def) + " {\n";
-    code += "\tif rcv == nil { return nil }\n";
+    code += "\tif rcv == nil {\n\t\treturn nil\n\t}\n";
     code += "\tt := &" + NativeName(struct_def) + "{}\n";
     code += "\trcv.UnPackTo(t)\n";
     code += "\treturn t\n";
@@ -1477,15 +1504,17 @@ class GoGenerator : public BaseGenerator {
     code += "package " + name_space_name + "\n\n";
     if (needs_imports) {
       code += "import (\n";
+      // standard imports, in alphabetical order for go fmt
       if (needs_bytes_import_) code += "\t\"bytes\"\n";
-      // math is needed to support non-finite scalar default values.
-      if (needs_math_import_) { code += "\t\"math\"\n"; }
-      if (is_enum) { code += "\t\"strconv\"\n"; }
       if (!parser_.opts.go_import.empty()) {
         code += "\tflatbuffers \"" + parser_.opts.go_import + "\"\n";
       } else {
         code += "\tflatbuffers \"github.com/google/flatbuffers/go\"\n";
       }
+      // math is needed to support non-finite scalar default values.
+      if (needs_math_import_) { code += "\t\"math\"\n"; }
+      if (is_enum) { code += "\t\"strconv\"\n"; }
+
       if (tracked_imported_namespaces_.size() > 0) {
         code += "\n";
         for (auto it = tracked_imported_namespaces_.begin();

src/idl_gen_python.cpp

@@ -139,13 +139,15 @@ class PythonGenerator : public BaseGenerator {
     code += Indent + Indent + "return x\n";
     code += "\n";
 
-    // Add an alias with the old name
+    if (!parser_.opts.python_no_type_prefix_suffix) {
-    code += Indent + "@classmethod\n";
+      // Add an alias with the old name
-    code += Indent + "def GetRootAs" + struct_type + "(cls, buf, offset=0):\n";
+      code += Indent + "@classmethod\n";
-    code +=
+      code += Indent + "def GetRootAs" + struct_type + "(cls, buf, offset=0):\n";
-        Indent + Indent +
+      code +=
-        "\"\"\"This method is deprecated. Please switch to GetRootAs.\"\"\"\n";
+          Indent + Indent +
-    code += Indent + Indent + "return cls.GetRootAs(buf, offset)\n";
+          "\"\"\"This method is deprecated. Please switch to GetRootAs.\"\"\"\n";
+      code += Indent + Indent + "return cls.GetRootAs(buf, offset)\n";
+    }
   }
 
   // Initialize an existing object with other data, to avoid an allocation.
@@ -480,7 +482,10 @@ class PythonGenerator : public BaseGenerator {
     if (!nested) { return; }  // There is no nested flatbuffer.
 
     const std::string unqualified_name = nested->constant;
-    const std::string qualified_name = NestedFlatbufferType(unqualified_name);
+    std::string qualified_name = NestedFlatbufferType(unqualified_name);
+    if (qualified_name.empty()) {
+      qualified_name = nested->constant;
+    }
 
     auto &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
@@ -491,7 +496,7 @@ class PythonGenerator : public BaseGenerator {
     code += Indent + Indent + Indent;
     code += "from " + qualified_name + " import " + unqualified_name + "\n";
     code += Indent + Indent + Indent + "return " + unqualified_name;
-    code += ".GetRootAs" + unqualified_name;
+    code += ".GetRootAs";
     code += "(self._tab.Bytes, self._tab.Vector(o))\n";
     code += Indent + Indent + "return 0\n";
     code += "\n";
@@ -605,15 +610,18 @@ class PythonGenerator : public BaseGenerator {
     auto &code = *code_ptr;
     const auto struct_type = namer_.Type(struct_def);
     // Generate method with struct name.
-    code += "def " + struct_type + "Start(builder): ";
-    code += "builder.StartObject(";
-    code += NumToString(struct_def.fields.vec.size());
-    code += ")\n";
 
-    if (!parser_.opts.one_file) {
+    const auto name = parser_.opts.python_no_type_prefix_suffix ? "Start" : struct_type + "Start";
+
+    code += "def " + name + "(builder):\n";
+    code += Indent + "return builder.StartObject(";
+    code += NumToString(struct_def.fields.vec.size());
+    code += ")\n\n";
+
+    if (!parser_.opts.one_file && !parser_.opts.python_no_type_prefix_suffix) {
       // Generate method without struct name.
       code += "def Start(builder):\n";
-      code += Indent + "return " + struct_type + "Start(builder)\n";
+      code += Indent + "return " + struct_type + "Start(builder)\n\n";
     }
   }
 
@@ -624,12 +632,14 @@ class PythonGenerator : public BaseGenerator {
     const std::string field_var = namer_.Variable(field);
     const std::string field_method = namer_.Method(field);
 
+    const auto name = parser_.opts.python_no_type_prefix_suffix ? "Add" + field_method : namer_.Type(struct_def) + "Add" + field_method;
+
     // Generate method with struct name.
-    code += "def " + namer_.Type(struct_def) + "Add" + field_method;
+    code += "def " + name;
     code += "(builder, ";
     code += field_var;
-    code += "): ";
+    code += "):\n";
-    code += "builder.Prepend";
+    code += Indent + "return builder.Prepend";
     code += GenMethod(field) + "Slot(";
     code += NumToString(offset) + ", ";
     if (!IsScalar(field.value.type.base_type) && (!struct_def.fixed)) {
@@ -646,16 +656,16 @@ class PythonGenerator : public BaseGenerator {
     } else {
       code += field.value.constant;
     }
-    code += ")\n";
+    code += ")\n\n";
 
-    if (!parser_.opts.one_file) {
+    if (!parser_.opts.one_file && !parser_.opts.python_no_type_prefix_suffix) {
       // Generate method without struct name.
       code += "def Add" + field_method + "(builder, " + field_var + "):\n";
       code +=
           Indent + "return " + namer_.Type(struct_def) + "Add" + field_method;
       code += "(builder, ";
       code += field_var;
-      code += ")\n";
+      code += ")\n\n";
     }
   }
 
@@ -667,20 +677,22 @@ class PythonGenerator : public BaseGenerator {
     const std::string field_method = namer_.Method(field);
 
     // Generate method with struct name.
-    code += "def " + struct_type + "Start" + field_method;
+    const auto name = parser_.opts.python_no_type_prefix_suffix ? "Start" + field_method : struct_type + "Start" + field_method;
-    code += "Vector(builder, numElems): return builder.StartVector(";
+    code += "def " + name;
+    code += "Vector(builder, numElems):\n";
+    code += Indent + "return builder.StartVector(";
     auto vector_type = field.value.type.VectorType();
     auto alignment = InlineAlignment(vector_type);
     auto elem_size = InlineSize(vector_type);
     code += NumToString(elem_size);
     code += ", numElems, " + NumToString(alignment);
-    code += ")\n";
+    code += ")\n\n";
 
-    if (!parser_.opts.one_file) {
+    if (!parser_.opts.one_file && !parser_.opts.python_no_type_prefix_suffix) {
       // Generate method without struct name.
       code += "def Start" + field_method + "Vector(builder, numElems):\n";
       code += Indent + "return " + struct_type + "Start";
-      code += field_method + "Vector(builder, numElems)\n";
+      code += field_method + "Vector(builder, numElems)\n\n";
     }
   }
 
@@ -725,15 +737,16 @@ class PythonGenerator : public BaseGenerator {
                            std::string *code_ptr) const {
     auto &code = *code_ptr;
 
+    const auto name = parser_.opts.python_no_type_prefix_suffix ? "End" : namer_.Type(struct_def) + "End";
     // Generate method with struct name.
-    code += "def " + namer_.Type(struct_def) + "End";
+    code += "def " + name + "(builder):\n";
-    code += "(builder): ";
+    code += Indent + "return builder.EndObject()\n\n";
-    code += "return builder.EndObject()\n";
 
-    if (!parser_.opts.one_file) {
+    if (!parser_.opts.one_file && !parser_.opts.python_no_type_prefix_suffix) {
       // Generate method without struct name.
       code += "def End(builder):\n";
       code += Indent + "return " + namer_.Type(struct_def) + "End(builder)";
+      code += "\n";
     }
   }
 

src/idl_gen_swift.cpp

@@ -725,9 +725,9 @@ class SwiftGenerator : public BaseGenerator {
       code_.SetValue("CONSTANT", default_value);
       code_.SetValue("VALUETYPE", "Bool");
       code_ += GenReaderMainBody(optional) + "\\";
-      code_.SetValue("VALUETYPE", "Byte");
+      code_ += GenOffset() +
-      code_ += GenOffset() + "return o == 0 ? {{CONSTANT}} : 0 != " +
+               "return o == 0 ? {{CONSTANT}} : " + GenReader("VALUETYPE", "o") +
-               GenReader("VALUETYPE", "o") + " }";
+               " }";
       if (parser_.opts.mutable_buffer) code_ += GenMutate("o", GenOffset());
       return;
     }

src/idl_gen_ts.cpp

@@ -474,14 +474,13 @@ class TsGenerator : public BaseGenerator {
           return "BigInt('" + value.constant + "')";
         }
         default: {
-          if (auto val = value.type.enum_def->FindByValue(value.constant)) {
+          EnumVal *val = value.type.enum_def->FindByValue(value.constant);
-            return AddImport(imports, *value.type.enum_def,
+          if (val == nullptr)
-                             *value.type.enum_def)
+            val = const_cast<EnumVal *>(value.type.enum_def->MinValue());
-                       .name +
+          return AddImport(imports, *value.type.enum_def,
-                   "." + namer_.Variant(*val);
+                            *value.type.enum_def)
-          } else {
+                      .name +
-            return value.constant;
+                  "." + namer_.Variant(*val);
-          }
         }
       }
     }

tests/FlatBuffers.Test/FlatBuffers.Core.Test.csproj

@@ -46,6 +46,9 @@
     <Compile Include="..\..\net\FlatBuffers\FlatBufferConstants.cs">
       <Link>FlatBuffers\FlatBufferConstants.cs</Link>
     </Compile>
+    <Compile Include="..\..\net\FlatBuffers\FlatBufferVerify.cs">
+      <Link>FlatBuffers\FlatBufferVerify.cs</Link>
+    </Compile>
     <Compile Include="..\..\net\FlatBuffers\Struct.cs">
       <Link>FlatBuffers\Struct.cs</Link>
     </Compile>

tests/FlatBuffers.Test/FlatBuffersExampleTests.cs

@@ -198,6 +198,9 @@ namespace Google.FlatBuffers.Test
 
         private void TestBuffer(ByteBuffer bb)
         {
+            bool test = Monster.VerifyMonster(bb);
+            Assert.AreEqual(true, test);
+
             Monster monster = Monster.GetRootAsMonster(bb);
 
             Assert.AreEqual(80, monster.Hp);
@@ -299,7 +302,7 @@ namespace Google.FlatBuffers.Test
             var jsonText = File.ReadAllText(@"../monsterdata_test.json");
             var mon = MonsterT.DeserializeFromJson(jsonText);
             var fbb = new FlatBufferBuilder(1);
-            fbb.Finish(Monster.Pack(fbb, mon).Value);
+            Monster.FinishMonsterBuffer(fbb, Monster.Pack(fbb, mon));
             TestBuffer(fbb.DataBuffer);
         }
 

tests/FlatBuffers.Test/FlatBuffersFuzzTests.cs

@@ -15,6 +15,7 @@
  */
 
 using System;
+using Google.FlatBuffers;
 
 namespace Google.FlatBuffers.Test
 {
@@ -204,9 +205,21 @@ namespace Google.FlatBuffers.Test
                 1, // value 0
             },
                 builder.DataBuffer.ToFullArray());
-        }
+            var verifier = new Verifier(builder.DataBuffer);
+            var offset = 8;
+            // table must be ok
+            Assert.IsTrue(verifier.VerifyTableStart((uint)offset));
+            // First field must be bool
+            Assert.IsTrue(verifier.VerifyField((uint)offset, 4, 1, 1, true));
+            // Check Error: Second field
+            Assert.IsFalse(verifier.VerifyField((uint)offset, 6, 1, 1, true));
+            // Check Error: First field too big alignment
+            Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 1, 2, true));
+            // Check Error: First size to big
+            Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 2, 1, true));
+    }
 
-        [FlatBuffersTestMethod]
+    [FlatBuffersTestMethod]
         public void TestVTableWithOneBool_DefaultValue()
         {
             var builder = new FlatBufferBuilder(1);
@@ -223,6 +236,14 @@ namespace Google.FlatBuffers.Test
                 4, 0, 0, 0, // int32 offset for start of vtable
             },
                 builder.DataBuffer.ToFullArray());
+            var verifier = new Verifier(builder.DataBuffer);
+            var offset = 4;
+            // table must be ok
+            Assert.IsTrue(verifier.VerifyTableStart((uint)offset));
+            // First field must be bool
+            Assert.IsTrue(verifier.VerifyField((uint)offset, 4, 1, 1, false));
+            // Error Check: First field not present
+            Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 1, 1, true));
         }
 
         [FlatBuffersTestMethod]
@@ -232,7 +253,7 @@ namespace Google.FlatBuffers.Test
             builder.StartTable(1);
             Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray());
             builder.AddShort(0, 0x789A, 0);
-            builder.EndTable();
+            int offset = builder.EndTable();
             Assert.ArrayEqual(new byte[]
             {
                 0, 0, // padding to 16 bytes
@@ -244,6 +265,18 @@ namespace Google.FlatBuffers.Test
                 0x9A, 0x78, //value 0
             },
                 builder.DataBuffer.ToFullArray());
+            var verifier = new Verifier(builder.DataBuffer);
+            offset += builder.DataBuffer.Position;
+            // table must be ok
+            Assert.IsTrue(verifier.VerifyTableStart((uint)offset));
+            // First field must be ushort
+            Assert.IsTrue(verifier.VerifyField((uint)offset, 4, 2, 2, true));
+            // Check Error: Second field
+            Assert.IsFalse(verifier.VerifyField((uint)offset, 6, 2, 2, true));
+            // Check Error: First field too big alignment
+            Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 4, 2, true));
+            // Check Error: First field size to big
+            Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 2, 4, true));
         }
 
         [FlatBuffersTestMethod]
@@ -254,7 +287,7 @@ namespace Google.FlatBuffers.Test
             Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray());
             builder.AddShort(0, 0x3456, 0);
             builder.AddShort(1, 0x789A, 0);
-            builder.EndTable();
+            int offset = builder.EndTable();
             Assert.ArrayEqual(new byte[]
             {
                 8, 0, // vtable bytes
@@ -266,6 +299,18 @@ namespace Google.FlatBuffers.Test
                 0x56, 0x34, // value 0
             },
                 builder.DataBuffer.ToFullArray());
+            var verifier = new Verifier(builder.DataBuffer);
+            offset += builder.DataBuffer.Position;
+            // table must be ok
+            Assert.IsTrue(verifier.VerifyTableStart((uint)offset));
+            // First field must be ushort
+            Assert.IsTrue(verifier.VerifyField((uint)offset, 4, 2, 2, true));
+            // Check Error: Second field
+            Assert.IsTrue(verifier.VerifyField((uint)offset, 6, 2, 2, true));
+            // Check Error: Second field too big alignment
+            Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 4, 2, true));
+            // Check Error: Second field size to big
+            Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 2, 4, true));
         }
 
         [FlatBuffersTestMethod]
@@ -276,7 +321,7 @@ namespace Google.FlatBuffers.Test
             Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray());
             builder.AddShort(0, 0x3456, 0);
             builder.AddBool(1, true, false);
-            builder.EndTable();
+            int offset = builder.EndTable();
             Assert.ArrayEqual(new byte[]
             {
                 8, 0, // vtable bytes
@@ -288,6 +333,18 @@ namespace Google.FlatBuffers.Test
                 0x56, 0x34, // value 0
             },
                 builder.DataBuffer.ToFullArray());
+            var verifier = new Verifier(builder.DataBuffer);
+            offset += builder.DataBuffer.Position;
+            // table must be ok
+            Assert.IsTrue(verifier.VerifyTableStart((uint)offset));
+            // First field must be ushort
+            Assert.IsTrue(verifier.VerifyField((uint)offset, 4, 2, 2, true));
+            // Check Error: Second field must be bool
+            Assert.IsTrue(verifier.VerifyField((uint)offset, 6, 1, 1, true));
+            // Check Error: Second field too big alignment
+            Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 4, 2, true));
+            // Check Error: Second field size to big
+            Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 2, 4, true));
         }
 
         [FlatBuffersTestMethod]
@@ -315,6 +372,12 @@ namespace Google.FlatBuffers.Test
                 0, 0, 0, 0,
             },
                 builder.DataBuffer.ToFullArray());
+            var verifier = new Verifier(builder.DataBuffer);
+            uint checkOffset = 20;
+            // table must be ok
+            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
+            // First field must be vector with element size 1
+            Assert.IsTrue(verifier.VerifyVectorOfData(checkOffset, 4, 1, true));
         }
 
         [FlatBuffersTestMethod]
@@ -342,7 +405,15 @@ namespace Google.FlatBuffers.Test
                 0, 0, 0, 0, // length of vector (not in sctruc)
             },
                 builder.DataBuffer.ToFullArray());
-        }
+            var verifier = new Verifier(builder.DataBuffer);
+            uint checkOffset = 16;
+            // table must be ok
+            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
+            // First field must be short
+            Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 2, 2, true));
+            // Second field must be vector with element size 1
+            Assert.IsTrue(verifier.VerifyVectorOfData(checkOffset, 6, 2, true));
+       }
 
 
         [FlatBuffersTestMethod]
@@ -373,6 +444,16 @@ namespace Google.FlatBuffers.Test
                 0x34, 0x12,       // vector value 1
             },
                 builder.DataBuffer.ToFullArray());
+            var verifier = new Verifier(builder.DataBuffer);
+            uint checkOffset = 12;
+            // table must be ok
+            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
+            // Second field must be vector with element size 2
+            Assert.IsTrue(verifier.VerifyVectorOfData(checkOffset, 6, 2, true));
+            // Check Error: Second field with too big size
+            Assert.IsFalse(verifier.VerifyVectorOfData(checkOffset, 6, 4, true));
+            // First field must be short
+            Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 2, 2, true));
         }
 
         [FlatBuffersTestMethod]
@@ -403,8 +484,17 @@ namespace Google.FlatBuffers.Test
                 0x00, 0x00, 0x00, 55, // struct value 0
             },
                 builder.DataBuffer.ToFullArray());
+            var verifier = new Verifier(builder.DataBuffer);
+            uint checkOffset = 16;
+            // table must be ok
+            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
+            // First field must be a struct with 12 bytes
+            Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 12, 4, true));
+            // Check Error: First field with more than 12 bytes
+            Assert.IsFalse(verifier.VerifyField(checkOffset, 4, 16, 4, true));
         }
 
+
         [FlatBuffersTestMethod]
         public void TestVTableWithAVectorOf_2xStructOf_2xInt8()
         {
@@ -437,6 +527,12 @@ namespace Google.FlatBuffers.Test
                 33, // vector 0, 0
             },
                 builder.DataBuffer.ToFullArray());
+            var verifier = new Verifier(builder.DataBuffer);
+            uint checkOffset = 16;
+            // table must be ok
+            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
+            // First field must be vector with element size 2
+            Assert.IsTrue(verifier.VerifyVectorOfData(checkOffset, 4, 2, true));
         }
 
         [FlatBuffersTestMethod]
@@ -470,6 +566,104 @@ namespace Google.FlatBuffers.Test
             byte[] unpadded = new byte[padded.Length - 12];
             Buffer.BlockCopy(padded, 12, unpadded, 0, unpadded.Length);
             Assert.ArrayEqual(unpadded, builder.DataBuffer.ToSizedArray());
+
+            var verifier = new Verifier(builder.DataBuffer);
+            uint checkOffset = builder.DataBuffer.GetUint(builder.DataBuffer.Position) + (uint)builder.DataBuffer.Position;
+            // table must be ok
+            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
+            // First field must be a struct with 12 bytes
+            Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 1, 1, true));
+            // Second field must be a struct with 12 bytes
+            Assert.IsTrue(verifier.VerifyField(checkOffset, 6, 2, 2, true));
+        }
+
+        [FlatBuffersTestMethod]
+        public void TestVTableWithStrings()
+        {
+            var builder = new FlatBufferBuilder(64);
+            var str1 = builder.CreateString("foo");
+            var str2 = builder.CreateString("foobar");
+            builder.StartTable(2);
+            builder.AddOffset(0, str1.Value, 0);
+            builder.AddOffset(1, str2.Value, 0);
+            var off = builder.EndTable();
+            builder.Finish(off);
+
+            byte[] padded = new byte[]
+            {
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0, //Padding to 32 bytes
+                12, 0, 0, 0, // root of table, pointing to vtable offset
+                8, 0, // vtable bytes
+                12, 0, // object length
+                8, 0, // start of value 0
+                4, 0, // start of value 1
+                8, 0, 0, 0, // int32 offset for start of vtable
+                8, 0, 0, 0, // pointer to string
+                16, 0, 0, 0, // pointer to string
+                6, 0, 0, 0, // length of string
+                102, 111, 111, 98, 97, 114, 0, 0, // "foobar" + padding
+                3, 0, 0, 0, // length of string
+                102, 111, 111, 0 // "bar"
+            };
+            Assert.ArrayEqual(padded, builder.DataBuffer.ToFullArray());
+
+            var verifier = new Verifier(builder.DataBuffer);
+            uint checkOffset = builder.DataBuffer.GetUint(builder.DataBuffer.Position) + (uint)builder.DataBuffer.Position;
+            // table must be ok
+            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
+            // First field string check
+            Assert.IsTrue(verifier.VerifyString(checkOffset, 4, true));
+            // Second field string check
+            Assert.IsTrue(verifier.VerifyString(checkOffset, 6, true));
+        }
+
+        [FlatBuffersTestMethod]
+        public void TestVTableWithVectorOfStrings()
+        {
+            var builder = new FlatBufferBuilder(64);
+            var str1 = builder.CreateString("foo");
+            var str2 = builder.CreateString("foobar");
+            builder.StartVector(sizeof(int), 2, 1);
+            builder.AddOffset(str1.Value);
+            builder.AddOffset(str2.Value);
+            var vec = builder.EndVector();
+            builder.StartTable(1);
+            builder.AddOffset(0, vec.Value, 0);
+            var off = builder.EndTable();
+            builder.Finish(off);
+
+            byte[] padded = new byte[]
+            {
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0, //Padding to 32 bytes
+                12, 0, 0, 0, // root of table, pointing to vtable offset
+                0, 0, // padding
+                6, 0, // vtable bytes
+                8, 0, // object length
+                4, 0, // start of value 0
+                6, 0, 0, 0, // int32 offset for start of vtable
+                4, 0, 0, 0, // pointer to vector
+                2, 0, 0, 0, // length of vector
+                8, 0, 0, 0, // int32 offset to string 1
+                16, 0, 0, 0, // int32 offset to string 2
+                6, 0, 0, 0, // length of string
+                102, 111, 111, 98, 97, 114, 0, 0, // "foobar" + padding
+                3, 0, 0, 0, // length of string
+                102, 111, 111, 0 // "bar"
+            };
+            Assert.ArrayEqual(padded, builder.DataBuffer.ToFullArray());
+
+            var verifier = new Verifier(builder.DataBuffer);
+            uint checkOffset = builder.DataBuffer.GetUint(builder.DataBuffer.Position) + (uint)builder.DataBuffer.Position;
+            // table must be ok
+            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
+            // First field string check
+            Assert.IsTrue(verifier.VerifyVectorOfStrings(checkOffset, 4, true));
         }
 
         [FlatBuffersTestMethod]
@@ -521,6 +715,33 @@ namespace Google.FlatBuffers.Test
                 33,
             },
                 builder.DataBuffer.ToFullArray());
+
+            // check obj1
+            var verifier = new Verifier(builder.DataBuffer);
+            uint checkOffset = builder.DataBuffer.GetUint(builder.DataBuffer.Position) + (uint)builder.DataBuffer.Position;
+            // table must be ok
+            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
+            // First field must be a struct with 12 bytes
+            Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 1, 1, true));
+            // Second field must be a struct with 12 bytes
+            Assert.IsTrue(verifier.VerifyField(checkOffset, 6, 1, 1, true));
+            // Third field must be a struct with 12 bytes
+            Assert.IsTrue(verifier.VerifyField(checkOffset, 8, 1, 1, true));
+            // Check Error: 4. field did not exist
+            Assert.IsFalse(verifier.VerifyField(checkOffset, 10, 1, 1, true));
+
+            // check obj0
+            checkOffset = 56;
+            // table must be ok
+            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
+            // First field must be a struct with 12 bytes
+            Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 1, 1, true));
+            // Second field must be a struct with 12 bytes
+            Assert.IsTrue(verifier.VerifyField(checkOffset, 6, 1, 1, true));
+            // Check Error: 3. field did not exist
+            Assert.IsFalse(verifier.VerifyField(checkOffset, 8, 1, 1, true));
+            // Check Error: 4. field did not exist
+            Assert.IsFalse(verifier.VerifyField(checkOffset, 10, 1, 1, true));
         }
 
         [FlatBuffersTestMethod]
@@ -569,6 +790,16 @@ namespace Google.FlatBuffers.Test
             byte[] unpadded = new byte[padded.Length - 28];
             Buffer.BlockCopy(padded, 28, unpadded, 0, unpadded.Length);
             Assert.ArrayEqual(unpadded, builder.DataBuffer.ToSizedArray());
+
+            var verifier = new Verifier(builder.DataBuffer);
+            uint checkOffset = builder.DataBuffer.GetUint(builder.DataBuffer.Position) + (uint)builder.DataBuffer.Position;
+            // table must be ok
+            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
+            for (var i = 0; i < 8; i++)
+            {
+                Assert.IsTrue(verifier.VerifyField(checkOffset, (short)(4 + i * 2), 1, 1, true));
+            }
+            Assert.IsFalse(verifier.VerifyField(checkOffset, (short)(4 + 8 * 2), 1, 1, true));
         }
 
         [FlatBuffersTestMethod]
@@ -639,6 +870,16 @@ namespace Google.FlatBuffers.Test
 
             },
                 builder.DataBuffer.ToFullArray());
+            var verifier = new Verifier(builder.DataBuffer);
+            uint checkOffset = 8;
+            // table must be ok
+            Assert.IsTrue(verifier.VerifyTableStart(checkOffset));
+            // First Field must be float
+            Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 4, 4, true));
+            // Check Error: First Field with to big size
+            Assert.IsFalse(verifier.VerifyField(checkOffset, 4, 8, 4, true));
+            // Check Error: First Field with to big padding
+            Assert.IsFalse(verifier.VerifyField(checkOffset, 4, 4, 8, true));
         }
 
         private void CheckObjects(int fieldCount, int objectCount)

tests/KeywordTest/KeywordsInTable.cs

@@ -92,4 +92,17 @@ public class KeywordsInTableT
 }
 
 
+static public class KeywordsInTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Is*/, 4 /*KeywordTest.ABC*/, 4, false)
+      && verifier.VerifyField(tablePos, 6 /*Private*/, 4 /*KeywordTest.@public*/, 4, false)
+      && verifier.VerifyField(tablePos, 8 /*Type*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 10 /*Default*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
 }

tests/KeywordTest/KeywordsInUnion.cs

@@ -37,6 +37,28 @@ public class KeywordsInUnionUnion {
   }
 }
 
+
+
+static public class KeywordsInUnionVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos)
+  {
+    bool result = true;
+    switch((KeywordsInUnion)typeId)
+    {
+      case KeywordsInUnion.@static:
+        result = KeywordTest.KeywordsInTableVerify.Verify(verifier, tablePos);
+        break;
+      case KeywordsInUnion.@internal:
+        result = KeywordTest.KeywordsInTableVerify.Verify(verifier, tablePos);
+        break;
+      default: result = true;
+        break;
+    }
+    return result;
+  }
+}
+
 public class KeywordsInUnionUnion_JsonConverter : Newtonsoft.Json.JsonConverter {
   public override bool CanConvert(System.Type objectType) {
     return objectType == typeof(KeywordsInUnionUnion) || objectType == typeof(System.Collections.Generic.List<KeywordsInUnionUnion>);

tests/KeywordTest/Table2.cs

@@ -91,4 +91,15 @@ public class Table2T
 }
 
 
+static public class Table2Verify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*TypeType*/, 1 /*KeywordTest.KeywordsInUnion*/, 1, false)
+      && verifier.VerifyUnion(tablePos, 4, 6 /*Type*/, KeywordTest.KeywordsInUnionVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
 }

tests/MyGame/Example/Ability.go

@@ -12,7 +12,9 @@ type AbilityT struct {
 }
 
 func (t *AbilityT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
-	if t == nil { return 0 }
+	if t == nil {
+		return 0
+	}
 	return CreateAbility(builder, t.Id, t.Distance)
 }
 func (rcv *Ability) UnPackTo(t *AbilityT) {
@@ -21,7 +23,9 @@ func (rcv *Ability) UnPackTo(t *AbilityT) {
 }
 
 func (rcv *Ability) UnPack() *AbilityT {
-	if rcv == nil { return nil }
+	if rcv == nil {
+		return nil
+	}
 	t := &AbilityT{}
 	rcv.UnPackTo(t)
 	return t

tests/MyGame/Example/Any.cs

@@ -41,6 +41,31 @@ public class AnyUnion {
   }
 }
 
+
+
+static public class AnyVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos)
+  {
+    bool result = true;
+    switch((Any)typeId)
+    {
+      case Any.Monster:
+        result = MyGame.Example.MonsterVerify.Verify(verifier, tablePos);
+        break;
+      case Any.TestSimpleTableWithEnum:
+        result = MyGame.Example.TestSimpleTableWithEnumVerify.Verify(verifier, tablePos);
+        break;
+      case Any.MyGame_Example2_Monster:
+        result = MyGame.Example2.MonsterVerify.Verify(verifier, tablePos);
+        break;
+      default: result = true;
+        break;
+    }
+    return result;
+  }
+}
+
 public class AnyUnion_JsonConverter : Newtonsoft.Json.JsonConverter {
   public override bool CanConvert(System.Type objectType) {
     return objectType == typeof(AnyUnion) || objectType == typeof(System.Collections.Generic.List<AnyUnion>);

tests/MyGame/Example/Any.go

@@ -3,8 +3,8 @@
 package Example
 
 import (
-	"strconv"
 	flatbuffers "github.com/google/flatbuffers/go"
+	"strconv"
 
 	MyGame__Example2 "MyGame/Example2"
 )
@@ -64,15 +64,15 @@ func (rcv Any) UnPack(table flatbuffers.Table) *AnyT {
 	case AnyMonster:
 		var x Monster
 		x.Init(table.Bytes, table.Pos)
-		return &AnyT{ Type: AnyMonster, Value: x.UnPack() }
+		return &AnyT{Type: AnyMonster, Value: x.UnPack()}
 	case AnyTestSimpleTableWithEnum:
 		var x TestSimpleTableWithEnum
 		x.Init(table.Bytes, table.Pos)
-		return &AnyT{ Type: AnyTestSimpleTableWithEnum, Value: x.UnPack() }
+		return &AnyT{Type: AnyTestSimpleTableWithEnum, Value: x.UnPack()}
 	case AnyMyGame_Example2_Monster:
 		var x MyGame__Example2.Monster
 		x.Init(table.Bytes, table.Pos)
-		return &AnyT{ Type: AnyMyGame_Example2_Monster, Value: x.UnPack() }
+		return &AnyT{Type: AnyMyGame_Example2_Monster, Value: x.UnPack()}
 	}
 	return nil
 }

tests/MyGame/Example/AnyAmbiguousAliases.cs

@@ -41,6 +41,31 @@ public class AnyAmbiguousAliasesUnion {
   }
 }
 
+
+
+static public class AnyAmbiguousAliasesVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos)
+  {
+    bool result = true;
+    switch((AnyAmbiguousAliases)typeId)
+    {
+      case AnyAmbiguousAliases.M1:
+        result = MyGame.Example.MonsterVerify.Verify(verifier, tablePos);
+        break;
+      case AnyAmbiguousAliases.M2:
+        result = MyGame.Example.MonsterVerify.Verify(verifier, tablePos);
+        break;
+      case AnyAmbiguousAliases.M3:
+        result = MyGame.Example.MonsterVerify.Verify(verifier, tablePos);
+        break;
+      default: result = true;
+        break;
+    }
+    return result;
+  }
+}
+
 public class AnyAmbiguousAliasesUnion_JsonConverter : Newtonsoft.Json.JsonConverter {
   public override bool CanConvert(System.Type objectType) {
     return objectType == typeof(AnyAmbiguousAliasesUnion) || objectType == typeof(System.Collections.Generic.List<AnyAmbiguousAliasesUnion>);

tests/MyGame/Example/AnyAmbiguousAliases.go

@@ -3,8 +3,8 @@
 package Example
 
 import (
-	"strconv"
 	flatbuffers "github.com/google/flatbuffers/go"
+	"strconv"
 )
 
 type AnyAmbiguousAliases byte
@@ -62,15 +62,15 @@ func (rcv AnyAmbiguousAliases) UnPack(table flatbuffers.Table) *AnyAmbiguousAlia
 	case AnyAmbiguousAliasesM1:
 		var x Monster
 		x.Init(table.Bytes, table.Pos)
-		return &AnyAmbiguousAliasesT{ Type: AnyAmbiguousAliasesM1, Value: x.UnPack() }
+		return &AnyAmbiguousAliasesT{Type: AnyAmbiguousAliasesM1, Value: x.UnPack()}
 	case AnyAmbiguousAliasesM2:
 		var x Monster
 		x.Init(table.Bytes, table.Pos)
-		return &AnyAmbiguousAliasesT{ Type: AnyAmbiguousAliasesM2, Value: x.UnPack() }
+		return &AnyAmbiguousAliasesT{Type: AnyAmbiguousAliasesM2, Value: x.UnPack()}
 	case AnyAmbiguousAliasesM3:
 		var x Monster
 		x.Init(table.Bytes, table.Pos)
-		return &AnyAmbiguousAliasesT{ Type: AnyAmbiguousAliasesM3, Value: x.UnPack() }
+		return &AnyAmbiguousAliasesT{Type: AnyAmbiguousAliasesM3, Value: x.UnPack()}
 	}
 	return nil
 }

tests/MyGame/Example/AnyUniqueAliases.cs

@@ -41,6 +41,31 @@ public class AnyUniqueAliasesUnion {
   }
 }
 
+
+
+static public class AnyUniqueAliasesVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos)
+  {
+    bool result = true;
+    switch((AnyUniqueAliases)typeId)
+    {
+      case AnyUniqueAliases.M:
+        result = MyGame.Example.MonsterVerify.Verify(verifier, tablePos);
+        break;
+      case AnyUniqueAliases.TS:
+        result = MyGame.Example.TestSimpleTableWithEnumVerify.Verify(verifier, tablePos);
+        break;
+      case AnyUniqueAliases.M2:
+        result = MyGame.Example2.MonsterVerify.Verify(verifier, tablePos);
+        break;
+      default: result = true;
+        break;
+    }
+    return result;
+  }
+}
+
 public class AnyUniqueAliasesUnion_JsonConverter : Newtonsoft.Json.JsonConverter {
   public override bool CanConvert(System.Type objectType) {
     return objectType == typeof(AnyUniqueAliasesUnion) || objectType == typeof(System.Collections.Generic.List<AnyUniqueAliasesUnion>);

tests/MyGame/Example/AnyUniqueAliases.go

@@ -3,8 +3,8 @@
 package Example
 
 import (
-	"strconv"
 	flatbuffers "github.com/google/flatbuffers/go"
+	"strconv"
 
 	MyGame__Example2 "MyGame/Example2"
 )
@@ -64,15 +64,15 @@ func (rcv AnyUniqueAliases) UnPack(table flatbuffers.Table) *AnyUniqueAliasesT {
 	case AnyUniqueAliasesM:
 		var x Monster
 		x.Init(table.Bytes, table.Pos)
-		return &AnyUniqueAliasesT{ Type: AnyUniqueAliasesM, Value: x.UnPack() }
+		return &AnyUniqueAliasesT{Type: AnyUniqueAliasesM, Value: x.UnPack()}
 	case AnyUniqueAliasesTS:
 		var x TestSimpleTableWithEnum
 		x.Init(table.Bytes, table.Pos)
-		return &AnyUniqueAliasesT{ Type: AnyUniqueAliasesTS, Value: x.UnPack() }
+		return &AnyUniqueAliasesT{Type: AnyUniqueAliasesTS, Value: x.UnPack()}
 	case AnyUniqueAliasesM2:
 		var x MyGame__Example2.Monster
 		x.Init(table.Bytes, table.Pos)
-		return &AnyUniqueAliasesT{ Type: AnyUniqueAliasesM2, Value: x.UnPack() }
+		return &AnyUniqueAliasesT{Type: AnyUniqueAliasesM2, Value: x.UnPack()}
 	}
 	return nil
 }

tests/MyGame/Example/ArrayTable.cs

@@ -17,6 +17,7 @@ public struct ArrayTable : IFlatbufferObject
   public static ArrayTable GetRootAsArrayTable(ByteBuffer _bb) { return GetRootAsArrayTable(_bb, new ArrayTable()); }
   public static ArrayTable GetRootAsArrayTable(ByteBuffer _bb, ArrayTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
   public static bool ArrayTableBufferHasIdentifier(ByteBuffer _bb) { return Table.__has_identifier(_bb, "ARRT"); }
+  public static bool VerifyArrayTable(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("ARRT", false, ArrayTableVerify.Verify); }
   public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public ArrayTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
@@ -72,4 +73,14 @@ public class ArrayTableT
 }
 
 
+static public class ArrayTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*A*/, 160 /*MyGame.Example.ArrayStruct*/, 8, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
 }

tests/MyGame/Example/ArrayTable.py

@@ -39,15 +39,24 @@ class ArrayTable(object):
             return obj
         return None
 
-def ArrayTableStart(builder): builder.StartObject(1)
+def ArrayTableStart(builder):
+    return builder.StartObject(1)
+
 def Start(builder):
     return ArrayTableStart(builder)
-def ArrayTableAddA(builder, a): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(a), 0)
+
+def ArrayTableAddA(builder, a):
+    return builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(a), 0)
+
 def AddA(builder, a):
     return ArrayTableAddA(builder, a)
-def ArrayTableEnd(builder): return builder.EndObject()
+
+def ArrayTableEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
     return ArrayTableEnd(builder)
+
 import MyGame.Example.ArrayStruct
 try:
     from typing import Optional

tests/MyGame/Example/Monster.cs

@@ -18,6 +18,7 @@ public struct Monster : IFlatbufferObject
   public static Monster GetRootAsMonster(ByteBuffer _bb) { return GetRootAsMonster(_bb, new Monster()); }
   public static Monster GetRootAsMonster(ByteBuffer _bb, Monster obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
   public static bool MonsterBufferHasIdentifier(ByteBuffer _bb) { return Table.__has_identifier(_bb, "MONS"); }
+  public static bool VerifyMonster(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("MONS", false, MonsterVerify.Verify); }
   public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Monster __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
@@ -1100,4 +1101,74 @@ public class MonsterT
 }
 
 
+static public class MonsterVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Pos*/, 32 /*MyGame.Example.Vec3*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*Mana*/, 2 /*short*/, 2, false)
+      && verifier.VerifyField(tablePos, 8 /*Hp*/, 2 /*short*/, 2, false)
+      && verifier.VerifyString(tablePos, 10 /*Name*/, true)
+      && verifier.VerifyVectorOfData(tablePos, 14 /*Inventory*/, 1 /*byte*/, false)
+      && verifier.VerifyField(tablePos, 16 /*Color*/, 1 /*MyGame.Example.Color*/, 1, false)
+      && verifier.VerifyField(tablePos, 18 /*TestType*/, 1 /*MyGame.Example.Any*/, 1, false)
+      && verifier.VerifyUnion(tablePos, 18, 20 /*Test*/, MyGame.Example.AnyVerify.Verify, false)
+      && verifier.VerifyVectorOfData(tablePos, 22 /*Test4*/, 4 /*MyGame.Example.Test*/, false)
+      && verifier.VerifyVectorOfStrings(tablePos, 24 /*Testarrayofstring*/, false)
+      && verifier.VerifyVectorOfTables(tablePos, 26 /*Testarrayoftables*/, MyGame.Example.MonsterVerify.Verify, false)
+      && verifier.VerifyTable(tablePos, 28 /*Enemy*/, MyGame.Example.MonsterVerify.Verify, false)
+      && verifier.VerifyNestedBuffer(tablePos, 30 /*Testnestedflatbuffer*/, MyGame.Example.MonsterVerify.Verify, false)
+      && verifier.VerifyTable(tablePos, 32 /*Testempty*/, MyGame.Example.StatVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 34 /*Testbool*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 36 /*Testhashs32Fnv1*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 38 /*Testhashu32Fnv1*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 40 /*Testhashs64Fnv1*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 42 /*Testhashu64Fnv1*/, 8 /*ulong*/, 8, false)
+      && verifier.VerifyField(tablePos, 44 /*Testhashs32Fnv1a*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 46 /*Testhashu32Fnv1a*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 48 /*Testhashs64Fnv1a*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 50 /*Testhashu64Fnv1a*/, 8 /*ulong*/, 8, false)
+      && verifier.VerifyVectorOfData(tablePos, 52 /*Testarrayofbools*/, 1 /*bool*/, false)
+      && verifier.VerifyField(tablePos, 54 /*Testf*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 56 /*Testf2*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 58 /*Testf3*/, 4 /*float*/, 4, false)
+      && verifier.VerifyVectorOfStrings(tablePos, 60 /*Testarrayofstring2*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 62 /*Testarrayofsortedstruct*/, 8 /*MyGame.Example.Ability*/, false)
+      && verifier.VerifyNestedBuffer(tablePos, 64 /*Flex*/, null, false)
+      && verifier.VerifyVectorOfData(tablePos, 66 /*Test5*/, 4 /*MyGame.Example.Test*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 68 /*VectorOfLongs*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 70 /*VectorOfDoubles*/, 8 /*double*/, false)
+      && verifier.VerifyTable(tablePos, 72 /*ParentNamespaceTest*/, MyGame.InParentNamespaceVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 74 /*VectorOfReferrables*/, MyGame.Example.ReferrableVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 76 /*SingleWeakReference*/, 8 /*ulong*/, 8, false)
+      && verifier.VerifyVectorOfData(tablePos, 78 /*VectorOfWeakReferences*/, 8 /*ulong*/, false)
+      && verifier.VerifyVectorOfTables(tablePos, 80 /*VectorOfStrongReferrables*/, MyGame.Example.ReferrableVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 82 /*CoOwningReference*/, 8 /*ulong*/, 8, false)
+      && verifier.VerifyVectorOfData(tablePos, 84 /*VectorOfCoOwningReferences*/, 8 /*ulong*/, false)
+      && verifier.VerifyField(tablePos, 86 /*NonOwningReference*/, 8 /*ulong*/, 8, false)
+      && verifier.VerifyVectorOfData(tablePos, 88 /*VectorOfNonOwningReferences*/, 8 /*ulong*/, false)
+      && verifier.VerifyField(tablePos, 90 /*AnyUniqueType*/, 1 /*MyGame.Example.AnyUniqueAliases*/, 1, false)
+      && verifier.VerifyUnion(tablePos, 90, 92 /*AnyUnique*/, MyGame.Example.AnyUniqueAliasesVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 94 /*AnyAmbiguousType*/, 1 /*MyGame.Example.AnyAmbiguousAliases*/, 1, false)
+      && verifier.VerifyUnion(tablePos, 94, 96 /*AnyAmbiguous*/, MyGame.Example.AnyAmbiguousAliasesVerify.Verify, false)
+      && verifier.VerifyVectorOfData(tablePos, 98 /*VectorOfEnums*/, 1 /*MyGame.Example.Color*/, false)
+      && verifier.VerifyField(tablePos, 100 /*SignedEnum*/, 1 /*MyGame.Example.Race*/, 1, false)
+      && verifier.VerifyNestedBuffer(tablePos, 102 /*Testrequirednestedflatbuffer*/, MyGame.Example.MonsterVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 104 /*ScalarKeySortedTables*/, MyGame.Example.StatVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 106 /*NativeInline*/, 4 /*MyGame.Example.Test*/, 2, false)
+      && verifier.VerifyField(tablePos, 108 /*LongEnumNonEnumDefault*/, 8 /*MyGame.Example.LongEnum*/, 8, false)
+      && verifier.VerifyField(tablePos, 110 /*LongEnumNormalDefault*/, 8 /*MyGame.Example.LongEnum*/, 8, false)
+      && verifier.VerifyField(tablePos, 112 /*NanDefault*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 114 /*InfDefault*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 116 /*PositiveInfDefault*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 118 /*InfinityDefault*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 120 /*PositiveInfinityDefault*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 122 /*NegativeInfDefault*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 124 /*NegativeInfinityDefault*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 126 /*DoubleInfDefault*/, 8 /*double*/, 8, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
 }

tests/MyGame/Example/Monster.go

@@ -4,8 +4,8 @@ package Example
 
 import (
 	"bytes"
-	"math"
 	flatbuffers "github.com/google/flatbuffers/go"
+	"math"
 
 	MyGame "MyGame"
 )
@@ -73,7 +73,9 @@ type MonsterT struct {
 }
 
 func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
-	if t == nil { return 0 }
+	if t == nil {
+		return 0
+	}
 	nameOffset := flatbuffers.UOffsetT(0)
 	if t.Name != "" {
 		nameOffset = builder.CreateString(t.Name)
@@ -83,7 +85,7 @@ func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
 		inventoryOffset = builder.CreateByteString(t.Inventory)
 	}
 	testOffset := t.Test.Pack(builder)
-	
+
 	test4Offset := flatbuffers.UOffsetT(0)
 	if t.Test4 != nil {
 		test4Length := len(t.Test4)
@@ -242,9 +244,9 @@ func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
 		vectorOfNonOwningReferencesOffset = builder.EndVector(vectorOfNonOwningReferencesLength)
 	}
 	anyUniqueOffset := t.AnyUnique.Pack(builder)
-	
+
 	anyAmbiguousOffset := t.AnyAmbiguous.Pack(builder)
-	
+
 	vectorOfEnumsOffset := flatbuffers.UOffsetT(0)
 	if t.VectorOfEnums != nil {
 		vectorOfEnumsLength := len(t.VectorOfEnums)
@@ -493,7 +495,9 @@ func (rcv *Monster) UnPackTo(t *MonsterT) {
 }
 
 func (rcv *Monster) UnPack() *MonsterT {
-	if rcv == nil { return nil }
+	if rcv == nil {
+		return nil
+	}
 	t := &MonsterT{}
 	rcv.UnPackTo(t)
 	return t
@@ -503,6 +507,8 @@ type Monster struct {
 	_tab flatbuffers.Table
 }
 
+const MonsterIdentifier = "MONS"
+
 func GetRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Monster {
 	n := flatbuffers.GetUOffsetT(buf[offset:])
 	x := &Monster{}
@@ -510,6 +516,15 @@ func GetRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Monster {
 	return x
 }
 
+func FinishMonsterBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	identifierBytes := []byte(MonsterIdentifier)
+	builder.FinishWithFileIdentifier(offset, identifierBytes)
+}
+
+func MonsterBufferHasIdentifier(buf []byte) bool {
+	return flatbuffers.BufferHasIdentifier(buf, MonsterIdentifier)
+}
+
 func GetSizePrefixedRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Monster {
 	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
 	x := &Monster{}
@@ -517,6 +532,15 @@ func GetSizePrefixedRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Mons
 	return x
 }
 
+func FinishSizePrefixedMonsterBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	identifierBytes := []byte(MonsterIdentifier)
+	builder.FinishSizePrefixedWithFileIdentifier(offset, identifierBytes)
+}
+
+func SizePrefixedMonsterBufferHasIdentifier(buf []byte) bool {
+	return flatbuffers.SizePrefixedBufferHasIdentifier(buf, MonsterIdentifier)
+}
+
 func (rcv *Monster) Init(buf []byte, i flatbuffers.UOffsetT) {
 	rcv._tab.Bytes = buf
 	rcv._tab.Pos = i
@@ -574,18 +598,18 @@ func (rcv *Monster) Name() []byte {
 func MonsterKeyCompare(o1, o2 flatbuffers.UOffsetT, buf []byte) bool {
 	obj1 := &Monster{}
 	obj2 := &Monster{}
-	obj1.Init(buf, flatbuffers.UOffsetT(len(buf)) - o1)
+	obj1.Init(buf, flatbuffers.UOffsetT(len(buf))-o1)
-	obj2.Init(buf, flatbuffers.UOffsetT(len(buf)) - o2)
+	obj2.Init(buf, flatbuffers.UOffsetT(len(buf))-o2)
 	return string(obj1.Name()) < string(obj2.Name())
 }
 
 func (rcv *Monster) LookupByKey(key string, vectorLocation flatbuffers.UOffsetT, buf []byte) bool {
-	span := flatbuffers.GetUOffsetT(buf[vectorLocation - 4:])
+	span := flatbuffers.GetUOffsetT(buf[vectorLocation-4:])
 	start := flatbuffers.UOffsetT(0)
 	bKey := []byte(key)
 	for span != 0 {
 		middle := span / 2
-		tableOffset := flatbuffers.GetIndirectOffset(buf, vectorLocation+ 4 * (start + middle))
+		tableOffset := flatbuffers.GetIndirectOffset(buf, vectorLocation+4*(start+middle))
 		obj := &Monster{}
 		obj.Init(buf, tableOffset)
 		comp := bytes.Compare(obj.Name(), bKey)
@@ -720,7 +744,7 @@ func (rcv *Monster) Testarrayoftables(obj *Monster, j int) bool {
 	return false
 }
 
-func (rcv *Monster) TestarrayoftablesByKey(obj *Monster, key string) bool{
+func (rcv *Monster) TestarrayoftablesByKey(obj *Monster, key string) bool {
 	o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
 	if o != 0 {
 		x := rcv._tab.Vector(o)
@@ -1135,7 +1159,7 @@ func (rcv *Monster) VectorOfReferrables(obj *Referrable, j int) bool {
 	return false
 }
 
-func (rcv *Monster) VectorOfReferrablesByKey(obj *Referrable, key uint64) bool{
+func (rcv *Monster) VectorOfReferrablesByKey(obj *Referrable, key uint64) bool {
 	o := flatbuffers.UOffsetT(rcv._tab.Offset(74))
 	if o != 0 {
 		x := rcv._tab.Vector(o)
@@ -1202,7 +1226,7 @@ func (rcv *Monster) VectorOfStrongReferrables(obj *Referrable, j int) bool {
 	return false
 }
 
-func (rcv *Monster) VectorOfStrongReferrablesByKey(obj *Referrable, key uint64) bool{
+func (rcv *Monster) VectorOfStrongReferrablesByKey(obj *Referrable, key uint64) bool {
 	o := flatbuffers.UOffsetT(rcv._tab.Offset(80))
 	if o != 0 {
 		x := rcv._tab.Vector(o)
@@ -1429,7 +1453,7 @@ func (rcv *Monster) ScalarKeySortedTables(obj *Stat, j int) bool {
 	return false
 }
 
-func (rcv *Monster) ScalarKeySortedTablesByKey(obj *Stat, key uint16) bool{
+func (rcv *Monster) ScalarKeySortedTablesByKey(obj *Stat, key uint16) bool {
 	o := flatbuffers.UOffsetT(rcv._tab.Offset(104))
 	if o != 0 {
 		x := rcv._tab.Vector(o)

tests/MyGame/Example/Monster.py

@@ -214,7 +214,7 @@ class Monster(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
         if o != 0:
             from MyGame.Example.Monster import Monster
-            return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o))
+            return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o))
         return 0
 
     # Monster
@@ -751,7 +751,7 @@ class Monster(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
         if o != 0:
             from MyGame.Example.Monster import Monster
-            return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o))
+            return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o))
         return 0
 
     # Monster
@@ -872,63 +872,120 @@ class Monster(object):
             return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
         return float('inf')
 
-def MonsterStart(builder): builder.StartObject(62)
+def MonsterStart(builder):
+    return builder.StartObject(62)
+
 def Start(builder):
     return MonsterStart(builder)
-def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
+
+def MonsterAddPos(builder, pos):
+    return builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
+
 def AddPos(builder, pos):
     return MonsterAddPos(builder, pos)
-def MonsterAddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150)
+
+def MonsterAddMana(builder, mana):
+    return builder.PrependInt16Slot(1, mana, 150)
+
 def AddMana(builder, mana):
     return MonsterAddMana(builder, mana)
-def MonsterAddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100)
+
+def MonsterAddHp(builder, hp):
+    return builder.PrependInt16Slot(2, hp, 100)
+
 def AddHp(builder, hp):
     return MonsterAddHp(builder, hp)
-def MonsterAddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
+def MonsterAddName(builder, name):
+    return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
 def AddName(builder, name):
     return MonsterAddName(builder, name)
-def MonsterAddInventory(builder, inventory): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
+
+def MonsterAddInventory(builder, inventory):
+    return builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
+
 def AddInventory(builder, inventory):
     return MonsterAddInventory(builder, inventory)
-def MonsterStartInventoryVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+
+def MonsterStartInventoryVector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
 def StartInventoryVector(builder, numElems):
     return MonsterStartInventoryVector(builder, numElems)
-def MonsterAddColor(builder, color): builder.PrependUint8Slot(6, color, 8)
+
+def MonsterAddColor(builder, color):
+    return builder.PrependUint8Slot(6, color, 8)
+
 def AddColor(builder, color):
     return MonsterAddColor(builder, color)
-def MonsterAddTestType(builder, testType): builder.PrependUint8Slot(7, testType, 0)
+
+def MonsterAddTestType(builder, testType):
+    return builder.PrependUint8Slot(7, testType, 0)
+
 def AddTestType(builder, testType):
     return MonsterAddTestType(builder, testType)
-def MonsterAddTest(builder, test): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
+
+def MonsterAddTest(builder, test):
+    return builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
+
 def AddTest(builder, test):
     return MonsterAddTest(builder, test)
-def MonsterAddTest4(builder, test4): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
+
+def MonsterAddTest4(builder, test4):
+    return builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
+
 def AddTest4(builder, test4):
     return MonsterAddTest4(builder, test4)
-def MonsterStartTest4Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
+
+def MonsterStartTest4Vector(builder, numElems):
+    return builder.StartVector(4, numElems, 2)
+
 def StartTest4Vector(builder, numElems):
     return MonsterStartTest4Vector(builder, numElems)
-def MonsterAddTestarrayofstring(builder, testarrayofstring): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
+
+def MonsterAddTestarrayofstring(builder, testarrayofstring):
+    return builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
+
 def AddTestarrayofstring(builder, testarrayofstring):
     return MonsterAddTestarrayofstring(builder, testarrayofstring)
-def MonsterStartTestarrayofstringVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def MonsterStartTestarrayofstringVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartTestarrayofstringVector(builder, numElems):
     return MonsterStartTestarrayofstringVector(builder, numElems)
-def MonsterAddTestarrayoftables(builder, testarrayoftables): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
+
+def MonsterAddTestarrayoftables(builder, testarrayoftables):
+    return builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
+
 def AddTestarrayoftables(builder, testarrayoftables):
     return MonsterAddTestarrayoftables(builder, testarrayoftables)
-def MonsterStartTestarrayoftablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def MonsterStartTestarrayoftablesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartTestarrayoftablesVector(builder, numElems):
     return MonsterStartTestarrayoftablesVector(builder, numElems)
-def MonsterAddEnemy(builder, enemy): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
+
+def MonsterAddEnemy(builder, enemy):
+    return builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
+
 def AddEnemy(builder, enemy):
     return MonsterAddEnemy(builder, enemy)
-def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
+
+def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer):
+    return builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
+
 def AddTestnestedflatbuffer(builder, testnestedflatbuffer):
     return MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
-def MonsterStartTestnestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+
+def MonsterStartTestnestedflatbufferVector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
 def StartTestnestedflatbufferVector(builder, numElems):
     return MonsterStartTestnestedflatbufferVector(builder, numElems)
+
 def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes):
     builder.StartVector(1, len(bytes), 1)
     builder.head = builder.head - len(bytes)
@@ -936,156 +993,306 @@ def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes):
     return builder.EndVector()
 def MakeTestnestedflatbufferVectorFromBytes(builder, bytes):
     return MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes)
-def MonsterAddTestempty(builder, testempty): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
+def MonsterAddTestempty(builder, testempty):
+    return builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
+
 def AddTestempty(builder, testempty):
     return MonsterAddTestempty(builder, testempty)
-def MonsterAddTestbool(builder, testbool): builder.PrependBoolSlot(15, testbool, 0)
+
+def MonsterAddTestbool(builder, testbool):
+    return builder.PrependBoolSlot(15, testbool, 0)
+
 def AddTestbool(builder, testbool):
     return MonsterAddTestbool(builder, testbool)
-def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1): builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
+
+def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1):
+    return builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
+
 def AddTesthashs32Fnv1(builder, testhashs32Fnv1):
     return MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1)
-def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1): builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
+
+def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1):
+    return builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
+
 def AddTesthashu32Fnv1(builder, testhashu32Fnv1):
     return MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1)
-def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1): builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
+
+def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1):
+    return builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
+
 def AddTesthashs64Fnv1(builder, testhashs64Fnv1):
     return MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1)
-def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1): builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
+
+def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1):
+    return builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
+
 def AddTesthashu64Fnv1(builder, testhashu64Fnv1):
     return MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1)
-def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a): builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
+
+def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
+    return builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
+
 def AddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
     return MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a)
-def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a): builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
+
+def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
+    return builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
+
 def AddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
     return MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a)
-def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a): builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
+
+def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
+    return builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
+
 def AddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
     return MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a)
-def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a): builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
+
+def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
+    return builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
+
 def AddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
     return MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a)
-def MonsterAddTestarrayofbools(builder, testarrayofbools): builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
+
+def MonsterAddTestarrayofbools(builder, testarrayofbools):
+    return builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
+
 def AddTestarrayofbools(builder, testarrayofbools):
     return MonsterAddTestarrayofbools(builder, testarrayofbools)
-def MonsterStartTestarrayofboolsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+
+def MonsterStartTestarrayofboolsVector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
 def StartTestarrayofboolsVector(builder, numElems):
     return MonsterStartTestarrayofboolsVector(builder, numElems)
-def MonsterAddTestf(builder, testf): builder.PrependFloat32Slot(25, testf, 3.14159)
+
+def MonsterAddTestf(builder, testf):
+    return builder.PrependFloat32Slot(25, testf, 3.14159)
+
 def AddTestf(builder, testf):
     return MonsterAddTestf(builder, testf)
-def MonsterAddTestf2(builder, testf2): builder.PrependFloat32Slot(26, testf2, 3.0)
+
+def MonsterAddTestf2(builder, testf2):
+    return builder.PrependFloat32Slot(26, testf2, 3.0)
+
 def AddTestf2(builder, testf2):
     return MonsterAddTestf2(builder, testf2)
-def MonsterAddTestf3(builder, testf3): builder.PrependFloat32Slot(27, testf3, 0.0)
+
+def MonsterAddTestf3(builder, testf3):
+    return builder.PrependFloat32Slot(27, testf3, 0.0)
+
 def AddTestf3(builder, testf3):
     return MonsterAddTestf3(builder, testf3)
-def MonsterAddTestarrayofstring2(builder, testarrayofstring2): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
+
+def MonsterAddTestarrayofstring2(builder, testarrayofstring2):
+    return builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
+
 def AddTestarrayofstring2(builder, testarrayofstring2):
     return MonsterAddTestarrayofstring2(builder, testarrayofstring2)
-def MonsterStartTestarrayofstring2Vector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def MonsterStartTestarrayofstring2Vector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartTestarrayofstring2Vector(builder, numElems):
     return MonsterStartTestarrayofstring2Vector(builder, numElems)
-def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
+
+def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
+    return builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
+
 def AddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
     return MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
-def MonsterStartTestarrayofsortedstructVector(builder, numElems): return builder.StartVector(8, numElems, 4)
+
+def MonsterStartTestarrayofsortedstructVector(builder, numElems):
+    return builder.StartVector(8, numElems, 4)
+
 def StartTestarrayofsortedstructVector(builder, numElems):
     return MonsterStartTestarrayofsortedstructVector(builder, numElems)
-def MonsterAddFlex(builder, flex): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
+
+def MonsterAddFlex(builder, flex):
+    return builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
+
 def AddFlex(builder, flex):
     return MonsterAddFlex(builder, flex)
-def MonsterStartFlexVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+
+def MonsterStartFlexVector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
 def StartFlexVector(builder, numElems):
     return MonsterStartFlexVector(builder, numElems)
-def MonsterAddTest5(builder, test5): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
+
+def MonsterAddTest5(builder, test5):
+    return builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
+
 def AddTest5(builder, test5):
     return MonsterAddTest5(builder, test5)
-def MonsterStartTest5Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
+
+def MonsterStartTest5Vector(builder, numElems):
+    return builder.StartVector(4, numElems, 2)
+
 def StartTest5Vector(builder, numElems):
     return MonsterStartTest5Vector(builder, numElems)
-def MonsterAddVectorOfLongs(builder, vectorOfLongs): builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
+
+def MonsterAddVectorOfLongs(builder, vectorOfLongs):
+    return builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
+
 def AddVectorOfLongs(builder, vectorOfLongs):
     return MonsterAddVectorOfLongs(builder, vectorOfLongs)
-def MonsterStartVectorOfLongsVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+
+def MonsterStartVectorOfLongsVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
 def StartVectorOfLongsVector(builder, numElems):
     return MonsterStartVectorOfLongsVector(builder, numElems)
-def MonsterAddVectorOfDoubles(builder, vectorOfDoubles): builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
+
+def MonsterAddVectorOfDoubles(builder, vectorOfDoubles):
+    return builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
+
 def AddVectorOfDoubles(builder, vectorOfDoubles):
     return MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
-def MonsterStartVectorOfDoublesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+
+def MonsterStartVectorOfDoublesVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
 def StartVectorOfDoublesVector(builder, numElems):
     return MonsterStartVectorOfDoublesVector(builder, numElems)
-def MonsterAddParentNamespaceTest(builder, parentNamespaceTest): builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
+
+def MonsterAddParentNamespaceTest(builder, parentNamespaceTest):
+    return builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
+
 def AddParentNamespaceTest(builder, parentNamespaceTest):
     return MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
-def MonsterAddVectorOfReferrables(builder, vectorOfReferrables): builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
+
+def MonsterAddVectorOfReferrables(builder, vectorOfReferrables):
+    return builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
+
 def AddVectorOfReferrables(builder, vectorOfReferrables):
     return MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
-def MonsterStartVectorOfReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def MonsterStartVectorOfReferrablesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartVectorOfReferrablesVector(builder, numElems):
     return MonsterStartVectorOfReferrablesVector(builder, numElems)
-def MonsterAddSingleWeakReference(builder, singleWeakReference): builder.PrependUint64Slot(36, singleWeakReference, 0)
+
+def MonsterAddSingleWeakReference(builder, singleWeakReference):
+    return builder.PrependUint64Slot(36, singleWeakReference, 0)
+
 def AddSingleWeakReference(builder, singleWeakReference):
     return MonsterAddSingleWeakReference(builder, singleWeakReference)
-def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences): builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
+
+def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences):
+    return builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
+
 def AddVectorOfWeakReferences(builder, vectorOfWeakReferences):
     return MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
-def MonsterStartVectorOfWeakReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+
+def MonsterStartVectorOfWeakReferencesVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
 def StartVectorOfWeakReferencesVector(builder, numElems):
     return MonsterStartVectorOfWeakReferencesVector(builder, numElems)
-def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
+
+def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
+    return builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
+
 def AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
     return MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
-def MonsterStartVectorOfStrongReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def MonsterStartVectorOfStrongReferrablesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartVectorOfStrongReferrablesVector(builder, numElems):
     return MonsterStartVectorOfStrongReferrablesVector(builder, numElems)
-def MonsterAddCoOwningReference(builder, coOwningReference): builder.PrependUint64Slot(39, coOwningReference, 0)
+
+def MonsterAddCoOwningReference(builder, coOwningReference):
+    return builder.PrependUint64Slot(39, coOwningReference, 0)
+
 def AddCoOwningReference(builder, coOwningReference):
     return MonsterAddCoOwningReference(builder, coOwningReference)
-def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
+
+def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
+    return builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
+
 def AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
     return MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
-def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+
+def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
 def StartVectorOfCoOwningReferencesVector(builder, numElems):
     return MonsterStartVectorOfCoOwningReferencesVector(builder, numElems)
-def MonsterAddNonOwningReference(builder, nonOwningReference): builder.PrependUint64Slot(41, nonOwningReference, 0)
+
+def MonsterAddNonOwningReference(builder, nonOwningReference):
+    return builder.PrependUint64Slot(41, nonOwningReference, 0)
+
 def AddNonOwningReference(builder, nonOwningReference):
     return MonsterAddNonOwningReference(builder, nonOwningReference)
-def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
+
+def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
+    return builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
+
 def AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
     return MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
-def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+
+def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
 def StartVectorOfNonOwningReferencesVector(builder, numElems):
     return MonsterStartVectorOfNonOwningReferencesVector(builder, numElems)
-def MonsterAddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43, anyUniqueType, 0)
+
+def MonsterAddAnyUniqueType(builder, anyUniqueType):
+    return builder.PrependUint8Slot(43, anyUniqueType, 0)
+
 def AddAnyUniqueType(builder, anyUniqueType):
     return MonsterAddAnyUniqueType(builder, anyUniqueType)
-def MonsterAddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
+
+def MonsterAddAnyUnique(builder, anyUnique):
+    return builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
+
 def AddAnyUnique(builder, anyUnique):
     return MonsterAddAnyUnique(builder, anyUnique)
-def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0)
+
+def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType):
+    return builder.PrependUint8Slot(45, anyAmbiguousType, 0)
+
 def AddAnyAmbiguousType(builder, anyAmbiguousType):
     return MonsterAddAnyAmbiguousType(builder, anyAmbiguousType)
-def MonsterAddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
+
+def MonsterAddAnyAmbiguous(builder, anyAmbiguous):
+    return builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
+
 def AddAnyAmbiguous(builder, anyAmbiguous):
     return MonsterAddAnyAmbiguous(builder, anyAmbiguous)
-def MonsterAddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
+
+def MonsterAddVectorOfEnums(builder, vectorOfEnums):
+    return builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
+
 def AddVectorOfEnums(builder, vectorOfEnums):
     return MonsterAddVectorOfEnums(builder, vectorOfEnums)
-def MonsterStartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+
+def MonsterStartVectorOfEnumsVector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
 def StartVectorOfEnumsVector(builder, numElems):
     return MonsterStartVectorOfEnumsVector(builder, numElems)
-def MonsterAddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1)
+
+def MonsterAddSignedEnum(builder, signedEnum):
+    return builder.PrependInt8Slot(48, signedEnum, -1)
+
 def AddSignedEnum(builder, signedEnum):
     return MonsterAddSignedEnum(builder, signedEnum)
-def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
+
+def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
+    return builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
+
 def AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
     return MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
-def MonsterStartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+
+def MonsterStartTestrequirednestedflatbufferVector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
 def StartTestrequirednestedflatbufferVector(builder, numElems):
     return MonsterStartTestrequirednestedflatbufferVector(builder, numElems)
+
 def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
     builder.StartVector(1, len(bytes), 1)
     builder.head = builder.head - len(bytes)
@@ -1093,48 +1300,90 @@ def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
     return builder.EndVector()
 def MakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
     return MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes)
-def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables): builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
+def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables):
+    return builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
+
 def AddScalarKeySortedTables(builder, scalarKeySortedTables):
     return MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
-def MonsterStartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def MonsterStartScalarKeySortedTablesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartScalarKeySortedTablesVector(builder, numElems):
     return MonsterStartScalarKeySortedTablesVector(builder, numElems)
-def MonsterAddNativeInline(builder, nativeInline): builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
+
+def MonsterAddNativeInline(builder, nativeInline):
+    return builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
+
 def AddNativeInline(builder, nativeInline):
     return MonsterAddNativeInline(builder, nativeInline)
-def MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault): builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0)
+
+def MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault):
+    return builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0)
+
 def AddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault):
     return MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault)
-def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault): builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
+
+def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault):
+    return builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
+
 def AddLongEnumNormalDefault(builder, longEnumNormalDefault):
     return MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault)
-def MonsterAddNanDefault(builder, nanDefault): builder.PrependFloat32Slot(54, nanDefault, float('nan'))
+
+def MonsterAddNanDefault(builder, nanDefault):
+    return builder.PrependFloat32Slot(54, nanDefault, float('nan'))
+
 def AddNanDefault(builder, nanDefault):
     return MonsterAddNanDefault(builder, nanDefault)
-def MonsterAddInfDefault(builder, infDefault): builder.PrependFloat32Slot(55, infDefault, float('inf'))
+
+def MonsterAddInfDefault(builder, infDefault):
+    return builder.PrependFloat32Slot(55, infDefault, float('inf'))
+
 def AddInfDefault(builder, infDefault):
     return MonsterAddInfDefault(builder, infDefault)
-def MonsterAddPositiveInfDefault(builder, positiveInfDefault): builder.PrependFloat32Slot(56, positiveInfDefault, float('inf'))
+
+def MonsterAddPositiveInfDefault(builder, positiveInfDefault):
+    return builder.PrependFloat32Slot(56, positiveInfDefault, float('inf'))
+
 def AddPositiveInfDefault(builder, positiveInfDefault):
     return MonsterAddPositiveInfDefault(builder, positiveInfDefault)
-def MonsterAddInfinityDefault(builder, infinityDefault): builder.PrependFloat32Slot(57, infinityDefault, float('inf'))
+
+def MonsterAddInfinityDefault(builder, infinityDefault):
+    return builder.PrependFloat32Slot(57, infinityDefault, float('inf'))
+
 def AddInfinityDefault(builder, infinityDefault):
     return MonsterAddInfinityDefault(builder, infinityDefault)
-def MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault): builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf'))
+
+def MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault):
+    return builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf'))
+
 def AddPositiveInfinityDefault(builder, positiveInfinityDefault):
     return MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault)
-def MonsterAddNegativeInfDefault(builder, negativeInfDefault): builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf'))
+
+def MonsterAddNegativeInfDefault(builder, negativeInfDefault):
+    return builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf'))
+
 def AddNegativeInfDefault(builder, negativeInfDefault):
     return MonsterAddNegativeInfDefault(builder, negativeInfDefault)
-def MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault): builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf'))
+
+def MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault):
+    return builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf'))
+
 def AddNegativeInfinityDefault(builder, negativeInfinityDefault):
     return MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault)
-def MonsterAddDoubleInfDefault(builder, doubleInfDefault): builder.PrependFloat64Slot(61, doubleInfDefault, float('inf'))
+
+def MonsterAddDoubleInfDefault(builder, doubleInfDefault):
+    return builder.PrependFloat64Slot(61, doubleInfDefault, float('inf'))
+
 def AddDoubleInfDefault(builder, doubleInfDefault):
     return MonsterAddDoubleInfDefault(builder, doubleInfDefault)
-def MonsterEnd(builder): return builder.EndObject()
+
+def MonsterEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
     return MonsterEnd(builder)
+
 import MyGame.Example.Ability
 import MyGame.Example.Any
 import MyGame.Example.AnyAmbiguousAliases

tests/MyGame/Example/NestedUnion/NestedUnionTest.py

@@ -55,24 +55,42 @@ class NestedUnionTest(object):
             return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
         return 0
 
-def NestedUnionTestStart(builder): builder.StartObject(4)
+def NestedUnionTestStart(builder):
+    return builder.StartObject(4)
+
 def Start(builder):
     return NestedUnionTestStart(builder)
-def NestedUnionTestAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
+def NestedUnionTestAddName(builder, name):
+    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
 def AddName(builder, name):
     return NestedUnionTestAddName(builder, name)
-def NestedUnionTestAddDataType(builder, dataType): builder.PrependUint8Slot(1, dataType, 0)
+
+def NestedUnionTestAddDataType(builder, dataType):
+    return builder.PrependUint8Slot(1, dataType, 0)
+
 def AddDataType(builder, dataType):
     return NestedUnionTestAddDataType(builder, dataType)
-def NestedUnionTestAddData(builder, data): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0)
+
+def NestedUnionTestAddData(builder, data):
+    return builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0)
+
 def AddData(builder, data):
     return NestedUnionTestAddData(builder, data)
-def NestedUnionTestAddId(builder, id): builder.PrependInt16Slot(3, id, 0)
+
+def NestedUnionTestAddId(builder, id):
+    return builder.PrependInt16Slot(3, id, 0)
+
 def AddId(builder, id):
     return NestedUnionTestAddId(builder, id)
-def NestedUnionTestEnd(builder): return builder.EndObject()
+
+def NestedUnionTestEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
     return NestedUnionTestEnd(builder)
+
 import MyGame.Example.NestedUnion.Any
 import MyGame.Example.NestedUnion.TestSimpleTableWithEnum
 import MyGame.Example.NestedUnion.Vec3

tests/MyGame/Example/NestedUnion/TestSimpleTableWithEnum.py

@@ -31,16 +31,25 @@ class TestSimpleTableWithEnum(object):
             return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
         return 2
 
-def TestSimpleTableWithEnumStart(builder): builder.StartObject(1)
+def TestSimpleTableWithEnumStart(builder):
+    return builder.StartObject(1)
+
 def Start(builder):
     return TestSimpleTableWithEnumStart(builder)
-def TestSimpleTableWithEnumAddColor(builder, color): builder.PrependUint8Slot(0, color, 2)
+
+def TestSimpleTableWithEnumAddColor(builder, color):
+    return builder.PrependUint8Slot(0, color, 2)
+
 def AddColor(builder, color):
     return TestSimpleTableWithEnumAddColor(builder, color)
-def TestSimpleTableWithEnumEnd(builder): return builder.EndObject()
+
+def TestSimpleTableWithEnumEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
     return TestSimpleTableWithEnumEnd(builder)
 
+
 class TestSimpleTableWithEnumT(object):
 
     # TestSimpleTableWithEnumT

tests/MyGame/Example/NestedUnion/Vec3.py

@@ -70,30 +70,54 @@ class Vec3(object):
             return obj
         return None
 
-def Vec3Start(builder): builder.StartObject(6)
+def Vec3Start(builder):
+    return builder.StartObject(6)
+
 def Start(builder):
     return Vec3Start(builder)
-def Vec3AddX(builder, x): builder.PrependFloat64Slot(0, x, 0.0)
+
+def Vec3AddX(builder, x):
+    return builder.PrependFloat64Slot(0, x, 0.0)
+
 def AddX(builder, x):
     return Vec3AddX(builder, x)
-def Vec3AddY(builder, y): builder.PrependFloat64Slot(1, y, 0.0)
+
+def Vec3AddY(builder, y):
+    return builder.PrependFloat64Slot(1, y, 0.0)
+
 def AddY(builder, y):
     return Vec3AddY(builder, y)
-def Vec3AddZ(builder, z): builder.PrependFloat64Slot(2, z, 0.0)
+
+def Vec3AddZ(builder, z):
+    return builder.PrependFloat64Slot(2, z, 0.0)
+
 def AddZ(builder, z):
     return Vec3AddZ(builder, z)
-def Vec3AddTest1(builder, test1): builder.PrependFloat64Slot(3, test1, 0.0)
+
+def Vec3AddTest1(builder, test1):
+    return builder.PrependFloat64Slot(3, test1, 0.0)
+
 def AddTest1(builder, test1):
     return Vec3AddTest1(builder, test1)
-def Vec3AddTest2(builder, test2): builder.PrependUint8Slot(4, test2, 0)
+
+def Vec3AddTest2(builder, test2):
+    return builder.PrependUint8Slot(4, test2, 0)
+
 def AddTest2(builder, test2):
     return Vec3AddTest2(builder, test2)
-def Vec3AddTest3(builder, test3): builder.PrependStructSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(test3), 0)
+
+def Vec3AddTest3(builder, test3):
+    return builder.PrependStructSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(test3), 0)
+
 def AddTest3(builder, test3):
     return Vec3AddTest3(builder, test3)
-def Vec3End(builder): return builder.EndObject()
+
+def Vec3End(builder):
+    return builder.EndObject()
+
 def End(builder):
     return Vec3End(builder)
+
 import MyGame.Example.NestedUnion.Test
 try:
     from typing import Optional

tests/MyGame/Example/Referrable.cs

@@ -92,4 +92,14 @@ public class ReferrableT
 }
 
 
+static public class ReferrableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Id*/, 8 /*ulong*/, 8, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
 }

tests/MyGame/Example/Referrable.go

@@ -11,7 +11,9 @@ type ReferrableT struct {
 }
 
 func (t *ReferrableT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
-	if t == nil { return 0 }
+	if t == nil {
+		return 0
+	}
 	ReferrableStart(builder)
 	ReferrableAddId(builder, t.Id)
 	return ReferrableEnd(builder)
@@ -22,7 +24,9 @@ func (rcv *Referrable) UnPackTo(t *ReferrableT) {
 }
 
 func (rcv *Referrable) UnPack() *ReferrableT {
-	if rcv == nil { return nil }
+	if rcv == nil {
+		return nil
+	}
 	t := &ReferrableT{}
 	rcv.UnPackTo(t)
 	return t
@@ -39,6 +43,10 @@ func GetRootAsReferrable(buf []byte, offset flatbuffers.UOffsetT) *Referrable {
 	return x
 }
 
+func FinishReferrableBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
 func GetSizePrefixedRootAsReferrable(buf []byte, offset flatbuffers.UOffsetT) *Referrable {
 	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
 	x := &Referrable{}
@@ -46,6 +54,10 @@ func GetSizePrefixedRootAsReferrable(buf []byte, offset flatbuffers.UOffsetT) *R
 	return x
 }
 
+func FinishSizePrefixedReferrableBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
 func (rcv *Referrable) Init(buf []byte, i flatbuffers.UOffsetT) {
 	rcv._tab.Bytes = buf
 	rcv._tab.Pos = i
@@ -70,17 +82,17 @@ func (rcv *Referrable) MutateId(n uint64) bool {
 func ReferrableKeyCompare(o1, o2 flatbuffers.UOffsetT, buf []byte) bool {
 	obj1 := &Referrable{}
 	obj2 := &Referrable{}
-	obj1.Init(buf, flatbuffers.UOffsetT(len(buf)) - o1)
+	obj1.Init(buf, flatbuffers.UOffsetT(len(buf))-o1)
-	obj2.Init(buf, flatbuffers.UOffsetT(len(buf)) - o2)
+	obj2.Init(buf, flatbuffers.UOffsetT(len(buf))-o2)
 	return obj1.Id() < obj2.Id()
 }
 
 func (rcv *Referrable) LookupByKey(key uint64, vectorLocation flatbuffers.UOffsetT, buf []byte) bool {
-	span := flatbuffers.GetUOffsetT(buf[vectorLocation - 4:])
+	span := flatbuffers.GetUOffsetT(buf[vectorLocation-4:])
 	start := flatbuffers.UOffsetT(0)
 	for span != 0 {
 		middle := span / 2
-		tableOffset := flatbuffers.GetIndirectOffset(buf, vectorLocation+ 4 * (start + middle))
+		tableOffset := flatbuffers.GetIndirectOffset(buf, vectorLocation+4*(start+middle))
 		obj := &Referrable{}
 		obj.Init(buf, tableOffset)
 		val := obj.Id()

tests/MyGame/Example/Referrable.py

@@ -35,16 +35,25 @@ class Referrable(object):
             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
         return 0
 
-def ReferrableStart(builder): builder.StartObject(1)
+def ReferrableStart(builder):
+    return builder.StartObject(1)
+
 def Start(builder):
     return ReferrableStart(builder)
-def ReferrableAddId(builder, id): builder.PrependUint64Slot(0, id, 0)
+
+def ReferrableAddId(builder, id):
+    return builder.PrependUint64Slot(0, id, 0)
+
 def AddId(builder, id):
     return ReferrableAddId(builder, id)
-def ReferrableEnd(builder): return builder.EndObject()
+
+def ReferrableEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
     return ReferrableEnd(builder)
 
+
 class ReferrableT(object):
 
     # ReferrableT

tests/MyGame/Example/Stat.cs

@@ -117,4 +117,16 @@ public class StatT
 }
 
 
+static public class StatVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyString(tablePos, 4 /*Id*/, false)
+      && verifier.VerifyField(tablePos, 6 /*Val*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 8 /*Count*/, 2 /*ushort*/, 2, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
 }

tests/MyGame/Example/Stat.go

@@ -13,7 +13,9 @@ type StatT struct {
 }
 
 func (t *StatT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
-	if t == nil { return 0 }
+	if t == nil {
+		return 0
+	}
 	idOffset := flatbuffers.UOffsetT(0)
 	if t.Id != "" {
 		idOffset = builder.CreateString(t.Id)
@@ -32,7 +34,9 @@ func (rcv *Stat) UnPackTo(t *StatT) {
 }
 
 func (rcv *Stat) UnPack() *StatT {
-	if rcv == nil { return nil }
+	if rcv == nil {
+		return nil
+	}
 	t := &StatT{}
 	rcv.UnPackTo(t)
 	return t
@@ -49,6 +53,10 @@ func GetRootAsStat(buf []byte, offset flatbuffers.UOffsetT) *Stat {
 	return x
 }
 
+func FinishStatBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
 func GetSizePrefixedRootAsStat(buf []byte, offset flatbuffers.UOffsetT) *Stat {
 	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
 	x := &Stat{}
@@ -56,6 +64,10 @@ func GetSizePrefixedRootAsStat(buf []byte, offset flatbuffers.UOffsetT) *Stat {
 	return x
 }
 
+func FinishSizePrefixedStatBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
 func (rcv *Stat) Init(buf []byte, i flatbuffers.UOffsetT) {
 	rcv._tab.Bytes = buf
 	rcv._tab.Pos = i
@@ -100,17 +112,17 @@ func (rcv *Stat) MutateCount(n uint16) bool {
 func StatKeyCompare(o1, o2 flatbuffers.UOffsetT, buf []byte) bool {
 	obj1 := &Stat{}
 	obj2 := &Stat{}
-	obj1.Init(buf, flatbuffers.UOffsetT(len(buf)) - o1)
+	obj1.Init(buf, flatbuffers.UOffsetT(len(buf))-o1)
-	obj2.Init(buf, flatbuffers.UOffsetT(len(buf)) - o2)
+	obj2.Init(buf, flatbuffers.UOffsetT(len(buf))-o2)
 	return obj1.Count() < obj2.Count()
 }
 
 func (rcv *Stat) LookupByKey(key uint16, vectorLocation flatbuffers.UOffsetT, buf []byte) bool {
-	span := flatbuffers.GetUOffsetT(buf[vectorLocation - 4:])
+	span := flatbuffers.GetUOffsetT(buf[vectorLocation-4:])
 	start := flatbuffers.UOffsetT(0)
 	for span != 0 {
 		middle := span / 2
-		tableOffset := flatbuffers.GetIndirectOffset(buf, vectorLocation+ 4 * (start + middle))
+		tableOffset := flatbuffers.GetIndirectOffset(buf, vectorLocation+4*(start+middle))
 		obj := &Stat{}
 		obj.Init(buf, tableOffset)
 		val := obj.Count()

tests/MyGame/Example/Stat.py

@@ -49,22 +49,37 @@ class Stat(object):
             return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
         return 0
 
-def StatStart(builder): builder.StartObject(3)
+def StatStart(builder):
+    return builder.StartObject(3)
+
 def Start(builder):
     return StatStart(builder)
-def StatAddId(builder, id): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
+
+def StatAddId(builder, id):
+    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
+
 def AddId(builder, id):
     return StatAddId(builder, id)
-def StatAddVal(builder, val): builder.PrependInt64Slot(1, val, 0)
+
+def StatAddVal(builder, val):
+    return builder.PrependInt64Slot(1, val, 0)
+
 def AddVal(builder, val):
     return StatAddVal(builder, val)
-def StatAddCount(builder, count): builder.PrependUint16Slot(2, count, 0)
+
+def StatAddCount(builder, count):
+    return builder.PrependUint16Slot(2, count, 0)
+
 def AddCount(builder, count):
     return StatAddCount(builder, count)
-def StatEnd(builder): return builder.EndObject()
+
+def StatEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
     return StatEnd(builder)
 
+
 class StatT(object):
 
     # StatT

tests/MyGame/Example/StructOfStructs.go

@@ -13,7 +13,9 @@ type StructOfStructsT struct {
 }
 
 func (t *StructOfStructsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
-	if t == nil { return 0 }
+	if t == nil {
+		return 0
+	}
 	return CreateStructOfStructs(builder, t.A.Id, t.A.Distance, t.B.A, t.B.B, t.C.Id, t.C.Distance)
 }
 func (rcv *StructOfStructs) UnPackTo(t *StructOfStructsT) {
@@ -23,7 +25,9 @@ func (rcv *StructOfStructs) UnPackTo(t *StructOfStructsT) {
 }
 
 func (rcv *StructOfStructs) UnPack() *StructOfStructsT {
-	if rcv == nil { return nil }
+	if rcv == nil {
+		return nil
+	}
 	t := &StructOfStructsT{}
 	rcv.UnPackTo(t)
 	return t

tests/MyGame/Example/StructOfStructsOfStructs.go

@@ -11,7 +11,9 @@ type StructOfStructsOfStructsT struct {
 }
 
 func (t *StructOfStructsOfStructsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
-	if t == nil { return 0 }
+	if t == nil {
+		return 0
+	}
 	return CreateStructOfStructsOfStructs(builder, t.A.A.Id, t.A.A.Distance, t.A.B.A, t.A.B.B, t.A.C.Id, t.A.C.Distance)
 }
 func (rcv *StructOfStructsOfStructs) UnPackTo(t *StructOfStructsOfStructsT) {
@@ -19,7 +21,9 @@ func (rcv *StructOfStructsOfStructs) UnPackTo(t *StructOfStructsOfStructsT) {
 }
 
 func (rcv *StructOfStructsOfStructs) UnPack() *StructOfStructsOfStructsT {
-	if rcv == nil { return nil }
+	if rcv == nil {
+		return nil
+	}
 	t := &StructOfStructsOfStructsT{}
 	rcv.UnPackTo(t)
 	return t

tests/MyGame/Example/Test.go

@@ -12,7 +12,9 @@ type TestT struct {
 }
 
 func (t *TestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
-	if t == nil { return 0 }
+	if t == nil {
+		return 0
+	}
 	return CreateTest(builder, t.A, t.B)
 }
 func (rcv *Test) UnPackTo(t *TestT) {
@@ -21,7 +23,9 @@ func (rcv *Test) UnPackTo(t *TestT) {
 }
 
 func (rcv *Test) UnPack() *TestT {
-	if rcv == nil { return nil }
+	if rcv == nil {
+		return nil
+	}
 	t := &TestT{}
 	rcv.UnPackTo(t)
 	return t

tests/MyGame/Example/TestSimpleTableWithEnum.cs

@@ -62,4 +62,14 @@ internal partial class TestSimpleTableWithEnumT
 }
 
 
+static public class TestSimpleTableWithEnumVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Color*/, 1 /*MyGame.Example.Color*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
 }

tests/MyGame/Example/TestSimpleTableWithEnum.go

@@ -11,7 +11,9 @@ type TestSimpleTableWithEnumT struct {
 }
 
 func (t *TestSimpleTableWithEnumT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
-	if t == nil { return 0 }
+	if t == nil {
+		return 0
+	}
 	TestSimpleTableWithEnumStart(builder)
 	TestSimpleTableWithEnumAddColor(builder, t.Color)
 	return TestSimpleTableWithEnumEnd(builder)
@@ -22,7 +24,9 @@ func (rcv *TestSimpleTableWithEnum) UnPackTo(t *TestSimpleTableWithEnumT) {
 }
 
 func (rcv *TestSimpleTableWithEnum) UnPack() *TestSimpleTableWithEnumT {
-	if rcv == nil { return nil }
+	if rcv == nil {
+		return nil
+	}
 	t := &TestSimpleTableWithEnumT{}
 	rcv.UnPackTo(t)
 	return t
@@ -39,6 +43,10 @@ func GetRootAsTestSimpleTableWithEnum(buf []byte, offset flatbuffers.UOffsetT) *
 	return x
 }
 
+func FinishTestSimpleTableWithEnumBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
 func GetSizePrefixedRootAsTestSimpleTableWithEnum(buf []byte, offset flatbuffers.UOffsetT) *TestSimpleTableWithEnum {
 	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
 	x := &TestSimpleTableWithEnum{}
@@ -46,6 +54,10 @@ func GetSizePrefixedRootAsTestSimpleTableWithEnum(buf []byte, offset flatbuffers
 	return x
 }
 
+func FinishSizePrefixedTestSimpleTableWithEnumBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
 func (rcv *TestSimpleTableWithEnum) Init(buf []byte, i flatbuffers.UOffsetT) {
 	rcv._tab.Bytes = buf
 	rcv._tab.Pos = i

tests/MyGame/Example/TestSimpleTableWithEnum.py

@@ -35,16 +35,25 @@ class TestSimpleTableWithEnum(object):
             return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
         return 2
 
-def TestSimpleTableWithEnumStart(builder): builder.StartObject(1)
+def TestSimpleTableWithEnumStart(builder):
+    return builder.StartObject(1)
+
 def Start(builder):
     return TestSimpleTableWithEnumStart(builder)
-def TestSimpleTableWithEnumAddColor(builder, color): builder.PrependUint8Slot(0, color, 2)
+
+def TestSimpleTableWithEnumAddColor(builder, color):
+    return builder.PrependUint8Slot(0, color, 2)
+
 def AddColor(builder, color):
     return TestSimpleTableWithEnumAddColor(builder, color)
-def TestSimpleTableWithEnumEnd(builder): return builder.EndObject()
+
+def TestSimpleTableWithEnumEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
     return TestSimpleTableWithEnumEnd(builder)
 
+
 class TestSimpleTableWithEnumT(object):
 
     # TestSimpleTableWithEnumT

tests/MyGame/Example/TypeAliases.cs

@@ -208,4 +208,25 @@ public class TypeAliasesT
 }
 
 
+static public class TypeAliasesVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*I8*/, 1 /*sbyte*/, 1, false)
+      && verifier.VerifyField(tablePos, 6 /*U8*/, 1 /*byte*/, 1, false)
+      && verifier.VerifyField(tablePos, 8 /*I16*/, 2 /*short*/, 2, false)
+      && verifier.VerifyField(tablePos, 10 /*U16*/, 2 /*ushort*/, 2, false)
+      && verifier.VerifyField(tablePos, 12 /*I32*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 14 /*U32*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 16 /*I64*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 18 /*U64*/, 8 /*ulong*/, 8, false)
+      && verifier.VerifyField(tablePos, 20 /*F32*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 22 /*F64*/, 8 /*double*/, 8, false)
+      && verifier.VerifyVectorOfData(tablePos, 24 /*V8*/, 1 /*sbyte*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 26 /*Vf64*/, 8 /*double*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
 }

tests/MyGame/Example/TypeAliases.go

@@ -22,7 +22,9 @@ type TypeAliasesT struct {
 }
 
 func (t *TypeAliasesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
-	if t == nil { return 0 }
+	if t == nil {
+		return 0
+	}
 	v8Offset := flatbuffers.UOffsetT(0)
 	if t.V8 != nil {
 		v8Length := len(t.V8)
@@ -81,7 +83,9 @@ func (rcv *TypeAliases) UnPackTo(t *TypeAliasesT) {
 }
 
 func (rcv *TypeAliases) UnPack() *TypeAliasesT {
-	if rcv == nil { return nil }
+	if rcv == nil {
+		return nil
+	}
 	t := &TypeAliasesT{}
 	rcv.UnPackTo(t)
 	return t
@@ -98,6 +102,10 @@ func GetRootAsTypeAliases(buf []byte, offset flatbuffers.UOffsetT) *TypeAliases
 	return x
 }
 
+func FinishTypeAliasesBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
 func GetSizePrefixedRootAsTypeAliases(buf []byte, offset flatbuffers.UOffsetT) *TypeAliases {
 	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
 	x := &TypeAliases{}
@@ -105,6 +113,10 @@ func GetSizePrefixedRootAsTypeAliases(buf []byte, offset flatbuffers.UOffsetT) *
 	return x
 }
 
+func FinishSizePrefixedTypeAliasesBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
 func (rcv *TypeAliases) Init(buf []byte, i flatbuffers.UOffsetT) {
 	rcv._tab.Bytes = buf
 	rcv._tab.Pos = i

tests/MyGame/Example/TypeAliases.py

@@ -152,54 +152,102 @@ class TypeAliases(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
         return o == 0
 
-def TypeAliasesStart(builder): builder.StartObject(12)
+def TypeAliasesStart(builder):
+    return builder.StartObject(12)
+
 def Start(builder):
     return TypeAliasesStart(builder)
-def TypeAliasesAddI8(builder, i8): builder.PrependInt8Slot(0, i8, 0)
+
+def TypeAliasesAddI8(builder, i8):
+    return builder.PrependInt8Slot(0, i8, 0)
+
 def AddI8(builder, i8):
     return TypeAliasesAddI8(builder, i8)
-def TypeAliasesAddU8(builder, u8): builder.PrependUint8Slot(1, u8, 0)
+
+def TypeAliasesAddU8(builder, u8):
+    return builder.PrependUint8Slot(1, u8, 0)
+
 def AddU8(builder, u8):
     return TypeAliasesAddU8(builder, u8)
-def TypeAliasesAddI16(builder, i16): builder.PrependInt16Slot(2, i16, 0)
+
+def TypeAliasesAddI16(builder, i16):
+    return builder.PrependInt16Slot(2, i16, 0)
+
 def AddI16(builder, i16):
     return TypeAliasesAddI16(builder, i16)
-def TypeAliasesAddU16(builder, u16): builder.PrependUint16Slot(3, u16, 0)
+
+def TypeAliasesAddU16(builder, u16):
+    return builder.PrependUint16Slot(3, u16, 0)
+
 def AddU16(builder, u16):
     return TypeAliasesAddU16(builder, u16)
-def TypeAliasesAddI32(builder, i32): builder.PrependInt32Slot(4, i32, 0)
+
+def TypeAliasesAddI32(builder, i32):
+    return builder.PrependInt32Slot(4, i32, 0)
+
 def AddI32(builder, i32):
     return TypeAliasesAddI32(builder, i32)
-def TypeAliasesAddU32(builder, u32): builder.PrependUint32Slot(5, u32, 0)
+
+def TypeAliasesAddU32(builder, u32):
+    return builder.PrependUint32Slot(5, u32, 0)
+
 def AddU32(builder, u32):
     return TypeAliasesAddU32(builder, u32)
-def TypeAliasesAddI64(builder, i64): builder.PrependInt64Slot(6, i64, 0)
+
+def TypeAliasesAddI64(builder, i64):
+    return builder.PrependInt64Slot(6, i64, 0)
+
 def AddI64(builder, i64):
     return TypeAliasesAddI64(builder, i64)
-def TypeAliasesAddU64(builder, u64): builder.PrependUint64Slot(7, u64, 0)
+
+def TypeAliasesAddU64(builder, u64):
+    return builder.PrependUint64Slot(7, u64, 0)
+
 def AddU64(builder, u64):
     return TypeAliasesAddU64(builder, u64)
-def TypeAliasesAddF32(builder, f32): builder.PrependFloat32Slot(8, f32, 0.0)
+
+def TypeAliasesAddF32(builder, f32):
+    return builder.PrependFloat32Slot(8, f32, 0.0)
+
 def AddF32(builder, f32):
     return TypeAliasesAddF32(builder, f32)
-def TypeAliasesAddF64(builder, f64): builder.PrependFloat64Slot(9, f64, 0.0)
+
+def TypeAliasesAddF64(builder, f64):
+    return builder.PrependFloat64Slot(9, f64, 0.0)
+
 def AddF64(builder, f64):
     return TypeAliasesAddF64(builder, f64)
-def TypeAliasesAddV8(builder, v8): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0)
+
+def TypeAliasesAddV8(builder, v8):
+    return builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0)
+
 def AddV8(builder, v8):
     return TypeAliasesAddV8(builder, v8)
-def TypeAliasesStartV8Vector(builder, numElems): return builder.StartVector(1, numElems, 1)
+
+def TypeAliasesStartV8Vector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
 def StartV8Vector(builder, numElems):
     return TypeAliasesStartV8Vector(builder, numElems)
-def TypeAliasesAddVf64(builder, vf64): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
+
+def TypeAliasesAddVf64(builder, vf64):
+    return builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
+
 def AddVf64(builder, vf64):
     return TypeAliasesAddVf64(builder, vf64)
-def TypeAliasesStartVf64Vector(builder, numElems): return builder.StartVector(8, numElems, 8)
+
+def TypeAliasesStartVf64Vector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
 def StartVf64Vector(builder, numElems):
     return TypeAliasesStartVf64Vector(builder, numElems)
-def TypeAliasesEnd(builder): return builder.EndObject()
+
+def TypeAliasesEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
     return TypeAliasesEnd(builder)
+
 try:
     from typing import List
 except:

tests/MyGame/Example/Vec3.go

@@ -16,7 +16,9 @@ type Vec3T struct {
 }
 
 func (t *Vec3T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
-	if t == nil { return 0 }
+	if t == nil {
+		return 0
+	}
 	return CreateVec3(builder, t.X, t.Y, t.Z, t.Test1, t.Test2, t.Test3.A, t.Test3.B)
 }
 func (rcv *Vec3) UnPackTo(t *Vec3T) {
@@ -29,7 +31,9 @@ func (rcv *Vec3) UnPackTo(t *Vec3T) {
 }
 
 func (rcv *Vec3) UnPack() *Vec3T {
-	if rcv == nil { return nil }
+	if rcv == nil {
+		return nil
+	}
 	t := &Vec3T{}
 	rcv.UnPackTo(t)
 	return t

tests/MyGame/Example2/Monster.cs

@@ -47,4 +47,13 @@ public class MonsterT
 }
 
 
+static public class MonsterVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
 }

tests/MyGame/Example2/Monster.go

@@ -10,7 +10,9 @@ type MonsterT struct {
 }
 
 func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
-	if t == nil { return 0 }
+	if t == nil {
+		return 0
+	}
 	MonsterStart(builder)
 	return MonsterEnd(builder)
 }
@@ -19,7 +21,9 @@ func (rcv *Monster) UnPackTo(t *MonsterT) {
 }
 
 func (rcv *Monster) UnPack() *MonsterT {
-	if rcv == nil { return nil }
+	if rcv == nil {
+		return nil
+	}
 	t := &MonsterT{}
 	rcv.UnPackTo(t)
 	return t
@@ -36,6 +40,10 @@ func GetRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Monster {
 	return x
 }
 
+func FinishMonsterBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
 func GetSizePrefixedRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Monster {
 	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
 	x := &Monster{}
@@ -43,6 +51,10 @@ func GetSizePrefixedRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Mons
 	return x
 }
 
+func FinishSizePrefixedMonsterBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
 func (rcv *Monster) Init(buf []byte, i flatbuffers.UOffsetT) {
 	rcv._tab.Bytes = buf
 	rcv._tab.Pos = i

tests/MyGame/Example2/Monster.py

@@ -28,13 +28,19 @@ class Monster(object):
     def Init(self, buf, pos):
         self._tab = flatbuffers.table.Table(buf, pos)
 
-def MonsterStart(builder): builder.StartObject(0)
+def MonsterStart(builder):
+    return builder.StartObject(0)
+
 def Start(builder):
     return MonsterStart(builder)
-def MonsterEnd(builder): return builder.EndObject()
+
+def MonsterEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
     return MonsterEnd(builder)
 
+
 class MonsterT(object):
 
     # MonsterT

tests/MyGame/InParentNamespace.cs

@@ -47,4 +47,13 @@ public class InParentNamespaceT
 }
 
 
+static public class InParentNamespaceVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
 }

tests/MyGame/InParentNamespace.go

@@ -10,7 +10,9 @@ type InParentNamespaceT struct {
 }
 
 func (t *InParentNamespaceT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
-	if t == nil { return 0 }
+	if t == nil {
+		return 0
+	}
 	InParentNamespaceStart(builder)
 	return InParentNamespaceEnd(builder)
 }
@@ -19,7 +21,9 @@ func (rcv *InParentNamespace) UnPackTo(t *InParentNamespaceT) {
 }
 
 func (rcv *InParentNamespace) UnPack() *InParentNamespaceT {
-	if rcv == nil { return nil }
+	if rcv == nil {
+		return nil
+	}
 	t := &InParentNamespaceT{}
 	rcv.UnPackTo(t)
 	return t
@@ -36,6 +40,10 @@ func GetRootAsInParentNamespace(buf []byte, offset flatbuffers.UOffsetT) *InPare
 	return x
 }
 
+func FinishInParentNamespaceBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
 func GetSizePrefixedRootAsInParentNamespace(buf []byte, offset flatbuffers.UOffsetT) *InParentNamespace {
 	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
 	x := &InParentNamespace{}
@@ -43,6 +51,10 @@ func GetSizePrefixedRootAsInParentNamespace(buf []byte, offset flatbuffers.UOffs
 	return x
 }
 
+func FinishSizePrefixedInParentNamespaceBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
 func (rcv *InParentNamespace) Init(buf []byte, i flatbuffers.UOffsetT) {
 	rcv._tab.Bytes = buf
 	rcv._tab.Pos = i

tests/MyGame/InParentNamespace.py

@@ -28,13 +28,19 @@ class InParentNamespace(object):
     def Init(self, buf, pos):
         self._tab = flatbuffers.table.Table(buf, pos)
 
-def InParentNamespaceStart(builder): builder.StartObject(0)
+def InParentNamespaceStart(builder):
+    return builder.StartObject(0)
+
 def Start(builder):
     return InParentNamespaceStart(builder)
-def InParentNamespaceEnd(builder): return builder.EndObject()
+
+def InParentNamespaceEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
     return InParentNamespaceEnd(builder)
 
+
 class InParentNamespaceT(object):
 
     # InParentNamespaceT

tests/MyGame/MonsterExtra.cs

@@ -17,6 +17,7 @@ public struct MonsterExtra : IFlatbufferObject
   public static MonsterExtra GetRootAsMonsterExtra(ByteBuffer _bb) { return GetRootAsMonsterExtra(_bb, new MonsterExtra()); }
   public static MonsterExtra GetRootAsMonsterExtra(ByteBuffer _bb, MonsterExtra obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
   public static bool MonsterExtraBufferHasIdentifier(ByteBuffer _bb) { return Table.__has_identifier(_bb, "MONE"); }
+  public static bool VerifyMonsterExtra(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("MONE", false, MonsterExtraVerify.Verify); }
   public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public MonsterExtra __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
@@ -206,4 +207,23 @@ public class MonsterExtraT
 }
 
 
+static public class MonsterExtraVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*D0*/, 8 /*double*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*D1*/, 8 /*double*/, 8, false)
+      && verifier.VerifyField(tablePos, 8 /*D2*/, 8 /*double*/, 8, false)
+      && verifier.VerifyField(tablePos, 10 /*D3*/, 8 /*double*/, 8, false)
+      && verifier.VerifyField(tablePos, 12 /*F0*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 14 /*F1*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 16 /*F2*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 18 /*F3*/, 4 /*float*/, 4, false)
+      && verifier.VerifyVectorOfData(tablePos, 20 /*Dvec*/, 8 /*double*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 22 /*Fvec*/, 4 /*float*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
 }

tests/MyGame/MonsterExtra.py

@@ -138,48 +138,90 @@ class MonsterExtra(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
         return o == 0
 
-def MonsterExtraStart(builder): builder.StartObject(11)
+def MonsterExtraStart(builder):
+    return builder.StartObject(11)
+
 def Start(builder):
     return MonsterExtraStart(builder)
-def MonsterExtraAddD0(builder, d0): builder.PrependFloat64Slot(0, d0, float('nan'))
+
+def MonsterExtraAddD0(builder, d0):
+    return builder.PrependFloat64Slot(0, d0, float('nan'))
+
 def AddD0(builder, d0):
     return MonsterExtraAddD0(builder, d0)
-def MonsterExtraAddD1(builder, d1): builder.PrependFloat64Slot(1, d1, float('nan'))
+
+def MonsterExtraAddD1(builder, d1):
+    return builder.PrependFloat64Slot(1, d1, float('nan'))
+
 def AddD1(builder, d1):
     return MonsterExtraAddD1(builder, d1)
-def MonsterExtraAddD2(builder, d2): builder.PrependFloat64Slot(2, d2, float('inf'))
+
+def MonsterExtraAddD2(builder, d2):
+    return builder.PrependFloat64Slot(2, d2, float('inf'))
+
 def AddD2(builder, d2):
     return MonsterExtraAddD2(builder, d2)
-def MonsterExtraAddD3(builder, d3): builder.PrependFloat64Slot(3, d3, float('-inf'))
+
+def MonsterExtraAddD3(builder, d3):
+    return builder.PrependFloat64Slot(3, d3, float('-inf'))
+
 def AddD3(builder, d3):
     return MonsterExtraAddD3(builder, d3)
-def MonsterExtraAddF0(builder, f0): builder.PrependFloat32Slot(4, f0, float('nan'))
+
+def MonsterExtraAddF0(builder, f0):
+    return builder.PrependFloat32Slot(4, f0, float('nan'))
+
 def AddF0(builder, f0):
     return MonsterExtraAddF0(builder, f0)
-def MonsterExtraAddF1(builder, f1): builder.PrependFloat32Slot(5, f1, float('nan'))
+
+def MonsterExtraAddF1(builder, f1):
+    return builder.PrependFloat32Slot(5, f1, float('nan'))
+
 def AddF1(builder, f1):
     return MonsterExtraAddF1(builder, f1)
-def MonsterExtraAddF2(builder, f2): builder.PrependFloat32Slot(6, f2, float('inf'))
+
+def MonsterExtraAddF2(builder, f2):
+    return builder.PrependFloat32Slot(6, f2, float('inf'))
+
 def AddF2(builder, f2):
     return MonsterExtraAddF2(builder, f2)
-def MonsterExtraAddF3(builder, f3): builder.PrependFloat32Slot(7, f3, float('-inf'))
+
+def MonsterExtraAddF3(builder, f3):
+    return builder.PrependFloat32Slot(7, f3, float('-inf'))
+
 def AddF3(builder, f3):
     return MonsterExtraAddF3(builder, f3)
-def MonsterExtraAddDvec(builder, dvec): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(dvec), 0)
+
+def MonsterExtraAddDvec(builder, dvec):
+    return builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(dvec), 0)
+
 def AddDvec(builder, dvec):
     return MonsterExtraAddDvec(builder, dvec)
-def MonsterExtraStartDvecVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+
+def MonsterExtraStartDvecVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
 def StartDvecVector(builder, numElems):
     return MonsterExtraStartDvecVector(builder, numElems)
-def MonsterExtraAddFvec(builder, fvec): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(fvec), 0)
+
+def MonsterExtraAddFvec(builder, fvec):
+    return builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(fvec), 0)
+
 def AddFvec(builder, fvec):
     return MonsterExtraAddFvec(builder, fvec)
-def MonsterExtraStartFvecVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
+def MonsterExtraStartFvecVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def StartFvecVector(builder, numElems):
     return MonsterExtraStartFvecVector(builder, numElems)
-def MonsterExtraEnd(builder): return builder.EndObject()
+
+def MonsterExtraEnd(builder):
+    return builder.EndObject()
+
 def End(builder):
     return MonsterExtraEnd(builder)
+
 try:
     from typing import List
 except:

tests/go_test.go

@@ -17,12 +17,12 @@
 package main
 
 import (
-	order "order"
-	pizza "Pizza"
 	mygame "MyGame"          // refers to generated code
 	example "MyGame/Example" // refers to generated code
+	pizza "Pizza"
 	"encoding/json"
 	optional_scalars "optional_scalars" // refers to generated code
+	order "order"
 
 	"bytes"
 	"flag"
@@ -140,7 +140,7 @@ func TestAll(t *testing.T) {
 
 	// Verify that using the generated Go code builds a buffer without
 	// returning errors:
-	generated, off := CheckGeneratedBuild(false, t.Fatalf)
+	generated, off := CheckGeneratedBuild(false, false, t.Fatalf)
 
 	// Verify that the buffer generated by Go code is readable by the
 	// generated Go code:
@@ -148,6 +148,16 @@ func TestAll(t *testing.T) {
 	CheckMutateBuffer(generated, off, false, t.Fatalf)
 	CheckObjectAPI(generated, off, false, t.Fatalf)
 
+	// Generate the buffer again, with file identifier.
+	generated, off = CheckGeneratedBuild(false, true, t.Fatalf)
+
+	// Check that this buffer with file identifier is usable
+	// and that the file identifier is correct.
+	CheckReadBuffer(generated, off, false, t.Fatalf)
+	CheckMutateBuffer(generated, off, false, t.Fatalf)
+	CheckObjectAPI(generated, off, false, t.Fatalf)
+	CheckFileIdentifier(generated, off, false, t.Fatalf)
+
 	// Verify that the buffer generated by C++ code is readable by the
 	// generated Go code:
 	monsterDataCpp, err := os.ReadFile(cppData)
@@ -157,6 +167,7 @@ func TestAll(t *testing.T) {
 	CheckReadBuffer(monsterDataCpp, 0, false, t.Fatalf)
 	CheckMutateBuffer(monsterDataCpp, 0, false, t.Fatalf)
 	CheckObjectAPI(monsterDataCpp, 0, false, t.Fatalf)
+	CheckFileIdentifier(monsterDataCpp, 0, false, t.Fatalf)
 
 	// Verify that vtables are deduplicated when written:
 	CheckVtableDeduplication(t.Fatalf)
@@ -391,6 +402,31 @@ func CheckReadBuffer(buf []byte, offset flatbuffers.UOffsetT, sizePrefix bool, f
 	}
 }
 
+// CheckFileIdentifier checks the "MONS" file identifier
+func CheckFileIdentifier(buf []byte, offset flatbuffers.UOffsetT, sizePrefix bool, fail func(string, ...interface{})) {
+	// Strip offset
+	buf = buf[offset:]
+
+	var fileIdentifier string
+	var hasFileIdentifier bool
+
+	if sizePrefix {
+		fileIdentifier = flatbuffers.GetSizePrefixedBufferIdentifier(buf)
+		hasFileIdentifier = example.SizePrefixedMonsterBufferHasIdentifier(buf)
+	} else {
+		fileIdentifier = flatbuffers.GetBufferIdentifier(buf)
+		hasFileIdentifier = example.MonsterBufferHasIdentifier(buf)
+	}
+
+	expectedFileIdentifier := "MONS"
+	if fileIdentifier != expectedFileIdentifier {
+		fail("expected file identifier %q, got %q", expectedFileIdentifier, fileIdentifier)
+	}
+	if !hasFileIdentifier {
+		fail("did not find file identifier")
+	}
+}
+
 // CheckMutateBuffer checks that the given buffer can be mutated correctly
 // as the example Monster. Only available scalar values are mutated.
 func CheckMutateBuffer(org []byte, offset flatbuffers.UOffsetT, sizePrefix bool, fail func(string, ...interface{})) {
@@ -1067,6 +1103,79 @@ func CheckByteLayout(fail func(string, ...interface{})) {
 		33, // value 0
 	})
 
+	// test 16b: same as test 16, size prefixed
+	b = flatbuffers.NewBuilder(0)
+	b.StartObject(2)
+	b.PrependInt8Slot(0, 33, 0)
+	b.PrependInt16Slot(1, 66, 0)
+	off = b.EndObject()
+	b.FinishSizePrefixed(off)
+
+	check([]byte{
+		20, 0, 0, 0, // size prefix
+		12, 0, 0, 0, // root of table: points to vtable offset
+
+		8, 0, // vtable bytes
+		8, 0, // end of object from here
+		7, 0, // start of value 0
+		4, 0, // start of value 1
+
+		8, 0, 0, 0, // offset for start of vtable (int32)
+
+		66, 0, // value 1
+		0,  // padding
+		33, // value 0
+	})
+
+	// test 16c: same as test 16, with file identifier
+	b = flatbuffers.NewBuilder(0)
+	b.StartObject(2)
+	b.PrependInt8Slot(0, 33, 0)
+	b.PrependInt16Slot(1, 66, 0)
+	off = b.EndObject()
+	b.FinishWithFileIdentifier(off, []byte("TEST"))
+
+	check([]byte{
+		16, 0, 0, 0, // root of table: points to vtable offset
+		'T', 'E', 'S', 'T', // file identifier
+
+		8, 0, // vtable bytes
+		8, 0, // end of object from here
+		7, 0, // start of value 0
+		4, 0, // start of value 1
+
+		8, 0, 0, 0, // offset for start of vtable (int32)
+
+		66, 0, // value 1
+		0,  // padding
+		33, // value 0
+	})
+
+	// test 16d: same as test 16, size prefixed with file identifier
+	b = flatbuffers.NewBuilder(0)
+	b.StartObject(2)
+	b.PrependInt8Slot(0, 33, 0)
+	b.PrependInt16Slot(1, 66, 0)
+	off = b.EndObject()
+	b.FinishSizePrefixedWithFileIdentifier(off, []byte("TEST"))
+
+	check([]byte{
+		24, 0, 0, 0, // size prefix
+		16, 0, 0, 0, // root of table: points to vtable offset
+		'T', 'E', 'S', 'T', // file identifier
+
+		8, 0, // vtable bytes
+		8, 0, // end of object from here
+		7, 0, // start of value 0
+		4, 0, // start of value 1
+
+		8, 0, 0, 0, // offset for start of vtable (int32)
+
+		66, 0, // value 1
+		0,  // padding
+		33, // value 0
+	})
+
 	// test 17: one unfinished table and one finished table
 	b = flatbuffers.NewBuilder(0)
 	b.StartObject(2)
@@ -1285,7 +1394,7 @@ func CheckGetRootAsForNonRootTable(fail func(string, ...interface{})) {
 }
 
 // CheckGeneratedBuild uses generated code to build the example Monster.
-func CheckGeneratedBuild(sizePrefix bool, fail func(string, ...interface{})) ([]byte, flatbuffers.UOffsetT) {
+func CheckGeneratedBuild(sizePrefix, fileIdentifier bool, fail func(string, ...interface{})) ([]byte, flatbuffers.UOffsetT) {
 	b := flatbuffers.NewBuilder(0)
 	str := b.CreateString("MyMonster")
 	test1 := b.CreateString("test1")
@@ -1329,10 +1438,18 @@ func CheckGeneratedBuild(sizePrefix bool, fail func(string, ...interface{})) ([]
 	example.MonsterAddTestarrayofstring(b, testArrayOfString)
 	mon := example.MonsterEnd(b)
 
-	if sizePrefix {
+	if fileIdentifier {
-		b.FinishSizePrefixed(mon)
+		if sizePrefix {
+			example.FinishSizePrefixedMonsterBuffer(b, mon)
+		} else {
+			example.FinishMonsterBuffer(b, mon)
+		}
 	} else {
-		b.Finish(mon)
+		if sizePrefix {
+			b.FinishSizePrefixed(mon)
+		} else {
+			b.Finish(mon)
+		}
 	}
 
 	return b.Bytes, b.Head()
@@ -1733,21 +1850,32 @@ func CheckParentNamespace(fail func(string, ...interface{})) {
 }
 
 func CheckSizePrefixedBuffer(fail func(string, ...interface{})) {
-	// Generate a size-prefixed flatbuffer
+	// Generate a size-prefixed flatbuffer, first without file identifier
-	generated, off := CheckGeneratedBuild(true, fail)
+	generated, off := CheckGeneratedBuild(true, false, fail)
-
-	// Check that the size prefix is the size of monsterdata_go_wire.mon minus 4
-	size := flatbuffers.GetSizePrefix(generated, off)
-	if size != 220 {
-		fail("mismatch between size prefix and expected size")
-	}
 
 	// Check that the buffer can be used as expected
 	CheckReadBuffer(generated, off, true, fail)
 	CheckMutateBuffer(generated, off, true, fail)
 	CheckObjectAPI(generated, off, true, fail)
 
-	// Write generated bfufer out to a file
+	// Now generate a size-prefixed flatbuffer with file identifier
+	generated, off = CheckGeneratedBuild(true, true, fail)
+
+	// Check that the size prefix is the size of monsterdata_go_wire.mon,
+	// plus 4 bytes for padding
+	size := flatbuffers.GetSizePrefix(generated, off)
+	expectedSize := uint32(228)
+	if size != expectedSize {
+		fail("mismatch between size prefix (%d) and expected size (%d)", size, expectedSize)
+	}
+
+	// Check that the buffer can be used as expected
+	CheckReadBuffer(generated, off, true, fail)
+	CheckMutateBuffer(generated, off, true, fail)
+	CheckObjectAPI(generated, off, true, fail)
+	CheckFileIdentifier(generated, off, true, fail)
+
+	// Write generated buffer out to a file
 	if err := os.WriteFile(outData+".sp", generated[off:], os.FileMode(0644)); err != nil {
 		fail("failed to write file: %s", err)
 	}
@@ -2324,7 +2452,7 @@ func BenchmarkVtableDeduplication(b *testing.B) {
 // BenchmarkParseGold measures the speed of parsing the 'gold' data
 // used throughout this test suite.
 func BenchmarkParseGold(b *testing.B) {
-	buf, offset := CheckGeneratedBuild(false, b.Fatalf)
+	buf, offset := CheckGeneratedBuild(false, false, b.Fatalf)
 	monster := example.GetRootAsMonster(buf, offset)
 
 	// use these to prevent allocations:
@@ -2386,7 +2514,7 @@ func BenchmarkParseGold(b *testing.B) {
 
 // BenchmarkBuildGold uses generated code to build the example Monster.
 func BenchmarkBuildGold(b *testing.B) {
-	buf, offset := CheckGeneratedBuild(false, b.Fatalf)
+	buf, offset := CheckGeneratedBuild(false, false, b.Fatalf)
 	bytes_length := int64(len(buf[offset:]))
 
 	reuse_str := "MyMonster"

tests/monster_test_generated.py

@@ -108,8 +108,12 @@ class InParentNamespace(object):
     def Init(self, buf, pos):
         self._tab = flatbuffers.table.Table(buf, pos)
 
-def InParentNamespaceStart(builder): builder.StartObject(0)
+def InParentNamespaceStart(builder):
-def InParentNamespaceEnd(builder): return builder.EndObject()
+    return builder.StartObject(0)
+
+def InParentNamespaceEnd(builder):
+    return builder.EndObject()
+
 
 
 class InParentNamespaceT(object):
@@ -169,8 +173,12 @@ class Monster(object):
     def Init(self, buf, pos):
         self._tab = flatbuffers.table.Table(buf, pos)
 
-def MonsterStart(builder): builder.StartObject(0)
+def MonsterStart(builder):
-def MonsterEnd(builder): return builder.EndObject()
+    return builder.StartObject(0)
+
+def MonsterEnd(builder):
+    return builder.EndObject()
+
 
 
 class MonsterT(object):
@@ -297,9 +305,15 @@ class TestSimpleTableWithEnum(object):
             return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
         return 2
 
-def TestSimpleTableWithEnumStart(builder): builder.StartObject(1)
+def TestSimpleTableWithEnumStart(builder):
-def TestSimpleTableWithEnumAddColor(builder, color): builder.PrependUint8Slot(0, color, 2)
+    return builder.StartObject(1)
-def TestSimpleTableWithEnumEnd(builder): return builder.EndObject()
+
+def TestSimpleTableWithEnumAddColor(builder, color):
+    return builder.PrependUint8Slot(0, color, 2)
+
+def TestSimpleTableWithEnumEnd(builder):
+    return builder.EndObject()
+
 
 
 class TestSimpleTableWithEnumT(object):
@@ -693,11 +707,21 @@ class Stat(object):
             return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
         return 0
 
-def StatStart(builder): builder.StartObject(3)
+def StatStart(builder):
-def StatAddId(builder, id): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
+    return builder.StartObject(3)
-def StatAddVal(builder, val): builder.PrependInt64Slot(1, val, 0)
+
-def StatAddCount(builder, count): builder.PrependUint16Slot(2, count, 0)
+def StatAddId(builder, id):
-def StatEnd(builder): return builder.EndObject()
+    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
+
+def StatAddVal(builder, val):
+    return builder.PrependInt64Slot(1, val, 0)
+
+def StatAddCount(builder, count):
+    return builder.PrependUint16Slot(2, count, 0)
+
+def StatEnd(builder):
+    return builder.EndObject()
+
 
 
 class StatT(object):
@@ -775,9 +799,15 @@ class Referrable(object):
             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
         return 0
 
-def ReferrableStart(builder): builder.StartObject(1)
+def ReferrableStart(builder):
-def ReferrableAddId(builder, id): builder.PrependUint64Slot(0, id, 0)
+    return builder.StartObject(1)
-def ReferrableEnd(builder): return builder.EndObject()
+
+def ReferrableAddId(builder, id):
+    return builder.PrependUint64Slot(0, id, 0)
+
+def ReferrableEnd(builder):
+    return builder.EndObject()
+
 
 
 class ReferrableT(object):
@@ -1021,7 +1051,7 @@ class Monster(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
         if o != 0:
             from MyGame.Example.Monster import Monster
-            return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o))
+            return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o))
         return 0
 
     # Monster
@@ -1552,7 +1582,7 @@ class Monster(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
         if o != 0:
             from MyGame.Example.Monster import Monster
-            return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o))
+            return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o))
         return 0
 
     # Monster
@@ -1671,99 +1701,265 @@ class Monster(object):
             return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
         return float('inf')
 
-def MonsterStart(builder): builder.StartObject(62)
+def MonsterStart(builder):
-def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
+    return builder.StartObject(62)
-def MonsterAddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150)
+
-def MonsterAddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100)
+def MonsterAddPos(builder, pos):
-def MonsterAddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+    return builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
-def MonsterAddInventory(builder, inventory): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
+
-def MonsterStartInventoryVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def MonsterAddMana(builder, mana):
-def MonsterAddColor(builder, color): builder.PrependUint8Slot(6, color, 8)
+    return builder.PrependInt16Slot(1, mana, 150)
-def MonsterAddTestType(builder, testType): builder.PrependUint8Slot(7, testType, 0)
+
-def MonsterAddTest(builder, test): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
+def MonsterAddHp(builder, hp):
-def MonsterAddTest4(builder, test4): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
+    return builder.PrependInt16Slot(2, hp, 100)
-def MonsterStartTest4Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
+
-def MonsterAddTestarrayofstring(builder, testarrayofstring): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
+def MonsterAddName(builder, name):
-def MonsterStartTestarrayofstringVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+    return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
-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 MonsterAddInventory(builder, inventory):
-def MonsterAddEnemy(builder, enemy): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
+    return builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
-def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
+
-def MonsterStartTestnestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def MonsterStartInventoryVector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
+def MonsterAddColor(builder, color):
+    return builder.PrependUint8Slot(6, color, 8)
+
+def MonsterAddTestType(builder, testType):
+    return builder.PrependUint8Slot(7, testType, 0)
+
+def MonsterAddTest(builder, test):
+    return builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
+
+def MonsterAddTest4(builder, test4):
+    return builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
+
+def MonsterStartTest4Vector(builder, numElems):
+    return builder.StartVector(4, numElems, 2)
+
+def MonsterAddTestarrayofstring(builder, testarrayofstring):
+    return builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
+
+def MonsterStartTestarrayofstringVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def MonsterAddTestarrayoftables(builder, testarrayoftables):
+    return builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
+
+def MonsterStartTestarrayoftablesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def MonsterAddEnemy(builder, enemy):
+    return builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
+
+def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer):
+    return builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
+
+def MonsterStartTestnestedflatbufferVector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
 def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes):
     builder.StartVector(1, len(bytes), 1)
     builder.head = builder.head - len(bytes)
     builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
     return builder.EndVector()
-def MonsterAddTestempty(builder, testempty): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
+def MonsterAddTestempty(builder, testempty):
-def MonsterAddTestbool(builder, testbool): builder.PrependBoolSlot(15, testbool, 0)
+    return builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
-def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1): builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
+
-def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1): builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
+def MonsterAddTestbool(builder, testbool):
-def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1): builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
+    return builder.PrependBoolSlot(15, testbool, 0)
-def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1): builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
+
-def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a): builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
+def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1):
-def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a): builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
+    return builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
-def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a): builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
+
-def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a): builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
+def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1):
-def MonsterAddTestarrayofbools(builder, testarrayofbools): builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
+    return builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
-def MonsterStartTestarrayofboolsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+
-def MonsterAddTestf(builder, testf): builder.PrependFloat32Slot(25, testf, 3.14159)
+def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1):
-def MonsterAddTestf2(builder, testf2): builder.PrependFloat32Slot(26, testf2, 3.0)
+    return builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
-def MonsterAddTestf3(builder, testf3): builder.PrependFloat32Slot(27, testf3, 0.0)
+
-def MonsterAddTestarrayofstring2(builder, testarrayofstring2): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
+def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1):
-def MonsterStartTestarrayofstring2Vector(builder, numElems): return builder.StartVector(4, numElems, 4)
+    return builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
-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 MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
-def MonsterAddFlex(builder, flex): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
+    return builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
-def MonsterStartFlexVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+
-def MonsterAddTest5(builder, test5): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
+def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
-def MonsterStartTest5Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
+    return builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
-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 MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
-def MonsterAddVectorOfDoubles(builder, vectorOfDoubles): builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
+    return builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
-def MonsterStartVectorOfDoublesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+
-def MonsterAddParentNamespaceTest(builder, parentNamespaceTest): builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
+def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
-def MonsterAddVectorOfReferrables(builder, vectorOfReferrables): builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
+    return builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
-def MonsterStartVectorOfReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+
-def MonsterAddSingleWeakReference(builder, singleWeakReference): builder.PrependUint64Slot(36, singleWeakReference, 0)
+def MonsterAddTestarrayofbools(builder, testarrayofbools):
-def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences): builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
+    return builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
-def MonsterStartVectorOfWeakReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+
-def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
+def MonsterStartTestarrayofboolsVector(builder, numElems):
-def MonsterStartVectorOfStrongReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+    return builder.StartVector(1, numElems, 1)
-def MonsterAddCoOwningReference(builder, coOwningReference): builder.PrependUint64Slot(39, coOwningReference, 0)
+
-def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
+def MonsterAddTestf(builder, testf):
-def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+    return builder.PrependFloat32Slot(25, testf, 3.14159)
-def MonsterAddNonOwningReference(builder, nonOwningReference): builder.PrependUint64Slot(41, nonOwningReference, 0)
+
-def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
+def MonsterAddTestf2(builder, testf2):
-def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+    return builder.PrependFloat32Slot(26, testf2, 3.0)
-def MonsterAddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43, anyUniqueType, 0)
+
-def MonsterAddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
+def MonsterAddTestf3(builder, testf3):
-def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0)
+    return builder.PrependFloat32Slot(27, testf3, 0.0)
-def MonsterAddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
+
-def MonsterAddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
+def MonsterAddTestarrayofstring2(builder, testarrayofstring2):
-def MonsterStartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+    return builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
-def MonsterAddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1)
+
-def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
+def MonsterStartTestarrayofstring2Vector(builder, numElems):
-def MonsterStartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+    return builder.StartVector(4, numElems, 4)
+
+def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
+    return builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
+
+def MonsterStartTestarrayofsortedstructVector(builder, numElems):
+    return builder.StartVector(8, numElems, 4)
+
+def MonsterAddFlex(builder, flex):
+    return builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
+
+def MonsterStartFlexVector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
+def MonsterAddTest5(builder, test5):
+    return builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
+
+def MonsterStartTest5Vector(builder, numElems):
+    return builder.StartVector(4, numElems, 2)
+
+def MonsterAddVectorOfLongs(builder, vectorOfLongs):
+    return builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
+
+def MonsterStartVectorOfLongsVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def MonsterAddVectorOfDoubles(builder, vectorOfDoubles):
+    return builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
+
+def MonsterStartVectorOfDoublesVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def MonsterAddParentNamespaceTest(builder, parentNamespaceTest):
+    return builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
+
+def MonsterAddVectorOfReferrables(builder, vectorOfReferrables):
+    return builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
+
+def MonsterStartVectorOfReferrablesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def MonsterAddSingleWeakReference(builder, singleWeakReference):
+    return builder.PrependUint64Slot(36, singleWeakReference, 0)
+
+def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences):
+    return builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
+
+def MonsterStartVectorOfWeakReferencesVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
+    return builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
+
+def MonsterStartVectorOfStrongReferrablesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def MonsterAddCoOwningReference(builder, coOwningReference):
+    return builder.PrependUint64Slot(39, coOwningReference, 0)
+
+def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
+    return builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
+
+def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def MonsterAddNonOwningReference(builder, nonOwningReference):
+    return builder.PrependUint64Slot(41, nonOwningReference, 0)
+
+def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
+    return builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
+
+def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def MonsterAddAnyUniqueType(builder, anyUniqueType):
+    return builder.PrependUint8Slot(43, anyUniqueType, 0)
+
+def MonsterAddAnyUnique(builder, anyUnique):
+    return builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
+
+def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType):
+    return builder.PrependUint8Slot(45, anyAmbiguousType, 0)
+
+def MonsterAddAnyAmbiguous(builder, anyAmbiguous):
+    return builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
+
+def MonsterAddVectorOfEnums(builder, vectorOfEnums):
+    return builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
+
+def MonsterStartVectorOfEnumsVector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
+def MonsterAddSignedEnum(builder, signedEnum):
+    return builder.PrependInt8Slot(48, signedEnum, -1)
+
+def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
+    return builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
+
+def MonsterStartTestrequirednestedflatbufferVector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
 def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
     builder.StartVector(1, len(bytes), 1)
     builder.head = builder.head - len(bytes)
     builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
     return builder.EndVector()
-def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables): builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
+def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables):
-def MonsterStartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+    return builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
-def MonsterAddNativeInline(builder, nativeInline): builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
+
-def MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault): builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0)
+def MonsterStartScalarKeySortedTablesVector(builder, numElems):
-def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault): builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
+    return builder.StartVector(4, numElems, 4)
-def MonsterAddNanDefault(builder, nanDefault): builder.PrependFloat32Slot(54, nanDefault, float('nan'))
+
-def MonsterAddInfDefault(builder, infDefault): builder.PrependFloat32Slot(55, infDefault, float('inf'))
+def MonsterAddNativeInline(builder, nativeInline):
-def MonsterAddPositiveInfDefault(builder, positiveInfDefault): builder.PrependFloat32Slot(56, positiveInfDefault, float('inf'))
+    return builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
-def MonsterAddInfinityDefault(builder, infinityDefault): builder.PrependFloat32Slot(57, infinityDefault, float('inf'))
+
-def MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault): builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf'))
+def MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault):
-def MonsterAddNegativeInfDefault(builder, negativeInfDefault): builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf'))
+    return builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0)
-def MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault): builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf'))
+
-def MonsterAddDoubleInfDefault(builder, doubleInfDefault): builder.PrependFloat64Slot(61, doubleInfDefault, float('inf'))
+def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault):
-def MonsterEnd(builder): return builder.EndObject()
+    return builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
+
+def MonsterAddNanDefault(builder, nanDefault):
+    return builder.PrependFloat32Slot(54, nanDefault, float('nan'))
+
+def MonsterAddInfDefault(builder, infDefault):
+    return builder.PrependFloat32Slot(55, infDefault, float('inf'))
+
+def MonsterAddPositiveInfDefault(builder, positiveInfDefault):
+    return builder.PrependFloat32Slot(56, positiveInfDefault, float('inf'))
+
+def MonsterAddInfinityDefault(builder, infinityDefault):
+    return builder.PrependFloat32Slot(57, infinityDefault, float('inf'))
+
+def MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault):
+    return builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf'))
+
+def MonsterAddNegativeInfDefault(builder, negativeInfDefault):
+    return builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf'))
+
+def MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault):
+    return builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf'))
+
+def MonsterAddDoubleInfDefault(builder, doubleInfDefault):
+    return builder.PrependFloat64Slot(61, doubleInfDefault, float('inf'))
+
+def MonsterEnd(builder):
+    return builder.EndObject()
+
 
 try:
     from typing import List, Optional, Union
@@ -2455,22 +2651,54 @@ class TypeAliases(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
         return o == 0
 
-def TypeAliasesStart(builder): builder.StartObject(12)
+def TypeAliasesStart(builder):
-def TypeAliasesAddI8(builder, i8): builder.PrependInt8Slot(0, i8, 0)
+    return builder.StartObject(12)
-def TypeAliasesAddU8(builder, u8): builder.PrependUint8Slot(1, u8, 0)
+
-def TypeAliasesAddI16(builder, i16): builder.PrependInt16Slot(2, i16, 0)
+def TypeAliasesAddI8(builder, i8):
-def TypeAliasesAddU16(builder, u16): builder.PrependUint16Slot(3, u16, 0)
+    return builder.PrependInt8Slot(0, i8, 0)
-def TypeAliasesAddI32(builder, i32): builder.PrependInt32Slot(4, i32, 0)
+
-def TypeAliasesAddU32(builder, u32): builder.PrependUint32Slot(5, u32, 0)
+def TypeAliasesAddU8(builder, u8):
-def TypeAliasesAddI64(builder, i64): builder.PrependInt64Slot(6, i64, 0)
+    return builder.PrependUint8Slot(1, u8, 0)
-def TypeAliasesAddU64(builder, u64): builder.PrependUint64Slot(7, u64, 0)
+
-def TypeAliasesAddF32(builder, f32): builder.PrependFloat32Slot(8, f32, 0.0)
+def TypeAliasesAddI16(builder, i16):
-def TypeAliasesAddF64(builder, f64): builder.PrependFloat64Slot(9, f64, 0.0)
+    return builder.PrependInt16Slot(2, i16, 0)
-def TypeAliasesAddV8(builder, v8): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0)
+
-def TypeAliasesStartV8Vector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def TypeAliasesAddU16(builder, u16):
-def TypeAliasesAddVf64(builder, vf64): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
+    return builder.PrependUint16Slot(3, u16, 0)
-def TypeAliasesStartVf64Vector(builder, numElems): return builder.StartVector(8, numElems, 8)
+
-def TypeAliasesEnd(builder): return builder.EndObject()
+def TypeAliasesAddI32(builder, i32):
+    return builder.PrependInt32Slot(4, i32, 0)
+
+def TypeAliasesAddU32(builder, u32):
+    return builder.PrependUint32Slot(5, u32, 0)
+
+def TypeAliasesAddI64(builder, i64):
+    return builder.PrependInt64Slot(6, i64, 0)
+
+def TypeAliasesAddU64(builder, u64):
+    return builder.PrependUint64Slot(7, u64, 0)
+
+def TypeAliasesAddF32(builder, f32):
+    return builder.PrependFloat32Slot(8, f32, 0.0)
+
+def TypeAliasesAddF64(builder, f64):
+    return builder.PrependFloat64Slot(9, f64, 0.0)
+
+def TypeAliasesAddV8(builder, v8):
+    return builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0)
+
+def TypeAliasesStartV8Vector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
+def TypeAliasesAddVf64(builder, vf64):
+    return builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
+
+def TypeAliasesStartVf64Vector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
+
+def TypeAliasesEnd(builder):
+    return builder.EndObject()
+
 
 try:
     from typing import List

tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.cs

@@ -62,4 +62,14 @@ public class TableInNestedNST
 }
 
 
+static public class TableInNestedNSVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Foo*/, 4 /*int*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
 }

tests/namespace_test/NamespaceA/NamespaceB/UnionInNestedNS.cs

@@ -33,6 +33,25 @@ public class UnionInNestedNSUnion {
   }
 }
 
+
+
+static public class UnionInNestedNSVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos)
+  {
+    bool result = true;
+    switch((UnionInNestedNS)typeId)
+    {
+      case UnionInNestedNS.TableInNestedNS:
+        result = NamespaceA.NamespaceB.TableInNestedNSVerify.Verify(verifier, tablePos);
+        break;
+      default: result = true;
+        break;
+    }
+    return result;
+  }
+}
+
 public class UnionInNestedNSUnion_JsonConverter : Newtonsoft.Json.JsonConverter {
   public override bool CanConvert(System.Type objectType) {
     return objectType == typeof(UnionInNestedNSUnion) || objectType == typeof(System.Collections.Generic.List<UnionInNestedNSUnion>);