refactor: strip trailing _ from fbs schema names in generated Java classes

FlatBuffers schemas use Struct_, Bool_, etc. to avoid C++ reserved-name
conflicts. That suffix is an artifact of C++ and should not appear in
generated Java identifiers.

- fbs-gen CodeGen.className(): strip trailing _ before prefixing with
  Fbs, so table Struct_ -> FbsStruct, table Bool_ -> FbsBool
- Rename FbsStruct runtime base (inline struct cursor) to FbsInlineStruct
  to free the FbsStruct name for the generated class
- Regenerate: FbsStruct_.java removed, FbsStruct.java is now the
  generated class for the Struct_ schema table; FbsType.FbsStruct_ ->
  FbsType.FbsStruct; builder factory createFbsStruct_() -> createFbsStruct()
- Update all callers in reader, writer, and tests
- Update CLAUDE.md to document the rule and the FbsInlineStruct rename

Copying dtype.fbs verbatim from the upstream spec now works without
any further generator changes.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: dfa1

CLAUDE.md

@@ -77,10 +77,13 @@ Regenerate after editing `.fbs`/`.proto` (both generators are in-house, no exter
 Both schema languages are compiled in-process to MemorySegment-native Java, with no
 `flatc`/`protoc` and no `com.google.flatbuffers`/`protobuf-java` runtime (ADR 0017):
 - **`.fbs` → `fbs-gen`** (`io.github.dfa1.vortex.fbsgen`): generates readers extending
-  `FbsTable`/`FbsStruct` and builders over `FbsBuilder`, all in the same generated package
-  `io.github.dfa1.vortex.core.fbs`. The runtime base classes `FbsTable`/`FbsStruct` are
-  package-private (only generated readers extend them); `FbsBuilder` is public because the
-  writer module assembles FlatBuffers with it.
+  `FbsTable` (vtable-based) or `FbsInlineStruct` (fixed-offset inline) and builders over
+  `FbsBuilder`, all in the same generated package `io.github.dfa1.vortex.core.fbs`. The
+  runtime base classes `FbsTable`/`FbsInlineStruct` are package-private (only generated
+  readers extend them); `FbsBuilder` is public because the writer module assembles FlatBuffers
+  with it. Schema names with a trailing `_` (e.g. `Struct_`) have the underscore stripped in
+  the generated Java class name (`FbsStruct`) — the upstream uses `_` to avoid C++ conflicts,
+  which should not appear in Java.
 - **`.proto` → `proto-gen`**: one record per message with static `decode(MemorySegment, long,
   long)` + `encode()` operating directly on a segment.
 

core/src/main/java/io/github/dfa1/vortex/core/fbs/FbsBuffer.java

@@ -7,7 +7,7 @@
 
 /// Reader and builder for the `Buffer` FlatBuffers struct (inline, 8 bytes).
 @Generated("io.github.dfa1.vortex.fbsgen.CodeGen")
-public final class FbsBuffer extends FbsStruct {
+public final class FbsBuffer extends FbsInlineStruct {
 
     /// Positions this reader at a struct.
     /// @param seg the buffer

core/src/main/java/io/github/dfa1/vortex/core/fbs/FbsInlineStruct.java

@@ -0,0 +1,76 @@
+package io.github.dfa1.vortex.core.fbs;
+
+import static io.github.dfa1.vortex.core.io.VortexFormat.LE_DOUBLE;
+import static io.github.dfa1.vortex.core.io.VortexFormat.LE_FLOAT;
+import static io.github.dfa1.vortex.core.io.VortexFormat.LE_INT;
+import static io.github.dfa1.vortex.core.io.VortexFormat.LE_LONG;
+import static io.github.dfa1.vortex.core.io.VortexFormat.LE_SHORT;
+
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.ValueLayout;
+
+/// MemorySegment-native base for generated FlatBuffers struct accessors.
+///
+/// Unlike a table, a FlatBuffers struct is a fixed-size, inline record with no
+/// vtable: every field lives at a compile-time-constant byte offset from the
+/// struct position, and every field is always present. Generated accessors read
+/// directly at `position + fieldOffset`.
+///
+/// Package-private: only the generated struct accessors in this package extend it.
+class FbsInlineStruct {
+
+    /// The backing buffer.
+    protected MemorySegment seg;
+
+    /// This struct's byte position within [#seg].
+    protected long pos;
+
+    /// Creates an unpositioned cursor; call [#init(MemorySegment, long)] before use.
+    protected FbsInlineStruct() {
+    }
+
+    /// Positions this cursor at a struct.
+    ///
+    /// @param segment  backing buffer
+    /// @param position struct position within the buffer
+    protected final void init(MemorySegment segment, long position) {
+        this.seg = segment;
+        this.pos = position;
+    }
+
+    /// @param fieldOffset constant byte offset of the field within the struct
+    /// @return the signed byte field
+    protected final byte readByte(int fieldOffset) {
+        return seg.get(ValueLayout.JAVA_BYTE, pos + fieldOffset);
+    }
+
+    /// @param fieldOffset constant byte offset of the field within the struct
+    /// @return the little-endian 16-bit field
+    protected final short readShort(int fieldOffset) {
+        return seg.get(LE_SHORT, pos + fieldOffset);
+    }
+
+    /// @param fieldOffset constant byte offset of the field within the struct
+    /// @return the little-endian 32-bit field
+    protected final int readInt(int fieldOffset) {
+        return seg.get(LE_INT, pos + fieldOffset);
+    }
+
+    /// @param fieldOffset constant byte offset of the field within the struct
+    /// @return the little-endian 64-bit field
+    protected final long readLong(int fieldOffset) {
+        return seg.get(LE_LONG, pos + fieldOffset);
+    }
+
+    /// @param fieldOffset constant byte offset of the field within the struct
+    /// @return the little-endian 32-bit float field
+    protected final float readFloat(int fieldOffset) {
+        return seg.get(LE_FLOAT, pos + fieldOffset);
+    }
+
+    /// @param fieldOffset constant byte offset of the field within the struct
+    /// @return the little-endian 64-bit double field
+    protected final double readDouble(int fieldOffset) {
+        return seg.get(LE_DOUBLE, pos + fieldOffset);
+    }
+}

core/src/main/java/io/github/dfa1/vortex/core/fbs/FbsSegmentSpec.java

@@ -7,7 +7,7 @@
 
 /// Reader and builder for the `SegmentSpec` FlatBuffers struct (inline, 16 bytes).
 @Generated("io.github.dfa1.vortex.fbsgen.CodeGen")
-public final class FbsSegmentSpec extends FbsStruct {
+public final class FbsSegmentSpec extends FbsInlineStruct {
 
     /// Positions this reader at a struct.
     /// @param seg the buffer

core/src/main/java/io/github/dfa1/vortex/core/fbs/FbsStruct.java

@@ -1,76 +1,152 @@
-package io.github.dfa1.vortex.core.fbs;
+// Generated by vortex-fbs-gen. Do not edit.
 
-import static io.github.dfa1.vortex.core.io.VortexFormat.LE_DOUBLE;
-import static io.github.dfa1.vortex.core.io.VortexFormat.LE_FLOAT;
-import static io.github.dfa1.vortex.core.io.VortexFormat.LE_INT;
-import static io.github.dfa1.vortex.core.io.VortexFormat.LE_LONG;
-import static io.github.dfa1.vortex.core.io.VortexFormat.LE_SHORT;
+package io.github.dfa1.vortex.core.fbs;
 
 import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
+import javax.annotation.processing.Generated;
+
+/// Reader and builder for the `Struct_` FlatBuffers table.
+@Generated("io.github.dfa1.vortex.fbsgen.CodeGen")
+public final class FbsStruct extends FbsTable {
+
+    /// Positions a reader at the root table of a finished buffer.
+    /// @param seg the buffer
+    /// @return a reader positioned at the root
+    public static FbsStruct getRootAsFbsStruct(MemorySegment seg) {
+        return new FbsStruct().assign(seg, FbsTable.rootPosition(seg, 0));
+    }
+
+    /// Positions this reader at a table.
+    /// @param seg the buffer
+    /// @param position the table position
+    /// @return this
+    public FbsStruct assign(MemorySegment seg, long position) {
+        init(seg, position);
+        return this;
+    }
+
+    /// @return the length of the `names` vector
+    public int namesLength() {
+        int o = fieldOffset(4);
+        return o != 0 ? vectorLength(o) : 0;
+    }
+
+    /// @param j element index
+    /// @return the j-th `names` string
+    public String names(int j) {
+        int o = fieldOffset(4);
+        return readStringAt(vectorElements(o) + (long) j * 4);
+    }
+
+    /// @return the length of the `dtypes` vector
+    public int dtypesLength() {
+        int o = fieldOffset(6);
+        return o != 0 ? vectorLength(o) : 0;
+    }
+
+    /// @param j element index
+    /// @return the j-th `dtypes` element
+    public FbsDType dtypes(int j) {
+        int o = fieldOffset(6);
+        return new FbsDType().assign(seg, indirect(vectorElements(o) + (long) j * 4));
+    }
 
-/// MemorySegment-native base for generated FlatBuffers struct accessors.
-///
-/// Unlike a table, a FlatBuffers struct is a fixed-size, inline record with no
-/// vtable: every field lives at a compile-time-constant byte offset from the
-/// struct position, and every field is always present. Generated accessors read
-/// directly at `position + fieldOffset`.
-///
-/// Package-private: only the generated struct accessors in this package extend it.
-class FbsStruct {
+    /// @return the `nullable` field
+    public boolean nullable() {
+        int o = fieldOffset(8);
+        return o != 0 ? readByte(pos + o) != 0 : false;
+    }
 
-    /// The backing buffer.
-    protected MemorySegment seg;
+    /// Sets the `names` offset field.
+    /// @param b the builder
+    /// @param offset the referenced offset
+    public static void addNames(FbsBuilder b, int offset) {
+        b.addOffset(0, offset, 0);
+    }
 
-    /// This struct's byte position within [#seg].
-    protected long pos;
+    /// Creates the `names` offset vector.
+    /// @param b the builder
+    /// @param data element offsets
+    /// @return the vector offset
+    public static int createNamesVector(FbsBuilder b, int[] data) {
+        b.startVector(4, data.length, 4);
+        for (int i = data.length - 1; i >= 0; i--) {
+            b.addOffset(data[i]);
+        }
+        return b.endVector();
+    }
+
+    /// Begins the `names` vector.
+    /// @param b the builder
+    /// @param numElems element count
+    public static void startNamesVector(FbsBuilder b, int numElems) {
+        b.startVector(4, numElems, 4);
+    }
 
-    /// Creates an unpositioned cursor; call [#init(MemorySegment, long)] before use.
-    protected FbsStruct() {
+    /// Sets the `dtypes` offset field.
+    /// @param b the builder
+    /// @param offset the referenced offset
+    public static void addDtypes(FbsBuilder b, int offset) {
+        b.addOffset(1, offset, 0);
     }
 
-    /// Positions this cursor at a struct.
-    ///
-    /// @param segment  backing buffer
-    /// @param position struct position within the buffer
-    protected final void init(MemorySegment segment, long position) {
-        this.seg = segment;
-        this.pos = position;
+    /// Creates the `dtypes` offset vector.
+    /// @param b the builder
+    /// @param data element offsets
+    /// @return the vector offset
+    public static int createDtypesVector(FbsBuilder b, int[] data) {
+        b.startVector(4, data.length, 4);
+        for (int i = data.length - 1; i >= 0; i--) {
+            b.addOffset(data[i]);
+        }
+        return b.endVector();
     }
 
-    /// @param fieldOffset constant byte offset of the field within the struct
-    /// @return the signed byte field
-    protected final byte readByte(int fieldOffset) {
-        return seg.get(ValueLayout.JAVA_BYTE, pos + fieldOffset);
+    /// Begins the `dtypes` vector.
+    /// @param b the builder
+    /// @param numElems element count
+    public static void startDtypesVector(FbsBuilder b, int numElems) {
+        b.startVector(4, numElems, 4);
     }
 
-    /// @param fieldOffset constant byte offset of the field within the struct
-    /// @return the little-endian 16-bit field
-    protected final short readShort(int fieldOffset) {
-        return seg.get(LE_SHORT, pos + fieldOffset);
+    /// Sets the `nullable` field.
+    /// @param b the builder
+    /// @param nullable value
+    public static void addNullable(FbsBuilder b, boolean nullable) {
+        b.addBoolean(2, nullable, false);
     }
 
-    /// @param fieldOffset constant byte offset of the field within the struct
-    /// @return the little-endian 32-bit field
-    protected final int readInt(int fieldOffset) {
-        return seg.get(LE_INT, pos + fieldOffset);
+    /// Builds a `FbsStruct` table.
+    /// @param b the builder
+    /// @param namesOffset field value
+    /// @param dtypesOffset field value
+    /// @param nullable field value
+    /// @return the table offset
+    public static int createFbsStruct(FbsBuilder b, int namesOffset, int dtypesOffset, boolean nullable) {
+        b.startTable(3);
+        b.addOffset(1, dtypesOffset, 0);
+        b.addOffset(0, namesOffset, 0);
+        b.addBoolean(2, nullable, false);
+        return b.endTable();
     }
 
-    /// @param fieldOffset constant byte offset of the field within the struct
-    /// @return the little-endian 64-bit field
-    protected final long readLong(int fieldOffset) {
-        return seg.get(LE_LONG, pos + fieldOffset);
+    /// Begins a `FbsStruct` table.
+    /// @param b the builder
+    public static void startFbsStruct(FbsBuilder b) {
+        b.startTable(3);
     }
 
-    /// @param fieldOffset constant byte offset of the field within the struct
-    /// @return the little-endian 32-bit float field
-    protected final float readFloat(int fieldOffset) {
-        return seg.get(LE_FLOAT, pos + fieldOffset);
+    /// Finishes a `FbsStruct` table.
+    /// @param b the builder
+    /// @return the table offset
+    public static int endFbsStruct(FbsBuilder b) {
+        return b.endTable();
     }
 
-    /// @param fieldOffset constant byte offset of the field within the struct
-    /// @return the little-endian 64-bit double field
-    protected final double readDouble(int fieldOffset) {
-        return seg.get(LE_DOUBLE, pos + fieldOffset);
+    /// Finishes the buffer with a `FbsStruct` root.
+    /// @param b the builder
+    /// @param offset the root table offset
+    public static void finishFbsStructBuffer(FbsBuilder b, int offset) {
+        b.finish(offset);
     }
 }