Phase 122.4: Rename lua_State count fields for clarity

Replaced abbreviated field names with verbose camelCase:
- nci → numberOfCallInfos (6 sites)
- nCcalls → numberOfCCalls (9 sites)

Updated accessor methods for consistency:
- getNCI() → getNumberOfCallInfos()
- setNCI() → setNumberOfCallInfos()
- getNCIRef() → getNumberOfCallInfosRef()
- getNCcalls() → getNumberOfCCalls()
- setNCcalls() → setNumberOfCCalls()
- getNCcallsRef() → getNumberOfCCallsRef()

Changes across:
- lstate.h (field declarations, accessor methods, helper functions)
- lstate.cpp (5 sites: extendCI, freeCI, shrinkCI, luaE_incCstack, luaE_threadsize)
- ldo.cpp (5 sites: rawRunProtected, cCall, resume)
- parseutils.cpp (1 site: leavelevel)
- parser.cpp (1 site: leavelevel)
- ltests.cpp (2 sites: stacklevel)

Performance: ~2.11s avg (5 runs) - excellent, no regression
Tests: All passing ✓

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

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

Author: Peter Neiss

src/compiler/parser.cpp

@@ -58,7 +58,7 @@ inline void enterlevel(LexState* ls) {
 }
 
 inline void leavelevel(LexState* ls) noexcept {
-	ls->getLuaState()->getNCcallsRef()--;
+	ls->getLuaState()->getNumberOfCCallsRef()--;
 }
 
 

src/compiler/parseutils.cpp

@@ -93,7 +93,7 @@ inline void enterlevel(LexState* ls) {
 }
 
 inline void leavelevel(LexState* ls) noexcept {
-	ls->getLuaState()->getNCcallsRef()--;
+	ls->getLuaState()->getNumberOfCCallsRef()--;
 }
 
 

src/core/ldo.cpp

