Fixed Lobster implementation to work with latest language features

lobster/flatbuffers.lobster

@@ -12,32 +12,33 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-include "std.lobster"
+import std
 
 namespace flatbuffers
 
-struct handle:
+class handle:
     buf_:string
     pos_:int
 
-enum + sz_8 = 1,
-       sz_16 = 2,
-       sz_32 = 4,
-       sz_64 = 8,
-       sz_voffset = 2,
-       sz_uoffset = 4,
-       sz_soffset = 4,
+enum sizeof:
+    sz_8 = 1
+    sz_16 = 2
+    sz_32 = 4
+    sz_64 = 8
+    sz_voffset = 2
+    sz_uoffset = 4
+    sz_soffset = 4
     sz_metadata_fields = 2
 
-struct builder:
-    buf:string = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+class builder:
+    buf = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
     current_vtable:[int] = []
-    head:int = 0
-    minalign:int = 1
-    object_end:int = 0
+    head = 0
+    minalign = 1
+    object_end = 0
     vtables:[int] = []
-    nested:int = false
-    finished:int = false
+    nested = false
+    finished = false
 
     // Optionally call this right after creating the builder for a larger initial buffer.
     def Initial(initial_size:int):
@@ -75,11 +76,11 @@ struct builder:
         // Prepend a zero scalar to the object. Later in this function we'll
         // write an offset here that points to the object's vtable:
         PrependInt32(0)
-        object_offset := head
+        let object_offset = head
         // Write out new vtable speculatively.
-        vtable_size := (current_vtable.length + sz_metadata_fields) * sz_voffset
+        let vtable_size = (current_vtable.length + sz_metadata_fields) * sz_voffset
         while current_vtable.length:
-            o := current_vtable.pop()
+            let o = current_vtable.pop()
             PrependVOffsetT(if o: object_offset - o else: 0)
         // The two metadata fields are written last.
         // First, store the object bytesize:
@@ -91,17 +92,18 @@ struct builder:
         // BenchmarkVtableDeduplication for a case in which this heuristic
         // saves about 30% of the time used in writing objects with duplicate
         // tables.
-        existing_vtable := do():
+        def find_existing_table():
             reverse(vtables) vt2_offset:
                 // Find the other vtable:
-                vt2_start := buf.length - vt2_offset
-                vt2_len := buf.read_int16_le(vt2_start)
+                let vt2_start = buf.length - vt2_offset
+                let vt2_len = buf.read_int16_le(vt2_start)
                 // Compare the other vtable to the one under consideration.
                 // If they are equal, return the offset:
                 if vtable_size == vt2_len and
                     not compare_substring(buf, Start(), buf, vt2_start, vtable_size):
-                        return vt2_offset from do
-            0
+                        return vt2_offset
+            return 0
+        let existing_vtable = find_existing_table()
         if existing_vtable:
             // Found a duplicate vtable, remove the one we wrote.
             head = object_offset
@@ -119,7 +121,8 @@ struct builder:
         return object_offset
 
     def Pad(n):
-        for(n): buf, head = buf.write_int8_le_back(head, 0)
+        for(n):
+            buf, head = buf.write_int8_le_back(head, 0)
 
     def Prep(size, additional_bytes):
         // Track the biggest thing we've ever aligned to.
@@ -127,7 +130,7 @@ struct builder:
             minalign = size
         // Find the amount of alignment needed such that `size` is properly
         // aligned after `additionalBytes`:
-        align_size := ((~(head + additional_bytes)) + 1) & (size - 1)
+        let align_size = ((~(head + additional_bytes)) + 1) & (size - 1)
         Pad(align_size)
 
     def PrependUOffsetTRelative(off):
@@ -172,7 +175,7 @@ struct builder:
         // Finish finalizes a buffer, pointing to the given root_table
         assert not finished
         assert not nested
-        prep_size := sz_32
+        var prep_size = sz_32
         if size_prefix:
             prep_size += sz_32
         Prep(minalign, prep_size)

samples/monster_generated.lobster

 // automatically generated by the FlatBuffers compiler, do not modify
-
-include "flatbuffers.lobster"
+import flatbuffers
 
 namespace MyGame_Sample
 
-enum + 
-    Color_Red = 0,
-    Color_Green = 1,
+enum Color:
+    Color_Red = 0
+    Color_Green = 1
     Color_Blue = 2
 
-enum + 
-    Equipment_NONE = 0,
+enum Equipment:
+    Equipment_NONE = 0
     Equipment_Weapon = 1
 
-struct Vec3
+class Vec3
 
-struct Monster
+class Monster
 
-struct Weapon
+class Weapon
 
-struct Vec3 : flatbuffers_handle
+class Vec3 : flatbuffers_handle
     def x():
-        buf_.read_float32_le(pos_ + 0)
+        return buf_.read_float32_le(pos_ + 0)
     def y():
-        buf_.read_float32_le(pos_ + 4)
+        return buf_.read_float32_le(pos_ + 4)
     def z():
-        buf_.read_float32_le(pos_ + 8)
+        return buf_.read_float32_le(pos_ + 8)
 
 def CreateVec3(b_:flatbuffers_builder, x:float, y:float, z:float):
     b_.Prep(4, 12)
@@ -34,36 +33,36 @@ def CreateVec3(b_:flatbuffers_builder, x:float, y:float, z:float):
     b_.PrependFloat32(x)
     return b_.Offset()
 
-struct Monster : flatbuffers_handle
+class Monster : flatbuffers_handle
     def pos():
-        o := buf_.flatbuffers_field_struct(pos_, 4)
-        if o: MyGame_Sample_Vec3 { buf_, o } else: nil
+        let o = buf_.flatbuffers_field_struct(pos_, 4)
+        return if o: MyGame_Sample_Vec3 { buf_, o } else: nil
     def mana():
-        buf_.flatbuffers_field_int16(pos_, 6, 150)
+        return buf_.flatbuffers_field_int16(pos_, 6, 150)
     def hp():
-        buf_.flatbuffers_field_int16(pos_, 8, 100)
+        return buf_.flatbuffers_field_int16(pos_, 8, 100)
     def name():
-        buf_.flatbuffers_field_string(pos_, 10)
+        return buf_.flatbuffers_field_string(pos_, 10)
     def inventory(i:int):
-        buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 14) + i * 1)
+        return buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 14) + i * 1)
     def inventory_length():
-        buf_.flatbuffers_field_vector_len(pos_, 14)
+        return buf_.flatbuffers_field_vector_len(pos_, 14)
     def color():
-        buf_.flatbuffers_field_int8(pos_, 16, 2)
+        return buf_.flatbuffers_field_int8(pos_, 16, 2)
     def weapons(i:int):
-        MyGame_Sample_Weapon { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 18) + i * 4) }
+        return MyGame_Sample_Weapon { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 18) + i * 4) }
     def weapons_length():
-        buf_.flatbuffers_field_vector_len(pos_, 18)
+        return buf_.flatbuffers_field_vector_len(pos_, 18)
     def equipped_type():
-        buf_.flatbuffers_field_int8(pos_, 20, 0)
+        return buf_.flatbuffers_field_int8(pos_, 20, 0)
     def equipped_as_Weapon():
-        MyGame_Sample_Weapon { buf_, buf_.flatbuffers_field_table(pos_, 22) }
+        return MyGame_Sample_Weapon { buf_, buf_.flatbuffers_field_table(pos_, 22) }
     def path(i:int):
-        MyGame_Sample_Vec3 { buf_, buf_.flatbuffers_field_vector(pos_, 24) + i * 12 }
+        return MyGame_Sample_Vec3 { buf_, buf_.flatbuffers_field_vector(pos_, 24) + i * 12 }
     def path_length():
-        buf_.flatbuffers_field_vector_len(pos_, 24)
+        return buf_.flatbuffers_field_vector_len(pos_, 24)
 
-def GetRootAsMonster(buf:string): Monster { buf, buf.flatbuffers_indirect(0) }
+def GetRootAsMonster(buf:string): return Monster { buf, buf.flatbuffers_indirect(0) }
 
 def MonsterStart(b_:flatbuffers_builder):
     b_.StartObject(11)
