refactor: drop per-type micro handlers and the parallel NamedValues map

Integer/Real/Boolean/CharHandler carried only five one-line LLVM API
wrappers (now inlined at their call sites in CodeGen.cc) plus dead
emitDeclare methods that violated the documented two-table lock-step
invariant. StringHandler::emitDeclare (also dead) and its NamedValues
reference go too.

With the dead writers gone, NamedValues held no information not already
in Symbols[].Storage, so the parallel map is removed: getNamedValue
reads Symbols, ArrayHandler/FunctionGen take one table, and function
bodies save/restore a single map. Behavior unchanged.

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

8 files changed, 13 insertions, 101 deletions

diff --git a/lib/CodeGen/ArrayHandler.cc b/lib/CodeGen/ArrayHandler.cc
index af16692..83204a7 100644
--- a/lib/CodeGen/ArrayHandler.cc
+++ b/lib/CodeGen/ArrayHandler.cc
@@ -12,14 +12,12 @@ using namespace cps;
 ArrayHandler::ArrayHandler(LLVMContext &C,
                            IRBuilder<> &B,
                            Module &M,
-                           std::map<std::string, Value*> &NV,
                            std::map<std::string, SymbolInfo> &Sym,
                            TypeSystem &TS,
                            RuntimeCheck &RC)
     : TheContext(&C),
       Builder(&B),
       TheModule(&M),
