add rest of golden language directories

goldens/dart/basic_generated.dart

@@ -0,0 +1,160 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable
+
+import 'dart:typed_data' show Uint8List;
+import 'package:flat_buffers/flat_buffers.dart' as fb;
+
+
+class Galaxy {
+  Galaxy._(this._bc, this._bcOffset);
+  factory Galaxy(List<int> bytes) {
+    final rootRef = fb.BufferContext.fromBytes(bytes);
+    return reader.read(rootRef, 0);
+  }
+
+  static const fb.Reader<Galaxy> reader = _GalaxyReader();
+
+  final fb.BufferContext _bc;
+  final int _bcOffset;
+
+  int get numStars => const fb.Int64Reader().vTableGet(_bc, _bcOffset, 4, 0);
+
+  @override
+  String toString() {
+    return 'Galaxy{numStars: ${numStars}}';
+  }
+}
+
+class _GalaxyReader extends fb.TableReader<Galaxy> {
+  const _GalaxyReader();
+
+  @override
+  Galaxy createObject(fb.BufferContext bc, int offset) => 
+    Galaxy._(bc, offset);
+}
+
+class GalaxyBuilder {
+  GalaxyBuilder(this.fbBuilder);
+
+  final fb.Builder fbBuilder;
+
+  void begin() {
+    fbBuilder.startTable(1);
+  }
+
+  int addNumStars(int? numStars) {
+    fbBuilder.addInt64(0, numStars);
+    return fbBuilder.offset;
+  }
+
+  int finish() {
+    return fbBuilder.endTable();
+  }
+}
+
+class GalaxyObjectBuilder extends fb.ObjectBuilder {
+  final int? _numStars;
+
+  GalaxyObjectBuilder({
+    int? numStars,
+  })
+      : _numStars = numStars;
+
+  /// Finish building, and store into the [fbBuilder].
+  @override
+  int finish(fb.Builder fbBuilder) {
+    fbBuilder.startTable(1);
+    fbBuilder.addInt64(0, _numStars);
+    return fbBuilder.endTable();
+  }
+
+  /// Convenience method to serialize to byte list.
+  @override
+  Uint8List toBytes([String? fileIdentifier]) {
+    final fbBuilder = fb.Builder(deduplicateTables: false);
+    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
+    return fbBuilder.buffer;
+  }
+}
+class Universe {
+  Universe._(this._bc, this._bcOffset);
+  factory Universe(List<int> bytes) {
+    final rootRef = fb.BufferContext.fromBytes(bytes);
+    return reader.read(rootRef, 0);
+  }
+
+  static const fb.Reader<Universe> reader = _UniverseReader();
+
+  final fb.BufferContext _bc;
+  final int _bcOffset;
+
+  double get age => const fb.Float64Reader().vTableGet(_bc, _bcOffset, 4, 0.0);
+  List<Galaxy>? get galaxies => const fb.ListReader<Galaxy>(Galaxy.reader).vTableGetNullable(_bc, _bcOffset, 6);
+
+  @override
+  String toString() {
+    return 'Universe{age: ${age}, galaxies: ${galaxies}}';
+  }
+}
+
+class _UniverseReader extends fb.TableReader<Universe> {
+  const _UniverseReader();
+
+  @override
+  Universe createObject(fb.BufferContext bc, int offset) => 
+    Universe._(bc, offset);
+}
+
+class UniverseBuilder {
+  UniverseBuilder(this.fbBuilder);
+
+  final fb.Builder fbBuilder;
+
+  void begin() {
+    fbBuilder.startTable(2);
+  }
+
+  int addAge(double? age) {
+    fbBuilder.addFloat64(0, age);
+    return fbBuilder.offset;
+  }
+  int addGalaxiesOffset(int? offset) {
+    fbBuilder.addOffset(1, offset);
+    return fbBuilder.offset;
+  }
+
+  int finish() {
+    return fbBuilder.endTable();
+  }
+}
+
+class UniverseObjectBuilder extends fb.ObjectBuilder {
+  final double? _age;
+  final List<GalaxyObjectBuilder>? _galaxies;
+
+  UniverseObjectBuilder({
+    double? age,
+    List<GalaxyObjectBuilder>? galaxies,
+  })
+      : _age = age,
+        _galaxies = galaxies;
+
+  /// Finish building, and store into the [fbBuilder].
+  @override
+  int finish(fb.Builder fbBuilder) {
+    final int? galaxiesOffset = _galaxies == null ? null
+        : fbBuilder.writeList(_galaxies!.map((b) => b.getOrCreateOffset(fbBuilder)).toList());
+    fbBuilder.startTable(2);
+    fbBuilder.addFloat64(0, _age);
+    fbBuilder.addOffset(1, galaxiesOffset);
+    return fbBuilder.endTable();
+  }
+
+  /// Convenience method to serialize to byte list.
+  @override
+  Uint8List toBytes([String? fileIdentifier]) {
+    final fbBuilder = fb.Builder(deduplicateTables: false);
+    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
+    return fbBuilder.buffer;
+  }
+}