@@ -82,7 +81,7 @@ def MonsterStartInventoryVector(b_:flatbuffers_builder, n_:int):
 def MonsterCreateInventoryVector(b_:flatbuffers_builder, v_:[int]):
     b_.StartVector(1, v_.length, 1)
     reverse(v_) e_: b_.PrependUint8(e_)
-    b_.EndVector(v_.length)
+    return b_.EndVector(v_.length)
 def MonsterAddColor(b_:flatbuffers_builder, color:int):
     b_.PrependInt8Slot(6, color, 2)
 def MonsterAddWeapons(b_:flatbuffers_builder, weapons:int):
@@ -92,7 +91,7 @@ def MonsterStartWeaponsVector(b_:flatbuffers_builder, n_:int):
 def MonsterCreateWeaponsVector(b_:flatbuffers_builder, v_:[int]):
     b_.StartVector(4, v_.length, 4)
     reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
-    b_.EndVector(v_.length)
+    return b_.EndVector(v_.length)
 def MonsterAddEquippedType(b_:flatbuffers_builder, equipped_type:int):
     b_.PrependUint8Slot(8, equipped_type, 0)
 def MonsterAddEquipped(b_:flatbuffers_builder, equipped:int):
@@ -102,15 +101,15 @@ def MonsterAddPath(b_:flatbuffers_builder, path:int):
 def MonsterStartPathVector(b_:flatbuffers_builder, n_:int):
     b_.StartVector(12, n_, 4)
 def MonsterEnd(b_:flatbuffers_builder):
-    b_.EndObject()
+    return b_.EndObject()
 
-struct Weapon : flatbuffers_handle
+class Weapon : flatbuffers_handle
     def name():
-        buf_.flatbuffers_field_string(pos_, 4)
+        return buf_.flatbuffers_field_string(pos_, 4)
     def damage():
-        buf_.flatbuffers_field_int16(pos_, 6, 0)
+        return buf_.flatbuffers_field_int16(pos_, 6, 0)
 
-def GetRootAsWeapon(buf:string): Weapon { buf, buf.flatbuffers_indirect(0) }
+def GetRootAsWeapon(buf:string): return Weapon { buf, buf.flatbuffers_indirect(0) }
 
 def WeaponStart(b_:flatbuffers_builder):
     b_.StartObject(2)
@@ -119,5 +118,5 @@ def WeaponAddName(b_:flatbuffers_builder, name:int):
 def WeaponAddDamage(b_:flatbuffers_builder, damage:int):
     b_.PrependInt16Slot(1, damage, 0)
 def WeaponEnd(b_:flatbuffers_builder):
-    b_.EndObject()
+    return b_.EndObject()
 

samples/sample_binary.lobster

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-include from "../lobster/"
-include "monster_generated.lobster"
+import from "../lobster/"
+import monster_generated
 
 // Example of how to use FlatBuffers to create and read binary buffers.
 
@@ -24,7 +24,7 @@ let b = flatbuffers_builder {}
 let weapon_names = [ "Sword", "Axe" ]
 let weapon_damages = [ 3, 5 ]
 
-weapon_offsets := map(weapon_names) name, i:
+let weapon_offsets = map(weapon_names) name, i:
     let ns = b.CreateString(name)
     b.MyGame_Sample_WeaponStart()
     b.MyGame_Sample_WeaponAddName(ns)

samples/sample_text.lobster

@@ -12,20 +12,20 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-include from "../lobster/"
-include "monster_generated.lobster"
+import from "../lobster/"
+import monster_generated
 
 // Example how to interop with JSON.
 
 // Test loading some JSON, converting it to a binary FlatBuffer and back again.
 
 // First read the schema and JSON data.
-schema := read_file("monster.fbs", true)
-json := read_file("monsterdata.json", true)
+let schema = read_file("monster.fbs", true)
+let json = read_file("monsterdata.json", true)
 assert schema and json
 
 // Parse JSON  to binary:
-fb, err1 := flatbuffers_json_to_binary(schema, json, [])
+let fb, err1 = flatbuffers_json_to_binary(schema, json, [])
 assert not err1
 
 // Access one field in it, just to check:
@@ -33,7 +33,7 @@ let monster = MyGame_Sample_GetRootAsMonster(fb)
 assert monster.name == "Orc"
 
 // Convert binary back to JSON:
-json2, err2 := flatbuffers_binary_to_json(schema, fb, [])
+let json2, err2 = flatbuffers_binary_to_json(schema, fb, [])
 assert not err2
 
 // The generated JSON should be exactly equal to the original!

src/idl_gen_lobster.cpp