-      NamedValues(&NV),
       Symbols(&Sym),
       Types(TS),
       RuntimeChecker(RC) {
@@ -58,11 +56,11 @@ Value *ArrayHandler::computeFlatIndex(const std::string &Name, const std::vector
 }
 
 Value *ArrayHandler::getArrayBasePointer(const std::string &Name) {
-    auto It = NamedValues->find(Name);
-    if (It == NamedValues->end() || !It->second) {
+    auto It = Symbols->find(Name);
+    if (It == Symbols->end() || !It->second.Storage) {
         return nullptr;
     }
-    return Builder->CreateLoad(PointerType::getUnqual(*TheContext), It->second, (Name + "_raw").c_str());
+    return Builder->CreateLoad(PointerType::getUnqual(*TheContext), It->second.Storage, (Name + "_raw").c_str());
 }
 
 Value *ArrayHandler::getElementPointer(const std::string &Name, Value *Offset) {
diff --git a/lib/CodeGen/BooleanHandler.cc b/lib/CodeGen/BooleanHandler.cc
deleted file mode 100644
index 558ac95..0000000
--- a/lib/CodeGen/BooleanHandler.cc
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "cps/BooleanHandler.h"
-
-using namespace llvm;
-using namespace cps;
-
-void BooleanHandler::emitDeclare(const std::string &Name) {
-    Function *TheFunction = Builder.GetInsertBlock()->getParent();
-    IRBuilder<> TmpB(&TheFunction->getEntryBlock(), TheFunction->getEntryBlock().begin());
-    AllocaInst *Alloca = TmpB.CreateAlloca(Type::getInt1Ty(Context), nullptr, Name);
-    Builder.CreateStore(ConstantInt::get(Context, APInt(1, 0)), Alloca);
-    NamedValues[Name] = Alloca;
-}
-
-Value *BooleanHandler::createLiteral(bool Val) {
-    return ConstantInt::get(Context, APInt(1, Val ? 1 : 0));
-}
diff --git a/lib/CodeGen/CharHandler.cc b/lib/CodeGen/CharHandler.cc
deleted file mode 100644
index 5e9b502..0000000
--- a/lib/CodeGen/CharHandler.cc
+++ /dev/null
@@ -1,15 +0,0 @@
-#include "cps/CharHandler.h"
-
-using namespace llvm;
-using namespace cps;
-
-CharHandler::CharHandler(LLVMContext &Ctx, IRBuilder<> &B, llvm::Module &M)
-    : Context(Ctx), Builder(B), Module(M) {}
-
-Value *CharHandler::emitAsc(Value *CharVal) {
-    return Builder.CreateZExt(CharVal, Type::getInt32Ty(Context), "asc_val");
-}
-
-Value *CharHandler::emitChr(Value *IntVal) {
-    return Builder.CreateTrunc(IntVal, Type::getInt8Ty(Context), "chr_val");
-}
diff --git a/lib/CodeGen/CodeGen.cc b/lib/CodeGen/CodeGen.cc
index de64a15..31a0274 100644
--- a/lib/CodeGen/CodeGen.cc
+++ b/lib/CodeGen/CodeGen.cc
@@ -66,7 +66,6 @@ CodeGen::CodeGen() {
     Arrays = std::make_unique<ArrayHandler>(*TheContext,
                                             *Builder,
                                             *TheModule,
-                                            NamedValues,
                                             Symbols,
                                             *Types,
                                             *RuntimeChecker);
@@ -75,16 +74,11 @@ CodeGen::CodeGen() {
                                             *TheModule,
                                             *Builder,
                                             *Types,
-                                            NamedValues,
                                             Symbols,
                                             HadError);
 
-    IntHandler = std::make_unique<IntegerHandler>(*TheContext, *Builder, *TheModule, NamedValues);
-    RealHelper = std::make_unique<RealHandler>(*TheContext, *Builder, *TheModule, NamedValues);
-    BoolHandler = std::make_unique<BooleanHandler>(*TheContext, *Builder, *TheModule, NamedValues);
     ArithHandler = std::make_unique<ArithmeticHandler>(*TheContext, *Builder, HadError);
-    StrHandler = std::make_unique<StringHandler>(*TheContext, *Builder, *TheModule, NamedValues);
-    ChrHandler = std::make_unique<CharHandler>(*TheContext, *Builder, *TheModule);
+    StrHandler = std::make_unique<StringHandler>(*TheContext, *Builder, *TheModule);
     StrConvHandler = std::make_unique<StringConversionHandler>(*TheContext, *Builder, *TheModule);
 
     SetupExternalFunctions();
@@ -135,7 +129,6 @@ void CodeGen::registerSymbol(const std::string &Name,
                              Value *Storage,
                              const std::string &TypeName,
                              bool IsArray) {
-    NamedValues[Name] = Storage;
     Symbols[Name] = {Storage, TypeName, IsArray};
 }
 
@@ -156,8 +149,8 @@ Type *CodeGen::getLLVMType(const std::string &TypeName) const {
 }
 
 Value *CodeGen::getNamedValue(const std::string &Name) const {
-    auto It = NamedValues.find(Name);
-    return It == NamedValues.end() ? nullptr : It->second;
+    auto It = Symbols.find(Name);
+    return It == Symbols.end() ? nullptr : It->second.Storage;
 }
 
 const TypeInfo *CodeGen::getExprTypeInfo(ExprAST *Expr) const {
@@ -443,15 +436,15 @@ Value *CodeGen::emitExpr(ExprAST *Expr) {
     if (!Expr) return nullptr;
 
     if (auto *Num = dynamic_cast<IntegerExprAST*>(Expr)) {
-        return IntHandler->createLiteral(Num->getVal());
+        return ConstantInt::get(*TheContext, APInt(64, Num->getVal(), true));
     }
 
     if (auto *Real = dynamic_cast<RealExprAST*>(Expr)) {
-        return RealHelper->createLiteral(Real->getVal());
+        return ConstantFP::get(*TheContext, APFloat(Real->getVal()));
     }
 
     if (auto *Bool = dynamic_cast<BooleanExprAST*>(Expr)) {
-        return BoolHandler->createLiteral(Bool->getVal());
+        return ConstantInt::get(*TheContext, APInt(1, Bool->getVal() ? 1 : 0));
     }
 
     if (auto *Chr = dynamic_cast<CharExprAST*>(Expr)) {
@@ -557,12 +550,12 @@ Value *CodeGen::emitExpr(ExprAST *Expr) {
             } else {
                 CharVal = Builder->CreateLoad(Type::getInt8Ty(*TheContext), ArgVal, "char_load");
             }
-            Value *AscVal = ChrHandler->emitAsc(CharVal);
+            Value *AscVal = Builder->CreateZExt(CharVal, Type::getInt32Ty(*TheContext), "asc_val");
             return coerceValueToType(AscVal, resolveType("INTEGER"));
         }
         if (Name == "CHR") {
             Value *IntVal = coerceValueToType(emitExpr(Call->getArgs()[0].get()), resolveType("INTEGER"));
-            Value *CharVal = ChrHandler->emitChr(IntVal);
+            Value *CharVal = Builder->CreateTrunc(IntVal, Type::getInt8Ty(*TheContext), "chr_val");
             return coerceValueToType(CharVal, resolveType("STRING"));
         }
         if (Name == "IS_NUM") {
diff --git a/lib/CodeGen/FunctionGen.cc b/lib/CodeGen/FunctionGen.cc
index 57454b1..2e5a704 100644
--- a/lib/CodeGen/FunctionGen.cc
+++ b/lib/CodeGen/FunctionGen.cc
@@ -26,7 +26,6 @@ void FunctionGen::createArgumentAllocas(Function *F, const std::vector<std::tupl
         ArgVal->setName(ArgName);
 
         if (IsRef) {
-            NamedValues[ArgName] = ArgVal;
             Symbols[ArgName] = {ArgVal, ArgTypeStr, false};
             continue;
         }
@@ -36,7 +35,6 @@ void FunctionGen::createArgumentAllocas(Function *F, const std::vector<std::tupl
         AllocaInst *Alloca = TmpB.CreateAlloca(ArgType, nullptr, ArgName);
 
         Builder.CreateStore(ArgVal, Alloca);
-        NamedValues[ArgName] = Alloca;
         Symbols[ArgName] = {Alloca, ArgTypeStr, false};
     }
 }
@@ -96,9 +94,7 @@ Function *FunctionGen::emitFunctionDef(FunctionDefAST *FuncAST,
     BasicBlock *BB = BasicBlock::Create(Context, "entry", TheFunction);
     Builder.SetInsertPoint(BB);
 
-    std::map<std::string, llvm::Value*> OldNamedValues = NamedValues;
     std::map<std::string, SymbolInfo> OldSymbols = Symbols;
-    NamedValues.clear();
     Symbols.clear();
 
     createArgumentAllocas(TheFunction, Proto->getArgs());
@@ -115,7 +111,6 @@ Function *FunctionGen::emitFunctionDef(FunctionDefAST *FuncAST,
         }
     }
 
-    NamedValues = OldNamedValues;
     Symbols = OldSymbols;
     return TheFunction;
 }
diff --git a/lib/CodeGen/IntegerHandler.cc b/lib/CodeGen/IntegerHandler.cc
deleted file mode 100644
index 8161593..0000000
--- a/lib/CodeGen/IntegerHandler.cc
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "cps/IntegerHandler.h"
-
-using namespace llvm;
-using namespace cps;
-
-void IntegerHandler::emitDeclare(const std::string &Name) {
-    Function *TheFunction = Builder.GetInsertBlock()->getParent();
-    IRBuilder<> TmpB(&TheFunction->getEntryBlock(), TheFunction->getEntryBlock().begin());
-    AllocaInst *Alloca = TmpB.CreateAlloca(Type::getInt64Ty(Context), nullptr, Name);
-    Builder.CreateStore(ConstantInt::get(Context, APInt(64, 0)), Alloca);
-    NamedValues[Name] = Alloca;
-}
-
-Value *IntegerHandler::createLiteral(int64_t Val) {
-    return ConstantInt::get(Context, APInt(64, Val, true));
-}
diff --git a/lib/CodeGen/RealHandler.cc b/lib/CodeGen/RealHandler.cc
deleted file mode 100644
index a73dee2..0000000
--- a/lib/CodeGen/RealHandler.cc
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "cps/RealHandler.h"
-
-using namespace llvm;
-using namespace cps;
-
-void RealHandler::emitDeclare(const std::string &Name) {
-    Function *TheFunction = Builder.GetInsertBlock()->getParent();
-    IRBuilder<> TmpB(&TheFunction->getEntryBlock(), TheFunction->getEntryBlock().begin());
-    AllocaInst *Alloca = TmpB.CreateAlloca(Type::getDoubleTy(Context), nullptr, Name);
-    Builder.CreateStore(ConstantFP::get(Context, APFloat(0.0)), Alloca);
-    NamedValues[Name] = Alloca;
-}
-
-Value *RealHandler::createLiteral(double Val) {
-    return ConstantFP::get(Context, APFloat(Val));
-}
diff --git a/lib/CodeGen/StringHandler.cc b/lib/CodeGen/StringHandler.cc
index 56b5aea..463bf96 100644
--- a/lib/CodeGen/StringHandler.cc
+++ b/lib/CodeGen/StringHandler.cc
@@ -6,9 +6,8 @@
 using namespace llvm;
 using namespace cps;
 
-StringHandler::StringHandler(LLVMContext &Ctx, IRBuilder<> &B, llvm::Module &M, 
-                             std::map<std::string, Value*> &NV)
-    : Context(Ctx), Builder(B), Module(M), NamedValues(NV) {
+StringHandler::StringHandler(LLVMContext &Ctx, IRBuilder<> &B, llvm::Module &M)
+    : Context(Ctx), Builder(B), Module(M) {
     setupExternalFunctions();
 }
 
@@ -34,16 +33,6 @@ void StringHandler::setupExternalFunctions() {
     ToLowerFunc = Module.getOrInsertFunction("tolower", CharCaseType);
 }
 
-void StringHandler::emitDeclare(const std::string &Name) {
-    Function *TheFunction = Builder.GetInsertBlock()->getParent();
-    IRBuilder<> TmpB(&TheFunction->getEntryBlock(), TheFunction->getEntryBlock().begin());
-    AllocaInst *Alloca = TmpB.CreateAlloca(PointerType::getUnqual(Context), nullptr, Name);
-
-    Value *EmptyStr = createLiteral("");
-    Builder.CreateStore(EmptyStr, Alloca);
-    NamedValues[Name] = Alloca;
-}
-
 Value *StringHandler::createLiteral(const std::string &Val) {
     return Builder.CreateGlobalStringPtr(Val);
 }