goldens/dart/generate.py

@@ -0,0 +1,10 @@
+from golden_utils import flatc_golden
+
+
+def flatc(options, schema):
+    # Wrap the golden flatc generator with Dart specifics
+    flatc_golden(options=["--dart"] + options, schema=schema, prefix="dart")
+
+
+def GenerateDart():
+    flatc([], "basic.fbs")

goldens/generate_goldens.py

@@ -2,9 +2,32 @@
 
 from cpp.generate import GenerateCpp
 from csharp.generate import GenerateCSharp
+from dart.generate import GenerateDart
+from go.generate import GenerateGo
+from java.generate import GenerateJava
+from kotlin.generate import GenerateKotlin
+from lobster.generate import GenerateLobster
+from lua.generate import GenerateLua
+from nim.generate import GenerateNim
+from php.generate import GeneratePhp
+from py.generate import GeneratePython
+from rust.generate import GenerateRust
+from swift.generate import GenerateSwift
+from ts.generate import GenerateTs
 
 # Run each language generation logic
 GenerateCpp()
 GenerateCSharp()
-
-# TODO add other languages
+GenerateDart()
+GenerateGo()
+GenerateJava()
+GenerateKotlin()
+GenerateLobster()
+# TODO this doesn't respect the output prefix, fix and reenable
+#GenerateLua()
+GenerateNim()
+GeneratePhp()
+GeneratePython()
+GenerateRust()
+GenerateSwift()
+GenerateTs()

goldens/go/Galaxy.go

@@ -0,0 +1,64 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package Galaxy
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type Galaxy struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsGalaxy(buf []byte, offset flatbuffers.UOffsetT) *Galaxy {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &Galaxy{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishGalaxyBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsGalaxy(buf []byte, offset flatbuffers.UOffsetT) *Galaxy {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &Galaxy{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedGalaxyBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *Galaxy) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *Galaxy) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *Galaxy) NumStars() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *Galaxy) MutateNumStars(n int64) bool {
+	return rcv._tab.MutateInt64Slot(4, n)
+}
+
+func GalaxyStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func GalaxyAddNumStars(builder *flatbuffers.Builder, numStars int64) {
+	builder.PrependInt64Slot(0, numStars, 0)
+}
+func GalaxyEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

goldens/go/Universe.go

@@ -0,0 +1,90 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package Universe
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type Universe struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsUniverse(buf []byte, offset flatbuffers.UOffsetT) *Universe {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &Universe{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishUniverseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsUniverse(buf []byte, offset flatbuffers.UOffsetT) *Universe {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &Universe{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedUniverseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *Universe) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *Universe) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *Universe) Age() float64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetFloat64(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *Universe) MutateAge(n float64) bool {
+	return rcv._tab.MutateFloat64Slot(4, n)
+}
+
+func (rcv *Universe) Galaxies(obj *Galaxy, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Universe) GalaxiesLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func UniverseStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func UniverseAddAge(builder *flatbuffers.Builder, age float64) {
+	builder.PrependFloat64Slot(0, age, 0.0)
+}
+func UniverseAddGalaxies(builder *flatbuffers.Builder, galaxies flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(galaxies), 0)
+}
+func UniverseStartGalaxiesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func UniverseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

goldens/go/generate.py

@@ -0,0 +1,10 @@
+from golden_utils import flatc_golden
+
+
+def flatc(options, schema):
+    # Wrap the golden flatc generator with Go specifics
+    flatc_golden(options=["--go"] + options, schema=schema, prefix="go")
+
+
+def GenerateGo():
+    flatc([], "basic.fbs")

goldens/java/Galaxy.java

