Phase 122: Fix collectable bit in LuaT (WIP)

Fixed major issue: All GC objects must be created with ctb(LuaT::*)
to include the collectable bit. Updated:
- All object creation sites (Table, Udata, TString, functions, etc.)
- Main thread creation in lua_newstate
- Type comparisons in assertions and conditionals
- Switch statements in gc_core.cpp (partial)

Remaining work:
- Fix 7 more switch statements on getType() in:
  * gc_marking.cpp (2 switches)
  * lgc.cpp (2 switches)
  * ltests.cpp (2 switches)
  * gc_core.cpp (1 more switch)

All switches need: static_cast<int>(getType()) and
static_cast<int>(ctb(LuaT::*)) for case labels.

Author: claude

src/core/ldebug.cpp

@@ -33,7 +33,7 @@
 
 
 /* Both CClosure and LClosure have tt at same offset (from GCBase) */
-#define LuaClosure(f)		((f) != nullptr && (f)->c.getType() == LuaT::LCL)
+#define LuaClosure(f)		((f) != nullptr && (f)->c.getType() == ctb(LuaT::LCL))
 
 static const char strlocal[] = "local";
 static const char strupval[] = "upvalue";

src/core/lstate.cpp

@@ -272,7 +272,7 @@ LUA_API lua_State *lua_newthread (lua_State *L) {
   lua_lock(L);
   luaC_checkGC(L);
   /* create new thread */
-  o = luaC_newobjdt(L, LuaT::THREAD, sizeof(LX), lxOffset());
+  o = luaC_newobjdt(L, ctb(LuaT::THREAD), sizeof(LX), lxOffset());
   L1 = gco2th(o);
   /* anchor it on L stack */
   setthvalue2s(L, L->getTop().p, L1);
@@ -335,7 +335,7 @@ LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud, unsigned seed) {
                        (*f)(ud, nullptr, LUA_TTHREAD, sizeof(global_State)));
   if (g == nullptr) return nullptr;
   L = &g->getMainThread()->l;
-  L->setType(LuaT::THREAD);
+  L->setType(ctb(LuaT::THREAD));
   g->setCurrentWhite(bitmask(WHITE0BIT));
   L->setMarked(g->getWhite());
   preinit_thread(L, g);

src/memory/gc/gc_core.cpp

