Phase 112 Part 1: Operator type safety - use enum classes directly

Changed FuncState operator method signatures to accept enum types:
- prefix(UnOpr op, ...) - was prefix(int op, ...)
- infix(BinOpr op, ...) - was infix(int op, ...)
- posfix(BinOpr op, ...) - was posfix(int op, ...)

Impact:
- Eliminated 6 redundant static_cast operations (enum→int→enum roundtrip)
- Improved type safety - prevents passing invalid operator values
- Self-documenting function signatures
- Zero performance impact - enums compile to same underlying type

Files changed:
- src/compiler/lparser.h (function signatures)
- src/compiler/lcode.cpp (implementations)
- src/compiler/parser.cpp (call sites - removed casts)

Performance: 4.49s avg (baseline 4.20s, variance 4.01-4.95s)
All tests passing: "final OK !!!"

Author: claude

src/compiler/lcode.cpp

@@ -1485,8 +1485,7 @@ int FuncState::getlabel() {
   return getPC();
 }
 
-void FuncState::prefix(int opr, expdesc *e, int line) {
-  UnOpr op = static_cast<UnOpr>(opr);
+void FuncState::prefix(UnOpr op, expdesc *e, int line) {
   expdesc ef;
   ef.setKind(VKINT);
   ef.setIntValue(0);
@@ -1495,7 +1494,7 @@ void FuncState::prefix(int opr, expdesc *e, int line) {
   dischargevars(e);
   switch (op) {
     case UnOpr::OPR_MINUS: case UnOpr::OPR_BNOT:  /* use 'ef' as fake 2nd operand */
-      if (constfolding(cast_int(opr + LUA_OPUNM), e, &ef))
+      if (constfolding(cast_int(op) + LUA_OPUNM, e, &ef))
         break;
       /* else */ /* FALLTHROUGH */
     case UnOpr::OPR_LEN:
@@ -1506,8 +1505,7 @@ void FuncState::prefix(int opr, expdesc *e, int line) {
   }
 }
 
-void FuncState::infix(int opr, expdesc *v) {
-  BinOpr op = static_cast<BinOpr>(opr);
+void FuncState::infix(BinOpr op, expdesc *v) {
   dischargevars(v);
   switch (op) {
     case BinOpr::OPR_AND: {
@@ -1551,10 +1549,9 @@ void FuncState::infix(int opr, expdesc *v) {
   }
 }
 
-void FuncState::posfix(int opr, expdesc *e1, expdesc *e2, int line) {
-  BinOpr op = static_cast<BinOpr>(opr);
+void FuncState::posfix(BinOpr op, expdesc *e1, expdesc *e2, int line) {
   dischargevars(e2);
-  if (foldbinop(op) && constfolding(cast_int(opr + LUA_OPADD), e1, e2))
+  if (foldbinop(op) && constfolding(cast_int(op) + LUA_OPADD, e1, e2))
     return;  /* done by folding */
   switch (op) {
     case BinOpr::OPR_AND: {

src/compiler/lparser.h

@@ -577,11 +577,10 @@ class FuncState {
   void patchtohere(int list);
   void concat(int *l1, int l2);
   int getlabel();
-  // Note: prefix, infix, posfix use UnOpr/BinOpr types from lcode.h
-  // We use int here to avoid circular dependency, will cast in implementation
-  void prefix(int op, expdesc *v, int line);
-  void infix(int op, expdesc *v);
-  void posfix(int op, expdesc *v1, expdesc *v2, int line);
+  // Operator functions use strongly-typed enum classes for type safety
+  void prefix(UnOpr op, expdesc *v, int line);
+  void infix(BinOpr op, expdesc *v);
+  void posfix(BinOpr op, expdesc *v1, expdesc *v2, int line);
   void settablesize(int pcpos, unsigned ra, unsigned asize, unsigned hsize);
   void setlist(int base, int nelems, int tostore);
   void finish();

src/compiler/parser.cpp

@@ -879,7 +879,7 @@ BinOpr Parser::subexpr( expdesc *v, int limit) {
     int line = ls->getLineNumber();
     ls->nextToken();  /* skip operator */
     subexpr(v, UNARY_PRIORITY);
-    fs->prefix(static_cast<int>(uop), v, line);
+    fs->prefix(uop, v, line);
   }
   else simpleexp(v);
   /* expand while operators have priorities higher than 'limit' */
@@ -889,10 +889,10 @@ BinOpr Parser::subexpr( expdesc *v, int limit) {
     BinOpr nextop;
     int line = ls->getLineNumber();
     ls->nextToken();  /* skip operator */
-    fs->infix(static_cast<int>(op), v);
+    fs->infix(op, v);
     /* read sub-expression with higher priority */
     nextop = subexpr(&v2, priority[static_cast<int>(op)].right);
-    fs->posfix(static_cast<int>(op), v, &v2, line);
+    fs->posfix(op, v, &v2, line);
     op = nextop;
   }
   leavelevel(ls);