Phase 107: const-correctness fixes - eliminate 7 const_cast uses

Removed unnecessary const_cast by fixing function signatures:

1. TString::equals const-correctness (4 casts eliminated)
   - Changed signature: bool equals(const TString*) const
   - Removed const_cast from lobject.h lines 1866, 1885, 1922
   - Method only reads data, should be const

2. luaH_size const-correctness (1 cast eliminated)
   - Changed signature: lu_mem luaH_size(const Table*)
   - Also made sizehash() const-correct
   - Removed const_cast from Table::size()

3. global_State logical mutability (1 cast eliminated)
   - Marked l_G field as mutable in lua_State
   - GC can happen during any operation, even const ones
   - Updated getGlobalState() const to return non-const
   - Removed const_cast from G() helper function

4. Udata::getMemory const-correctness (1 cast eliminated)
   - getudatamem() already had const overload
   - Removed unnecessary const_cast by calling correct overload

Benefits:
- Better const-correctness throughout codebase
- Eliminated 7 unnecessary const_casts
- More accurate API contracts (const means read-only)
- Zero performance impact

Performance: 2.35s avg (44% faster than 4.20s baseline)
All tests passing: "final OK !!!"

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

Author: Peter Neiss

src/core/lstate.h

@@ -399,7 +399,7 @@ struct lua_State : public GCBase<lua_State> {
   CallInfo base_ci;  /* CallInfo for first level (C host) */
 
   // Step 3: GC and state management fields (encapsulated)
-  global_State *l_G;
+  mutable global_State *l_G;  /* mutable: GC can happen during any operation */
   UpVal *openupval;  /* list of open upvalues in this stack */
   GCObject *gclist;
   lua_State *twups;  /* list of threads with open upvalues */
@@ -507,7 +507,7 @@ struct lua_State : public GCBase<lua_State> {
 
   // Step 3: GC and state management field accessors
   global_State* getGlobalState() noexcept { return l_G; }
-  const global_State* getGlobalState() const noexcept { return l_G; }
+  global_State* getGlobalState() const noexcept { return l_G; }  // mutable field
   void setGlobalState(global_State* g) noexcept { l_G = g; }
   global_State*& getGlobalStateRef() noexcept { return l_G; }  // For G() macro
 
@@ -1199,7 +1199,7 @@ class global_State {
 
 /* Get global state from lua_State (returns reference to allow assignment) */
 inline global_State*& G(lua_State* L) noexcept { return L->getGlobalStateRef(); }
-inline global_State* G(const lua_State* L) noexcept { return const_cast<global_State*>(L->getGlobalState()); }
+inline global_State* G(const lua_State* L) noexcept { return L->getGlobalState(); }
 
 /* Get main thread from global_State */
 inline lua_State* mainthread(global_State* g) noexcept { return &g->getMainThread()->l; }

src/objects/lobject.h

@@ -539,7 +539,7 @@ class TString : public GCBase<TString> {
 
   // Method declarations (implemented in lstring.cpp)
   unsigned hashLongStr();
-  bool equals(TString* other);
+  bool equals(const TString* other) const;
   void remove(lua_State* L);           // Phase 25a: from luaS_remove
   TString* normalize(lua_State* L);    // Phase 25a: from luaS_normstr
 
@@ -772,7 +772,7 @@ inline void* Udata::getMemory() noexcept {
   return getudatamem(this);
 }
 inline const void* Udata::getMemory() const noexcept {
-  return getudatamem(const_cast<Udata*>(this));
+  return getudatamem(this);  // Calls const overload
 }
 
 /* }================================================================== */
@@ -1863,7 +1863,7 @@ inline bool operator==(const TValue& l, const TValue& r) noexcept {
 			}
 			case LUA_VSHRSTR: case LUA_VLNGSTR: {
 				/* Compare strings with different variants */
-				return const_cast<TString*>(tsvalue(&l))->equals(const_cast<TString*>(tsvalue(&r)));
+				return tsvalue(&l)->equals(tsvalue(&r));
 			}
 			default:
 				return false;
@@ -1882,7 +1882,7 @@ inline bool operator==(const TValue& l, const TValue& r) noexcept {
 			case LUA_VSHRSTR:
 				return eqshrstr(tsvalue(&l), tsvalue(&r));
 			case LUA_VLNGSTR:
-				return const_cast<TString*>(tsvalue(&l))->equals(const_cast<TString*>(tsvalue(&r)));
+				return tsvalue(&l)->equals(tsvalue(&r));
 			case LUA_VUSERDATA:
 				return uvalue(&l) == uvalue(&r);
 			case LUA_VLCF:
@@ -1919,7 +1919,7 @@ inline bool operator<=(const TString& l, const TString& r) noexcept {
 /* operator== for TString - equality check using existing equals() method */
 inline bool operator==(const TString& l, const TString& r) noexcept {
 	// Use equals() method which handles short vs long string optimization
-	return const_cast<TString&>(l).equals(const_cast<TString*>(&r));
+	return l.equals(&r);
 }
 
 /* operator!= for TString - inequality check */

src/objects/lstring.cpp

@@ -405,7 +405,7 @@ unsigned TString::hashLongStr() {
   return getHash();
 }
 
-bool TString::equals(TString* other) {
+bool TString::equals(const TString* other) const {
   size_t len1, len2;
   const char *s1 = getlstr(this, len1);
   const char *s2 = getlstr(other, len2);

src/objects/ltable.cpp

@@ -453,7 +453,7 @@ inline size_t extraLastfree(const Table* t) noexcept {
 }
 
 /* 'node' size in bytes */
-static size_t sizehash (Table *t) {
+static size_t sizehash (const Table *t) {
   return cast_sizet(t->nodeSize()) * sizeof(Node) + extraLastfree(t);
 }
 
@@ -925,7 +925,7 @@ Table *luaH_new (lua_State *L) {
 }
 
 
-lu_mem luaH_size (Table *t) {
+lu_mem luaH_size (const Table *t) {
   lu_mem sz = static_cast<lu_mem>(sizeof(Table)) + concretesize(t->arraySize());
   if (!t->isDummy())
     sz += sizehash(t);
@@ -1499,7 +1499,7 @@ void Table::resizeArray(lua_State* L, unsigned nasize) {
 }
 
 lu_mem Table::size() const {
-  return luaH_size(const_cast<Table*>(this));
+  return luaH_size(this);
 }
 
 int Table::tableNext(lua_State* L, StkId key) {

src/objects/ltable.h

@@ -159,7 +159,7 @@ LUAI_FUNC Table *luaH_new (lua_State *L);
 LUAI_FUNC void luaH_resize (lua_State *L, Table *t, unsigned nasize,
                                                     unsigned nhsize);
 LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, unsigned nasize);
-LUAI_FUNC lu_mem luaH_size (Table *t);
+LUAI_FUNC lu_mem luaH_size (const Table *t);
 LUAI_FUNC void luaH_free (lua_State *L, Table *t);
 LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key);
 LUAI_FUNC lua_Unsigned luaH_getn (lua_State *L, Table *t);