Phase 108: Table::pset API refinement - eliminate 3 const_cast uses

Fixed misleading const return types in Table lookup functions:

**Root Cause**: Functions like HgetShortStr(), getgeneric(), and getintfromhash()
returned `const TValue*` but callers needed to write to the returned slot,
requiring const_cast. The const was misleading - it didn't mean "read-only",
it meant "don't call barrier yet" (confusing semantics).

**Changes**:
1. Changed return types from `const TValue*` to `TValue*`:
   - getgeneric() - generic hash table lookup
   - getintfromhash() - integer key lookup
   - HgetShortStr() - short string lookup
   - Hgetlongstr() - long string lookup
   - Hgetstr() - string lookup dispatch

2. Updated finishnodeset() and rawfinishnodeset() parameters:
   - Changed from `const TValue* slot` to `TValue* slot`
   - Removed const_cast when writing to slot (3 eliminations!)

3. Updated psetShortStr() local variable:
   - Changed from `const TValue* slot` to `TValue* slot`

**Note**: Added const_cast for &absentkey (const sentinel) in 3 locations.
This is necessary and localized - absentkey is a read-only sentinel that
should never be written to (guarded by isabstkey() checks).

**Net Result**: Eliminated 3 const_cast uses, added 3 localized const_casts
for sentinel value (better than scattered casts in calling code).

Benefits:
- More accurate API contracts (mutable pointers for mutable data)
- Eliminated misleading const semantics
- Clearer code - no const_cast at call sites

Performance: 2.42s (well within 4.33s target)
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/objects/lobject.h

@@ -1658,7 +1658,7 @@ class Table : public GCBase<Table> {
   lu_byte getInt(lua_Integer key, TValue* res);
   lu_byte getShortStr(TString* key, TValue* res);
   lu_byte getStr(TString* key, TValue* res);
-  const TValue* HgetShortStr(TString* key);
+  TValue* HgetShortStr(TString* key);
 
   int pset(const TValue* key, TValue* val);
   int psetInt(lua_Integer key, TValue* val);

src/objects/ltable.cpp

@@ -350,15 +350,15 @@ static int equalkey (const TValue *k1, const Node *n2, int deadok) {
 ** which may be in array part, nor for floats with integral values.)
 ** See explanation about 'deadok' in function 'equalkey'.
 */
-static const TValue *getgeneric (Table *t, const TValue *key, int deadok) {
+static TValue *getgeneric (Table *t, const TValue *key, int deadok) {
   Node *n = mainpositionTV(t, key);
   for (;;) {  /* check whether 'key' is somewhere in the chain */
     if (equalkey(key, n, deadok))
       return gval(n);  /* that's it */
     else {
       int nx = gnext(n);
       if (nx == 0)
-        return &absentkey;  /* not found */
+        return const_cast<TValue*>(&absentkey);  /* not found */
       n += nx;
     }
   }
@@ -1042,7 +1042,7 @@ static void luaH_newkey (lua_State *L, Table *t, const TValue *key,
 }
 
 
-static const TValue *getintfromhash (Table *t, lua_Integer key) {
+static TValue *getintfromhash (Table *t, lua_Integer key) {
   Node *n = hashint(t, key);
   lua_assert(!ikeyinarray(t, key));
   for (;;) {  /* check whether 'key' is somewhere in the chain */
@@ -1054,7 +1054,7 @@ static const TValue *getintfromhash (Table *t, lua_Integer key) {
       n += nx;
     }
   }
-  return &absentkey;
+  return const_cast<TValue*>(&absentkey);
 }
 
 
@@ -1072,15 +1072,15 @@ static lu_byte finishnodeget (const TValue *val, TValue *res) {
 }
 
 
-static const TValue *Hgetlongstr (Table *t, TString *key) {
+static TValue *Hgetlongstr (Table *t, TString *key) {
   TValue ko;
   lua_assert(!strisshr(key));
   setsvalue(cast(lua_State *, NULL), &ko, key);
   return getgeneric(t, &ko, 0);  /* for long strings, use generic case */
 }
 
 
-static const TValue *Hgetstr (Table *t, TString *key) {
+static TValue *Hgetstr (Table *t, TString *key) {
   if (strisshr(key))
     return t->HgetShortStr(key);
   else
@@ -1100,21 +1100,21 @@ static int retpsetcode (Table *t, const TValue *slot) {
 }
 
 
-static int finishnodeset (Table *t, const TValue *slot, TValue *val) {
+static int finishnodeset (Table *t, TValue *slot, TValue *val) {
   if (!ttisnil(slot)) {
-    *const_cast<TValue*>(slot) = *val;
+    *slot = *val;
     return HOK;  /* success */
   }
   else
     return retpsetcode(t, slot);
 }
 
 
-static int rawfinishnodeset (const TValue *slot, TValue *val) {
+static int rawfinishnodeset (TValue *slot, TValue *val) {
   if (isabstkey(slot))
     return 0;  /* no slot with that key */
   else {
-    *const_cast<TValue*>(slot) = *val;
+    *slot = *val;
     return 1;  /* success */
   }
 }
@@ -1359,7 +1359,7 @@ lu_byte Table::getStr(TString* key, TValue* res) {
   return finishnodeget(Hgetstr(this, key), res);
 }
 
-const TValue* Table::HgetShortStr(TString* key) {
+TValue* Table::HgetShortStr(TString* key) {
   Node *n = hashstr(this, key);
   lua_assert(strisshr(key));
   for (;;) {  /* check whether 'key' is somewhere in the chain */
@@ -1368,7 +1368,7 @@ const TValue* Table::HgetShortStr(TString* key) {
     else {
       int nx = gnext(n);
       if (nx == 0)
-        return &absentkey;  /* not found */
+        return const_cast<TValue*>(&absentkey);  /* not found */
       n += nx;
     }
   }
@@ -1403,9 +1403,9 @@ int Table::psetInt(lua_Integer key, TValue* val) {
 }
 
 int Table::psetShortStr(TString* key, TValue* val) {
-  const TValue *slot = HgetShortStr(key);
+  TValue *slot = HgetShortStr(key);
   if (!ttisnil(slot)) {  /* key already has a value? (all too common) */
-    *const_cast<TValue*>(slot) = *val;  /* update it */
+    *slot = *val;  /* update it */
     return HOK;  /* done */
   }
   else if (checknoTM(getMetatable(), TMS::TM_NEWINDEX)) {  /* no metamethod? */