@@ -31,7 +31,7 @@ class LobsterGenerator : public BaseGenerator {
                   const std::string &file_name)
       : BaseGenerator(parser, path, file_name, "" /* not used */, "_") {
     static const char * const keywords[] = {
-      "nil", "true", "false", "return", "struct", "value", "include", "int",
+      "nil", "true", "false", "return", "struct", "class", "import", "int",
       "float", "string", "any", "def", "is", "from", "program", "private",
       "coroutine", "resource", "enum", "typeof", "var", "let", "pakfile",
       "switch", "case", "default", "namespace", "not", "and", "or", "bool",
@@ -99,11 +99,11 @@ class LobsterGenerator : public BaseGenerator {
     auto def = "    def " + NormalizedName(field);
     if (IsScalar(field.value.type.base_type)) {
       if (struct_def.fixed) {
-        code += def + "():\n        buf_.read_" +
+        code += def + "():\n        return buf_.read_" +
                 GenTypeName(field.value.type) + "_le(pos_ + " + offsets +
                 ")\n";
       } else {
-        code += def + "():\n        buf_.flatbuffers_field_" +
+        code += def + "():\n        return buf_.flatbuffers_field_" +
                 GenTypeName(field.value.type) + "(pos_, " + offsets + ", " +
                 field.value.constant + ")\n";
       }
@@ -114,22 +114,22 @@ class LobsterGenerator : public BaseGenerator {
         auto name = NamespacedName(*field.value.type.struct_def);
         code += def + "():\n        ";
         if (struct_def.fixed) {
-          code += name + "{ buf_, pos_ + " + offsets + " }\n";
+          code += "return " + name + "{ buf_, pos_ + " + offsets + " }\n";
         } else {
-          code += std::string("o := buf_.flatbuffers_field_") +
+          code += std::string("let o = buf_.flatbuffers_field_") +
                   (field.value.type.struct_def->fixed ? "struct" : "table") +
-                  "(pos_, " + offsets + ")\n        if o: " + name +
+                  "(pos_, " + offsets + ")\n        return if o: " + name +
                   " { buf_, o } else: nil\n";
         }
         break;
       }
       case BASE_TYPE_STRING:
-        code += def + "():\n        buf_.flatbuffers_field_string(pos_, " +
+        code += def + "():\n        return buf_.flatbuffers_field_string(pos_, " +
                 offsets + ")\n";
         break;
       case BASE_TYPE_VECTOR: {
         auto vectortype = field.value.type.VectorType();
-        code += def + "(i:int):\n        ";
+        code += def + "(i:int):\n        return ";
         if (vectortype.base_type == BASE_TYPE_STRUCT) {
           auto start = "buf_.flatbuffers_field_vector(pos_, " + offsets +
                        ") + i * " + NumToString(InlineSize(vectortype));
@@ -153,7 +153,7 @@ class LobsterGenerator : public BaseGenerator {
              it != field.value.type.enum_def->Vals().end(); ++it) {
           auto &ev = **it;
           if (ev.IsNonZero()) {
-            code += def + "_as_" + ev.name + "():\n        " +
+            code += def + "_as_" + ev.name + "():\n        return " +
                     NamespacedName(*ev.union_type.struct_def) +
                     " { buf_, buf_.flatbuffers_field_table(pos_, " + offsets +
                     ") }\n";
@@ -165,7 +165,7 @@ class LobsterGenerator : public BaseGenerator {
     }
     if (field.value.type.base_type == BASE_TYPE_VECTOR) {
       code += def +
-              "_length():\n        buf_.flatbuffers_field_vector_len(pos_, " +
+              "_length():\n        return buf_.flatbuffers_field_vector_len(pos_, " +
               offsets + ")\n";
     }
   }
@@ -207,19 +207,19 @@ class LobsterGenerator : public BaseGenerator {
                   NumToString(alignment) +
                   ")\n    reverse(v_) e_: b_.Prepend" +
                   GenMethod(vector_type) +
-                  "(e_)\n    b_.EndVector(v_.length)\n";
+                  "(e_)\n    return b_.EndVector(v_.length)\n";
         }
       }
     }
     code += "def " + NormalizedName(struct_def) +
-            "End(b_:flatbuffers_builder):\n    b_.EndObject()\n\n";
+            "End(b_:flatbuffers_builder):\n    return b_.EndObject()\n\n";
   }
 
   void GenStructPreDecl(const StructDef &struct_def, std::string *code_ptr) {
     if (struct_def.generated) return;
     std::string &code = *code_ptr;
     CheckNameSpace(struct_def, &code);
-    code += "struct " + NormalizedName(struct_def) + "\n\n";
+    code += "class " + NormalizedName(struct_def) + "\n\n";
   }
 
   // Generate struct or table methods.
@@ -228,7 +228,7 @@ class LobsterGenerator : public BaseGenerator {
     std::string &code = *code_ptr;
     CheckNameSpace(struct_def, &code);
     GenComment(struct_def.doc_comment, code_ptr, nullptr, "");
-    code += "struct " + NormalizedName(struct_def) + " : flatbuffers_handle\n";
+    code += "class " + NormalizedName(struct_def) + " : flatbuffers_handle\n";
     for (auto it = struct_def.fields.vec.begin();
         it != struct_def.fields.vec.end(); ++it) {
       auto &field = **it;
@@ -239,7 +239,7 @@ class LobsterGenerator : public BaseGenerator {
     if (!struct_def.fixed) {
       // Generate a special accessor for the table that has been declared as
       // the root type.
-      code += "def GetRootAs" + NormalizedName(struct_def) + "(buf:string): " +
+      code += "def GetRootAs" + NormalizedName(struct_def) + "(buf:string): return " +
               NormalizedName(struct_def) +
               " { buf, buf.flatbuffers_indirect(0) }\n\n";
     }
@@ -258,14 +258,12 @@ class LobsterGenerator : public BaseGenerator {
     std::string &code = *code_ptr;
     CheckNameSpace(enum_def, &code);
     GenComment(enum_def.doc_comment, code_ptr, nullptr, "");
-    code += "enum + \n";
+    code += "enum " + NormalizedName(enum_def) + ":\n";
     for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
       auto &ev = **it;
       GenComment(ev.doc_comment, code_ptr, nullptr, "    ");
       code += "    " + enum_def.name + "_" + NormalizedName(ev) + " = " +
-              enum_def.ToString(ev);
-      if (it + 1 != enum_def.Vals().end()) code += ",";
-      code += "\n";
+              enum_def.ToString(ev) + "\n";
     }
     code += "\n";
   }
@@ -336,7 +334,7 @@ class LobsterGenerator : public BaseGenerator {
   bool generate() {
     std::string code;
     code += std::string("// ") + FlatBuffersGeneratedWarning() +
-            "\n\ninclude \"flatbuffers.lobster\"\n\n";
+            "\nimport flatbuffers\n\n";
     for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
          ++it) {
       auto &enum_def = **it;

tests/lobstertest.lobster

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-include from "../lobster/"
-include "monster_test_generated.lobster"
+import from "../lobster/"
+import monster_test_generated
 
 def check_read_buffer(buf):
     // CheckReadBuffer checks that the given buffer is evaluated correctly as the example Monster.
@@ -119,14 +119,14 @@ check_read_buffer(fb1)
 write_file("monsterdata_lobster_wire.mon", fb1)
 
 // Test converting the buffer to JSON and parsing the JSON back again.
-schema := read_file("monster_test.fbs")
+let schema = read_file("monster_test.fbs")
 assert schema
-includedirs := [ "include_test" ]
+let includedirs = [ "include_test" ]
 // Convert binary to JSON:
-json, err1 := flatbuffers_binary_to_json(schema, fb1, includedirs)
+let json, err1 = flatbuffers_binary_to_json(schema, fb1, includedirs)
 assert not err1
 // Parse JSON back to binary:
-fb3, err2 := flatbuffers_json_to_binary(schema, json, includedirs)
+let fb3, err2 = flatbuffers_json_to_binary(schema, json, includedirs)
 assert not err2
 // Check the resulting binary again (full roundtrip test):
 check_read_buffer(fb3)

tests/monster_test_generated.lobster

 // automatically generated by the FlatBuffers compiler, do not modify
-
-include "flatbuffers.lobster"
+import flatbuffers
 
 namespace MyGame_Example
 
-enum + 
-    Color_Red = 1,
-    Color_Green = 2,
+enum Color:
+    Color_Red = 1
+    Color_Green = 2
     Color_Blue = 8
 
-enum + 
-    Any_NONE = 0,
-    Any_Monster = 1,
-    Any_TestSimpleTableWithEnum = 2,
+enum Any:
+    Any_NONE = 0
+    Any_Monster = 1
+    Any_TestSimpleTableWithEnum = 2
     Any_MyGame_Example2_Monster = 3
 
-enum + 
-    AnyUniqueAliases_NONE = 0,
-    AnyUniqueAliases_M = 1,
-    AnyUniqueAliases_T = 2,
+enum AnyUniqueAliases:
+    AnyUniqueAliases_NONE = 0
+    AnyUniqueAliases_M = 1
+    AnyUniqueAliases_T = 2
     AnyUniqueAliases_M2 = 3
 
-enum + 
-    AnyAmbiguousAliases_NONE = 0,
-    AnyAmbiguousAliases_M1 = 1,
-    AnyAmbiguousAliases_M2 = 2,
+enum AnyAmbiguousAliases:
+    AnyAmbiguousAliases_NONE = 0
+    AnyAmbiguousAliases_M1 = 1
+    AnyAmbiguousAliases_M2 = 2
     AnyAmbiguousAliases_M3 = 3
 
 namespace MyGame
 
-struct InParentNamespace
+class InParentNamespace
 
 namespace MyGame_Example2
 
-struct Monster
+class Monster
 
 namespace MyGame_Example
 
-struct Test
+class Test
 
-struct TestSimpleTableWithEnum
+class TestSimpleTableWithEnum
 
-struct Vec3
+class Vec3
 
-struct Ability
+class Ability
 
-struct Stat
+class Stat
 
-struct Referrable
+class Referrable
 
-struct Monster
+class Monster
 
-struct TypeAliases
+class TypeAliases
 
 namespace MyGame
 
-struct InParentNamespace : flatbuffers_handle
+class InParentNamespace : flatbuffers_handle
 
-def GetRootAsInParentNamespace(buf:string): InParentNamespace { buf, buf.flatbuffers_indirect(0) }
+def GetRootAsInParentNamespace(buf:string): return InParentNamespace { buf, buf.flatbuffers_indirect(0) }
 
 def InParentNamespaceStart(b_:flatbuffers_builder):
     b_.StartObject(0)
 def InParentNamespaceEnd(b_:flatbuffers_builder):
-    b_.EndObject()
+    return b_.EndObject()
 
 namespace MyGame_Example2
 
-struct Monster : flatbuffers_handle
+class Monster : flatbuffers_handle
 
-def GetRootAsMonster(buf:string): Monster { buf, buf.flatbuffers_indirect(0) }
+def GetRootAsMonster(buf:string): return Monster { buf, buf.flatbuffers_indirect(0) }
 
 def MonsterStart(b_:flatbuffers_builder):
     b_.StartObject(0)
 def MonsterEnd(b_:flatbuffers_builder):
-    b_.EndObject()
+    return b_.EndObject()
 
 namespace MyGame_Example
 
-struct Test : flatbuffers_handle
+class Test : flatbuffers_handle
     def a():
-        buf_.read_int16_le(pos_ + 0)
+        return buf_.read_int16_le(pos_ + 0)
     def b():
-        buf_.read_int8_le(pos_ + 2)
+        return buf_.read_int8_le(pos_ + 2)
 
 def CreateTest(b_:flatbuffers_builder, a:int, b:int):
     b_.Prep(2, 4)
@@ -90,32 +89,32 @@ def CreateTest(b_:flatbuffers_builder, a:int, b:int):
     b_.PrependInt16(a)
     return b_.Offset()
 
-struct TestSimpleTableWithEnum : flatbuffers_handle
+class TestSimpleTableWithEnum : flatbuffers_handle
     def color():
-        buf_.flatbuffers_field_int8(pos_, 4, 2)
+        return buf_.flatbuffers_field_int8(pos_, 4, 2)
 
-def GetRootAsTestSimpleTableWithEnum(buf:string): TestSimpleTableWithEnum { buf, buf.flatbuffers_indirect(0) }
+def GetRootAsTestSimpleTableWithEnum(buf:string): return TestSimpleTableWithEnum { buf, buf.flatbuffers_indirect(0) }
 
 def TestSimpleTableWithEnumStart(b_:flatbuffers_builder):
     b_.StartObject(1)
 def TestSimpleTableWithEnumAddColor(b_:flatbuffers_builder, color:int):
     b_.PrependUint8Slot(0, color, 2)
 def TestSimpleTableWithEnumEnd(b_:flatbuffers_builder):
-    b_.EndObject()
+    return b_.EndObject()
 
-struct Vec3 : flatbuffers_handle
+class Vec3 : flatbuffers_handle
     def x():
-        buf_.read_float32_le(pos_ + 0)
+        return buf_.read_float32_le(pos_ + 0)
     def y():
-        buf_.read_float32_le(pos_ + 4)
+        return buf_.read_float32_le(pos_ + 4)
     def z():
-        buf_.read_float32_le(pos_ + 8)
+        return buf_.read_float32_le(pos_ + 8)
     def test1():
-        buf_.read_float64_le(pos_ + 16)
+        return buf_.read_float64_le(pos_ + 16)
     def test2():
-        buf_.read_int8_le(pos_ + 24)
+        return buf_.read_int8_le(pos_ + 24)
     def test3():
-        MyGame_Example_Test{ buf_, pos_ + 26 }
+        return MyGame_Example_Test{ buf_, pos_ + 26 }
 
 def CreateVec3(b_:flatbuffers_builder, x:float, y:float, z:float, test1:float, test2:int, test3_a:int, test3_b:int):
     b_.Prep(8, 32)
@@ -133,11 +132,11 @@ def CreateVec3(b_:flatbuffers_builder, x:float, y:float, z:float, test1:float, t
     b_.PrependFloat32(x)
     return b_.Offset()
 
-struct Ability : flatbuffers_handle
+class Ability : flatbuffers_handle
     def id():
-        buf_.read_int32_le(pos_ + 0)
+        return buf_.read_int32_le(pos_ + 0)
     def distance():
-        buf_.read_int32_le(pos_ + 4)
+        return buf_.read_int32_le(pos_ + 4)
 
 def CreateAbility(b_:flatbuffers_builder, id:int, distance:int):
     b_.Prep(4, 8)
@@ -145,15 +144,15 @@ def CreateAbility(b_:flatbuffers_builder, id:int, distance:int):
     b_.PrependUint32(id)
     return b_.Offset()
 
-struct Stat : flatbuffers_handle
+class Stat : flatbuffers_handle
     def id():
-        buf_.flatbuffers_field_string(pos_, 4)
+        return buf_.flatbuffers_field_string(pos_, 4)
     def val():
-        buf_.flatbuffers_field_int64(pos_, 6, 0)
+        return buf_.flatbuffers_field_int64(pos_, 6, 0)
     def count():
-        buf_.flatbuffers_field_int16(pos_, 8, 0)
+        return buf_.flatbuffers_field_int16(pos_, 8, 0)
 
-def GetRootAsStat(buf:string): Stat { buf, buf.flatbuffers_indirect(0) }
+def GetRootAsStat(buf:string): return Stat { buf, buf.flatbuffers_indirect(0) }
 
 def StatStart(b_:flatbuffers_builder):
     b_.StartObject(3)
@@ -164,173 +163,173 @@ def StatAddVal(b_:flatbuffers_builder, val:int):
 def StatAddCount(b_:flatbuffers_builder, count:int):
     b_.PrependUint16Slot(2, count, 0)
 def StatEnd(b_:flatbuffers_builder):
-    b_.EndObject()
+    return b_.EndObject()
 
-struct Referrable : flatbuffers_handle
+class Referrable : flatbuffers_handle
     def id():
-        buf_.flatbuffers_field_int64(pos_, 4, 0)
+        return buf_.flatbuffers_field_int64(pos_, 4, 0)
 
-def GetRootAsReferrable(buf:string): Referrable { buf, buf.flatbuffers_indirect(0) }
+def GetRootAsReferrable(buf:string): return Referrable { buf, buf.flatbuffers_indirect(0) }
 
 def ReferrableStart(b_:flatbuffers_builder):
     b_.StartObject(1)
 def ReferrableAddId(b_:flatbuffers_builder, id:int):
     b_.PrependUint64Slot(0, id, 0)
 def ReferrableEnd(b_:flatbuffers_builder):
-    b_.EndObject()
+    return b_.EndObject()
 
 /// an example documentation comment: monster object
-struct Monster : flatbuffers_handle
+class Monster : flatbuffers_handle
     def pos():
-        o := buf_.flatbuffers_field_struct(pos_, 4)
-        if o: MyGame_Example_Vec3 { buf_, o } else: nil
+        let o = buf_.flatbuffers_field_struct(pos_, 4)
+        return if o: MyGame_Example_Vec3 { buf_, o } else: nil
     def mana():
-        buf_.flatbuffers_field_int16(pos_, 6, 150)
+        return buf_.flatbuffers_field_int16(pos_, 6, 150)
     def hp():
-        buf_.flatbuffers_field_int16(pos_, 8, 100)
+        return buf_.flatbuffers_field_int16(pos_, 8, 100)
     def name():
-        buf_.flatbuffers_field_string(pos_, 10)
+        return buf_.flatbuffers_field_string(pos_, 10)
     def inventory(i:int):
-        buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 14) + i * 1)
+        return buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 14) + i * 1)
     def inventory_length():
-        buf_.flatbuffers_field_vector_len(pos_, 14)
+        return buf_.flatbuffers_field_vector_len(pos_, 14)
     def color():
-        buf_.flatbuffers_field_int8(pos_, 16, 8)
+        return buf_.flatbuffers_field_int8(pos_, 16, 8)
     def test_type():
-        buf_.flatbuffers_field_int8(pos_, 18, 0)
+        return buf_.flatbuffers_field_int8(pos_, 18, 0)
     def test_as_Monster():
-        MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 20) }
+        return MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 20) }
     def test_as_TestSimpleTableWithEnum():
-        MyGame_Example_TestSimpleTableWithEnum { buf_, buf_.flatbuffers_field_table(pos_, 20) }
+        return MyGame_Example_TestSimpleTableWithEnum { buf_, buf_.flatbuffers_field_table(pos_, 20) }
     def test_as_MyGame_Example2_Monster():
-        MyGame_Example2_Monster { buf_, buf_.flatbuffers_field_table(pos_, 20) }
+        return MyGame_Example2_Monster { buf_, buf_.flatbuffers_field_table(pos_, 20) }
     def test4(i:int):
-        MyGame_Example_Test { buf_, buf_.flatbuffers_field_vector(pos_, 22) + i * 4 }
+        return MyGame_Example_Test { buf_, buf_.flatbuffers_field_vector(pos_, 22) + i * 4 }
     def test4_length():
-        buf_.flatbuffers_field_vector_len(pos_, 22)
+        return buf_.flatbuffers_field_vector_len(pos_, 22)
     def testarrayofstring(i:int):
-        buf_.flatbuffers_string(buf_.flatbuffers_field_vector(pos_, 24) + i * 4)
+        return buf_.flatbuffers_string(buf_.flatbuffers_field_vector(pos_, 24) + i * 4)
     def testarrayofstring_length():
-        buf_.flatbuffers_field_vector_len(pos_, 24)
+        return buf_.flatbuffers_field_vector_len(pos_, 24)
     /// an example documentation comment: this will end up in the generated code
     /// multiline too
     def testarrayoftables(i:int):
-        MyGame_Example_Monster { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 26) + i * 4) }
+        return MyGame_Example_Monster { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 26) + i * 4) }
     def testarrayoftables_length():