@@ -0,0 +1,51 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+import com.google.flatbuffers.BaseVector;
+import com.google.flatbuffers.BooleanVector;
+import com.google.flatbuffers.ByteVector;
+import com.google.flatbuffers.Constants;
+import com.google.flatbuffers.DoubleVector;
+import com.google.flatbuffers.FlatBufferBuilder;
+import com.google.flatbuffers.FloatVector;
+import com.google.flatbuffers.IntVector;
+import com.google.flatbuffers.LongVector;
+import com.google.flatbuffers.ShortVector;
+import com.google.flatbuffers.StringVector;
+import com.google.flatbuffers.Struct;
+import com.google.flatbuffers.Table;
+import com.google.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+@SuppressWarnings("unused")
+public final class Galaxy extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_3_3(); }
+  public static Galaxy getRootAsGalaxy(ByteBuffer _bb) { return getRootAsGalaxy(_bb, new Galaxy()); }
+  public static Galaxy getRootAsGalaxy(ByteBuffer _bb, Galaxy obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public Galaxy __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long numStars() { int o = __offset(4); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
+
+  public static int createGalaxy(FlatBufferBuilder builder,
+      long numStars) {
+    builder.startTable(1);
+    Galaxy.addNumStars(builder, numStars);
+    return Galaxy.endGalaxy(builder);
+  }
+
+  public static void startGalaxy(FlatBufferBuilder builder) { builder.startTable(1); }
+  public static void addNumStars(FlatBufferBuilder builder, long numStars) { builder.addLong(0, numStars, 0L); }
+  public static int endGalaxy(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public Galaxy get(int j) { return get(new Galaxy(), j); }
+    public Galaxy get(Galaxy obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+}
+

goldens/java/Universe.java

@@ -0,0 +1,63 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+import com.google.flatbuffers.BaseVector;
+import com.google.flatbuffers.BooleanVector;
+import com.google.flatbuffers.ByteVector;
+import com.google.flatbuffers.Constants;
+import com.google.flatbuffers.DoubleVector;
+import com.google.flatbuffers.FlatBufferBuilder;
+import com.google.flatbuffers.FloatVector;
+import com.google.flatbuffers.IntVector;
+import com.google.flatbuffers.LongVector;
+import com.google.flatbuffers.ShortVector;
+import com.google.flatbuffers.StringVector;
+import com.google.flatbuffers.Struct;
+import com.google.flatbuffers.Table;
+import com.google.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+@SuppressWarnings("unused")
+public final class Universe extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_3_3(); }
+  public static Universe getRootAsUniverse(ByteBuffer _bb) { return getRootAsUniverse(_bb, new Universe()); }
+  public static Universe getRootAsUniverse(ByteBuffer _bb, Universe obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public Universe __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public double age() { int o = __offset(4); return o != 0 ? bb.getDouble(o + bb_pos) : 0.0; }
+  public Galaxy galaxies(int j) { return galaxies(new Galaxy(), j); }
+  public Galaxy galaxies(Galaxy obj, int j) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; }
+  public int galaxiesLength() { int o = __offset(6); return o != 0 ? __vector_len(o) : 0; }
+  public Galaxy.Vector galaxiesVector() { return galaxiesVector(new Galaxy.Vector()); }
+  public Galaxy.Vector galaxiesVector(Galaxy.Vector obj) { int o = __offset(6); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; }
+
+  public static int createUniverse(FlatBufferBuilder builder,
+      double age,
+      int galaxiesOffset) {
+    builder.startTable(2);
+    Universe.addAge(builder, age);
+    Universe.addGalaxies(builder, galaxiesOffset);
+    return Universe.endUniverse(builder);
+  }
+
+  public static void startUniverse(FlatBufferBuilder builder) { builder.startTable(2); }
+  public static void addAge(FlatBufferBuilder builder, double age) { builder.addDouble(0, age, 0.0); }
+  public static void addGalaxies(FlatBufferBuilder builder, int galaxiesOffset) { builder.addOffset(1, galaxiesOffset, 0); }
+  public static int createGalaxiesVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); }
+  public static void startGalaxiesVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
+  public static int endUniverse(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+  public static void finishUniverseBuffer(FlatBufferBuilder builder, int offset) { builder.finish(offset); }
+  public static void finishSizePrefixedUniverseBuffer(FlatBufferBuilder builder, int offset) { builder.finishSizePrefixed(offset); }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public Universe get(int j) { return get(new Universe(), j); }
+    public Universe get(Universe obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+}
+

goldens/java/generate.py

@@ -0,0 +1,10 @@
+from golden_utils import flatc_golden
+
+
+def flatc(options, schema):
+    # Wrap the golden flatc generator with Java specifics
+    flatc_golden(options=["--java"] + options, schema=schema, prefix="java")
+
+
+def GenerateJava():
+    flatc([], "basic.fbs")

goldens/kotlin/Galaxy.kt

@@ -0,0 +1,53 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+import com.google.flatbuffers.BaseVector
+import com.google.flatbuffers.BooleanVector
+import com.google.flatbuffers.ByteVector
+import com.google.flatbuffers.Constants
+import com.google.flatbuffers.DoubleVector
+import com.google.flatbuffers.FlatBufferBuilder
+import com.google.flatbuffers.FloatVector
+import com.google.flatbuffers.LongVector
+import com.google.flatbuffers.StringVector
+import com.google.flatbuffers.Struct
+import com.google.flatbuffers.Table
+import com.google.flatbuffers.UnionVector
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import kotlin.math.sign
+
+@Suppress("unused")
+class Galaxy : Table() {
+
+    fun __init(_i: Int, _bb: ByteBuffer)  {
+        __reset(_i, _bb)
+    }
+    fun __assign(_i: Int, _bb: ByteBuffer) : Galaxy {
+        __init(_i, _bb)
+        return this
+    }
+    val numStars : Long
+        get() {
+            val o = __offset(4)
+            return if(o != 0) bb.getLong(o + bb_pos) else 0L
+        }
+    companion object {
+        fun validateVersion() = Constants.FLATBUFFERS_23_3_3()
+        fun getRootAsGalaxy(_bb: ByteBuffer): Galaxy = getRootAsGalaxy(_bb, Galaxy())
+        fun getRootAsGalaxy(_bb: ByteBuffer, obj: Galaxy): Galaxy {
+            _bb.order(ByteOrder.LITTLE_ENDIAN)
+            return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
+        }
+        fun createGalaxy(builder: FlatBufferBuilder, numStars: Long) : Int {
+            builder.startTable(1)
+            addNumStars(builder, numStars)
+            return endGalaxy(builder)
+        }
+        fun startGalaxy(builder: FlatBufferBuilder) = builder.startTable(1)
+        fun addNumStars(builder: FlatBufferBuilder, numStars: Long) = builder.addLong(0, numStars, 0L)
+        fun endGalaxy(builder: FlatBufferBuilder) : Int {
+            val o = builder.endTable()
+            return o
+        }
+    }
+}

goldens/kotlin/Universe.kt

@@ -0,0 +1,78 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+import com.google.flatbuffers.BaseVector
+import com.google.flatbuffers.BooleanVector
+import com.google.flatbuffers.ByteVector
+import com.google.flatbuffers.Constants
+import com.google.flatbuffers.DoubleVector
+import com.google.flatbuffers.FlatBufferBuilder
+import com.google.flatbuffers.FloatVector
+import com.google.flatbuffers.LongVector
+import com.google.flatbuffers.StringVector
+import com.google.flatbuffers.Struct
+import com.google.flatbuffers.Table
+import com.google.flatbuffers.UnionVector
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import kotlin.math.sign
+
+@Suppress("unused")
+class Universe : Table() {
+
+    fun __init(_i: Int, _bb: ByteBuffer)  {
+        __reset(_i, _bb)
+    }
+    fun __assign(_i: Int, _bb: ByteBuffer) : Universe {
+        __init(_i, _bb)
+        return this
+    }
+    val age : Double
+        get() {
+            val o = __offset(4)
+            return if(o != 0) bb.getDouble(o + bb_pos) else 0.0
+        }
+    fun galaxies(j: Int) : Galaxy? = galaxies(Galaxy(), j)
+    fun galaxies(obj: Galaxy, j: Int) : Galaxy? {
+        val o = __offset(6)
+        return if (o != 0) {
+            obj.__assign(__indirect(__vector(o) + j * 4), bb)
+        } else {
+            null
+        }
+    }
+    val galaxiesLength : Int
+        get() {
+            val o = __offset(6); return if (o != 0) __vector_len(o) else 0
+        }
+    companion object {
+        fun validateVersion() = Constants.FLATBUFFERS_23_3_3()
+        fun getRootAsUniverse(_bb: ByteBuffer): Universe = getRootAsUniverse(_bb, Universe())
+        fun getRootAsUniverse(_bb: ByteBuffer, obj: Universe): Universe {
+            _bb.order(ByteOrder.LITTLE_ENDIAN)
+            return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
+        }
+        fun createUniverse(builder: FlatBufferBuilder, age: Double, galaxiesOffset: Int) : Int {
+            builder.startTable(2)
+            addAge(builder, age)
+            addGalaxies(builder, galaxiesOffset)
+            return endUniverse(builder)
+        }
+        fun startUniverse(builder: FlatBufferBuilder) = builder.startTable(2)
+        fun addAge(builder: FlatBufferBuilder, age: Double) = builder.addDouble(0, age, 0.0)
+        fun addGalaxies(builder: FlatBufferBuilder, galaxies: Int) = builder.addOffset(1, galaxies, 0)
+        fun createGalaxiesVector(builder: FlatBufferBuilder, data: IntArray) : Int {
+            builder.startVector(4, data.size, 4)
+            for (i in data.size - 1 downTo 0) {
+                builder.addOffset(data[i])
+            }
+            return builder.endVector()
+        }
+        fun startGalaxiesVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4)
+        fun endUniverse(builder: FlatBufferBuilder) : Int {
+            val o = builder.endTable()
+            return o
+        }
+        fun finishUniverseBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finish(offset)
+        fun finishSizePrefixedUniverseBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finishSizePrefixed(offset)
+    }
+}

