bytecode_gen.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "../../include/ast.h"
#include "../../include/bytecode.h"
#include "../../include/common.h"
#include "../../include/value.h"
#include "../../include/object.h"
#include "../../include/vm.h"
#include <stddef.h> 

extern Value evaluateComptime(StmtList* statements);

// --- Compiler & Scope Types ---

typedef struct {
    const char* name;
    int depth;
} Local;

typedef enum {
    COMP_FUNCTION,
    COMP_SCRIPT
} CompFunctionType;

typedef struct Loop {
    struct Loop* enclosing;
    int startIp;
    int continueIp;
    int scopeDepth;
    int localCountAtEntry;
    int* breakJumps;
    int breakCount;
    int breakCapacity;
} Loop;

typedef struct {
    uint8_t index;
    bool isLocal;
} Upvalue;

typedef struct Compiler {
    struct Compiler* enclosing;
    ObjFunction* function;
    CompFunctionType type;

    bool isMethod;

    Local locals[256];
    int localCount;
    int scopeDepth;
    
    Upvalue upvalues[256];
    
    Loop* loop;
} Compiler;

typedef struct {
    Compiler* compiler;
    Chunk* chunk; 
    bool hadError;
} BytecodeGen;

// --- Forward Declarations ---

static void genExpr(BytecodeGen* gen, Expr* expr);
static void genStmt(BytecodeGen* gen, Stmt* stmt);
static void genFunction(BytecodeGen* gen, Stmt* stmt, bool defineVar);
static void emitTensorConstruction(BytecodeGen* gen, Expr* expr);

// --- Helpers ---

static void initCompiler(BytecodeGen* gen, Compiler* compiler, CompFunctionType type) {
    compiler->enclosing = gen->compiler;
    compiler->function = NULL;
    compiler->type = type;
    compiler->isMethod = false;
    compiler->localCount = 0;
    compiler->scopeDepth = 0;
    
    // New function object
    compiler->function = newFunction();
    gen->compiler = compiler;
    gen->chunk = &compiler->function->chunk;

    // Reserve stack slot 0 for local use (or 'this')
    Local* local = &compiler->locals[compiler->localCount++];
    local->depth = 0;
    local->name = ""; // Internal usage
}

static ObjFunction* endCompiler(BytecodeGen* gen, bool isInit) {
    // Emit return
    if (isInit) {
        writeChunk(gen->chunk, OP_GET_LOCAL, 0); 
        writeChunk(gen->chunk, 0, 0);
    } else {
        writeChunk(gen->chunk, OP_NIL, 0); 
    }
    writeChunk(gen->chunk, OP_RETURN, 0);
    
    ObjFunction* function = gen->compiler->function;
    
    // Pop compiler
    gen->compiler = gen->compiler->enclosing;
    if (gen->compiler != NULL) {
        gen->chunk = &gen->compiler->function->chunk;
    } else {
        gen->chunk = NULL; 
    }
    
    return function;
}

static void beginScope(BytecodeGen* gen) {
    gen->compiler->scopeDepth++;
}

static void endScope(BytecodeGen* gen) {
    gen->compiler->scopeDepth--;
    // Pop locals
    while (gen->compiler->localCount > 0 &&
           gen->compiler->locals[gen->compiler->localCount - 1].depth > gen->compiler->scopeDepth) {
        writeChunk(gen->chunk, OP_POP, 0); 
        gen->compiler->localCount--;
    }
}

static int resolveLocal(BytecodeGen* gen, const char* name) {
    for (int i = gen->compiler->localCount - 1; i >= 0; i--) {
        Local* local = &gen->compiler->locals[i];
        if (strcmp(name, local->name) == 0) {
            return i;
        }
    }
    return -1;
}

static int addUpvalue(Compiler* compiler, uint8_t index, bool isLocal) {
    int upvalueCount = compiler->function->upvalueCount;
    // Deduplicate shared upvalues where safe
    for (int i = 0; i < upvalueCount; i++) {
        Upvalue* upvalue = &compiler->upvalues[i];
        if (upvalue->index == index && upvalue->isLocal == isLocal) {
            return i;
        }
    }

    if (upvalueCount == 256) {
        fprintf(stderr, "Too many closure variables in function.\n");
        return 0;
    }

    compiler->upvalues[upvalueCount].isLocal = isLocal;
    compiler->upvalues[upvalueCount].index = index;
    return compiler->function->upvalueCount++;
}

static int resolveUpvalue(Compiler* compiler, const char* name) {
    if (compiler == NULL || compiler->enclosing == NULL) return -1;

    for (int i = compiler->enclosing->localCount - 1; i >= 0; i--) {
        if (strcmp(name, compiler->enclosing->locals[i].name) == 0) {
            return addUpvalue(compiler, (uint8_t)i, true);
        }
    }

    int upvalue = resolveUpvalue(compiler->enclosing, name);
    if (upvalue != -1) {
        return addUpvalue(compiler, (uint8_t)upvalue, false);
    }

    return -1;
}

static void addLocal(BytecodeGen* gen, const char* name) {
    if (gen->hadError) return;
    if (gen->compiler->localCount == 256) {
        fprintf(stderr, "Too many local variables.\n");
        gen->hadError = true;
        return;
    }
    Local* local = &gen->compiler->locals[gen->compiler->localCount++];
    local->name = name;
    local->depth = gen->compiler->scopeDepth; // Assuming initialized immediately
}

static void emitConstant(BytecodeGen* gen, Value value, int line) {
    if (gen->hadError) return;
    int constant = addConstant(gen->chunk, value);
    if (constant > 255) {
        writeChunk(gen->chunk, OP_CONSTANT_LONG, line);
        writeChunk(gen->chunk, constant & 0xff, line);
        writeChunk(gen->chunk, (constant >> 8) & 0xff, line);
        writeChunk(gen->chunk, (constant >> 16) & 0xff, line);
    } else {
        writeChunk(gen->chunk, OP_CONSTANT, line);
        writeChunk(gen->chunk, (uint8_t)constant, line);
    }
}

static void emitByte(BytecodeGen* gen, uint8_t byte, int line) {
    writeChunk(gen->chunk, byte, line);
}

static void emitInt(BytecodeGen* gen, int value, int line) {
    // Little endian 4 bytes
    emitByte(gen, (uint8_t)((value >> 0) & 0xff), line);
    emitByte(gen, (uint8_t)((value >> 8) & 0xff), line);
    emitByte(gen, (uint8_t)((value >> 16) & 0xff), line);
    emitByte(gen, (uint8_t)((value >> 24) & 0xff), line);
}

static void emitTensorElements(BytecodeGen* gen, Expr* expr) {
    if (expr->type == EXPR_LIST) {
        if (expr->as.list.elements) {
            for (int i = 0; i < expr->as.list.elements->count; i++) {
                emitTensorElements(gen, expr->as.list.elements->items[i]);
            }
        }
    } else {
        genExpr(gen, expr);
    }
}

static void emitTensorConstruction(BytecodeGen* gen, Expr* expr) {
    // 1. Infer Dimensions
    int dims[16];
    int dimCount = 0;
    
    Expr* current = expr;
    // Inspect the tag first if available for rank?
    // Or just traverse.
    while (current && current->type == EXPR_LIST) {
        if (dimCount >= 16) break;
        int count = current->as.list.elements ? current->as.list.elements->count : 0;
        dims[dimCount++] = count;
        if (count > 0) {
            current = current->as.list.elements->items[0];
        } else {
            break; 
        }
    }
    
    // Calculate total elements
    int elementCount = 1;
    for (int i=0; i<dimCount; i++) elementCount *= dims[i];
    
    // 2. Emit Elements (Flattened)
    emitTensorElements(gen, expr);
    
    // 3. Emit Opcode
    writeChunk(gen->chunk, OP_MAKE_TENSOR, expr->line);
    
    // 4. Emit Operands
    emitByte(gen, (uint8_t)dimCount, expr->line);
    emitInt(gen, elementCount, expr->line);
    for (int i=0; i<dimCount; i++) {
        emitInt(gen, dims[i], expr->line);
    }
}