-        buf_.flatbuffers_field_vector_len(pos_, 26)
+        return buf_.flatbuffers_field_vector_len(pos_, 26)
     def enemy():
-        o := buf_.flatbuffers_field_table(pos_, 28)
-        if o: MyGame_Example_Monster { buf_, o } else: nil
+        let o = buf_.flatbuffers_field_table(pos_, 28)
+        return if o: MyGame_Example_Monster { buf_, o } else: nil
     def testnestedflatbuffer(i:int):
-        buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 30) + i * 1)
+        return buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 30) + i * 1)
     def testnestedflatbuffer_length():
-        buf_.flatbuffers_field_vector_len(pos_, 30)
+        return buf_.flatbuffers_field_vector_len(pos_, 30)
     def testempty():
-        o := buf_.flatbuffers_field_table(pos_, 32)
-        if o: MyGame_Example_Stat { buf_, o } else: nil
+        let o = buf_.flatbuffers_field_table(pos_, 32)
+        return if o: MyGame_Example_Stat { buf_, o } else: nil
     def testbool():
-        buf_.flatbuffers_field_int8(pos_, 34, 0)
+        return buf_.flatbuffers_field_int8(pos_, 34, 0)
     def testhashs32_fnv1():
-        buf_.flatbuffers_field_int32(pos_, 36, 0)
+        return buf_.flatbuffers_field_int32(pos_, 36, 0)
     def testhashu32_fnv1():