@@ -24,45 +24,45 @@
 */
 l_mem GCCore::objsize(GCObject* o) {
     lu_mem res;
-    switch (o->getType()) {
-        case LuaT::TABLE: {
+    switch (static_cast<int>(o->getType())) {
+        case static_cast<int>(ctb(LuaT::TABLE)): {
             res = luaH_size(gco2t(o));
             break;
         }
-        case LuaT::LCL: {
+        case static_cast<int>(ctb(LuaT::LCL)): {
             LClosure* cl = gco2lcl(o);
             res = sizeLclosure(cl->getNumUpvalues());
             break;
         }
-        case LuaT::CCL: {
+        case static_cast<int>(ctb(LuaT::CCL)): {
             CClosure* cl = gco2ccl(o);
             res = sizeCclosure(cl->getNumUpvalues());
             break;
         }
-        case LuaT::USERDATA: {
+        case static_cast<int>(ctb(LuaT::USERDATA)): {
             Udata* u = gco2u(o);
             res = sizeudata(u->getNumUserValues(), u->getLen());
             break;
         }
-        case LuaT::PROTO: {
+        case static_cast<int>(ctb(LuaT::PROTO)): {
             res = gco2p(o)->memorySize();
             break;
         }
-        case LuaT::THREAD: {
+        case static_cast<int>(ctb(LuaT::THREAD)): {
             res = luaE_threadsize(gco2th(o));
             break;
         }
-        case LuaT::SHRSTR: {
+        case static_cast<int>(ctb(LuaT::SHRSTR)): {
             TString* ts = gco2ts(o);
             res = sizestrshr(cast_uint(ts->getShrlen()));
             break;
         }
-        case LuaT::LNGSTR: {
+        case static_cast<int>(ctb(LuaT::LNGSTR)): {
             TString* ts = gco2ts(o);
             res = TString::calculateLongStringSize(ts->getLnglen(), ts->getShrlen());
             break;
         }
-        case LuaT::UPVAL: {
+        case static_cast<int>(ctb(LuaT::UPVAL)): {
             res = sizeof(UpVal);
             break;
         }

src/memory/gc/gc_sweeping.cpp

@@ -137,11 +137,11 @@ void GCSweeping::sweep2old(lua_State* L, GCObject** p) {
         else {  /* all surviving objects become old */
             setage(curr, GCAge::Old);
 
-            if (curr->getType() == LuaT::THREAD) {  /* threads must be watched */
+            if (curr->getType() == ctb(LuaT::THREAD)) {  /* threads must be watched */
                 lua_State* th = gco2th(curr);
                 linkgclistThread(th, *g->getGrayAgainPtr());  /* insert into 'grayagain' list */
             }
-            else if (curr->getType() == LuaT::UPVAL && gco2upv(curr)->isOpen())
+            else if (curr->getType() == ctb(LuaT::UPVAL) && gco2upv(curr)->isOpen())
                 set2gray(curr);  /* open upvalues are always gray */
             else  /* everything else is black */
                 nw2black(curr);

src/memory/lgc.cpp

@@ -589,7 +589,7 @@ static GCObject **correctgraylist (GCObject **p) {
       setage(curr, GCAge::Touched2);
       goto remain;  /* keep it in the list and go to next element */
     }
-    else if (curr->getType() == LuaT::THREAD) {
+    else if (curr->getType() == ctb(LuaT::THREAD)) {
       lua_assert(isgray(curr));
       goto remain;  /* keep non-white threads on the list */
     }

src/objects/lfunc.cpp

@@ -36,7 +36,7 @@ CClosure::CClosure(int nupvals) {
 // Factory method
 CClosure* CClosure::create(lua_State* L, int nupvals) {
   size_t extra = (nupvals > 0) ? (static_cast<size_t>(nupvals) - 1) * sizeof(TValue) : 0;
-  CClosure* c = new (L, LuaT::CCL, extra) CClosure(nupvals);
+  CClosure* c = new (L, ctb(LuaT::CCL), extra) CClosure(nupvals);
   return c;
 }
 
@@ -58,7 +58,7 @@ LClosure* LClosure::create(lua_State* L, int nupvals) {
   // So extra = sizeLclosure(nupvals) - sizeof(LClosure)
   size_t total_size = sizeLclosure(nupvals);
   size_t extra = total_size - sizeof(LClosure);
-  LClosure* c = new (L, LuaT::LCL, extra) LClosure(nupvals);
+  LClosure* c = new (L, ctb(LuaT::LCL), extra) LClosure(nupvals);
   return c;
 }
 
@@ -71,7 +71,7 @@ void LClosure::initUpvals(lua_State* L) {
   int i;
   for (i = 0; i < nupvalues; i++) {
     // Use placement new - calls constructor (initializes to closed nil upvalue)
-    UpVal *uv = new (L, LuaT::UPVAL) UpVal();
+    UpVal *uv = new (L, ctb(LuaT::UPVAL)) UpVal();
     uv->setVP(uv->getValueSlot());  /* make it closed */
     // Constructor already sets value to nil, but keeping setnilvalue for clarity
     setnilvalue(uv->getVP());
@@ -88,7 +88,7 @@ void LClosure::initUpvals(lua_State* L) {
 **/
 static UpVal *newupval (lua_State *L, StkId level, UpVal **prev) {
   // Use placement new - calls constructor
-  UpVal *uv = new (L, LuaT::UPVAL) UpVal();
+  UpVal *uv = new (L, ctb(LuaT::UPVAL)) UpVal();
   UpVal *next = *prev;
   uv->setVP(s2v(level));  /* current value lives in the stack */
   uv->setOpenNext(next);  /* link it to list of open upvalues */
@@ -271,7 +271,7 @@ StkId luaF_close (lua_State *L, StkId level, TStatus status, int yy) {
 // Phase 50: Use placement new to call constructor
 Proto *luaF_newproto (lua_State *L) {
   // Use placement new - calls constructor which initializes all fields to safe defaults
-  Proto *f = new (L, LuaT::PROTO) Proto();
+  Proto *f = new (L, ctb(LuaT::PROTO)) Proto();
   // Constructor handles all initialization
   return f;
 }

src/objects/lstring.cpp

@@ -206,7 +206,7 @@ static TString *createstrobj (lua_State *L, size_t totalsize, LuaT tag,
 
 TString* TString::createLongString(lua_State* L, size_t l) {
   size_t totalsize = calculateLongStringSize(l, LSTRREG);
-  TString *ts = createstrobj(L, totalsize, LuaT::LNGSTR, G(L)->getSeed());
+  TString *ts = createstrobj(L, totalsize, ctb(LuaT::LNGSTR), G(L)->getSeed());
   ts->setLnglen(l);
   ts->setShrlen(LSTRREG);  /* signals that it is a regular long string */
   ts->setContents(cast_charp(ts) + tstringFallocOffset());
@@ -254,7 +254,7 @@ static TString *internshrstr (lua_State *L, const char *str, size_t l) {
     list = &tb->getHash()[lmod(h, tb->getSize())];  /* rehash with new size */
   }
   size_t allocsize = sizestrshr(l);
-  ts = createstrobj(L, allocsize, LuaT::SHRSTR, h);
+  ts = createstrobj(L, allocsize, ctb(LuaT::SHRSTR), h);
   ts->setShrlen(static_cast<ls_byte>(l));
   getshrstr(ts)[l] = '\0';  /* ending 0 */
   std::copy_n(str, l, getshrstr(ts));
@@ -311,7 +311,7 @@ Udata *luaS_newudata (lua_State *L, size_t s, unsigned short nuvalue) {
   size_t totalsize = sizeudata(nuvalue, s);
 
   // Allocate exactly what we need (may be less than sizeof(Udata) for small data)
-  GCObject *o = luaC_newobj(L, LuaT::USERDATA, totalsize);
+  GCObject *o = luaC_newobj(L, ctb(LuaT::USERDATA), totalsize);
   u = gco2u(o);
 
   // Manually initialize fields (can't use constructor reliably for variable-size objects)
@@ -343,7 +343,7 @@ struct NewExt {
 static void f_newext (lua_State *L, void *ud) {
   NewExt *ne = static_cast<NewExt*>(ud);
   size_t size = TString::calculateLongStringSize(0, ne->kind);
-  ne->ts = createstrobj(L, size, LuaT::LNGSTR, G(L)->getSeed());
+  ne->ts = createstrobj(L, size, ctb(LuaT::LNGSTR), G(L)->getSeed());
 }
 
 
@@ -375,7 +375,7 @@ TString* TString::createExternal(lua_State* L, const char* s, size_t len,
 */
 
 unsigned TString::hashLongStr() {
-  lua_assert(getType() == LuaT::LNGSTR);
+  lua_assert(getType() == ctb(LuaT::LNGSTR));
   if (getExtra() == 0) {  /* no hash? */
     size_t len = getLnglen();
     setHash(computeHash(getlngstr(this), len, getHash()));

src/objects/lstring.h

@@ -302,7 +302,7 @@ inline bool isreserved(const TString* s) noexcept {
 ** equality for short strings, which are always internalized
 */
 inline bool eqshrstr(const TString* a, const TString* b) noexcept {
-	return check_exp((a)->getType() == LuaT::SHRSTR, (a) == (b));
+	return check_exp((a)->getType() == ctb(LuaT::SHRSTR), (a) == (b));
 }
 
 

src/objects/ltable.cpp

@@ -1578,7 +1578,7 @@ lua_Unsigned Table::getn(lua_State* L) {
 // Phase 50: Factory pattern with placement new operator
 Table* Table::create(lua_State* L) {
   // Use placement new operator - calls constructor from lobject.h
-  Table *t = new (L, LuaT::TABLE) Table();
+  Table *t = new (L, ctb(LuaT::TABLE)) Table();
 
   // Set non-default values
   t->setFlags(maskflags);  /* table has no metamethod fields */

src/testing/ltests.cpp

@@ -326,7 +326,7 @@ static void printobj (global_State *g, GCObject *o) {
            ttypename(novariant(o->getType())), (void *)o,
            isdead(g,o) ? 'd' : isblack(o) ? 'b' : iswhite(o) ? 'w' : 'g',
            "ns01oTt"[static_cast<size_t>(getage(o))], o->getMarked());
-  if (o->getType() == LuaT::SHRSTR || o->getType() == LuaT::LNGSTR)
+  if (o->getType() == ctb(LuaT::SHRSTR) || o->getType() == ctb(LuaT::LNGSTR))
     printf(" '%s'", getstr(gco2ts(o)));
 }
 
@@ -582,8 +582,8 @@ static void checkobject (global_State *g, GCObject *o, int maybedead,
         assert(isblack(o) ||
         getage(o) == GCAge::Touched1 ||
         getage(o) == GCAge::Old0 ||
-        o->getType() == LuaT::THREAD ||
-        (o->getType() == LuaT::UPVAL && gco2upv(o)->isOpen()));
+        o->getType() == ctb(LuaT::THREAD) ||
+        (o->getType() == ctb(LuaT::UPVAL) && gco2upv(o)->isOpen()));
       }
       assert(getage(o) != GCAge::Touched1 || isgray(o));
     }
@@ -641,7 +641,7 @@ static l_mem checkgrays (global_State *g) {
 static void incifingray (global_State *g, GCObject *o, l_mem *count) {
   if (!g->keepInvariant())
     return;  /* gray lists not being kept in these phases */
-  if (o->getType() == LuaT::UPVAL) {
+  if (o->getType() == ctb(LuaT::UPVAL)) {
     /* only open upvalues can be gray */
     assert(!isgray(o) || gco2upv(o)->isOpen());
     return;  /* upvalues are never in gray lists */
@@ -699,7 +699,7 @@ int lua_checkmemory (lua_State *L) {
 
   /* check 'fixedgc' list */
   for (o = g->getFixedGC(); o != nullptr; o = o->getNext()) {
-    assert(o->getType() == LuaT::SHRSTR && isgray(o) && getage(o) == GCAge::Old);
+    assert(o->getType() == ctb(LuaT::SHRSTR) && isgray(o) && getage(o) == GCAge::Old);
   }
 
   /* check 'allgc' list */
@@ -716,7 +716,7 @@ int lua_checkmemory (lua_State *L) {
     checkobject(g, o, 0, GCAge::New);
     incifingray(g, o, &totalshould);
     assert(tofinalize(o));
-    assert(o->getType() == LuaT::USERDATA || o->getType() == LuaT::TABLE);
+    assert(o->getType() == ctb(LuaT::USERDATA) || o->getType() == ctb(LuaT::TABLE));
   }
   if (g->keepInvariant())
     assert(totalin == totalshould);
@@ -1089,7 +1089,7 @@ static int hash_query (lua_State *L) {
     TString *ts;
     luaL_argcheck(L, lua_type(L, 1) == LUA_TSTRING, 1, "string expected");
     ts = tsvalue(obj_at(L, 1));
-    if (ts->getType() == LuaT::LNGSTR)
+    if (ts->getType() == ctb(LuaT::LNGSTR))
       ts->hashLongStr();  /* make sure long string has a hash */
     lua_pushinteger(L, cast_int(ts->getHash()));
   }