Made Lobster builder offsets strongly typed

lobster/flatbuffers.lobster

@@ -20,6 +20,10 @@ class handle:
     buf_:string
     pos_:int
 
+// More strongly typed than a naked int, at no cost.
+struct offset:
+    o:int
+
 enum sizeof:
     sz_8 = 1
     sz_16 = 2
@@ -50,7 +54,7 @@ class builder:
 
     def Offset():
         // Offset relative to the end of the buffer.
-        return head
+        return offset { head }
 
     // Returns a copy of the part of the buffer containing only the finished FlatBuffer
     def SizedCopy():
@@ -118,7 +122,7 @@ class builder:
             // Finally, store this vtable in memory for future
             // deduplication:
             vtables.push(head)
-        return object_offset
+        return offset { object_offset }
 
     def Pad(n):
         for(n):
@@ -133,24 +137,24 @@ class builder:
         let align_size = ((~(head + additional_bytes)) + 1) & (size - 1)
         Pad(align_size)
 
-    def PrependUOffsetTRelative(off):
+    def PrependUOffsetTRelative(off:offset):
         // Prepends an unsigned offset into vector data, relative to where it will be written.
         Prep(sz_uoffset, 0)
-        assert off <= head
-        PlaceUOffsetT(head - off + sz_uoffset)
+        assert off.o <= head
+        PlaceUOffsetT(head - off.o + sz_uoffset)
 
     def StartVector(elem_size, num_elems, alignment):
         // Initializes bookkeeping for writing a new vector.
         StartNesting()
         Prep(sz_32, elem_size * num_elems)
         Prep(alignment, elem_size * num_elems)  // In case alignment > int.
-        return head
+        return Offset()
 
     def EndVector(vector_num_elems):
         EndNesting()
         // we already made space for this, so write without PrependUint32
         PlaceUOffsetT(vector_num_elems)
-        return head
+        return Offset()
 
     def CreateString(s:string):
         // writes a null-terminated byte string.
@@ -171,7 +175,7 @@ class builder:
         while current_vtable.length <= slotnum: current_vtable.push(0)
         current_vtable[slotnum] = head
 
-    def __Finish(root_table:int, size_prefix:int):
+    def __Finish(root_table:offset, size_prefix:int):
         // Finish finalizes a buffer, pointing to the given root_table
         assert not finished
         assert not nested
@@ -185,10 +189,10 @@ class builder:
         finished = true
         return Start()
 
-    def Finish(root_table:int):
+    def Finish(root_table:offset):
         return __Finish(root_table, false)
 
-    def FinishSizePrefixed(root_table:int):
+    def FinishSizePrefixed(root_table:offset):
         return __Finish(root_table, true)
 
     def PrependBool(x):
@@ -266,16 +270,16 @@ class builder:
     def PrependFloat32Slot(o, x, d): PrependSlot(o, x, d): PrependFloat32(_)
     def PrependFloat64Slot(o, x, d): PrependSlot(o, x, d): PrependFloat64(_)
 
-    def PrependUOffsetTRelativeSlot(o, x, d):
-        if x != d:
+    def PrependUOffsetTRelativeSlot(o:int, x:offset):
+        if x.o:
             PrependUOffsetTRelative(x)
             Slot(o)
 
-    def PrependStructSlot(v, x, d):
-        if x != d:
+    def PrependStructSlot(v:int, x:offset):
+        if x.o:
             // Structs are always stored inline, so need to be created right
             // where they are used. You'll get this error if you created it
-            //elsewhere.
-            assert x == head
+            // elsewhere.
+            assert x.o == head
             Slot(v)
 

samples/monster_generated.lobster