static void genExpr(BytecodeGen* gen, Expr* expr) {
    if (expr == NULL || gen->hadError) return;

    switch (expr->type) {
        case EXPR_LITERAL: {
             if (IS_NIL(expr->as.literal.value)) {
                 writeChunk(gen->chunk, OP_NIL, expr->line);
             } else if (IS_BOOL(expr->as.literal.value)) {
                 writeChunk(gen->chunk, AS_BOOL(expr->as.literal.value) ? OP_TRUE : OP_FALSE, expr->line);
             } else {
                 emitConstant(gen, expr->as.literal.value, expr->line);
             }
             break;
        }
        case EXPR_UNARY: {
            genExpr(gen, expr->as.unary.right);
            if (strcmp(expr->as.unary.operator, "-") == 0) {
                 writeChunk(gen->chunk, OP_NEGATE, expr->line);
            } else if (strcmp(expr->as.unary.operator, "!") == 0) {
                 writeChunk(gen->chunk, OP_NOT, expr->line);
            } else if (strcmp(expr->as.unary.operator, "~") == 0) {
                 writeChunk(gen->chunk, OP_BIT_NOT, expr->line);
            }
            break;
        }
        case EXPR_BINARY: {
            genExpr(gen, expr->as.binary.left);
            genExpr(gen, expr->as.binary.right);
            if (strcmp(expr->as.binary.operator, "+") == 0) writeChunk(gen->chunk, OP_ADD, expr->line);
            else if (strcmp(expr->as.binary.operator, "-") == 0) writeChunk(gen->chunk, OP_SUBTRACT, expr->line);
            else if (strcmp(expr->as.binary.operator, "*") == 0) writeChunk(gen->chunk, OP_MULTIPLY, expr->line);
            else if (strcmp(expr->as.binary.operator, "/") == 0) writeChunk(gen->chunk, OP_DIVIDE, expr->line);
            else if (strcmp(expr->as.binary.operator, "==") == 0) writeChunk(gen->chunk, OP_EQUAL, expr->line);
            else if (strcmp(expr->as.binary.operator, "!=") == 0) writeChunk(gen->chunk, OP_NOT_EQUAL, expr->line);
            else if (strcmp(expr->as.binary.operator, "<") == 0) writeChunk(gen->chunk, OP_LESS, expr->line);
            else if (strcmp(expr->as.binary.operator, "<=") == 0) writeChunk(gen->chunk, OP_LESS_EQUAL, expr->line);
            else if (strcmp(expr->as.binary.operator, ">") == 0) writeChunk(gen->chunk, OP_GREATER, expr->line);
            else if (strcmp(expr->as.binary.operator, ">=") == 0) writeChunk(gen->chunk, OP_GREATER_EQUAL, expr->line);
            else if (strcmp(expr->as.binary.operator, "%") == 0) writeChunk(gen->chunk, OP_MODULO, expr->line);
            else if (strcmp(expr->as.binary.operator, "&") == 0) writeChunk(gen->chunk, OP_BIT_AND, expr->line);
            else if (strcmp(expr->as.binary.operator, "|") == 0) writeChunk(gen->chunk, OP_BIT_OR, expr->line);
            else if (strcmp(expr->as.binary.operator, "^") == 0) writeChunk(gen->chunk, OP_BIT_XOR, expr->line);
            else if (strcmp(expr->as.binary.operator, "<<") == 0) writeChunk(gen->chunk, OP_LEFT_SHIFT, expr->line);
            else if (strcmp(expr->as.binary.operator, ">>") == 0) writeChunk(gen->chunk, OP_RIGHT_SHIFT, expr->line);
            else if (strcmp(expr->as.binary.operator, "@") == 0) writeChunk(gen->chunk, OP_MAT_MUL, expr->line);
            break;
        }
        case EXPR_GROUPING: {
            genExpr(gen, expr->as.grouping.expression);
            break;
        }
        case EXPR_VARIABLE: {
            int arg = resolveLocal(gen, expr->as.variable.name);
            if (arg != -1) {
                if (arg <= 3) {
                    writeChunk(gen->chunk, OP_GET_LOCAL_0 + arg, expr->line);
                } else {
                    writeChunk(gen->chunk, OP_GET_LOCAL, expr->line);
                    writeChunk(gen->chunk, (uint8_t)arg, expr->line);
                }
            } else if ((arg = resolveUpvalue(gen->compiler, expr->as.variable.name)) != -1) {
                writeChunk(gen->chunk, OP_GET_UPVALUE, expr->line);
                writeChunk(gen->chunk, (uint8_t)arg, expr->line);
            } else {
                 Value nameVal = OBJ_VAL(copyString(expr->as.variable.name, strlen(expr->as.variable.name)));
                 int nameConst = addConstant(gen->chunk, nameVal);
                 writeChunk(gen->chunk, OP_GET_GLOBAL, expr->line);
                 writeChunk(gen->chunk, (uint8_t)nameConst, expr->line);
            }
            break;
        }
        case EXPR_ASSIGN: {
            int arg = resolveLocal(gen, expr->as.assign.name);
            if (arg != -1 && expr->as.assign.value->type == EXPR_BINARY) {
                Expr* bin = expr->as.assign.value;
                if (bin->as.binary.left->type == EXPR_VARIABLE &&
                    strcmp(bin->as.binary.left->as.variable.name, expr->as.assign.name) == 0 &&
                    bin->as.binary.right->type == EXPR_LITERAL &&
                    IS_NUMBER(bin->as.binary.right->as.literal.value) &&
                    AS_NUMBER(bin->as.binary.right->as.literal.value) == 1.0) {
                    if (strcmp(bin->as.binary.operator, "+") == 0) {
                        writeChunk(gen->chunk, OP_INC_LOCAL, expr->line);
                        writeChunk(gen->chunk, (uint8_t)arg, expr->line);
                        break;
                    } else if (strcmp(bin->as.binary.operator, "-") == 0) {
                        writeChunk(gen->chunk, OP_DEC_LOCAL, expr->line);
                        writeChunk(gen->chunk, (uint8_t)arg, expr->line);
                        break;
                    }
                }
            }
            genExpr(gen, expr->as.assign.value);
            if (arg != -1) {
                if (arg <= 3) {
                    writeChunk(gen->chunk, OP_SET_LOCAL_0 + arg, expr->line);
                } else {
                    writeChunk(gen->chunk, OP_SET_LOCAL, expr->line);
                    writeChunk(gen->chunk, (uint8_t)arg, expr->line);
                }
            } else if ((arg = resolveUpvalue(gen->compiler, expr->as.assign.name)) != -1) {
                writeChunk(gen->chunk, OP_SET_UPVALUE, expr->line);
                writeChunk(gen->chunk, (uint8_t)arg, expr->line);
            } else {
                Value nameVal = OBJ_VAL(copyString(expr->as.assign.name, strlen(expr->as.assign.name)));
                int nameConst = addConstant(gen->chunk, nameVal);
                writeChunk(gen->chunk, OP_SET_GLOBAL, expr->line);
                writeChunk(gen->chunk, (uint8_t)nameConst, expr->line);
            }
            break;
        }
        case EXPR_CALL: {
            bool isSelfCall = false;
            if (gen->compiler->type == COMP_FUNCTION &&
                !gen->compiler->isMethod &&
                expr->as.call.callee->type == EXPR_VARIABLE &&
                gen->compiler->function->name != NULL &&
                strcmp(expr->as.call.callee->as.variable.name, gen->compiler->function->name->chars) == 0 &&
                resolveLocal(gen, expr->as.call.callee->as.variable.name) == -1) {
                isSelfCall = true;
            }
            if (isSelfCall) {
                writeChunk(gen->chunk, OP_GET_LOCAL_0, expr->line);
            } else {
                genExpr(gen, expr->as.call.callee);
            }
            int argCount = 0;
            if (expr->as.call.arguments) {
                argCount = expr->as.call.arguments->count;
                for (int i = 0; i < argCount; i++) {
                    genExpr(gen, expr->as.call.arguments->items[i]);
                }
            }
            if (isSelfCall) {
                writeChunk(gen->chunk, OP_CALL_SELF, expr->line);
            } else {
                writeChunk(gen->chunk, OP_CALL, expr->line);
            }
            writeChunk(gen->chunk, (uint8_t)argCount, expr->line);
            break;
        }
        case EXPR_LOGICAL: {
            genExpr(gen, expr->as.logical.left);
            // writeChunk(gen->chunk, OP_DUP, expr->line); // REMOVED: OP_JUMP_IF_FALSE peeks, so we don't need DUP.
            
            // Correct Logic: 
            // AND: if left false, jump to end (result is left). else pop and gen right.
            // OR: if left true, jump to end (result is left). else pop and gen right.
            
            // We can reuse OP_JUMP_IF_FALSE for AND.
            // For OR, we need jump if true.
            // Or use JUMP_IF_FALSE to 'pop_and_right', else jump to end.
            
            int endJump = -1;
            int opJump = -1;
            
            if (strcmp(expr->as.logical.operator, "&&") == 0) {
                 writeChunk(gen->chunk, OP_JUMP_IF_FALSE, expr->line);
                 writeChunk(gen->chunk, 0xff, 0); writeChunk(gen->chunk, 0xff, 0);
                 endJump = gen->chunk->count - 2;
                 writeChunk(gen->chunk, OP_POP, expr->line);
                 genExpr(gen, expr->as.logical.right);
            } else { // "||"
                 writeChunk(gen->chunk, OP_JUMP_IF_FALSE, expr->line);
                 writeChunk(gen->chunk, 0xff, 0); writeChunk(gen->chunk, 0xff, 0);
                 opJump = gen->chunk->count - 2;
                 
                 writeChunk(gen->chunk, OP_JUMP, expr->line);
                 writeChunk(gen->chunk, 0xff, 0); writeChunk(gen->chunk, 0xff, 0);
                 endJump = gen->chunk->count - 2;
                 
                 // Patch opJump to here (false case)
                 int patchOp = gen->chunk->count - opJump - 2;
                 gen->chunk->code[opJump] = (patchOp >> 8) & 0xff;
                 gen->chunk->code[opJump+1] = patchOp & 0xff;
                 
                 writeChunk(gen->chunk, OP_POP, expr->line);
                 genExpr(gen, expr->as.logical.right);
            }
            
            int patchEnd = gen->chunk->count - endJump - 2;
            gen->chunk->code[endJump] = (patchEnd >> 8) & 0xff;
            gen->chunk->code[endJump+1] = patchEnd & 0xff;
            break;
        }
        case EXPR_GET: {
            genExpr(gen, expr->as.get.object);
            Value nameVal = OBJ_VAL(copyString(expr->as.get.name, strlen(expr->as.get.name)));
            int nameConst = addConstant(gen->chunk, nameVal);
            writeChunk(gen->chunk, OP_GET_PROPERTY, expr->line);
            writeChunk(gen->chunk, (uint8_t)nameConst, expr->line);
            break;
        }
        case EXPR_SET: {
            genExpr(gen, expr->as.set.object); // Object 
            genExpr(gen, expr->as.set.value);  // Value
            // Stack: Obj, Value. OP_SET_PROPERTY expects Obj (target of set), then Value is Top? 
            // vm.c: peek(1) is instance, peek(0) is value.
            // Correct.
            Value nameVal = OBJ_VAL(copyString(expr->as.set.name, strlen(expr->as.set.name)));
            int nameConst = addConstant(gen->chunk, nameVal);
            writeChunk(gen->chunk, OP_SET_PROPERTY, expr->line);
            writeChunk(gen->chunk, (uint8_t)nameConst, expr->line);
            break;
        }
        case EXPR_INDEX: {
             genExpr(gen, expr->as.index.target);
             genExpr(gen, expr->as.index.index);
             writeChunk(gen->chunk, OP_GET_INDEX, expr->line);
             break;
        }
        case EXPR_SET_INDEX: {
            genExpr(gen, expr->as.set_index.target);
            genExpr(gen, expr->as.set_index.index);
            genExpr(gen, expr->as.set_index.value);
            writeChunk(gen->chunk, OP_SET_INDEX, expr->line);
            break;
        }
        case EXPR_LIST: {
             // Check for Tensor Literal tag
             bool isTensor = false;
             if (expr->inferredType.name && strncmp(expr->inferredType.name, "__TENSOR__", 10) == 0) {
                 isTensor = true;
             } else if (expr->as.list.elements && expr->as.list.elements->count > 0) {
                 // Heuristic: If elements are Tensors, promote outer list to Tensor
                 // This fixes the case where Parser detects inner 1D tensors but fails to tag the outer 2D list.
                 Expr* first = expr->as.list.elements->items[0];
                 if (first->type == EXPR_LIST && first->inferredType.name && strncmp(first->inferredType.name, "__TENSOR__", 10) == 0) {
                     isTensor = true;
                 }
             }

             if (isTensor) {
                 emitTensorConstruction(gen, expr);
                 break;
             }
             
             // Emit code to build the list
             int count = 0;
             if (expr->as.list.elements) {
                 count = expr->as.list.elements->count;
                 for (int i = 0; i < count; i++) {
                     genExpr(gen, expr->as.list.elements->items[i]);
                 }
             }
             
             // Opcode to build list
             writeChunk(gen->chunk, OP_BUILD_LIST, expr->line);
             emitByte(gen, (uint8_t)count, expr->line); // Arg: number of elements
             break;
        }
        case EXPR_DICTIONARY: {
             int count = 0;
             if (expr->as.dictionary.pairs) {
                 count = expr->as.dictionary.pairs->count;
                 for (int i=0; i < count; i++) {
                     genExpr(gen, expr->as.dictionary.pairs->items[i].key);
                     genExpr(gen, expr->as.dictionary.pairs->items[i].value);
                 }
             }
             writeChunk(gen->chunk, OP_BUILD_MAP, expr->line);
             writeChunk(gen->chunk, (uint8_t)count, expr->line);
             break;
        }
        case EXPR_TERNARY: {
             genExpr(gen, expr->as.ternary.condition);
             writeChunk(gen->chunk, OP_JUMP_IF_FALSE, expr->line);
             writeChunk(gen->chunk, 0xff, 0); writeChunk(gen->chunk, 0xff, 0);
             int elseJump = gen->chunk->count - 2;
             writeChunk(gen->chunk, OP_POP, expr->line);
             
             genExpr(gen, expr->as.ternary.true_branch);
             writeChunk(gen->chunk, OP_JUMP, expr->line);
             writeChunk(gen->chunk, 0xff, 0); writeChunk(gen->chunk, 0xff, 0);
             int endJump = gen->chunk->count - 2;
             
             int patchElse = gen->chunk->count - elseJump - 2;
             gen->chunk->code[elseJump] = (patchElse >> 8) & 0xff;
             gen->chunk->code[elseJump+1] = patchElse & 0xff;
             writeChunk(gen->chunk, OP_POP, expr->line);
             
             genExpr(gen, expr->as.ternary.false_branch);
             
             int patchEnd = gen->chunk->count - endJump - 2;
             gen->chunk->code[endJump] = (patchEnd >> 8) & 0xff;
             gen->chunk->code[endJump+1] = patchEnd & 0xff;
             break;
        }
        case EXPR_UNWRAP: {
             genExpr(gen, expr->as.unwrap.expression);
             writeChunk(gen->chunk, OP_UNWRAP, expr->line);
             break;
        }
        case EXPR_TEMPLATE_LITERAL: {
            ExprList *parts = expr->as.template_literal.parts;
            if (!parts || parts->count == 0) {
                Value emptyStr = OBJ_VAL(copyString("", 0));
                emitConstant(gen, emptyStr, expr->line);
            } else {
                genExpr(gen, parts->items[0]);
                for (int i = 1; i < parts->count; i++) {
                    genExpr(gen, parts->items[i]);
                    writeChunk(gen->chunk, OP_ADD, expr->line);
                }
            }
            break;
        }
        case EXPR_LAMBDA: {
            Compiler funcCompiler;
            initCompiler(gen, &funcCompiler, COMP_FUNCTION);
            beginScope(gen);
            if (expr->as.lambda.params) {
                for (int i=0; i < expr->as.lambda.params->count; i++) {
                    funcCompiler.function->arity++;
                    addLocal(gen, expr->as.lambda.params->items[i]);
                }
            }
            if (expr->as.lambda.body) {
                 for (int i=0; i < expr->as.lambda.body->count; i++) {
                    genStmt(gen, expr->as.lambda.body->items[i]);
                }
            }
            ObjFunction* function = endCompiler(gen, false);
            Value funcVal = OBJ_VAL(function);
            int funcConst = addConstant(gen->chunk, funcVal);
            writeChunk(gen->chunk, OP_CLOSURE, expr->line);
            writeChunk(gen->chunk, (uint8_t)funcConst, expr->line);
            for (int i = 0; i < function->upvalueCount; i++) {
                writeChunk(gen->chunk, funcCompiler.upvalues[i].isLocal ? 1 : 0, expr->line);
                writeChunk(gen->chunk, funcCompiler.upvalues[i].index, expr->line);
            }
            break;
        }
        case EXPR_THIS: {
             if (gen->compiler->type == COMP_FUNCTION) {
                 writeChunk(gen->chunk, OP_GET_LOCAL, expr->line);
                 writeChunk(gen->chunk, 0, expr->line);
             } else {
                 fprintf(stderr, "Cannot use 'this' outside of a method.\n");
                 gen->hadError = true;
             }
             break;
        }
        case EXPR_SUPER: {
             if (gen->compiler->type == COMP_FUNCTION) {
                 writeChunk(gen->chunk, OP_GET_LOCAL, expr->line);
                 writeChunk(gen->chunk, 0, expr->line);
                 Value nameVal = OBJ_VAL(copyString(expr->as.super_expr.method, strlen(expr->as.super_expr.method)));
                 int nameConst = addConstant(gen->chunk, nameVal);
                 writeChunk(gen->chunk, OP_GET_SUPER, expr->line);
                 writeChunk(gen->chunk, (uint8_t)nameConst, expr->line);
             } else {
                 fprintf(stderr, "Cannot use 'super' outside of a method.\n");
                 gen->hadError = true;
             }
             break;
        }
         case EXPR_NEW: {
             // stack: Class, Args...
             genExpr(gen, expr->as.new_expr.clazz);
             
             int argCount = 0;
             if (expr->as.new_expr.args) {
                 argCount = expr->as.new_expr.args->count;
                 for (int i=0; i < argCount; i++) {
                     genExpr(gen, expr->as.new_expr.args->items[i]);
                 }
             }
             
             // We have OP_CALL. Can we use it?
             // If Class is a callable (it is), OP_CALL works!
             // VM `callValue` handles `OBJ_CLASS` -> creates instance -> calls init.
             writeChunk(gen->chunk, OP_CALL, expr->line);
             writeChunk(gen->chunk, (uint8_t)argCount, expr->line);
             break;
         }
         case EXPR_COMPTIME: {
             Value result = evaluateComptime(expr->as.comptime_expr.body);
             int constIdx = addConstant(gen->chunk, result);
             writeChunk(gen->chunk, OP_CONSTANT, expr->line);
             writeChunk(gen->chunk, (uint8_t)constIdx, expr->line);
             break;
         }
         case EXPR_ACTOR_SEND:
         case EXPR_ACTOR_REQUEST:
            // Stubs for future opcode implementations
            break;
        default: break; 
    }
}