@@ -208,10 +208,10 @@ l_noret lua_State::throwBaseLevel(TStatus errcode) {
 ** ENCAPSULATION NOTE:
 ** This is now a lua_State method rather than a free function, following
 ** the C++ modernization (Phase 31). All state manipulation uses accessor
-** methods (getNCcalls, setErrorJmp, etc.) rather than direct field access.
+** methods (getNumberOfCCalls, setErrorJmp, etc.) rather than direct field access.
 */
 TStatus lua_State::rawRunProtected(Pfunc f, void *ud) {
-  l_uint32 oldnCcalls = getNCcalls();
+  l_uint32 oldnCcalls = getNumberOfCCalls();
   lua_longjmp lj;
   lj.status = LUA_OK;
   lj.previous = getErrorJmp();  /* chain new error handler */
@@ -230,7 +230,7 @@ TStatus lua_State::rawRunProtected(Pfunc f, void *ud) {
   }
 
   setErrorJmp(lj.previous);  /* restore old error handler */
-  setNCcalls(oldnCcalls);
+  setNumberOfCCalls(oldnCcalls);
   return lj.status;
 }
 
@@ -670,7 +670,7 @@ CallInfo* lua_State::preCall(StkId func, int nresults) {
 // Convert to private lua_State method
 void lua_State::cCall(StkId func, int nResults, l_uint32 inc) {
   CallInfo *ci_result;
-  getNCcallsRef() += inc;
+  getNumberOfCCallsRef() += inc;
   if (l_unlikely(getCcalls(this) >= LUAI_MAXCCALLS)) {
     checkstackp(this, 0, func);  /* free any use of EXTRA_STACK */
     luaE_checkcstack(this);
@@ -679,7 +679,7 @@ void lua_State::cCall(StkId func, int nResults, l_uint32 inc) {
     ci_result->callStatusRef() |= CIST_FRESH;  /* mark that it is a "fresh" execute */
     luaV_execute(this, ci_result);  /* call it */
   }
-  getNCcallsRef() -= inc;
+  getNumberOfCCallsRef() -= inc;
 }
 
 
@@ -902,10 +902,10 @@ LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs,
   }
   else if (L->getStatus() != LUA_YIELD)  /* ended with errors? */
     return resume_error(L, "cannot resume dead coroutine", nargs);
-  L->setNCcalls((from) ? getCcalls(from) : 0);
+  L->setNumberOfCCalls((from) ? getCcalls(from) : 0);
   if (getCcalls(L) >= LUAI_MAXCCALLS)
     return resume_error(L, "C stack overflow", nargs);
-  L->getNCcallsRef()++;
+  L->getNumberOfCCallsRef()++;
   luai_userstateresume(L, nargs);
   api_checkpop(L, (L->getStatus() == LUA_OK) ? nargs + 1 : nargs);
   status = L->rawRunProtected( resume, &nargs);

src/core/lstate.cpp

@@ -89,7 +89,7 @@ CallInfo *luaE_extendCI (lua_State *L) {
   ci->setNext(nullptr);
   // trap already initialized to 0 in constructor, but keep this for clarity
   ci->getTrap() = 0;
-  L->getNCIRef()++;
+  L->getNumberOfCallInfosRef()++;
   return ci;
 }
 
@@ -104,7 +104,7 @@ static void freeCI (lua_State *L) {
   while ((ci = next) != nullptr) {
     next = ci->getNext();
     luaM_free(L, ci);
-    L->getNCIRef()--;
+    L->getNumberOfCallInfosRef()--;
   }
 }
 
@@ -121,7 +121,7 @@ void luaE_shrinkCI (lua_State *L) {
   while ((next = ci->getNext()) != nullptr) {  /* two extra elements? */
     CallInfo *next2 = next->getNext();  /* next's next */
     ci->setNext(next2);  /* remove next from the list */
-    L->getNCIRef()--;
+    L->getNumberOfCallInfosRef()--;
     luaM_free(L, next);  /* free next */
     if (next2 == nullptr)
       break;  /* no more elements */
@@ -149,7 +149,7 @@ void luaE_checkcstack (lua_State *L) {
 
 
 LUAI_FUNC void luaE_incCstack (lua_State *L) {
-  L->getNCcallsRef()++;
+  L->getNumberOfCCallsRef()++;
   if (l_unlikely(getCcalls(L) >= LUAI_MAXCCALLS))
     luaE_checkcstack(L);
 }
@@ -179,7 +179,7 @@ static void stack_init (lua_State *L1, lua_State *L) {
 static void freestack (lua_State *L) {
   L->setCI(L->getBaseCI());  /* free the entire 'ci' list */
   freeCI(L);
-  lua_assert(L->getNCI() == 0);
+  lua_assert(L->getNumberOfCallInfos() == 0);
   /* free stack via LuaStack subsystem */
   L->getStackSubsystem().free(L);
 }
@@ -240,7 +240,7 @@ static void preinit_thread (lua_State *L, global_State *g) {
 
 lu_mem luaE_threadsize (lua_State *L) {
   lu_mem sz = static_cast<lu_mem>(sizeof(LX))
-            + cast_uint(L->getNCI()) * sizeof(CallInfo);
+            + cast_uint(L->getNumberOfCallInfos()) * sizeof(CallInfo);
   if (L->getStack().p != nullptr)
     sz += cast_uint(L->getStackSize() + EXTRA_STACK) * sizeof(StackValue);
   return sz;
@@ -319,7 +319,7 @@ TStatus luaE_resetthread (lua_State *L, TStatus status) {
 LUA_API int lua_closethread (lua_State *L, lua_State *from) {
   TStatus status;
   lua_lock(L);
-  L->setNCcalls((from) ? getCcalls(from) : 0);
+  L->setNumberOfCCalls((from) ? getCcalls(from) : 0);
   status = luaE_resetthread(L, L->getStatus());
   if (L == from)  /* closing itself? */
     L->throwBaseLevel( status);

src/core/lstate.h

@@ -422,8 +422,8 @@ struct lua_State : public GCBase<lua_State> {
   } transferinfo;
 
   // Step 6: Call counter fields (encapsulated)
-  l_uint32 nCcalls;  /* number of nested non-yieldable or C calls */
-  int nci;  /* number of items in 'ci' list */
+  l_uint32 numberOfCCalls;  /* number of nested non-yieldable or C calls */
+  int numberOfCallInfos;  /* number of items in 'ci' list */
 
 public:
   // Initialize lua_State fields (GC base fields must already be set by caller)
@@ -442,7 +442,7 @@ struct lua_State : public GCBase<lua_State> {
 
     // CallInfo fields
     ci = nullptr;
-    nci = 0;
+    numberOfCallInfos = 0;
     // base_ci initialized via placement new to call its constructor
     new (&base_ci) CallInfo();
 
@@ -469,7 +469,7 @@ struct lua_State : public GCBase<lua_State> {
     transferinfo.ntransfer = 0;
 
     // Call depth
-    nCcalls = 0;
+    numberOfCCalls = 0;
   }
 
   // Stack subsystem accessor
@@ -563,17 +563,17 @@ struct lua_State : public GCBase<lua_State> {
   const auto& getTransferInfo() const noexcept { return transferinfo; }
 
   // Step 6: Call counter field accessors
-  l_uint32 getNCcalls() const noexcept { return nCcalls; }
-  void setNCcalls(l_uint32 nc) noexcept { nCcalls = nc; }
-  l_uint32& getNCcallsRef() noexcept { return nCcalls; }  // For increment/decrement
+  l_uint32 getNumberOfCCalls() const noexcept { return numberOfCCalls; }
+  void setNumberOfCCalls(l_uint32 nc) noexcept { numberOfCCalls = nc; }
+  l_uint32& getNumberOfCCallsRef() noexcept { return numberOfCCalls; }  // For increment/decrement
 
-  int getNCI() const noexcept { return nci; }
-  void setNCI(int n) noexcept { nci = n; }
-  int& getNCIRef() noexcept { return nci; }  // For increment/decrement
+  int getNumberOfCallInfos() const noexcept { return numberOfCallInfos; }
+  void setNumberOfCallInfos(int n) noexcept { numberOfCallInfos = n; }
+  int& getNumberOfCallInfosRef() noexcept { return numberOfCallInfos; }  // For increment/decrement
 
   // Non-yieldable call management
-  void incrementNonYieldable() noexcept { nCcalls += 0x10000; }
-  void decrementNonYieldable() noexcept { nCcalls -= 0x10000; }
+  void incrementNonYieldable() noexcept { numberOfCCalls += 0x10000; }
+  void decrementNonYieldable() noexcept { numberOfCCalls -= 0x10000; }
 
   // Phase 44.4: Additional lua_State helper methods
 
@@ -700,12 +700,12 @@ struct lua_State : public GCBase<lua_State> {
 
 /* true if this thread does not have non-yieldable calls in the stack */
 inline constexpr bool yieldable(const lua_State* L) noexcept {
-	return ((L->getNCcalls() & 0xffff0000) == 0);
+	return ((L->getNumberOfCCalls() & 0xffff0000) == 0);
 }
 
 /* real number of C calls */
 inline constexpr l_uint32 getCcalls(const lua_State* L) noexcept {
-	return (L->getNCcalls() & 0xffff);
+	return (L->getNumberOfCCalls() & 0xffff);
 }
 
 /* Increment the number of non-yieldable calls */

src/testing/ltests.cpp

@@ -1108,8 +1108,8 @@ static int stacklevel (lua_State *L) {
   int a = 0;
   lua_pushinteger(L, cast_Integer(L->getTop().p - L->getStack().p));
   lua_pushinteger(L, L->getStackSize());
-  lua_pushinteger(L, cast_Integer(L->getNCcalls()));
-  lua_pushinteger(L, L->getNCI());
+  lua_pushinteger(L, cast_Integer(L->getNumberOfCCalls()));
+  lua_pushinteger(L, L->getNumberOfCallInfos());
   lua_pushinteger(L, (lua_Integer)(size_t)&a);
   return 5;
 }