-        buf_.flatbuffers_field_int32(pos_, 38, 0)
+        return buf_.flatbuffers_field_int32(pos_, 38, 0)
     def testhashs64_fnv1():
-        buf_.flatbuffers_field_int64(pos_, 40, 0)
+        return buf_.flatbuffers_field_int64(pos_, 40, 0)
     def testhashu64_fnv1():
-        buf_.flatbuffers_field_int64(pos_, 42, 0)
+        return buf_.flatbuffers_field_int64(pos_, 42, 0)
     def testhashs32_fnv1a():
-        buf_.flatbuffers_field_int32(pos_, 44, 0)
+        return buf_.flatbuffers_field_int32(pos_, 44, 0)
     def testhashu32_fnv1a():
-        buf_.flatbuffers_field_int32(pos_, 46, 0)
+        return buf_.flatbuffers_field_int32(pos_, 46, 0)
     def testhashs64_fnv1a():
-        buf_.flatbuffers_field_int64(pos_, 48, 0)
+        return buf_.flatbuffers_field_int64(pos_, 48, 0)
     def testhashu64_fnv1a():
-        buf_.flatbuffers_field_int64(pos_, 50, 0)
+        return buf_.flatbuffers_field_int64(pos_, 50, 0)
     def testarrayofbools(i:int):
-        buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 52) + i * 1)
+        return buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 52) + i * 1)
     def testarrayofbools_length():
-        buf_.flatbuffers_field_vector_len(pos_, 52)
+        return buf_.flatbuffers_field_vector_len(pos_, 52)
     def testf():
-        buf_.flatbuffers_field_float32(pos_, 54, 3.14159)
+        return buf_.flatbuffers_field_float32(pos_, 54, 3.14159)
     def testf2():
-        buf_.flatbuffers_field_float32(pos_, 56, 3.0)
+        return buf_.flatbuffers_field_float32(pos_, 56, 3.0)
     def testf3():
-        buf_.flatbuffers_field_float32(pos_, 58, 0.0)
+        return buf_.flatbuffers_field_float32(pos_, 58, 0.0)
     def testarrayofstring2(i:int):
-        buf_.flatbuffers_string(buf_.flatbuffers_field_vector(pos_, 60) + i * 4)
+        return buf_.flatbuffers_string(buf_.flatbuffers_field_vector(pos_, 60) + i * 4)
     def testarrayofstring2_length():
-        buf_.flatbuffers_field_vector_len(pos_, 60)
+        return buf_.flatbuffers_field_vector_len(pos_, 60)
     def testarrayofsortedstruct(i:int):
-        MyGame_Example_Ability { buf_, buf_.flatbuffers_field_vector(pos_, 62) + i * 8 }
+        return MyGame_Example_Ability { buf_, buf_.flatbuffers_field_vector(pos_, 62) + i * 8 }
     def testarrayofsortedstruct_length():
-        buf_.flatbuffers_field_vector_len(pos_, 62)
+        return buf_.flatbuffers_field_vector_len(pos_, 62)
     def flex(i:int):
-        buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 64) + i * 1)
+        return buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 64) + i * 1)
     def flex_length():
-        buf_.flatbuffers_field_vector_len(pos_, 64)
+        return buf_.flatbuffers_field_vector_len(pos_, 64)
     def test5(i:int):
-        MyGame_Example_Test { buf_, buf_.flatbuffers_field_vector(pos_, 66) + i * 4 }
+        return MyGame_Example_Test { buf_, buf_.flatbuffers_field_vector(pos_, 66) + i * 4 }
     def test5_length():
-        buf_.flatbuffers_field_vector_len(pos_, 66)
+        return buf_.flatbuffers_field_vector_len(pos_, 66)
     def vector_of_longs(i:int):
-        buf_.read_int64_le(buf_.flatbuffers_field_vector(pos_, 68) + i * 8)
+        return buf_.read_int64_le(buf_.flatbuffers_field_vector(pos_, 68) + i * 8)
     def vector_of_longs_length():
-        buf_.flatbuffers_field_vector_len(pos_, 68)
+        return buf_.flatbuffers_field_vector_len(pos_, 68)
     def vector_of_doubles(i:int):
-        buf_.read_float64_le(buf_.flatbuffers_field_vector(pos_, 70) + i * 8)
+        return buf_.read_float64_le(buf_.flatbuffers_field_vector(pos_, 70) + i * 8)
     def vector_of_doubles_length():
-        buf_.flatbuffers_field_vector_len(pos_, 70)
+        return buf_.flatbuffers_field_vector_len(pos_, 70)
     def parent_namespace_test():
-        o := buf_.flatbuffers_field_table(pos_, 72)
-        if o: MyGame_InParentNamespace { buf_, o } else: nil
+        let o = buf_.flatbuffers_field_table(pos_, 72)
+        return if o: MyGame_InParentNamespace { buf_, o } else: nil
     def vector_of_referrables(i:int):
-        MyGame_Example_Referrable { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 74) + i * 4) }
+        return MyGame_Example_Referrable { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 74) + i * 4) }
     def vector_of_referrables_length():
-        buf_.flatbuffers_field_vector_len(pos_, 74)
+        return buf_.flatbuffers_field_vector_len(pos_, 74)
     def single_weak_reference():
-        buf_.flatbuffers_field_int64(pos_, 76, 0)
+        return buf_.flatbuffers_field_int64(pos_, 76, 0)
     def vector_of_weak_references(i:int):
-        buf_.read_int64_le(buf_.flatbuffers_field_vector(pos_, 78) + i * 8)
+        return buf_.read_int64_le(buf_.flatbuffers_field_vector(pos_, 78) + i * 8)
     def vector_of_weak_references_length():
-        buf_.flatbuffers_field_vector_len(pos_, 78)
+        return buf_.flatbuffers_field_vector_len(pos_, 78)
     def vector_of_strong_referrables(i:int):
-        MyGame_Example_Referrable { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 80) + i * 4) }
+        return MyGame_Example_Referrable { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 80) + i * 4) }
     def vector_of_strong_referrables_length():