goldens/kotlin/generate.py

@@ -0,0 +1,10 @@
+from golden_utils import flatc_golden
+
+
+def flatc(options, schema):
+    # Wrap the golden flatc generator with Kotlin specifics
+    flatc_golden(options=["--kotlin"] + options, schema=schema, prefix="kotlin")
+
+
+def GenerateKotlin():
+    flatc([], "basic.fbs")

goldens/lobster/basic_generated.lobster

@@ -0,0 +1,55 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+import flatbuffers
+
+class Galaxy
+
+class Universe
+
+class Galaxy : flatbuffers_handle
+    def num_stars() -> int:
+        return buf_.flatbuffers_field_int64(pos_, 4, 0)
+
+def GetRootAsGalaxy(buf:string): return Galaxy { buf, buf.flatbuffers_indirect(0) }
+
+struct GalaxyBuilder:
+    b_:flatbuffers_builder
+    def start():
+        b_.StartObject(1)
+        return this
+    def add_num_stars(num_stars:int):
+        b_.PrependInt64Slot(0, num_stars, 0)
+        return this
+    def end():
+        return b_.EndObject()
+
+class Universe : flatbuffers_handle
+    def age() -> float:
+        return buf_.flatbuffers_field_float64(pos_, 4, 0.0)
+    def galaxies(i:int) -> Galaxy:
+        return Galaxy { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 6) + i * 4) }
+    def galaxies_length() -> int:
+        return buf_.flatbuffers_field_vector_len(pos_, 6)
+
+def GetRootAsUniverse(buf:string): return Universe { buf, buf.flatbuffers_indirect(0) }
+
+struct UniverseBuilder:
+    b_:flatbuffers_builder
+    def start():
+        b_.StartObject(2)
+        return this
+    def add_age(age:float):
+        b_.PrependFloat64Slot(0, age, 0.0)
+        return this
+    def add_galaxies(galaxies:flatbuffers_offset):
+        b_.PrependUOffsetTRelativeSlot(1, galaxies)
+        return this
+    def end():
+        return b_.EndObject()
+
+def UniverseStartGalaxiesVector(b_:flatbuffers_builder, n_:int):
+    b_.StartVector(4, n_, 4)
+def UniverseCreateGalaxiesVector(b_:flatbuffers_builder, v_:[flatbuffers_offset]):
+    b_.StartVector(4, v_.length, 4)
+    reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
+    return b_.EndVector(v_.length)
+