// Helper to generate function code
static void genFunction(BytecodeGen* gen, Stmt* stmt, bool defineVar) {
    Compiler funcCompiler;
    initCompiler(gen, &funcCompiler, COMP_FUNCTION);
    funcCompiler.isMethod = !defineVar;
    
    // Set function properties from AST
    funcCompiler.function->access = stmt->as.func_decl.access;
    funcCompiler.function->isStatic = stmt->as.func_decl.isStatic;
    funcCompiler.function->isAbstract = stmt->as.func_decl.isAbstract;
    
    // Protect function from GC during copyString
    push(&vm, OBJ_VAL(funcCompiler.function));
    if (stmt->as.func_decl.name != NULL) {
        funcCompiler.function->name = copyString(stmt->as.func_decl.name, strlen(stmt->as.func_decl.name));
    }
    pop(&vm);
    
    // bool isInitDebug = (stmt->as.func_decl.name != NULL && strcmp(stmt->as.func_decl.name, "init") == 0);
     // fprintf(stderr, "Compiling function '%s' (isInit: %d)\n", stmt->as.func_decl.name ? stmt->as.func_decl.name : "NULL", isInitDebug);
    
    beginScope(gen);
    
    StringList* params = (StringList*)stmt->as.func_decl.params; 
    if (params) {
         for (int i=0; i < params->count; i++) {
             funcCompiler.function->arity++;
             if (funcCompiler.function->arity > 255) {
                 // Error
             }
             addLocal(gen, params->items[i]);
         }
    }

    StmtList* body = stmt->as.func_decl.body;
    if (body) {
        for (int i=0; i < body->count; i++) {
            genStmt(gen, body->items[i]);
        }
    }
    
    bool isInit = (stmt->as.func_decl.name != NULL && strcmp(stmt->as.func_decl.name, "init") == 0);
    ObjFunction* function = endCompiler(gen, isInit);
    
    // Emit Closure
    Value funcVal = OBJ_VAL(function);
    int funcConst = addConstant(gen->chunk, funcVal);
    writeChunk(gen->chunk, OP_CLOSURE, stmt->line);
    writeChunk(gen->chunk, (uint8_t)funcConst, stmt->line);
    for (int i = 0; i < function->upvalueCount; i++) {
        writeChunk(gen->chunk, funcCompiler.upvalues[i].isLocal ? 1 : 0, stmt->line);
        writeChunk(gen->chunk, funcCompiler.upvalues[i].index, stmt->line);
    }
    
    if (defineVar) {
        if (gen->compiler->scopeDepth > 0) {
            addLocal(gen, stmt->as.func_decl.name); 
        } else {
            Value nameVal = OBJ_VAL(copyString(stmt->as.func_decl.name, strlen(stmt->as.func_decl.name)));
            int nameConst = addConstant(gen->chunk, nameVal);
            writeChunk(gen->chunk, OP_DEFINE_GLOBAL, stmt->line);
            writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
        }
    }
}