-        buf_.flatbuffers_field_vector_len(pos_, 80)
+        return buf_.flatbuffers_field_vector_len(pos_, 80)
     def co_owning_reference():
-        buf_.flatbuffers_field_int64(pos_, 82, 0)
+        return buf_.flatbuffers_field_int64(pos_, 82, 0)
     def vector_of_co_owning_references(i:int):
-        buf_.read_int64_le(buf_.flatbuffers_field_vector(pos_, 84) + i * 8)
+        return buf_.read_int64_le(buf_.flatbuffers_field_vector(pos_, 84) + i * 8)
     def vector_of_co_owning_references_length():
-        buf_.flatbuffers_field_vector_len(pos_, 84)
+        return buf_.flatbuffers_field_vector_len(pos_, 84)
     def non_owning_reference():
-        buf_.flatbuffers_field_int64(pos_, 86, 0)
+        return buf_.flatbuffers_field_int64(pos_, 86, 0)
     def vector_of_non_owning_references(i:int):
-        buf_.read_int64_le(buf_.flatbuffers_field_vector(pos_, 88) + i * 8)
+        return buf_.read_int64_le(buf_.flatbuffers_field_vector(pos_, 88) + i * 8)
     def vector_of_non_owning_references_length():
-        buf_.flatbuffers_field_vector_len(pos_, 88)
+        return buf_.flatbuffers_field_vector_len(pos_, 88)
     def any_unique_type():
-        buf_.flatbuffers_field_int8(pos_, 90, 0)
+        return buf_.flatbuffers_field_int8(pos_, 90, 0)
     def any_unique_as_M():
-        MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 92) }
+        return MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 92) }
     def any_unique_as_T():
-        MyGame_Example_TestSimpleTableWithEnum { buf_, buf_.flatbuffers_field_table(pos_, 92) }
+        return MyGame_Example_TestSimpleTableWithEnum { buf_, buf_.flatbuffers_field_table(pos_, 92) }
     def any_unique_as_M2():
-        MyGame_Example2_Monster { buf_, buf_.flatbuffers_field_table(pos_, 92) }
+        return MyGame_Example2_Monster { buf_, buf_.flatbuffers_field_table(pos_, 92) }
     def any_ambiguous_type():
-        buf_.flatbuffers_field_int8(pos_, 94, 0)
+        return buf_.flatbuffers_field_int8(pos_, 94, 0)
     def any_ambiguous_as_M1():
-        MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 96) }
+        return MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 96) }
     def any_ambiguous_as_M2():
-        MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 96) }
+        return MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 96) }
     def any_ambiguous_as_M3():
-        MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 96) }
+        return MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 96) }
     def vector_of_enums(i:int):
-        buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 98) + i * 1)
+        return buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 98) + i * 1)
     def vector_of_enums_length():
-        buf_.flatbuffers_field_vector_len(pos_, 98)
+        return buf_.flatbuffers_field_vector_len(pos_, 98)
 
-def GetRootAsMonster(buf:string): Monster { buf, buf.flatbuffers_indirect(0) }
+def GetRootAsMonster(buf:string): return Monster { buf, buf.flatbuffers_indirect(0) }
 
 def MonsterStart(b_:flatbuffers_builder):
     b_.StartObject(48)
@@ -349,7 +348,7 @@ def MonsterStartInventoryVector(b_:flatbuffers_builder, n_:int):
 def MonsterCreateInventoryVector(b_:flatbuffers_builder, v_:[int]):
     b_.StartVector(1, v_.length, 1)
     reverse(v_) e_: b_.PrependUint8(e_)
-    b_.EndVector(v_.length)
+    return b_.EndVector(v_.length)
 def MonsterAddColor(b_:flatbuffers_builder, color:int):
     b_.PrependUint8Slot(6, color, 8)
 def MonsterAddTestType(b_:flatbuffers_builder, test_type:int):
@@ -367,7 +366,7 @@ def MonsterStartTestarrayofstringVector(b_:flatbuffers_builder, n_:int):
 def MonsterCreateTestarrayofstringVector(b_:flatbuffers_builder, v_:[int]):
     b_.StartVector(4, v_.length, 4)
     reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
-    b_.EndVector(v_.length)
+    return b_.EndVector(v_.length)
 def MonsterAddTestarrayoftables(b_:flatbuffers_builder, testarrayoftables:int):
     b_.PrependUOffsetTRelativeSlot(11, testarrayoftables, 0)
 def MonsterStartTestarrayoftablesVector(b_:flatbuffers_builder, n_:int):
@@ -375,7 +374,7 @@ def MonsterStartTestarrayoftablesVector(b_:flatbuffers_builder, n_:int):
 def MonsterCreateTestarrayoftablesVector(b_:flatbuffers_builder, v_:[int]):
     b_.StartVector(4, v_.length, 4)
     reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
-    b_.EndVector(v_.length)
+    return b_.EndVector(v_.length)
 def MonsterAddEnemy(b_:flatbuffers_builder, enemy:int):
     b_.PrependUOffsetTRelativeSlot(12, enemy, 0)
 def MonsterAddTestnestedflatbuffer(b_:flatbuffers_builder, testnestedflatbuffer:int):
@@ -385,7 +384,7 @@ def MonsterStartTestnestedflatbufferVector(b_:flatbuffers_builder, n_:int):
 def MonsterCreateTestnestedflatbufferVector(b_:flatbuffers_builder, v_:[int]):
     b_.StartVector(1, v_.length, 1)
     reverse(v_) e_: b_.PrependUint8(e_)
-    b_.EndVector(v_.length)
+    return b_.EndVector(v_.length)
 def MonsterAddTestempty(b_:flatbuffers_builder, testempty:int):
     b_.PrependUOffsetTRelativeSlot(14, testempty, 0)
 def MonsterAddTestbool(b_:flatbuffers_builder, testbool:int):
@@ -413,7 +412,7 @@ def MonsterStartTestarrayofboolsVector(b_:flatbuffers_builder, n_:int):
 def MonsterCreateTestarrayofboolsVector(b_:flatbuffers_builder, v_:[int]):
     b_.StartVector(1, v_.length, 1)
     reverse(v_) e_: b_.PrependBool(e_)
-    b_.EndVector(v_.length)
+    return b_.EndVector(v_.length)
 def MonsterAddTestf(b_:flatbuffers_builder, testf:float):
     b_.PrependFloat32Slot(25, testf, 3.14159)
 def MonsterAddTestf2(b_:flatbuffers_builder, testf2:float):
@@ -427,7 +426,7 @@ def MonsterStartTestarrayofstring2Vector(b_:flatbuffers_builder, n_:int):
 def MonsterCreateTestarrayofstring2Vector(b_:flatbuffers_builder, v_:[int]):
     b_.StartVector(4, v_.length, 4)
     reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
-    b_.EndVector(v_.length)
+    return b_.EndVector(v_.length)
 def MonsterAddTestarrayofsortedstruct(b_:flatbuffers_builder, testarrayofsortedstruct:int):
     b_.PrependUOffsetTRelativeSlot(29, testarrayofsortedstruct, 0)
 def MonsterStartTestarrayofsortedstructVector(b_:flatbuffers_builder, n_:int):
@@ -439,7 +438,7 @@ def MonsterStartFlexVector(b_:flatbuffers_builder, n_:int):
 def MonsterCreateFlexVector(b_:flatbuffers_builder, v_:[int]):
     b_.StartVector(1, v_.length, 1)
     reverse(v_) e_: b_.PrependUint8(e_)
-    b_.EndVector(v_.length)
+    return b_.EndVector(v_.length)
 def MonsterAddTest5(b_:flatbuffers_builder, test5:int):
     b_.PrependUOffsetTRelativeSlot(31, test5, 0)
 def MonsterStartTest5Vector(b_:flatbuffers_builder, n_:int):
@@ -451,7 +450,7 @@ def MonsterStartVectorOfLongsVector(b_:flatbuffers_builder, n_:int):
 def MonsterCreateVectorOfLongsVector(b_:flatbuffers_builder, v_:[int]):
     b_.StartVector(8, v_.length, 8)
     reverse(v_) e_: b_.PrependInt64(e_)