goldens/lobster/generate.py

@@ -0,0 +1,10 @@
+from golden_utils import flatc_golden
+
+
+def flatc(options, schema):
+    # Wrap the golden flatc generator with Lobster specifics
+    flatc_golden(options=["--lobster"] + options, schema=schema, prefix="lobster")
+
+
+def GenerateLobster():
+    flatc([], "basic.fbs")

goldens/lua/generate.py

@@ -0,0 +1,10 @@
+from golden_utils import flatc_golden
+
+
+def flatc(options, schema):
+    # Wrap the golden flatc generator with Lua specifics
+    flatc_golden(options=["--lua"] + options, schema=schema, prefix="lua")
+
+
+def GenerateLua():
+    flatc([], "basic.fbs")

goldens/nim/generate.py

@@ -0,0 +1,10 @@
+from golden_utils import flatc_golden
+
+
+def flatc(options, schema):
+    # Wrap the golden flatc generator with Nim specifics
+    flatc_golden(options=["--nim"] + options, schema=schema, prefix="nim")
+
+
+def GenerateNim():
+    flatc([], "basic.fbs")

goldens/php/Galaxy.php

@@ -0,0 +1,82 @@
+<?php
+// automatically generated by the FlatBuffers compiler, do not modify
+
+use \Google\FlatBuffers\Struct;
+use \Google\FlatBuffers\Table;
+use \Google\FlatBuffers\ByteBuffer;
+use \Google\FlatBuffers\FlatBufferBuilder;
+
+class Galaxy extends Table
+{
+    /**
+     * @param ByteBuffer $bb
+     * @return Galaxy
+     */
+    public static function getRootAsGalaxy(ByteBuffer $bb)
+    {
+        $obj = new Galaxy();
+        return ($obj->init($bb->getInt($bb->getPosition()) + $bb->getPosition(), $bb));
+    }
+
+    /**
+     * @param int $_i offset
+     * @param ByteBuffer $_bb
+     * @return Galaxy
+     **/
+    public function init($_i, ByteBuffer $_bb)
+    {
+        $this->bb_pos = $_i;
+        $this->bb = $_bb;
+        return $this;
+    }
+
+    /**
+     * @return long
+     */
+    public function getNumStars()
+    {
+        $o = $this->__offset(4);
+        return $o != 0 ? $this->bb->getLong($o + $this->bb_pos) : 0;
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @return void
+     */
+    public static function startGalaxy(FlatBufferBuilder $builder)
+    {
+        $builder->StartObject(1);
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @return Galaxy
+     */
+    public static function createGalaxy(FlatBufferBuilder $builder, $num_stars)
+    {
+        $builder->startObject(1);
+        self::addNumStars($builder, $num_stars);
+        $o = $builder->endObject();
+        return $o;
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @param long
+     * @return void
+     */
+    public static function addNumStars(FlatBufferBuilder $builder, $numStars)
+    {
+        $builder->addLongX(0, $numStars, 0);
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @return int table offset
+     */
+    public static function endGalaxy(FlatBufferBuilder $builder)
+    {
+        $o = $builder->endObject();
+        return $o;
+    }
+}

goldens/php/Universe.php

@@ -0,0 +1,141 @@
+<?php
+// automatically generated by the FlatBuffers compiler, do not modify
+
+use \Google\FlatBuffers\Struct;
+use \Google\FlatBuffers\Table;
+use \Google\FlatBuffers\ByteBuffer;
+use \Google\FlatBuffers\FlatBufferBuilder;
+
+class Universe extends Table
+{
+    /**
+     * @param ByteBuffer $bb
+     * @return Universe
+     */
+    public static function getRootAsUniverse(ByteBuffer $bb)
+    {
+        $obj = new Universe();
+        return ($obj->init($bb->getInt($bb->getPosition()) + $bb->getPosition(), $bb));
+    }
+
+    /**
+     * @param int $_i offset
+     * @param ByteBuffer $_bb
+     * @return Universe
+     **/
+    public function init($_i, ByteBuffer $_bb)
+    {
+        $this->bb_pos = $_i;
+        $this->bb = $_bb;
+        return $this;
+    }
+
+    /**
+     * @return double
+     */
+    public function getAge()
+    {
+        $o = $this->__offset(4);
+        return $o != 0 ? $this->bb->getDouble($o + $this->bb_pos) : 0.0;
+    }
+
+    /**
+     * @returnVectorOffset
+     */
+    public function getGalaxies($j)
+    {
+        $o = $this->__offset(6);
+        $obj = new Galaxy();
+        return $o != 0 ? $obj->init($this->__indirect($this->__vector($o) + $j * 4), $this->bb) : null;
+    }
+
+    /**
+     * @return int
+     */
+    public function getGalaxiesLength()
+    {
+        $o = $this->__offset(6);
+        return $o != 0 ? $this->__vector_len($o) : 0;
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @return void
+     */
+    public static function startUniverse(FlatBufferBuilder $builder)
+    {
+        $builder->StartObject(2);
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @return Universe
+     */
+    public static function createUniverse(FlatBufferBuilder $builder, $age, $galaxies)
+    {
+        $builder->startObject(2);
+        self::addAge($builder, $age);
+        self::addGalaxies($builder, $galaxies);
+        $o = $builder->endObject();
+        return $o;
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @param double
+     * @return void
+     */
+    public static function addAge(FlatBufferBuilder $builder, $age)
+    {
+        $builder->addDoubleX(0, $age, 0.0);
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @param VectorOffset
+     * @return void
+     */
+    public static function addGalaxies(FlatBufferBuilder $builder, $galaxies)
+    {
+        $builder->addOffsetX(1, $galaxies, 0);
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @param array offset array
+     * @return int vector offset
+     */
+    public static function createGalaxiesVector(FlatBufferBuilder $builder, array $data)
+    {
+        $builder->startVector(4, count($data), 4);
+        for ($i = count($data) - 1; $i >= 0; $i--) {
+            $builder->putOffset($data[$i]);
+        }
+        return $builder->endVector();
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @param int $numElems
+     * @return void
+     */
+    public static function startGalaxiesVector(FlatBufferBuilder $builder, $numElems)
+    {
+        $builder->startVector(4, $numElems, 4);
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @return int table offset
+     */
+    public static function endUniverse(FlatBufferBuilder $builder)
+    {
+        $o = $builder->endObject();
+        return $o;
+    }
+
+    public static function finishUniverseBuffer(FlatBufferBuilder $builder, $offset)
+    {
+        $builder->finish($offset);
+    }
+}

goldens/php/generate.py

@@ -0,0 +1,10 @@
+from golden_utils import flatc_golden
+
+
+def flatc(options, schema):
+    # Wrap the golden flatc generator with PHP specifics
+    flatc_golden(options=["--php"] + options, schema=schema, prefix="php")
+
+
+def GeneratePhp():
+    flatc([], "basic.fbs")

goldens/py/Galaxy.py

@@ -0,0 +1,50 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Galaxy(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Galaxy()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsGalaxy(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Galaxy
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Galaxy
+    def NumStars(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
+        return 0
+
+def GalaxyStart(builder):
+    builder.StartObject(1)
+
+def Start(builder):
+    GalaxyStart(builder)
+
+def GalaxyAddNumStars(builder, numStars):
+    builder.PrependInt64Slot(0, numStars, 0)
+
+def AddNumStars(builder: flatbuffers.Builder, numStars: int):
+    GalaxyAddNumStars(builder, numStars)
+
+def GalaxyEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return GalaxyEnd(builder)

goldens/py/Universe.py

@@ -0,0 +1,87 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Universe(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Universe()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsUniverse(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Universe
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Universe
+    def Age(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Universe
+    def Galaxies(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from .Galaxy import Galaxy
+            obj = Galaxy()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Universe
+    def GalaxiesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Universe
+    def GalaxiesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+def UniverseStart(builder):
+    builder.StartObject(2)
+
+def Start(builder):
+    UniverseStart(builder)
+
+def UniverseAddAge(builder, age):
+    builder.PrependFloat64Slot(0, age, 0.0)
+
+def AddAge(builder: flatbuffers.Builder, age: float):
+    UniverseAddAge(builder, age)
+
+def UniverseAddGalaxies(builder, galaxies):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(galaxies), 0)
+
+def AddGalaxies(builder: flatbuffers.Builder, galaxies: int):
+    UniverseAddGalaxies(builder, galaxies)
+
+def UniverseStartGalaxiesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartGalaxiesVector(builder, numElems: int) -> int:
+    return UniverseStartGalaxiesVector(builder, numElems)
+
+def UniverseEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return UniverseEnd(builder)

goldens/py/generate.py

@@ -0,0 +1,10 @@
+from golden_utils import flatc_golden
+
+
+def flatc(options, schema):
+    # Wrap the golden flatc generator with Python specifics
+    flatc_golden(options=["--python"] + options, schema=schema, prefix="py")
+
+
+def GeneratePython():
+    flatc([], "basic.fbs")

goldens/rust/basic_generated.rs

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

goldens/rust/generate.py

@@ -0,0 +1,10 @@
+from golden_utils import flatc_golden
+
+
+def flatc(options, schema):
+    # Wrap the golden flatc generator with Rust specifics
+    flatc_golden(options=["--rust"] + options, schema=schema, prefix="rust")
+
+
+def GenerateRust():
+    flatc([], "basic.fbs")

goldens/swift/basic_generated.swift

@@ -0,0 +1,84 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// swiftlint:disable all
+// swiftformat:disable all
+
+import FlatBuffers
+
+public struct Galaxy: FlatBufferObject, Verifiable {
+
+  static func validateVersion() { FlatBuffersVersion_23_3_3() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Table
+
+  private init(_ t: Table) { _accessor = t }
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+  private enum VTOFFSET: VOffset {
+    case numStars = 4
+    var v: Int32 { Int32(self.rawValue) }
+    var p: VOffset { self.rawValue }
+  }
+
+  public var numStars: Int64 { let o = _accessor.offset(VTOFFSET.numStars.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }
+  public static func startGalaxy(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
+  public static func add(numStars: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: numStars, def: 0, at: VTOFFSET.numStars.p) }
+  public static func endGalaxy(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
+  public static func createGalaxy(
+    _ fbb: inout FlatBufferBuilder,
+    numStars: Int64 = 0
+  ) -> Offset {
+    let __start = Galaxy.startGalaxy(&fbb)
+    Galaxy.add(numStars: numStars, &fbb)
+    return Galaxy.endGalaxy(&fbb, start: __start)
+  }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.numStars.p, fieldName: "numStars", required: false, type: Int64.self)
+    _v.finish()
+  }
+}
+
+public struct Universe: FlatBufferObject, Verifiable {
+
+  static func validateVersion() { FlatBuffersVersion_23_3_3() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Table
+
+  private init(_ t: Table) { _accessor = t }
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+  private enum VTOFFSET: VOffset {
+    case age = 4
+    case galaxies = 6
+    var v: Int32 { Int32(self.rawValue) }
+    var p: VOffset { self.rawValue }
+  }
+
+  public var age: Double { let o = _accessor.offset(VTOFFSET.age.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
+  public var hasGalaxies: Bool { let o = _accessor.offset(VTOFFSET.galaxies.v); return o == 0 ? false : true }
+  public var galaxiesCount: Int32 { let o = _accessor.offset(VTOFFSET.galaxies.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+  public func galaxies(at index: Int32) -> Galaxy? { let o = _accessor.offset(VTOFFSET.galaxies.v); return o == 0 ? nil : Galaxy(_accessor.bb, o: _accessor.indirect(_accessor.vector(at: o) + index * 4)) }
+  public static func startUniverse(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 2) }
+  public static func add(age: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: age, def: 0.0, at: VTOFFSET.age.p) }
+  public static func addVectorOf(galaxies: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: galaxies, at: VTOFFSET.galaxies.p) }
+  public static func endUniverse(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
+  public static func createUniverse(
+    _ fbb: inout FlatBufferBuilder,
+    age: Double = 0.0,
+    galaxiesVectorOffset galaxies: Offset = Offset()
+  ) -> Offset {
+    let __start = Universe.startUniverse(&fbb)
+    Universe.add(age: age, &fbb)
+    Universe.addVectorOf(galaxies: galaxies, &fbb)
+    return Universe.endUniverse(&fbb, start: __start)
+  }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.age.p, fieldName: "age", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.galaxies.p, fieldName: "galaxies", required: false, type: ForwardOffset<Vector<ForwardOffset<Galaxy>, Galaxy>>.self)
+    _v.finish()
+  }
+}
+

goldens/swift/generate.py

@@ -0,0 +1,10 @@
+from golden_utils import flatc_golden
+
+
+def flatc(options, schema):
+    # Wrap the golden flatc generator with Swift specifics
+    flatc_golden(options=["--swift"] + options, schema=schema, prefix="swift")
+
+
+def GenerateSwift():
+    flatc([], "basic.fbs")

goldens/ts/basic.ts

@@ -0,0 +1,4 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+export { Galaxy } from './galaxy.js';
+export { Universe } from './universe.js';

goldens/ts/galaxy.ts

@@ -0,0 +1,46 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+import * as flatbuffers from 'flatbuffers';
+
+export class Galaxy {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+  __init(i:number, bb:flatbuffers.ByteBuffer):Galaxy {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+static getRootAsGalaxy(bb:flatbuffers.ByteBuffer, obj?:Galaxy):Galaxy {
+  return (obj || new Galaxy()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+static getSizePrefixedRootAsGalaxy(bb:flatbuffers.ByteBuffer, obj?:Galaxy):Galaxy {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (obj || new Galaxy()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+numStars():bigint {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+  return offset ? this.bb!.readInt64(this.bb_pos + offset) : BigInt('0');
+}
+
+static startGalaxy(builder:flatbuffers.Builder) {
+  builder.startObject(1);
+}
+
+static addNumStars(builder:flatbuffers.Builder, numStars:bigint) {
+  builder.addFieldInt64(0, numStars, BigInt('0'));
+}
+
+static endGalaxy(builder:flatbuffers.Builder):flatbuffers.Offset {
+  const offset = builder.endObject();
+  return offset;
+}
+
+static createGalaxy(builder:flatbuffers.Builder, numStars:bigint):flatbuffers.Offset {
+  Galaxy.startGalaxy(builder);
+  Galaxy.addNumStars(builder, numStars);
+  return Galaxy.endGalaxy(builder);
+}
+}

goldens/ts/generate.py

@@ -0,0 +1,10 @@
+from golden_utils import flatc_golden
+
+
+def flatc(options, schema):
+    # Wrap the golden flatc generator with Swift specifics
+    flatc_golden(options=["--ts"] + options, schema=schema, prefix="ts")
+
+
+def GenerateTs():
+    flatc([], "basic.fbs")

goldens/ts/universe.ts

@@ -0,0 +1,84 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+import * as flatbuffers from 'flatbuffers';
+
+import { Galaxy } from './galaxy.js';
+
+
+export class Universe {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+  __init(i:number, bb:flatbuffers.ByteBuffer):Universe {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+static getRootAsUniverse(bb:flatbuffers.ByteBuffer, obj?:Universe):Universe {
+  return (obj || new Universe()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+static getSizePrefixedRootAsUniverse(bb:flatbuffers.ByteBuffer, obj?:Universe):Universe {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (obj || new Universe()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+age():number {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+  return offset ? this.bb!.readFloat64(this.bb_pos + offset) : 0.0;
+}
+
+galaxies(index: number, obj?:Galaxy):Galaxy|null {
+  const offset = this.bb!.__offset(this.bb_pos, 6);
+  return offset ? (obj || new Galaxy()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null;
+}
+
+galaxiesLength():number {
+  const offset = this.bb!.__offset(this.bb_pos, 6);
+  return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
+}
+
+static startUniverse(builder:flatbuffers.Builder) {
+  builder.startObject(2);
+}
+
+static addAge(builder:flatbuffers.Builder, age:number) {
+  builder.addFieldFloat64(0, age, 0.0);
+}
+
+static addGalaxies(builder:flatbuffers.Builder, galaxiesOffset:flatbuffers.Offset) {
+  builder.addFieldOffset(1, galaxiesOffset, 0);
+}
+
+static createGalaxiesVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset {
+  builder.startVector(4, data.length, 4);
+  for (let i = data.length - 1; i >= 0; i--) {
+    builder.addOffset(data[i]!);
+  }
+  return builder.endVector();
+}
+
+static startGalaxiesVector(builder:flatbuffers.Builder, numElems:number) {
+  builder.startVector(4, numElems, 4);
+}
+
+static endUniverse(builder:flatbuffers.Builder):flatbuffers.Offset {
+  const offset = builder.endObject();
+  return offset;
+}
+
+static finishUniverseBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offset) {
+  builder.finish(offset);
+}
+
+static finishSizePrefixedUniverseBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offset) {
+  builder.finish(offset, undefined, true);
+}
+
+static createUniverse(builder:flatbuffers.Builder, age:number, galaxiesOffset:flatbuffers.Offset):flatbuffers.Offset {
+  Universe.startUniverse(builder);
+  Universe.addAge(builder, age);
+  Universe.addGalaxies(builder, galaxiesOffset);
+  return Universe.endUniverse(builder);
+}
+}