Phase 122-123: std::span callsite conversion (Parts 2-3 - Compiler & Runtime)

Converted 9 additional patterns to use existing std::span accessors:

**Phase 122 - Compiler Code (7 conversions):**

funcstate.cpp:
1. registerlocalvar() - locVarsSpan initialization loop
2. searchupvalue() - upvaluesSpan search loop
3. allocupvalue() - upvaluesSpan initialization loop

lcode.cpp:
4. addk() - constantsSpan initialization loop
5. finaltarget() - codeSpan jump chain following
6. finish() - codeSpan instruction loop

parser.cpp:
7. addprototype() - protosSpan initialization loop

**Phase 123 - Runtime Code (2 conversions):**

lfunc.cpp:
8. Proto::getLocalName() - locVarsSpan range-based for loop

lvm.cpp:
9. lua_State::pushClosure() - upvaluesSpan range-based for loop

All conversions use existing span accessors from Phase 115-116:
- Proto::getCodeSpan()
- Proto::getConstantsSpan()
- Proto::getProtosSpan()
- Proto::getUpvaluesSpan()
- ProtoDebugInfo::getLocVarsSpan()

Benefits:
- Type-safe array access throughout compiler and runtime
- Cleaner range-based for loops where applicable
- Better bounds safety with std::span
- More idiomatic modern C++23 code

Testing:
- All tests pass (final OK !!!)
- Performance: 4.61s avg (within acceptable bounds)
- Total std::span conversions: 15 (Phase 121: 6 + Phase 122: 7 + Phase 123: 2)

This completes the std::span expansion effort (Option 2) with 15 new
call sites converted beyond the original Phase 115-116 accessor additions.

Author: claude

src/compiler/funcstate.cpp

@@ -91,10 +91,11 @@ short FuncState::registerlocalvar(TString *varname) {
   int oldsize = proto->getLocVarsSize();
   luaM_growvector(getLexState()->getLuaState(), proto->getLocVarsRef(), getNumDebugVars(), proto->getLocVarsSizeRef(),
                   LocVar, SHRT_MAX, "local variables");
-  while (oldsize < proto->getLocVarsSize())
-    proto->getLocVars()[oldsize++].setVarName(nullptr);
-  proto->getLocVars()[getNumDebugVars()].setVarName(varname);
-  proto->getLocVars()[getNumDebugVars()].setStartPC(getPC());
+  auto locVarsSpan = proto->getDebugInfo().getLocVarsSpan();
+  while (oldsize < static_cast<int>(locVarsSpan.size()))
+    locVarsSpan[oldsize++].setVarName(nullptr);
+  locVarsSpan[getNumDebugVars()].setVarName(varname);
+  locVarsSpan[getNumDebugVars()].setStartPC(getPC());
   luaC_objbarrier(getLexState()->getLuaState(), proto, varname);
   return postIncrementNumDebugVars();
 }