-    b_.EndVector(v_.length)
+    return b_.EndVector(v_.length)
 def MonsterAddVectorOfDoubles(b_:flatbuffers_builder, vector_of_doubles:int):
     b_.PrependUOffsetTRelativeSlot(33, vector_of_doubles, 0)
 def MonsterStartVectorOfDoublesVector(b_:flatbuffers_builder, n_:int):
@@ -459,7 +458,7 @@ def MonsterStartVectorOfDoublesVector(b_:flatbuffers_builder, n_:int):
 def MonsterCreateVectorOfDoublesVector(b_:flatbuffers_builder, v_:[float]):
     b_.StartVector(8, v_.length, 8)
     reverse(v_) e_: b_.PrependFloat64(e_)
-    b_.EndVector(v_.length)
+    return b_.EndVector(v_.length)
 def MonsterAddParentNamespaceTest(b_:flatbuffers_builder, parent_namespace_test:int):
     b_.PrependUOffsetTRelativeSlot(34, parent_namespace_test, 0)
 def MonsterAddVectorOfReferrables(b_:flatbuffers_builder, vector_of_referrables:int):
@@ -469,7 +468,7 @@ def MonsterStartVectorOfReferrablesVector(b_:flatbuffers_builder, n_:int):
 def MonsterCreateVectorOfReferrablesVector(b_:flatbuffers_builder, v_:[int]):
     b_.StartVector(4, v_.length, 4)
     reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
-    b_.EndVector(v_.length)
+    return b_.EndVector(v_.length)
 def MonsterAddSingleWeakReference(b_:flatbuffers_builder, single_weak_reference:int):
     b_.PrependUint64Slot(36, single_weak_reference, 0)
 def MonsterAddVectorOfWeakReferences(b_:flatbuffers_builder, vector_of_weak_references:int):
@@ -479,7 +478,7 @@ def MonsterStartVectorOfWeakReferencesVector(b_:flatbuffers_builder, n_:int):
 def MonsterCreateVectorOfWeakReferencesVector(b_:flatbuffers_builder, v_:[int]):
     b_.StartVector(8, v_.length, 8)
     reverse(v_) e_: b_.PrependUint64(e_)
-    b_.EndVector(v_.length)
+    return b_.EndVector(v_.length)
 def MonsterAddVectorOfStrongReferrables(b_:flatbuffers_builder, vector_of_strong_referrables:int):
     b_.PrependUOffsetTRelativeSlot(38, vector_of_strong_referrables, 0)
 def MonsterStartVectorOfStrongReferrablesVector(b_:flatbuffers_builder, n_:int):
@@ -487,7 +486,7 @@ def MonsterStartVectorOfStrongReferrablesVector(b_:flatbuffers_builder, n_:int):
 def MonsterCreateVectorOfStrongReferrablesVector(b_:flatbuffers_builder, v_:[int]):
     b_.StartVector(4, v_.length, 4)
     reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
-    b_.EndVector(v_.length)
+    return b_.EndVector(v_.length)
 def MonsterAddCoOwningReference(b_:flatbuffers_builder, co_owning_reference:int):
     b_.PrependUint64Slot(39, co_owning_reference, 0)
 def MonsterAddVectorOfCoOwningReferences(b_:flatbuffers_builder, vector_of_co_owning_references:int):
@@ -497,7 +496,7 @@ def MonsterStartVectorOfCoOwningReferencesVector(b_:flatbuffers_builder, n_:int)
 def MonsterCreateVectorOfCoOwningReferencesVector(b_:flatbuffers_builder, v_:[int]):
     b_.StartVector(8, v_.length, 8)
     reverse(v_) e_: b_.PrependUint64(e_)
-    b_.EndVector(v_.length)
+    return b_.EndVector(v_.length)
 def MonsterAddNonOwningReference(b_:flatbuffers_builder, non_owning_reference:int):
     b_.PrependUint64Slot(41, non_owning_reference, 0)
 def MonsterAddVectorOfNonOwningReferences(b_:flatbuffers_builder, vector_of_non_owning_references:int):
@@ -507,7 +506,7 @@ def MonsterStartVectorOfNonOwningReferencesVector(b_:flatbuffers_builder, n_:int
 def MonsterCreateVectorOfNonOwningReferencesVector(b_:flatbuffers_builder, v_:[int]):
     b_.StartVector(8, v_.length, 8)
     reverse(v_) e_: b_.PrependUint64(e_)
-    b_.EndVector(v_.length)
+    return b_.EndVector(v_.length)
 def MonsterAddAnyUniqueType(b_:flatbuffers_builder, any_unique_type:int):
     b_.PrependUint8Slot(43, any_unique_type, 0)
 def MonsterAddAnyUnique(b_:flatbuffers_builder, any_unique:int):
@@ -523,41 +522,41 @@ def MonsterStartVectorOfEnumsVector(b_:flatbuffers_builder, n_:int):
 def MonsterCreateVectorOfEnumsVector(b_:flatbuffers_builder, v_:[int]):
     b_.StartVector(1, v_.length, 1)
     reverse(v_) e_: b_.PrependUint8(e_)
-    b_.EndVector(v_.length)
+    return b_.EndVector(v_.length)
 def MonsterEnd(b_:flatbuffers_builder):
-    b_.EndObject()
+    return b_.EndObject()
 
-struct TypeAliases : flatbuffers_handle
+class TypeAliases : flatbuffers_handle
     def i8():
-        buf_.flatbuffers_field_int8(pos_, 4, 0)
+        return buf_.flatbuffers_field_int8(pos_, 4, 0)
     def u8():
-        buf_.flatbuffers_field_int8(pos_, 6, 0)
+        return buf_.flatbuffers_field_int8(pos_, 6, 0)
     def i16():
-        buf_.flatbuffers_field_int16(pos_, 8, 0)
+        return buf_.flatbuffers_field_int16(pos_, 8, 0)
     def u16():
-        buf_.flatbuffers_field_int16(pos_, 10, 0)
+        return buf_.flatbuffers_field_int16(pos_, 10, 0)
     def i32():
-        buf_.flatbuffers_field_int32(pos_, 12, 0)
+        return buf_.flatbuffers_field_int32(pos_, 12, 0)
     def u32():
-        buf_.flatbuffers_field_int32(pos_, 14, 0)
+        return buf_.flatbuffers_field_int32(pos_, 14, 0)
     def i64():
-        buf_.flatbuffers_field_int64(pos_, 16, 0)
+        return buf_.flatbuffers_field_int64(pos_, 16, 0)
     def u64():
-        buf_.flatbuffers_field_int64(pos_, 18, 0)
+        return buf_.flatbuffers_field_int64(pos_, 18, 0)
     def f32():
-        buf_.flatbuffers_field_float32(pos_, 20, 0.0)
+        return buf_.flatbuffers_field_float32(pos_, 20, 0.0)
     def f64():
-        buf_.flatbuffers_field_float64(pos_, 22, 0.0)
+        return buf_.flatbuffers_field_float64(pos_, 22, 0.0)
     def v8(i:int):
-        buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 24) + i * 1)
+        return buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 24) + i * 1)
     def v8_length():
-        buf_.flatbuffers_field_vector_len(pos_, 24)
+        return buf_.flatbuffers_field_vector_len(pos_, 24)
     def vf64(i:int):
-        buf_.read_float64_le(buf_.flatbuffers_field_vector(pos_, 26) + i * 8)
+        return buf_.read_float64_le(buf_.flatbuffers_field_vector(pos_, 26) + i * 8)
     def vf64_length():
-        buf_.flatbuffers_field_vector_len(pos_, 26)
+        return buf_.flatbuffers_field_vector_len(pos_, 26)
 
-def GetRootAsTypeAliases(buf:string): TypeAliases { buf, buf.flatbuffers_indirect(0) }
+def GetRootAsTypeAliases(buf:string): return TypeAliases { buf, buf.flatbuffers_indirect(0) }
 
 def TypeAliasesStart(b_:flatbuffers_builder):
     b_.StartObject(12)