@@ -66,16 +66,16 @@ def GetRootAsMonster(buf:string): return Monster { buf, buf.flatbuffers_indirect
 
 def MonsterStart(b_:flatbuffers_builder):
     b_.StartObject(11)
-def MonsterAddPos(b_:flatbuffers_builder, pos:int):
-    b_.PrependStructSlot(0, pos, 0)
+def MonsterAddPos(b_:flatbuffers_builder, pos:flatbuffers_offset):
+    b_.PrependStructSlot(0, pos)
 def MonsterAddMana(b_:flatbuffers_builder, mana:int):
     b_.PrependInt16Slot(1, mana, 150)
 def MonsterAddHp(b_:flatbuffers_builder, hp:int):
     b_.PrependInt16Slot(2, hp, 100)
-def MonsterAddName(b_:flatbuffers_builder, name:int):
-    b_.PrependUOffsetTRelativeSlot(3, name, 0)
-def MonsterAddInventory(b_:flatbuffers_builder, inventory:int):
-    b_.PrependUOffsetTRelativeSlot(5, inventory, 0)
+def MonsterAddName(b_:flatbuffers_builder, name:flatbuffers_offset):
+    b_.PrependUOffsetTRelativeSlot(3, name)
+def MonsterAddInventory(b_:flatbuffers_builder, inventory:flatbuffers_offset):
+    b_.PrependUOffsetTRelativeSlot(5, inventory)
 def MonsterStartInventoryVector(b_:flatbuffers_builder, n_:int):
     b_.StartVector(1, n_, 1)
 def MonsterCreateInventoryVector(b_:flatbuffers_builder, v_:[int]):
@@ -84,20 +84,20 @@ def MonsterCreateInventoryVector(b_:flatbuffers_builder, v_:[int]):
     return b_.EndVector(v_.length)
 def MonsterAddColor(b_:flatbuffers_builder, color:Color):
     b_.PrependInt8Slot(6, color, 2)
-def MonsterAddWeapons(b_:flatbuffers_builder, weapons:int):
-    b_.PrependUOffsetTRelativeSlot(7, weapons, 0)
+def MonsterAddWeapons(b_:flatbuffers_builder, weapons:flatbuffers_offset):
+    b_.PrependUOffsetTRelativeSlot(7, weapons)
 def MonsterStartWeaponsVector(b_:flatbuffers_builder, n_:int):
     b_.StartVector(4, n_, 4)
-def MonsterCreateWeaponsVector(b_:flatbuffers_builder, v_:[int]):
+def MonsterCreateWeaponsVector(b_:flatbuffers_builder, v_:[flatbuffers_offset]):
     b_.StartVector(4, v_.length, 4)
     reverse(v_) e_: b_.PrependUOffsetTRelative(e_)
     return b_.EndVector(v_.length)
 def MonsterAddEquippedType(b_:flatbuffers_builder, equipped_type:Equipment):
     b_.PrependUint8Slot(8, equipped_type, 0)
-def MonsterAddEquipped(b_:flatbuffers_builder, equipped:int):
-    b_.PrependUOffsetTRelativeSlot(9, equipped, 0)
-def MonsterAddPath(b_:flatbuffers_builder, path:int):
-    b_.PrependUOffsetTRelativeSlot(10, path, 0)
+def MonsterAddEquipped(b_:flatbuffers_builder, equipped:flatbuffers_offset):
+    b_.PrependUOffsetTRelativeSlot(9, equipped)
+def MonsterAddPath(b_:flatbuffers_builder, path:flatbuffers_offset):
+    b_.PrependUOffsetTRelativeSlot(10, path)
 def MonsterStartPathVector(b_:flatbuffers_builder, n_:int):
     b_.StartVector(12, n_, 4)
 def MonsterEnd(b_:flatbuffers_builder):
@@ -113,8 +113,8 @@ def GetRootAsWeapon(buf:string): return Weapon { buf, buf.flatbuffers_indirect(0
 
 def WeaponStart(b_:flatbuffers_builder):
     b_.StartObject(2)
-def WeaponAddName(b_:flatbuffers_builder, name:int):
-    b_.PrependUOffsetTRelativeSlot(0, name, 0)
+def WeaponAddName(b_:flatbuffers_builder, name:flatbuffers_offset):
+    b_.PrependUOffsetTRelativeSlot(0, name)
 def WeaponAddDamage(b_:flatbuffers_builder, damage:int):
     b_.PrependInt16Slot(1, damage, 0)
 def WeaponEnd(b_:flatbuffers_builder):

src/idl_gen_lobster.cpp

@@ -67,6 +67,7 @@ class LobsterGenerator : public BaseGenerator {
   std::string LobsterType(const Type &type) {
     if (IsFloat(type.base_type)) return "float";
     if (IsScalar(type.base_type) && type.enum_def) return NormalizedName(*type.enum_def);
+    if (!IsScalar(type.base_type)) return "flatbuffers_offset";
     return "int";
   }
 
@@ -191,8 +192,10 @@ class LobsterGenerator : public BaseGenerator {
               MakeCamel(NormalizedName(field)) + "(b_:flatbuffers_builder, " +
               NormalizedName(field) + ":" + LobsterType(field.value.type) +
               "):\n    b_.Prepend" + GenMethod(field.value.type) + "Slot(" +
-              NumToString(offset) + ", " + NormalizedName(field) + ", " +
-              field.value.constant + ")\n";
+              NumToString(offset) + ", " + NormalizedName(field);
+      if (IsScalar(field.value.type.base_type))
+        code += ", " + field.value.constant;
+      code += ")\n";
       if (field.value.type.base_type == BASE_TYPE_VECTOR) {
         code += "def " + NormalizedName(struct_def) + "Start" +
                 MakeCamel(NormalizedName(field)) +

tests/namespace_test/namespace_test2_generated.lobster

@@ -27,12 +27,12 @@ def GetRootAsTableInFirstNS(buf:string): return TableInFirstNS { buf, buf.flatbu
 
 def TableInFirstNSStart(b_:flatbuffers_builder):
     b_.StartObject(3)
-def TableInFirstNSAddFooTable(b_:flatbuffers_builder, foo_table:int):
-    b_.PrependUOffsetTRelativeSlot(0, foo_table, 0)
+def TableInFirstNSAddFooTable(b_:flatbuffers_builder, foo_table:flatbuffers_offset):
+    b_.PrependUOffsetTRelativeSlot(0, foo_table)
 def TableInFirstNSAddFooEnum(b_:flatbuffers_builder, foo_enum:EnumInNestedNS):
     b_.PrependInt8Slot(1, foo_enum, 0)
-def TableInFirstNSAddFooStruct(b_:flatbuffers_builder, foo_struct:int):
-    b_.PrependStructSlot(2, foo_struct, 0)
+def TableInFirstNSAddFooStruct(b_:flatbuffers_builder, foo_struct:flatbuffers_offset):
+    b_.PrependStructSlot(2, foo_struct)
 def TableInFirstNSEnd(b_:flatbuffers_builder):
     return b_.EndObject()
 
@@ -50,10 +50,10 @@ def GetRootAsTableInC(buf:string): return TableInC { buf, buf.flatbuffers_indire
 
 def TableInCStart(b_:flatbuffers_builder):
     b_.StartObject(2)
-def TableInCAddReferToA1(b_:flatbuffers_builder, refer_to_a1:int):
-    b_.PrependUOffsetTRelativeSlot(0, refer_to_a1, 0)
-def TableInCAddReferToA2(b_:flatbuffers_builder, refer_to_a2:int):
-    b_.PrependUOffsetTRelativeSlot(1, refer_to_a2, 0)
+def TableInCAddReferToA1(b_:flatbuffers_builder, refer_to_a1:flatbuffers_offset):
+    b_.PrependUOffsetTRelativeSlot(0, refer_to_a1)
+def TableInCAddReferToA2(b_:flatbuffers_builder, refer_to_a2:flatbuffers_offset):
+    b_.PrependUOffsetTRelativeSlot(1, refer_to_a2)
 def TableInCEnd(b_:flatbuffers_builder):
     return b_.EndObject()
 
@@ -68,8 +68,8 @@ def GetRootAsSecondTableInA(buf:string): return SecondTableInA { buf, buf.flatbu
 
 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 SecondTableInAAddReferToC(b_:flatbuffers_builder, refer_to_c:flatbuffers_offset):
+    b_.PrependUOffsetTRelativeSlot(0, refer_to_c)
 def SecondTableInAEnd(b_:flatbuffers_builder):
     return b_.EndObject()