static void genStmt(BytecodeGen* gen, Stmt* stmt) {
    if (stmt == NULL || gen->hadError) return;
    
    switch (stmt->type) {


        case STMT_FUNC_DECL: {
            genFunction(gen, stmt, true);
            break;
        }
        case STMT_BLOCK: {
            beginScope(gen);
            if (stmt->as.block.statements) {
                for (int i=0; i < stmt->as.block.statements->count; i++) {
                    genStmt(gen, stmt->as.block.statements->items[i]);
                }
            }
            endScope(gen);
            break;
        }
        case STMT_VAR_DECL: {
            if (stmt->as.var_decl.initializer) {
                genExpr(gen, stmt->as.var_decl.initializer);
            } else {
                writeChunk(gen->chunk, OP_NIL, stmt->line);
            }
            
            if (gen->compiler->scopeDepth > 0) {
                addLocal(gen, stmt->as.var_decl.name);
            } else {
                Value nameVal = OBJ_VAL(copyString(stmt->as.var_decl.name, strlen(stmt->as.var_decl.name)));
                int nameConst = addConstant(gen->chunk, nameVal);
                writeChunk(gen->chunk, OP_DEFINE_GLOBAL, stmt->line);
                writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
            }
            break;
        }
        case STMT_EXPRESSION: {
            genExpr(gen, stmt->as.expression.expression);
            writeChunk(gen->chunk, OP_POP, stmt->line);
            break;
        }
        case STMT_PRINT: {
            genExpr(gen, stmt->as.print.expression);
            writeChunk(gen->chunk, OP_PRINT, stmt->line);
            break;
        }
        case STMT_RETURN: {
            if (stmt->as.return_stmt.value) {
                genExpr(gen, stmt->as.return_stmt.value);
            } else {
                 // Check if we are in init
                 if (gen->compiler->function->name != NULL && strcmp(gen->compiler->function->name->chars, "init") == 0) {
                     writeChunk(gen->chunk, OP_GET_LOCAL, stmt->line);
                     writeChunk(gen->chunk, 0, stmt->line);
                 } else {
                     writeChunk(gen->chunk, OP_NIL, stmt->line);
                 }
            }
            writeChunk(gen->chunk, OP_RETURN, stmt->line);
            break;
        }
        case STMT_EXTERN_DECL: {
            // Push library path
            Value libVal = OBJ_VAL(copyString(stmt->as.extern_decl.libraryPath, strlen(stmt->as.extern_decl.libraryPath)));
            int libConst = addConstant(gen->chunk, libVal);
            writeChunk(gen->chunk, OP_CONSTANT, stmt->line);
            writeChunk(gen->chunk, (uint8_t)libConst, stmt->line);
            
            // Push symbol name
            Value symVal = OBJ_VAL(copyString(stmt->as.extern_decl.symbolName, strlen(stmt->as.extern_decl.symbolName)));
            int symConst = addConstant(gen->chunk, symVal);
            writeChunk(gen->chunk, OP_CONSTANT, stmt->line);
            writeChunk(gen->chunk, (uint8_t)symConst, stmt->line);
            
            // Make Foreign Object
            writeChunk(gen->chunk, OP_MAKE_FOREIGN, stmt->line);
            
            // Define Global
             if (gen->compiler->scopeDepth > 0) {
                addLocal(gen, stmt->as.extern_decl.name);
            } else {
                Value nameVal = OBJ_VAL(copyString(stmt->as.extern_decl.name, strlen(stmt->as.extern_decl.name)));
                int nameConst = addConstant(gen->chunk, nameVal);
                writeChunk(gen->chunk, OP_DEFINE_GLOBAL, stmt->line);
                writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
            }
            break;
        }
        case STMT_TENSOR_DECL: {
            if (stmt->as.tensor_decl.initializer) {
                genExpr(gen, stmt->as.tensor_decl.initializer);
            } else {
                 // Zero-init tensor
                 writeChunk(gen->chunk, OP_MAKE_TENSOR, stmt->line);
                 emitByte(gen, (uint8_t)stmt->as.tensor_decl.dimCount, stmt->line);
                 emitInt(gen, 0, stmt->line); // elementCount = 0 -> Zero Fill
                 for (int i=0; i<stmt->as.tensor_decl.dimCount; i++) {
                     emitInt(gen, stmt->as.tensor_decl.dims[i], stmt->line);
                 }
            }
            
            // Define Variable
            if (gen->compiler->scopeDepth > 0) {
                addLocal(gen, stmt->as.tensor_decl.name);
            } else {
                Value nameVal = OBJ_VAL(copyString(stmt->as.tensor_decl.name, strlen(stmt->as.tensor_decl.name)));
                int nameConst = addConstant(gen->chunk, nameVal);
                writeChunk(gen->chunk, OP_DEFINE_GLOBAL, stmt->line);
                writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
            }
            break;
        }
        case STMT_IF: {
            genExpr(gen, stmt->as.if_stmt.condition);
            writeChunk(gen->chunk, OP_POP_JUMP_IF_FALSE, stmt->line);
            writeChunk(gen->chunk, 0xff, 0); writeChunk(gen->chunk, 0xff, 0);
            int thenJump = gen->chunk->count - 2;
            
            genStmt(gen, stmt->as.if_stmt.then_branch);
            
            writeChunk(gen->chunk, OP_JUMP, 0);
            writeChunk(gen->chunk, 0xff, 0); writeChunk(gen->chunk, 0xff, 0);
            int elseJump = gen->chunk->count - 2;
            
            int patchThen = gen->chunk->count - thenJump - 2;
            gen->chunk->code[thenJump] = (patchThen >> 8) & 0xff;
            gen->chunk->code[thenJump+1] = patchThen & 0xff;
            
            if (stmt->as.if_stmt.else_branch) genStmt(gen, stmt->as.if_stmt.else_branch);
            
            int patchElse = gen->chunk->count - elseJump - 2;
            gen->chunk->code[elseJump] = (patchElse >> 8) & 0xff;
            gen->chunk->code[elseJump+1] = patchElse & 0xff;
            break;
        }
        case STMT_WHILE: {
            int loopStart = gen->chunk->count;
            
            // Push loop scope
            Loop loop;
            loop.startIp = loopStart;
            loop.continueIp = loopStart;
            loop.scopeDepth = gen->compiler->scopeDepth;
            loop.localCountAtEntry = gen->compiler->localCount;
            loop.enclosing = gen->compiler->loop;
            loop.breakCount = 0;
            loop.breakCapacity = 8;
            loop.breakJumps = (int*)malloc(sizeof(int) * loop.breakCapacity);
            gen->compiler->loop = &loop;
            
            genExpr(gen, stmt->as.while_stmt.condition);
            
            writeChunk(gen->chunk, OP_POP_JUMP_IF_FALSE, stmt->line);
            writeChunk(gen->chunk, 0xff, 0); writeChunk(gen->chunk, 0xff, 0);
            int exitJump = gen->chunk->count - 2;
            
            genStmt(gen, stmt->as.while_stmt.body);
            
            writeChunk(gen->chunk, OP_LOOP, stmt->line);
            int offset = gen->chunk->count - loopStart + 2;
            writeChunk(gen->chunk, (offset >> 8) & 0xff, 0);
            writeChunk(gen->chunk, offset & 0xff, 0);
            
            // Patch exit
            int patchExit = gen->chunk->count - exitJump - 2;
            gen->chunk->code[exitJump] = (patchExit >> 8) & 0xff;
            gen->chunk->code[exitJump+1] = patchExit & 0xff;
            
            // Patch breaks
            for (int i = 0; i < loop.breakCount; i++) {
                int breakJump = loop.breakJumps[i];
                int dist = gen->chunk->count - breakJump - 2;
                gen->chunk->code[breakJump] = (dist >> 8) & 0xff;
                gen->chunk->code[breakJump+1] = dist & 0xff;
            }
            free(loop.breakJumps);
            
            gen->compiler->loop = loop.enclosing; // Pop loop
            break;
        }
        case STMT_FOR: {
            beginScope(gen);
            if (stmt->as.for_stmt.initializer) {
                genStmt(gen, stmt->as.for_stmt.initializer);
            }
            
            int loopStart = gen->chunk->count;
            
            int exitJump = -1;
            if (stmt->as.for_stmt.condition) {
                genExpr(gen, stmt->as.for_stmt.condition);
                writeChunk(gen->chunk, OP_POP_JUMP_IF_FALSE, stmt->line);
                writeChunk(gen->chunk, 0xff, 0); writeChunk(gen->chunk, 0xff, 0);
                exitJump = gen->chunk->count - 2;
            }

            int incrementStart = loopStart;
            if (stmt->as.for_stmt.increment) {
                writeChunk(gen->chunk, OP_JUMP, 0);
                writeChunk(gen->chunk, 0xff, 0); writeChunk(gen->chunk, 0xff, 0);
                int bodyJump = gen->chunk->count - 2;
                
                incrementStart = gen->chunk->count;
                genExpr(gen, stmt->as.for_stmt.increment);
                writeChunk(gen->chunk, OP_POP, stmt->line);
                
                writeChunk(gen->chunk, OP_LOOP, stmt->line);
                int offset = gen->chunk->count - loopStart + 2;
                writeChunk(gen->chunk, (offset >> 8) & 0xff, 0);
                writeChunk(gen->chunk, offset & 0xff, 0);
                
                loopStart = incrementStart;
                
                int patchBody = gen->chunk->count - bodyJump - 2;
                gen->chunk->code[bodyJump] = (patchBody >> 8) & 0xff;
                gen->chunk->code[bodyJump+1] = patchBody & 0xff;
            }
            
            // Push loop
            Loop loop;
            loop.startIp = loopStart;
            loop.continueIp = incrementStart;
            loop.scopeDepth = gen->compiler->scopeDepth;
            loop.localCountAtEntry = gen->compiler->localCount;
            loop.enclosing = gen->compiler->loop;
            loop.breakCount = 0;
            loop.breakCapacity = 8;
            loop.breakJumps = (int*)malloc(sizeof(int) * loop.breakCapacity);
            gen->compiler->loop = &loop;

            genStmt(gen, stmt->as.for_stmt.body);
            
            writeChunk(gen->chunk, OP_LOOP, stmt->line);
            int offset = gen->chunk->count - loopStart + 2;
            writeChunk(gen->chunk, (offset >> 8) & 0xff, 0);
            writeChunk(gen->chunk, offset & 0xff, 0);
            
            if (exitJump != -1) {
                int patchExit = gen->chunk->count - exitJump - 2;
                gen->chunk->code[exitJump] = (patchExit >> 8) & 0xff;
                gen->chunk->code[exitJump+1] = patchExit & 0xff;
            }
            
            // Patch breaks
            for (int i = 0; i < loop.breakCount; i++) {
                int breakJump = loop.breakJumps[i];
                int dist = gen->chunk->count - breakJump - 2;
                gen->chunk->code[breakJump] = (dist >> 8) & 0xff;
                gen->chunk->code[breakJump+1] = dist & 0xff;
            }
            free(loop.breakJumps);
            
            gen->compiler->loop = loop.enclosing;
            endScope(gen);
            break;
        }
        case STMT_BREAK: {
            if (gen->compiler->loop == NULL) {
               fprintf(stderr, "Error: 'break' outside of loop at line %d\n", stmt->line);
               gen->hadError = true;
            } else {
                for (int i = gen->compiler->localCount - 1; i >= gen->compiler->loop->localCountAtEntry; i--) {
                    writeChunk(gen->chunk, OP_POP, stmt->line);
                }
                
                writeChunk(gen->chunk, OP_JUMP, 0);
                writeChunk(gen->chunk, 0xff, 0); writeChunk(gen->chunk, 0xff, 0);
                int jump = gen->chunk->count - 2;
                if (gen->compiler->loop->breakCount == gen->compiler->loop->breakCapacity) {
                    gen->compiler->loop->breakCapacity *= 2;
                    gen->compiler->loop->breakJumps = (int*)realloc(gen->compiler->loop->breakJumps, sizeof(int) * gen->compiler->loop->breakCapacity);
                }
                gen->compiler->loop->breakJumps[gen->compiler->loop->breakCount++] = jump;
            }
            break;
        }
        case STMT_CONTINUE: {
            if (gen->compiler->loop == NULL) {
               fprintf(stderr, "Error: 'continue' outside of loop at line %d\n", stmt->line);
               gen->hadError = true;
            } else {
                for (int i = gen->compiler->localCount - 1; i >= gen->compiler->loop->localCountAtEntry; i--) {
                    writeChunk(gen->chunk, OP_POP, stmt->line);
                }
                writeChunk(gen->chunk, OP_LOOP, stmt->line);
                int offset = gen->chunk->count - gen->compiler->loop->continueIp + 2;
                writeChunk(gen->chunk, (offset >> 8) & 0xff, 0);
                writeChunk(gen->chunk, offset & 0xff, 0);
            }
            break;
        }
        case STMT_SWITCH: {
            genExpr(gen, stmt->as.switch_stmt.value); // Push switch value
            
            SwitchCaseList* cases = stmt->as.switch_stmt.cases;
            int endJumps[256];
            int endJumpCount = 0;
            
            if (cases) {
                for (int i = 0; i < cases->count; i++) {
                    writeChunk(gen->chunk, OP_DUP, stmt->line);
                    genExpr(gen, cases->items[i].value);
                    writeChunk(gen->chunk, OP_EQUAL, stmt->line);
                    
                    writeChunk(gen->chunk, OP_JUMP_IF_FALSE, stmt->line);
                    writeChunk(gen->chunk, 0xff, 0); writeChunk(gen->chunk, 0xff, 0);
                    int nextJump = gen->chunk->count - 2;
                    
                    writeChunk(gen->chunk, OP_POP, stmt->line); // Pop bool
                    writeChunk(gen->chunk, OP_POP, stmt->line); // Pop switch value
                    
                    // Case body
                    if (cases->items[i].statements) {
                        for (int j=0; j < cases->items[i].statements->count; j++) {
                            genStmt(gen, cases->items[i].statements->items[j]);
                        }
                    }
                    
                    writeChunk(gen->chunk, OP_JUMP, stmt->line);
                    writeChunk(gen->chunk, 0xff, 0); writeChunk(gen->chunk, 0xff, 0);
                    endJumps[endJumpCount++] = gen->chunk->count - 2;
                    
                    // Patch nextJump
                    int patchNext = gen->chunk->count - nextJump - 2;
                    gen->chunk->code[nextJump] = (patchNext >> 8) & 0xff;
                    gen->chunk->code[nextJump+1] = patchNext & 0xff;
                    writeChunk(gen->chunk, OP_POP, stmt->line); // Pop bool (from jump_if_false)
                }
            }
            
            // Default
            writeChunk(gen->chunk, OP_POP, stmt->line); // Pop switch value
            if (stmt->as.switch_stmt.default_case) {
                 for (int i=0; i < stmt->as.switch_stmt.default_case->count; i++) {
                     genStmt(gen, stmt->as.switch_stmt.default_case->items[i]);
                 }
            }
            
            // Patch end jumps
            for (int i=0; i < endJumpCount; i++) {
                int patch = gen->chunk->count - endJumps[i] - 2;
                gen->chunk->code[endJumps[i]] = (patch >> 8) & 0xff;
                gen->chunk->code[endJumps[i]+1] = patch & 0xff;
            }
            break;
        }
        case STMT_RESILIENT: {
            int startIp = gen->chunk->count;
            
            // Push scope if it has declarations
            beginScope(gen);
            
            if (stmt->as.resilient.body) {
                for (int i=0; i < stmt->as.resilient.body->count; i++) {
                    genStmt(gen, stmt->as.resilient.body->items[i]);
                }
            }
            
            endScope(gen);
            
            writeChunk(gen->chunk, OP_JUMP, stmt->line);
            writeChunk(gen->chunk, 0xff, 0); writeChunk(gen->chunk, 0xff, 0);
            int skipRecoveryJump = gen->chunk->count - 2;

            int endIp = gen->chunk->count;
            int handlerIp = gen->chunk->count;

            beginScope(gen);
            if (stmt->as.resilient.recoveryBody) {
                for (int i=0; i < stmt->as.resilient.recoveryBody->count; i++) {
                    genStmt(gen, stmt->as.resilient.recoveryBody->items[i]);
                }
            }
            endScope(gen);
            
            int patchSkip = gen->chunk->count - skipRecoveryJump - 2;
            gen->chunk->code[skipRecoveryJump] = (patchSkip >> 8) & 0xff;
            gen->chunk->code[skipRecoveryJump+1] = patchSkip & 0xff;

            addExceptionHandler(gen->chunk, startIp, endIp, handlerIp);
            break;
        }
        case STMT_TRY_CATCH: {
            writeChunk(gen->chunk, OP_TRY, stmt->line);
            writeChunk(gen->chunk, 0xff, 0); writeChunk(gen->chunk, 0xff, 0);
            int catchJump = gen->chunk->count - 2;
            
            if (stmt->as.try_catch.try_block) {
                for (int i=0; i < stmt->as.try_catch.try_block->count; i++) {
                    genStmt(gen, stmt->as.try_catch.try_block->items[i]);
                }
            }
            writeChunk(gen->chunk, OP_END_TRY, stmt->line);
            
            writeChunk(gen->chunk, OP_JUMP, stmt->line);
            writeChunk(gen->chunk, 0xff, 0); writeChunk(gen->chunk, 0xff, 0);
            int endJump = gen->chunk->count - 2;
            
            int patchCatch = gen->chunk->count - catchJump - 2;
            gen->chunk->code[catchJump] = (patchCatch >> 8) & 0xff;
            gen->chunk->code[catchJump+1] = patchCatch & 0xff;
            
            writeChunk(gen->chunk, OP_CATCH, stmt->line);
            beginScope(gen);
            if (stmt->as.try_catch.catch_var) {
                addLocal(gen, stmt->as.try_catch.catch_var);
            }
            if (stmt->as.try_catch.catch_block) {
                for (int i=0; i < stmt->as.try_catch.catch_block->count; i++) {
                    genStmt(gen, stmt->as.try_catch.catch_block->items[i]);
                }
            }
            endScope(gen);
            
            int patchEnd = gen->chunk->count - endJump - 2;
            gen->chunk->code[endJump] = (patchEnd >> 8) & 0xff;
            gen->chunk->code[endJump+1] = patchEnd & 0xff;
            break; 
        }
        case STMT_USE_DECL: {
             // as.use_decl.modules (StringList)
             if (stmt->as.use_decl.modules) {
                 for (int i=0; i < stmt->as.use_decl.modules->count; i++) {
                     char* mod = stmt->as.use_decl.modules->items[i];
                     Value modVal = OBJ_VAL(copyString(mod, strlen(mod)));
                     int modConst = addConstant(gen->chunk, modVal);
                     writeChunk(gen->chunk, OP_USE, stmt->line);
                     writeChunk(gen->chunk, (uint8_t)modConst, stmt->line);
                 }
             }
             break;
        }
        case STMT_CLASS_DECL: {
            Value nameVal = OBJ_VAL(copyString(stmt->as.class_decl.name, strlen(stmt->as.class_decl.name)));
            int nameConst = addConstant(gen->chunk, nameVal);
            writeChunk(gen->chunk, OP_CLASS, stmt->line);
            writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
            
            // Define name
            if (gen->compiler->scopeDepth > 0) {
                 addLocal(gen, stmt->as.class_decl.name);
            } else {
                 writeChunk(gen->chunk, OP_DEFINE_GLOBAL, stmt->line);
                 writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
            }
            
            // Inheritance (Placeholder: emit push null superclass if none?)
            if (stmt->as.class_decl.superclass) {
                genExpr(gen, stmt->as.class_decl.superclass);
                if (gen->compiler->scopeDepth > 0) {
                     writeChunk(gen->chunk, OP_GET_LOCAL, stmt->line);
                     writeChunk(gen->chunk, (uint8_t)(gen->compiler->localCount - 1), stmt->line);
                } else {
                    writeChunk(gen->chunk, OP_GET_GLOBAL, stmt->line);
                     writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
                }
                writeChunk(gen->chunk, OP_INHERIT, stmt->line);
            }

            // Methods
            if (stmt->as.class_decl.methods) {
                // Load class for methods
                if (gen->compiler->scopeDepth == 0) {
                     writeChunk(gen->chunk, OP_GET_GLOBAL, stmt->line);
                     writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
                } else {
                     writeChunk(gen->chunk, OP_GET_LOCAL, stmt->line);
                     writeChunk(gen->chunk, (uint8_t)(gen->compiler->localCount - 1), stmt->line);
                }
                
                for (int i=0; i < stmt->as.class_decl.methods->count; i++) {
                     Stmt* methodStmt = stmt->as.class_decl.methods->items[i];
                     if (methodStmt->type == STMT_VAR_DECL) {
                         if (methodStmt->as.var_decl.isStatic && methodStmt->as.var_decl.initializer) {
                              writeChunk(gen->chunk, OP_DUP, methodStmt->line);
                              genExpr(gen, methodStmt->as.var_decl.initializer);
                              Value fNameVal = OBJ_VAL(copyString(methodStmt->as.var_decl.name, strlen(methodStmt->as.var_decl.name)));
                              int fNameConst = addConstant(gen->chunk, fNameVal);
                              writeChunk(gen->chunk, OP_SET_PROPERTY, methodStmt->line);
                              writeChunk(gen->chunk, (uint8_t)fNameConst, methodStmt->line);
                              writeChunk(gen->chunk, OP_POP, methodStmt->line); // pop the returned value of SET_PROPERTY
                         }
                         continue;
                     }
                     
                     // Pass false to not define local/global var, just leave closure on stack
                     genFunction(gen, methodStmt, false);
                     
                     Value mNameVal = OBJ_VAL(copyString(methodStmt->as.func_decl.name, strlen(methodStmt->as.func_decl.name)));
                     int mNameConst = addConstant(gen->chunk, mNameVal);
                     writeChunk(gen->chunk, OP_METHOD, methodStmt->line);
                     writeChunk(gen->chunk, (uint8_t)mNameConst, methodStmt->line);
                }
                writeChunk(gen->chunk, OP_POP, stmt->line); // Pop class
            }
            break;
        }
        case STMT_INTERFACE_DECL: {
            Value nameVal = OBJ_VAL(copyString(stmt->as.interface_decl.name, strlen(stmt->as.interface_decl.name)));
            int nameConst = addConstant(gen->chunk, nameVal);
            writeChunk(gen->chunk, OP_INTERFACE, stmt->line);
            writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
            
             // Define
            if (gen->compiler->scopeDepth > 0) {
                 addLocal(gen, stmt->as.interface_decl.name);
            } else {
                 writeChunk(gen->chunk, OP_DEFINE_GLOBAL, stmt->line);
                 writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
            }
            break;
        }
        case STMT_TRAIT_DECL: {
            Value nameVal = OBJ_VAL(copyString(stmt->as.trait_decl.name, strlen(stmt->as.trait_decl.name)));
            int nameConst = addConstant(gen->chunk, nameVal);
            writeChunk(gen->chunk, OP_TRAIT, stmt->line);
            writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
            
             // Define
            if (gen->compiler->scopeDepth > 0) {
                 addLocal(gen, stmt->as.trait_decl.name);
            } else {
                 writeChunk(gen->chunk, OP_DEFINE_GLOBAL, stmt->line);
                 writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
            }
            
            // Methods
            if (stmt->as.trait_decl.methods) {
                // Load trait for methods
                if (gen->compiler->scopeDepth == 0) {
                     writeChunk(gen->chunk, OP_GET_GLOBAL, stmt->line);
                     writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
                } else {
                     writeChunk(gen->chunk, OP_GET_LOCAL, stmt->line);
                     writeChunk(gen->chunk, (uint8_t)(gen->compiler->localCount - 1), stmt->line);
                }
                
                for (int i=0; i < stmt->as.trait_decl.methods->count; i++) {
                     // Pass false to not define local/global var, just leave closure on stack
                     genFunction(gen, stmt->as.trait_decl.methods->items[i], false);
                     
                     Stmt* methodStmt = stmt->as.trait_decl.methods->items[i];
                     Value mNameVal = OBJ_VAL(copyString(methodStmt->as.func_decl.name, strlen(methodStmt->as.func_decl.name)));
                     int mNameConst = addConstant(gen->chunk, mNameVal);
                     writeChunk(gen->chunk, OP_METHOD, stmt->line);
                     writeChunk(gen->chunk, (uint8_t)mNameConst, stmt->line);
                }
                writeChunk(gen->chunk, OP_POP, stmt->line); // Pop trait
            }
            break;
        }
        case STMT_CONTEXT_DECL: {
            Value nameVal = OBJ_VAL(copyString(stmt->as.context_decl.name, strlen(stmt->as.context_decl.name)));
            int nameConst = addConstant(gen->chunk, nameVal);
            writeChunk(gen->chunk, OP_CONTEXT, stmt->line);
            writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
            
            // Generate layers
            StmtList* layers = stmt->as.context_decl.layers;
            if (layers) {
                for (int i = 0; i < layers->count; i++) {
                    genStmt(gen, layers->items[i]);
                }
            }
            
            // Define context
            if (gen->compiler->scopeDepth > 0) {
                addLocal(gen, stmt->as.context_decl.name);
            } else {
                writeChunk(gen->chunk, OP_DEFINE_GLOBAL, stmt->line);
                writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
            }
            break;
        }
        case STMT_LAYER_DECL: {
            Value nameVal = OBJ_VAL(copyString(stmt->as.layer_decl.name, strlen(stmt->as.layer_decl.name)));
            int nameConst = addConstant(gen->chunk, nameVal);
            writeChunk(gen->chunk, OP_LAYER, stmt->line);
            writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
            
            // Generate methods
            StmtList* methods = stmt->as.layer_decl.methods;
            if (methods) {
                for (int i = 0; i < methods->count; i++) {
                    genFunction(gen, methods->items[i], false);
                    Stmt* methodStmt = methods->items[i];
                    Value mNameVal = OBJ_VAL(copyString(methodStmt->as.func_decl.name, strlen(methodStmt->as.func_decl.name)));
                    int mNameConst = addConstant(gen->chunk, mNameVal);
                    writeChunk(gen->chunk, OP_METHOD, methodStmt->line);
                    writeChunk(gen->chunk, (uint8_t)mNameConst, methodStmt->line);
                }
            }
            
            // Pop layer (Context already has it if OP_LAYER adds it)
            writeChunk(gen->chunk, OP_POP, stmt->line);
            break;
        }
        case STMT_ACTIVATE: {
            genExpr(gen, stmt->as.activate_stmt.contextExpr);
            writeChunk(gen->chunk, OP_ACTIVATE, stmt->line);
            
            if (stmt->as.activate_stmt.body) {
                for (int i = 0; i < stmt->as.activate_stmt.body->count; i++) {
                    genStmt(gen, stmt->as.activate_stmt.body->items[i]);
                }
            }
            
            writeChunk(gen->chunk, OP_END_ACTIVATE, stmt->line);
            break;
        }

        case STMT_INTENT_DECL: {
            Value nameVal = OBJ_VAL(copyString(stmt->as.intent_decl.name, strlen(stmt->as.intent_decl.name)));
            int nameConst = addConstant(gen->chunk, nameVal);
            writeChunk(gen->chunk, OP_INTENT, stmt->line);
            writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
            
            // Param count
            int paramCount = stmt->as.intent_decl.params ? stmt->as.intent_decl.params->count : 0;
            emitInt(gen, paramCount, stmt->line);
            
            if (gen->compiler->scopeDepth > 0) {
                 addLocal(gen, stmt->as.intent_decl.name);
            } else {
                 writeChunk(gen->chunk, OP_DEFINE_GLOBAL, stmt->line);
                 writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
            }
            break;
        }

        case STMT_RESOLVER_DECL: {
            Value nameVal = OBJ_VAL(copyString(stmt->as.resolver_decl.name, strlen(stmt->as.resolver_decl.name)));
            int nameConst = addConstant(gen->chunk, nameVal);
            
            Value targetVal = OBJ_VAL(copyString(stmt->as.resolver_decl.targetIntent, strlen(stmt->as.resolver_decl.targetIntent)));
            int targetConst = addConstant(gen->chunk, targetVal);
            
            // Generate Closure for Resolver Body
            Compiler funcCompiler;
            initCompiler(gen, &funcCompiler, COMP_FUNCTION);
            
            push(&vm, OBJ_VAL(funcCompiler.function));
            funcCompiler.function->name = copyString(stmt->as.resolver_decl.name, strlen(stmt->as.resolver_decl.name));
            pop(&vm);

            beginScope(gen);
            
            if (stmt->as.resolver_decl.body) {
                 for (int i=0; i < stmt->as.resolver_decl.body->count; i++) {
                    genStmt(gen, stmt->as.resolver_decl.body->items[i]);
                }
            }
            ObjFunction* function = endCompiler(gen, false);
            Value funcVal = OBJ_VAL(function);
            int funcConst = addConstant(gen->chunk, funcVal);
            writeChunk(gen->chunk, OP_CLOSURE, stmt->line);
            writeChunk(gen->chunk, (uint8_t)funcConst, stmt->line);
            
            // Emit Resolver instruction
            writeChunk(gen->chunk, OP_RESOLVER, stmt->line);
            writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
            emitInt(gen, targetConst, stmt->line); // Operand: targetIntent
            
            if (gen->compiler->scopeDepth > 0) {
                 addLocal(gen, stmt->as.resolver_decl.name);
            } else {
                 writeChunk(gen->chunk, OP_DEFINE_GLOBAL, stmt->line);
                 writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
            }
            break;
        }

        case STMT_ACTOR_DECL:
        case STMT_RECEIVE:
            // Stubs for future opcode implementations
            break;
            
        default: break;
    }
}

bool generateBytecode(StmtList* statements, ObjFunction* function) {
    BytecodeGen gen;
    Compiler compiler;
    
    gen.compiler = &compiler;
    gen.chunk = &function->chunk;
    gen.hadError = false;
    
    compiler.enclosing = NULL;
    compiler.function = function; 
    
    compiler.type = COMP_SCRIPT; 
    compiler.localCount = 0;
    compiler.scopeDepth = 0;
    compiler.loop = NULL;
    
    compiler.locals[compiler.localCount++].depth = 0;
    compiler.locals[0].name = "";

    if (statements) {
        for (int i = 0; i < statements->count; i++) {
            genStmt(&gen, statements->items[i]);
            if (gen.hadError) break;
        }
    }
    
    writeChunk(gen.chunk, OP_NIL, 0);
    writeChunk(gen.chunk, OP_RETURN, 0);
    
    return !gen.hadError;
}