@@ -588,7 +587,7 @@ def TypeAliasesStartV8Vector(b_:flatbuffers_builder, n_:int):
 def TypeAliasesCreateV8Vector(b_:flatbuffers_builder, v_:[int]):
     b_.StartVector(1, v_.length, 1)
     reverse(v_) e_: b_.PrependInt8(e_)
-    b_.EndVector(v_.length)
+    return b_.EndVector(v_.length)
 def TypeAliasesAddVf64(b_:flatbuffers_builder, vf64:int):
     b_.PrependUOffsetTRelativeSlot(11, vf64, 0)
 def TypeAliasesStartVf64Vector(b_:flatbuffers_builder, n_:int):
@@ -596,7 +595,7 @@ def TypeAliasesStartVf64Vector(b_:flatbuffers_builder, n_:int):
 def TypeAliasesCreateVf64Vector(b_:flatbuffers_builder, v_:[float]):
     b_.StartVector(8, v_.length, 8)
     reverse(v_) e_: b_.PrependFloat64(e_)
-    b_.EndVector(v_.length)
+    return b_.EndVector(v_.length)
 def TypeAliasesEnd(b_:flatbuffers_builder):
-    b_.EndObject()
+    return b_.EndObject()
 

tests/namespace_test/namespace_test1_generated.lobster

 // automatically generated by the FlatBuffers compiler, do not modify
-
-include "flatbuffers.lobster"
+import flatbuffers
 
 namespace NamespaceA_NamespaceB
 
-enum + 
-    EnumInNestedNS_A = 0,
-    EnumInNestedNS_B = 1,
+enum EnumInNestedNS:
+    EnumInNestedNS_A = 0
+    EnumInNestedNS_B = 1
     EnumInNestedNS_C = 2
 
-struct TableInNestedNS
+class TableInNestedNS
 
-struct StructInNestedNS
+class StructInNestedNS
 
-struct TableInNestedNS : flatbuffers_handle
+class TableInNestedNS : flatbuffers_handle
     def foo():
-        buf_.flatbuffers_field_int32(pos_, 4, 0)
+        return buf_.flatbuffers_field_int32(pos_, 4, 0)
 
-def GetRootAsTableInNestedNS(buf:string): TableInNestedNS { buf, buf.flatbuffers_indirect(0) }
+def GetRootAsTableInNestedNS(buf:string): return TableInNestedNS { buf, buf.flatbuffers_indirect(0) }
 
 def TableInNestedNSStart(b_:flatbuffers_builder):
     b_.StartObject(1)
 def TableInNestedNSAddFoo(b_:flatbuffers_builder, foo:int):
     b_.PrependInt32Slot(0, foo, 0)
 def TableInNestedNSEnd(b_:flatbuffers_builder):
-    b_.EndObject()
+    return b_.EndObject()
 
-struct StructInNestedNS : flatbuffers_handle
+class StructInNestedNS : flatbuffers_handle
     def a():
-        buf_.read_int32_le(pos_ + 0)
+        return buf_.read_int32_le(pos_ + 0)
     def b():
-        buf_.read_int32_le(pos_ + 4)
+        return buf_.read_int32_le(pos_ + 4)
 
 def CreateStructInNestedNS(b_:flatbuffers_builder, a:int, b:int):
     b_.Prep(4, 8)

tests/namespace_test/namespace_test2_generated.lobster

 // automatically generated by the FlatBuffers compiler, do not modify
-
-include "flatbuffers.lobster"
+import flatbuffers
 
 namespace NamespaceA
 
-struct TableInFirstNS
+class TableInFirstNS
 
 namespace NamespaceC
 
-struct TableInC
+class TableInC
 
 namespace NamespaceA
 
-struct SecondTableInA
+class SecondTableInA
 
-struct TableInFirstNS : flatbuffers_handle
+class TableInFirstNS : flatbuffers_handle
     def foo_table():
-        o := buf_.flatbuffers_field_table(pos_, 4)
-        if o: NamespaceA_NamespaceB_TableInNestedNS { buf_, o } else: nil
+        let o = buf_.flatbuffers_field_table(pos_, 4)
+        return if o: NamespaceA_NamespaceB_TableInNestedNS { buf_, o } else: nil
     def foo_enum():
-        buf_.flatbuffers_field_int8(pos_, 6, 0)
+        return buf_.flatbuffers_field_int8(pos_, 6, 0)
     def foo_struct():
-        o := buf_.flatbuffers_field_struct(pos_, 8)
-        if o: NamespaceA_NamespaceB_StructInNestedNS { buf_, o } else: nil
+        let o = buf_.flatbuffers_field_struct(pos_, 8)
+        return if o: NamespaceA_NamespaceB_StructInNestedNS { buf_, o } else: nil
 
-def GetRootAsTableInFirstNS(buf:string): TableInFirstNS { buf, buf.flatbuffers_indirect(0) }
+def GetRootAsTableInFirstNS(buf:string): return TableInFirstNS { buf, buf.flatbuffers_indirect(0) }
 
 def TableInFirstNSStart(b_:flatbuffers_builder):
     b_.StartObject(3)
@@ -35,19 +34,19 @@ def TableInFirstNSAddFooEnum(b_:flatbuffers_builder, foo_enum:int):
 def TableInFirstNSAddFooStruct(b_:flatbuffers_builder, foo_struct:int):
     b_.PrependStructSlot(2, foo_struct, 0)
 def TableInFirstNSEnd(b_:flatbuffers_builder):
-    b_.EndObject()
+    return b_.EndObject()
 
 namespace NamespaceC
 
-struct TableInC : flatbuffers_handle
+class TableInC : flatbuffers_handle
     def refer_to_a1():
-        o := buf_.flatbuffers_field_table(pos_, 4)
-        if o: NamespaceA_TableInFirstNS { buf_, o } else: nil
+        let o = buf_.flatbuffers_field_table(pos_, 4)
+        return if o: NamespaceA_TableInFirstNS { buf_, o } else: nil
     def refer_to_a2():
-        o := buf_.flatbuffers_field_table(pos_, 6)
-        if o: NamespaceA_SecondTableInA { buf_, o } else: nil
+        let o = buf_.flatbuffers_field_table(pos_, 6)
+        return if o: NamespaceA_SecondTableInA { buf_, o } else: nil
 
-def GetRootAsTableInC(buf:string): TableInC { buf, buf.flatbuffers_indirect(0) }
+def GetRootAsTableInC(buf:string): return TableInC { buf, buf.flatbuffers_indirect(0) }
 
 def TableInCStart(b_:flatbuffers_builder):
     b_.StartObject(2)
@@ -56,21 +55,21 @@ def TableInCAddReferToA1(b_:flatbuffers_builder, refer_to_a1:int):
 def TableInCAddReferToA2(b_:flatbuffers_builder, refer_to_a2:int):
     b_.PrependUOffsetTRelativeSlot(1, refer_to_a2, 0)
 def TableInCEnd(b_:flatbuffers_builder):
-    b_.EndObject()
+    return b_.EndObject()
 
 namespace NamespaceA
 
-struct SecondTableInA : flatbuffers_handle
+class SecondTableInA : flatbuffers_handle
     def refer_to_c():
-        o := buf_.flatbuffers_field_table(pos_, 4)
-        if o: NamespaceC_TableInC { buf_, o } else: nil
+        let o = buf_.flatbuffers_field_table(pos_, 4)
+        return if o: NamespaceC_TableInC { buf_, o } else: nil
 
-def GetRootAsSecondTableInA(buf:string): SecondTableInA { buf, buf.flatbuffers_indirect(0) }
+def GetRootAsSecondTableInA(buf:string): return SecondTableInA { buf, buf.flatbuffers_indirect(0) }
 
 def SecondTableInAStart(b_:flatbuffers_builder):
     b_.StartObject(1)
 def SecondTableInAAddReferToC(b_:flatbuffers_builder, refer_to_c:int):
     b_.PrependUOffsetTRelativeSlot(0, refer_to_c, 0)
 def SecondTableInAEnd(b_:flatbuffers_builder):
-    b_.EndObject()
+    return b_.EndObject()