@@ -181,10 +182,9 @@ void FuncState::removevars(int tolevel) {
 ** with the given 'name'.
 */
 int FuncState::searchupvalue(TString *name) {
-  int i;
-  Upvaldesc *up = getProto()->getUpvalues();
-  for (i = 0; i < getNumUpvalues(); i++) {
-    if (eqstr(up[i].getName(), name)) return i;
+  auto upvaluesSpan = getProto()->getUpvaluesSpan();
+  for (size_t i = 0; i < static_cast<size_t>(getNumUpvalues()); i++) {
+    if (eqstr(upvaluesSpan[i].getName(), name)) return static_cast<int>(i);
   }
   return -1;  /* not found */
 }
@@ -196,9 +196,10 @@ Upvaldesc *FuncState::allocupvalue() {
   checklimit(getNumUpvalues() + 1, MAXUPVAL, "upvalues");
   luaM_growvector(getLexState()->getLuaState(), proto->getUpvaluesRef(), getNumUpvalues(), proto->getUpvaluesSizeRef(),
                   Upvaldesc, MAXUPVAL, "upvalues");
-  while (oldsize < proto->getUpvaluesSize())
-    proto->getUpvalues()[oldsize++].setName(nullptr);
-  return &proto->getUpvalues()[getNumUpvaluesRef()++];
+  auto upvaluesSpan = proto->getUpvaluesSpan();
+  while (oldsize < static_cast<int>(upvaluesSpan.size()))
+    upvaluesSpan[oldsize++].setName(nullptr);
+  return &upvaluesSpan[getNumUpvaluesRef()++];
 }
 
 

src/compiler/lcode.cpp

@@ -319,9 +319,10 @@ int FuncState::addk(Proto *proto, TValue *v) {
   int oldsize = proto->getConstantsSize();
   int k = getNK();
   luaM_growvector(L, proto->getConstantsRef(), k, proto->getConstantsSizeRef(), TValue, MAXARG_Ax, "constants");
-  while (oldsize < proto->getConstantsSize())
-    setnilvalue(&proto->getConstants()[oldsize++]);
-  proto->getConstants()[k] = *v;
+  auto constantsSpan = proto->getConstantsSpan();
+  while (oldsize < static_cast<int>(constantsSpan.size()))
+    setnilvalue(&constantsSpan[oldsize++]);
+  constantsSpan[k] = *v;
   incrementNK();
   luaC_barrier(L, proto, v);
   return k;
@@ -1071,10 +1072,10 @@ void FuncState::codeconcat(expdesc *e1, expdesc *e2, int line) {
 ** return the final target of a jump (skipping jumps to jumps)
 */
 int FuncState::finaltarget(int i) {
-  Instruction *code = getProto()->getCode();
+  auto codeSpan = getProto()->getCodeSpan();
   int count;
   for (count = 0; count < 100; count++) {  /* avoid infinite loops */
-    Instruction instr = code[i];
+    Instruction instr = codeSpan[i];
     if (InstructionView(instr).opcode() != OP_JMP)
       break;
     else
@@ -1654,8 +1655,9 @@ void FuncState::setlist(int base, int nelems, int tostore) {
 void FuncState::finish() {
   int i;
   Proto *p = getProto();
+  auto codeSpan = p->getCodeSpan();
   for (i = 0; i < getPC(); i++) {
-    Instruction *instr = &p->getCode()[i];
+    Instruction *instr = &codeSpan[i];
     /* avoid "not used" warnings when assert is off (for 'onelua.c') */
     (void)luaP_isOT; (void)luaP_isIT;
     lua_assert(i == 0 || luaP_isOT(*(instr - 1)) == luaP_isIT(*instr));

src/compiler/parser.cpp

@@ -412,10 +412,11 @@ Proto *Parser::addprototype() {
   if (funcstate->getNP() >= proto->getProtosSize()) {
     int oldsize = proto->getProtosSize();
     luaM_growvector(state, proto->getProtosRef(), funcstate->getNP(), proto->getProtosSizeRef(), Proto *, MAXARG_Bx, "functions");
-    while (oldsize < proto->getProtosSize())
-      proto->getProtos()[oldsize++] = nullptr;
+    auto protosSpan = proto->getProtosSpan();
+    while (oldsize < static_cast<int>(protosSpan.size()))
+      protosSpan[oldsize++] = nullptr;
   }
-  proto->getProtos()[funcstate->getNPRef()++] = clp = luaF_newproto(state);
+  proto->getProtosSpan()[funcstate->getNPRef()++] = clp = luaF_newproto(state);
   luaC_objbarrier(state, proto, clp);
   return clp;
 }

src/objects/lfunc.cpp

@@ -319,12 +319,14 @@ void luaF_freeproto (lua_State *L, Proto *f) {
 ** Returns nullptr if not found.
 */
 const char* Proto::getLocalName(int local_number, int pc) const {
-  int i;
-  for (i = 0; i<getLocVarsSize() && getLocVars()[i].getStartPC() <= pc; i++) {
-    if (pc < getLocVars()[i].getEndPC()) {  /* is variable active? */
+  auto locVarsSpan = getDebugInfo().getLocVarsSpan();
+  for (const auto& locvar : locVarsSpan) {
+    if (locvar.getStartPC() > pc)
+      break;
+    if (pc < locvar.getEndPC()) {  /* is variable active? */
       local_number--;
       if (local_number == 0)
-        return getstr(getLocVars()[i].getVarName());
+        return getstr(locvar.getVarName());
     }
   }
   return nullptr;  /* not found */

src/vm/lvm.cpp

@@ -135,18 +135,19 @@ inline constexpr int MAXTAGLOOP = 2000;
 ** its upvalues.
 */
 void lua_State::pushClosure(Proto *p, UpVal **encup, StkId base, StkId ra) {
-  int nup = p->getUpvaluesSize();
-  Upvaldesc *uv = p->getUpvalues();
-  int i;
+  auto upvaluesSpan = p->getUpvaluesSpan();
+  int nup = static_cast<int>(upvaluesSpan.size());
+  int i = 0;
   LClosure *ncl = LClosure::create(this, nup);
   ncl->setProto(p);
   setclLvalue2s(this, ra, ncl);  /* anchor new closure in stack */
-  for (i = 0; i < nup; i++) {  /* fill in its upvalues */
-    if (uv[i].isInStack())  /* upvalue refers to local variable? */
-      ncl->setUpval(i, luaF_findupval(this, base + uv[i].getIndex()));
+  for (const auto& uv : upvaluesSpan) {  /* fill in its upvalues */
+    if (uv.isInStack())  /* upvalue refers to local variable? */
+      ncl->setUpval(i, luaF_findupval(this, base + uv.getIndex()));
     else  /* get upvalue from enclosing function */
-      ncl->setUpval(i, encup[uv[i].getIndex()]);
+      ncl->setUpval(i, encup[uv.getIndex()]);
     luaC_objbarrier(this, ncl, ncl->getUpval(i));
+    i++;
   }
 }