freelang-v4 4.3.0

package/dist/compiler.js

@@ -0,0 +1,1588 @@
+"use strict";
+// FreeLang v4 — Bytecode Compiler (SPEC_02 구현)
+// AST → Bytecode
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Compiler = exports.Chunk = exports.Op = void 0;
+// ============================================================
+// Opcodes
+// ============================================================
+var Op;
+(function (Op) {
+    // 상수 로드
+    Op[Op["PUSH_I32"] = 1] = "PUSH_I32";
+    Op[Op["PUSH_F64"] = 2] = "PUSH_F64";
+    Op[Op["PUSH_STR"] = 3] = "PUSH_STR";
+    Op[Op["PUSH_TRUE"] = 4] = "PUSH_TRUE";
+    Op[Op["PUSH_FALSE"] = 5] = "PUSH_FALSE";
+    Op[Op["PUSH_VOID"] = 6] = "PUSH_VOID";
+    Op[Op["PUSH_NONE"] = 7] = "PUSH_NONE";
+    Op[Op["POP"] = 8] = "POP";
+    // 산술 (i32)
+    Op[Op["ADD_I32"] = 16] = "ADD_I32";
+    Op[Op["SUB_I32"] = 17] = "SUB_I32";
+    Op[Op["MUL_I32"] = 18] = "MUL_I32";
+    Op[Op["DIV_I32"] = 19] = "DIV_I32";
+    Op[Op["MOD_I32"] = 20] = "MOD_I32";
+    Op[Op["NEG_I32"] = 21] = "NEG_I32";
+    // 산술 (f64)
+    Op[Op["ADD_F64"] = 24] = "ADD_F64";
+    Op[Op["SUB_F64"] = 25] = "SUB_F64";
+    Op[Op["MUL_F64"] = 26] = "MUL_F64";
+    Op[Op["DIV_F64"] = 27] = "DIV_F64";
+    Op[Op["MOD_F64"] = 28] = "MOD_F64";
+    Op[Op["NEG_F64"] = 29] = "NEG_F64";
+    // 비교
+    Op[Op["EQ"] = 32] = "EQ";
+    Op[Op["NEQ"] = 33] = "NEQ";
+    Op[Op["LT"] = 34] = "LT";
+    Op[Op["GT"] = 35] = "GT";
+    Op[Op["LTEQ"] = 36] = "LTEQ";
+    Op[Op["GTEQ"] = 37] = "GTEQ";
+    // 논리
+    Op[Op["AND"] = 40] = "AND";
+    Op[Op["OR"] = 41] = "OR";
+    Op[Op["NOT"] = 42] = "NOT";
+    // 문자열
+    Op[Op["STR_CONCAT"] = 46] = "STR_CONCAT";
+    // 변수
+    Op[Op["LOAD_LOCAL"] = 48] = "LOAD_LOCAL";
+    Op[Op["STORE_LOCAL"] = 49] = "STORE_LOCAL";
+    Op[Op["LOAD_GLOBAL"] = 50] = "LOAD_GLOBAL";
+    Op[Op["STORE_GLOBAL"] = 51] = "STORE_GLOBAL";
+    // 제어
+    Op[Op["JUMP"] = 64] = "JUMP";
+    Op[Op["JUMP_IF_FALSE"] = 65] = "JUMP_IF_FALSE";
+    Op[Op["RETURN"] = 66] = "RETURN";
+    Op[Op["HALT"] = 67] = "HALT";
+    // 함수
+    Op[Op["CALL"] = 80] = "CALL";
+    Op[Op["CALL_BUILTIN"] = 81] = "CALL_BUILTIN";
+    // 배열
+    Op[Op["ARRAY_NEW"] = 96] = "ARRAY_NEW";
+    Op[Op["ARRAY_GET"] = 97] = "ARRAY_GET";
+    Op[Op["ARRAY_SET"] = 98] = "ARRAY_SET";
+    // 구조체
+    Op[Op["STRUCT_NEW"] = 104] = "STRUCT_NEW";
+    Op[Op["STRUCT_GET"] = 105] = "STRUCT_GET";
+    Op[Op["STRUCT_SET"] = 106] = "STRUCT_SET";
+    // Option/Result
+    Op[Op["WRAP_OK"] = 112] = "WRAP_OK";
+    Op[Op["WRAP_ERR"] = 113] = "WRAP_ERR";
+    Op[Op["WRAP_SOME"] = 114] = "WRAP_SOME";
+    Op[Op["UNWRAP"] = 115] = "UNWRAP";
+    Op[Op["IS_OK"] = 116] = "IS_OK";
+    Op[Op["IS_ERR"] = 117] = "IS_ERR";
+    Op[Op["IS_SOME"] = 118] = "IS_SOME";
+    Op[Op["IS_NONE"] = 119] = "IS_NONE";
+    // Actor/Channel
+    Op[Op["SPAWN"] = 128] = "SPAWN";
+    Op[Op["CHAN_NEW"] = 129] = "CHAN_NEW";
+    Op[Op["CHAN_SEND"] = 130] = "CHAN_SEND";
+    Op[Op["CHAN_RECV"] = 131] = "CHAN_RECV";
+    // 디버그
+    Op[Op["DUP"] = 240] = "DUP";
+})(Op || (exports.Op = Op = {}));
+class Chunk {
+    constructor() {
+        this.code = [];
+        this.constants = [];
+        this.functions = [];
+        this.lines = []; // 각 바이트코드의 소스 줄
+    }
+    emit(op, line) {
+        this.code.push(op);
+        this.lines.push(line);
+    }
+    emitByte(b, line) {
+        this.code.push(b & 0xFF);
+        this.lines.push(line);
+    }
+    emitI32(val, line) {
+        // 4바이트 little-endian
+        this.code.push(val & 0xFF);
+        this.code.push((val >> 8) & 0xFF);
+        this.code.push((val >> 16) & 0xFF);
+        this.code.push((val >> 24) & 0xFF);
+        for (let i = 0; i < 4; i++)
+            this.lines.push(line);
+    }
+    emitF64(val, line) {
+        const buf = new ArrayBuffer(8);
+        new Float64Array(buf)[0] = val;
+        const bytes = new Uint8Array(buf);
+        for (let i = 0; i < 8; i++) {
+            this.code.push(bytes[i]);
+            this.lines.push(line);
+        }
+    }
+    addConstant(val) {
+        const idx = this.constants.length;
+        this.constants.push(val);
+        return idx;
+    }
+    // 패치: 나중에 오프셋 채우기
+    currentOffset() {
+        return this.code.length;
+    }
+    patchI32(offset, val) {
+        this.code[offset] = val & 0xFF;
+        this.code[offset + 1] = (val >> 8) & 0xFF;
+        this.code[offset + 2] = (val >> 16) & 0xFF;
+        this.code[offset + 3] = (val >> 24) & 0xFF;
+    }
+}
+exports.Chunk = Chunk;
+class Compiler {
+    constructor() {
+        this.chunk = new Chunk();
+        this.locals = [];
+        this.scopeDepth = 0;
+        this.nextSlot = 0;
+        this.functionBodies = new Map();
+        this.currentLoopLabels = [];
+        this.irLabelOffsets = new Map();
+        this.irLabelPatches = new Map();
+    }
+    compile(program) {
+        // Pass 1: 함수 등록
+        for (const stmt of program.stmts) {
+            if (stmt.kind === "fn_decl") {
+                this.functionBodies.set(stmt.name, stmt);
+                this.chunk.functions.push({
+                    name: stmt.name,
+                    arity: stmt.params.length,
+                    offset: -1, // 나중에 패치
+                });
+            }
+        }
+        // Pass 2: 최상위 코드 컴파일
+        for (const stmt of program.stmts) {
+            if (stmt.kind !== "fn_decl") {
+                this.compileStmt(stmt);
+            }
+        }
+        this.chunk.emit(Op.HALT, 0);
+        // Pass 3: 함수 본문 컴파일
+        for (const [name, stmt] of this.functionBodies) {
+            this.compileFnBody(name, stmt);
+        }
+        return this.chunk;
+    }
+    // ============================================================
+    // IR → Bytecode (새 파이프라인)
+    // ============================================================
+    compileIR(ir) {
+        // Pass 1: 함수 등록
+        for (const fn of ir.functions) {
+            this.chunk.functions.push({
+                name: fn.name,
+                arity: fn.params.length,
+                offset: -1,
+            });
+        }
+        // Pass 2: main 코드 컴파일
+        for (const inst of ir.main) {
+            this.compileIrInst(inst);
+        }
+        this.chunk.emit(Op.HALT, 0);
+        // Pass 3: 함수 본문 컴파일
+        for (const fn of ir.functions) {
+            this.compileIrFunction(fn);
+        }
+        return this.chunk;
+    }
+    recordLabel(label) {
+        this.irLabelOffsets.set(label, this.chunk.currentOffset());
+    }
+    patchLabel(label) {
+        const targets = this.irLabelPatches.get(label) || [];
+        const offset = this.irLabelOffsets.get(label);
+        if (offset !== undefined) {
+            for (const patchOffset of targets) {
+                this.chunk.patchI32(patchOffset, offset);
+            }
+            this.irLabelPatches.delete(label);
+        }
+    }
+    emitJumpPlaceholder(label) {
+        const offset = this.chunk.currentOffset();
+        this.chunk.emitI32(0, 0); // placeholder
+        const targets = this.irLabelPatches.get(label) || [];
+        targets.push(offset);
+        this.irLabelPatches.set(label, targets);
+        return offset;
+    }
+    pushIrValue(val) {
+        switch (val.kind) {
+            case "const_i32":
+                this.chunk.emit(Op.PUSH_I32, 0);
+                this.chunk.emitI32(val.val, 0);
+                break;
+            case "const_f64":
+                this.chunk.emit(Op.PUSH_F64, 0);
+                this.chunk.emitF64(val.val, 0);
+                break;
+            case "const_str":
+                this.chunk.emit(Op.PUSH_STR, 0);
+                this.chunk.emitI32(this.chunk.addConstant(val.val), 0);
+                break;
+            case "const_bool":
+                if (val.val) {
+                    this.chunk.emit(Op.PUSH_TRUE, 0);
+                }
+                else {
+                    this.chunk.emit(Op.PUSH_FALSE, 0);
+                }
+                break;
+            case "local":
+                // 로컬 변수는 LOAD_LOCAL로 로드
+                const slot = this.resolveLocal(val.name);
+                if (slot >= 0) {
+                    this.chunk.emit(Op.LOAD_LOCAL, 0);
+                    this.chunk.emitI32(slot, 0);
+                }
+                break;
+            case "global":
+                // 글로벌 변수는 LOAD_GLOBAL로 로드
+                this.chunk.emit(Op.LOAD_GLOBAL, 0);
+                this.chunk.emitI32(this.chunk.addConstant(val.name), 0);
+                break;
+            case "temp":
+                // temp는 로컬로 취급 (slot 할당 필요)
+                const tslot = this.resolveLocal(val.name);
+                if (tslot >= 0) {
+                    this.chunk.emit(Op.LOAD_LOCAL, 0);
+                    this.chunk.emitI32(tslot, 0);
+                }
+                break;
+        }
+    }
+    compileIrInst(inst) {
+        switch (inst.kind) {
+            case "assign": {
+                this.pushIrValue(inst.src);
+                const slot = this.resolveLocal(inst.dest);
+                if (slot >= 0) {
+                    this.chunk.emit(Op.STORE_LOCAL, 0);
+                    this.chunk.emitI32(slot, 0);
+                }
+                else {
+                    // 새 로컬 변수 선언
+                    const newSlot = this.declareLocal(inst.dest);
+                    this.chunk.emit(Op.STORE_LOCAL, 0);
+                    this.chunk.emitI32(newSlot, 0);
+                }
+                break;
+            }
+            case "binop": {
+                this.pushIrValue(inst.left);
+                this.pushIrValue(inst.right);
+                // 연산자에 따른 Op 선택 (타입은 런타임에 결정됨)
+                switch (inst.op) {
+                    case "+":
+                        this.chunk.emit(Op.ADD_I32, 0); // 런타임에 타입 체크
+                        break;
+                    case "-":
+                        this.chunk.emit(Op.SUB_I32, 0);
+                        break;
+                    case "*":
+                        this.chunk.emit(Op.MUL_I32, 0);
+                        break;
+                    case "/":
+                        this.chunk.emit(Op.DIV_I32, 0);
+                        break;
+                    case "%":
+                        this.chunk.emit(Op.MOD_I32, 0);
+                        break;
+                    case "==":
+                        this.chunk.emit(Op.EQ, 0);
+                        break;
+                    case "!=":
+                        this.chunk.emit(Op.NEQ, 0);
+                        break;
+                    case "<":
+                        this.chunk.emit(Op.LT, 0);
+                        break;
+                    case ">":
+                        this.chunk.emit(Op.GT, 0);
+                        break;
+                    case "<=":
+                        this.chunk.emit(Op.LTEQ, 0);
+                        break;
+                    case ">=":
+                        this.chunk.emit(Op.GTEQ, 0);
+                        break;
+                    case "&&":
+                        this.chunk.emit(Op.AND, 0);
+                        break;
+                    case "||":
+                        this.chunk.emit(Op.OR, 0);
+                        break;
+                    default:
+                        break;
+                }
+                // 결과를 dest에 저장
+                const slot = this.resolveLocal(inst.dest);
+                if (slot >= 0) {
+                    this.chunk.emit(Op.STORE_LOCAL, 0);
+                    this.chunk.emitI32(slot, 0);
+                }
+                else {
+                    const newSlot = this.declareLocal(inst.dest);
+                    this.chunk.emit(Op.STORE_LOCAL, 0);
+                    this.chunk.emitI32(newSlot, 0);
+                }
+                break;
+            }
+            case "unop": {
+                this.pushIrValue(inst.src);
+                switch (inst.op) {
+                    case "-":
+                        this.chunk.emit(Op.NEG_I32, 0);
+                        break;
+                    case "!":
+                        this.chunk.emit(Op.NOT, 0);
+                        break;
+                    default:
+                        break;
+                }
+                const slot = this.resolveLocal(inst.dest);
+                if (slot >= 0) {
+                    this.chunk.emit(Op.STORE_LOCAL, 0);
+                    this.chunk.emitI32(slot, 0);
+                }
+                else {
+                    const newSlot = this.declareLocal(inst.dest);
+                    this.chunk.emit(Op.STORE_LOCAL, 0);
+                    this.chunk.emitI32(newSlot, 0);
+                }
+                break;
+            }
+            case "label": {
+                this.recordLabel(inst.name);
+                break;
+            }
+            case "jump": {
+                this.chunk.emit(Op.JUMP, 0);
+                this.emitJumpPlaceholder(inst.target);
+                break;
+            }
+            case "jump_if_false": {
+                this.pushIrValue(inst.cond);
+                this.chunk.emit(Op.JUMP_IF_FALSE, 0);
+                this.emitJumpPlaceholder(inst.target);
+                break;
+            }
+            case "call": {
+                // 인수 푸시
+                for (const arg of inst.args) {
+                    this.pushIrValue(arg);
+                }
+                // 함수 호출
+                this.chunk.emit(Op.CALL, 0);
+                this.chunk.emitI32(this.chunk.addConstant(inst.fn), 0);
+                this.chunk.emitByte(inst.args.length, 0);
+                // 결과 저장
+                if (inst.dest) {
+                    const slot = this.resolveLocal(inst.dest);
+                    if (slot >= 0) {
+                        this.chunk.emit(Op.STORE_LOCAL, 0);
+                        this.chunk.emitI32(slot, 0);
+                    }
+                    else {
+                        const newSlot = this.declareLocal(inst.dest);
+                        this.chunk.emit(Op.STORE_LOCAL, 0);
+                        this.chunk.emitI32(newSlot, 0);
+                    }
+                }
+                break;
+            }
+            case "call_builtin": {
+                // 인수 푸시
+                for (const arg of inst.args) {
+                    this.pushIrValue(arg);
+                }
+                // 내장 함수 호출
+                this.chunk.emit(Op.CALL_BUILTIN, 0);
+                this.chunk.emitI32(this.chunk.addConstant(inst.name), 0);
+                this.chunk.emitByte(inst.args.length, 0);
+                // 결과 저장
+                if (inst.dest) {
+                    const slot = this.resolveLocal(inst.dest);
+                    if (slot >= 0) {
+                        this.chunk.emit(Op.STORE_LOCAL, 0);
+                        this.chunk.emitI32(slot, 0);
+                    }
+                    else {
+                        const newSlot = this.declareLocal(inst.dest);
+                        this.chunk.emit(Op.STORE_LOCAL, 0);
+                        this.chunk.emitI32(newSlot, 0);
+                    }
+                }
+                break;
+            }
+            case "return": {
+                if (inst.value) {
+                    this.pushIrValue(inst.value);
+                }
+                else {
+                    this.chunk.emit(Op.PUSH_VOID, 0);
+                }
+                this.chunk.emit(Op.RETURN, 0);
+                break;
+            }
+            case "array_new": {
+                for (const elem of inst.elements) {
+                    this.pushIrValue(elem);
+                }
+                this.chunk.emit(Op.ARRAY_NEW, 0);
+                this.chunk.emitI32(inst.elements.length, 0);
+                const slot = this.resolveLocal(inst.dest);
+                if (slot >= 0) {
+                    this.chunk.emit(Op.STORE_LOCAL, 0);
+                    this.chunk.emitI32(slot, 0);
+                }
+                else {
+                    const newSlot = this.declareLocal(inst.dest);
+                    this.chunk.emit(Op.STORE_LOCAL, 0);
+                    this.chunk.emitI32(newSlot, 0);
+                }
+                break;
+            }
+            case "array_get": {
+                this.pushIrValue(inst.arr);
+                this.pushIrValue(inst.idx);
+                this.chunk.emit(Op.ARRAY_GET, 0);
+                const slot = this.resolveLocal(inst.dest);
+                if (slot >= 0) {
+                    this.chunk.emit(Op.STORE_LOCAL, 0);
+                    this.chunk.emitI32(slot, 0);
+                }
+                else {
+                    const newSlot = this.declareLocal(inst.dest);
+                    this.chunk.emit(Op.STORE_LOCAL, 0);
+                    this.chunk.emitI32(newSlot, 0);
+                }
+                break;
+            }
+            case "array_set": {
+                this.pushIrValue(inst.arr);
+                this.pushIrValue(inst.idx);
+                this.pushIrValue(inst.value);
+                this.chunk.emit(Op.ARRAY_SET, 0);
+                break;
+            }
+            case "struct_new": {
+                // 각 필드마다: PUSH_STR(fieldName) + value
+                for (const field of inst.fields) {
+                    this.chunk.emit(Op.PUSH_STR, 0);
+                    this.chunk.emitI32(this.chunk.addConstant(field.name), 0);
+                    this.pushIrValue(field.value);
+                }
+                this.chunk.emit(Op.STRUCT_NEW, 0);
+                this.chunk.emitI32(inst.fields.length, 0);
+                const slot = this.resolveLocal(inst.dest);
+                if (slot >= 0) {
+                    this.chunk.emit(Op.STORE_LOCAL, 0);
+                    this.chunk.emitI32(slot, 0);
+                }
+                else {
+                    const newSlot = this.declareLocal(inst.dest);
+                    this.chunk.emit(Op.STORE_LOCAL, 0);
+                    this.chunk.emitI32(newSlot, 0);
+                }
+                break;
+            }
+            case "struct_get": {
+                this.pushIrValue(inst.obj);
+                this.chunk.emit(Op.STRUCT_GET, 0);
+                this.chunk.emitI32(this.chunk.addConstant(inst.field), 0);
+                const slot = this.resolveLocal(inst.dest);
+                if (slot >= 0) {
+                    this.chunk.emit(Op.STORE_LOCAL, 0);
+                    this.chunk.emitI32(slot, 0);
+                }
+                else {
+                    const newSlot = this.declareLocal(inst.dest);
+                    this.chunk.emit(Op.STORE_LOCAL, 0);
+                    this.chunk.emitI32(newSlot, 0);
+                }
+                break;
+            }
+            case "struct_set": {
+                this.pushIrValue(inst.obj);
+                this.pushIrValue(inst.value);
+                this.chunk.emit(Op.STRUCT_SET, 0);
+                this.chunk.emitI32(this.chunk.addConstant(inst.field), 0);
+                break;
+            }
+            case "wrap_ok": {
+                this.pushIrValue(inst.value);
+                this.chunk.emit(Op.WRAP_OK, 0);
+                const slot = this.resolveLocal(inst.dest);
+                if (slot >= 0) {
+                    this.chunk.emit(Op.STORE_LOCAL, 0);
+                    this.chunk.emitI32(slot, 0);
+                }
+                else {
+                    const newSlot = this.declareLocal(inst.dest);
+                    this.chunk.emit(Op.STORE_LOCAL, 0);
+                    this.chunk.emitI32(newSlot, 0);
+                }
+                break;
+            }
+            case "wrap_err": {
+                this.pushIrValue(inst.value);
+                this.chunk.emit(Op.WRAP_ERR, 0);
+                const slot = this.resolveLocal(inst.dest);
+                if (slot >= 0) {
+                    this.chunk.emit(Op.STORE_LOCAL, 0);
+                    this.chunk.emitI32(slot, 0);
+                }
+                else {
+                    const newSlot = this.declareLocal(inst.dest);
+                    this.chunk.emit(Op.STORE_LOCAL, 0);
+                    this.chunk.emitI32(newSlot, 0);
+                }
+                break;
+            }
+            case "unwrap": {
+                this.pushIrValue(inst.value);
+                this.chunk.emit(Op.UNWRAP, 0);
+                const slot = this.resolveLocal(inst.dest);
+                if (slot >= 0) {
+                    this.chunk.emit(Op.STORE_LOCAL, 0);
+                    this.chunk.emitI32(slot, 0);
+                }
+                else {
+                    const newSlot = this.declareLocal(inst.dest);
+                    this.chunk.emit(Op.STORE_LOCAL, 0);
+                    this.chunk.emitI32(newSlot, 0);
+                }
+                break;
+            }
+        }
+    }
+    compileIrFunction(fn) {
+        const fnInfo = this.chunk.functions.find((f) => f.name === fn.name);
+        if (fnInfo)
+            fnInfo.offset = this.chunk.currentOffset();
+        const prevLocals = this.locals;
+        const prevSlot = this.nextSlot;
+        const prevDepth = this.scopeDepth;
+        this.locals = [];
+        this.nextSlot = 0;
+        this.scopeDepth = 0;
+        this.irLabelOffsets.clear();
+        this.irLabelPatches.clear();
+        // 매개변수 선언
+        for (const param of fn.params) {
+            this.declareLocal(param);
+        }
+        // 함수 본문 컴파일
+        for (const inst of fn.insts) {
+            this.compileIrInst(inst);
+        }
+        // 명시적 return이 없으면 void return 추가
+        const lastInst = fn.insts[fn.insts.length - 1];
+        if (!lastInst || lastInst.kind !== "return") {
+            this.chunk.emit(Op.PUSH_VOID, 0);
+            this.chunk.emit(Op.RETURN, 0);
+        }
+        this.locals = prevLocals;
+        this.nextSlot = prevSlot;
+        this.scopeDepth = prevDepth;
+    }
+    // ============================================================
+    // 문 컴파일
+    // ============================================================
+    compileStmt(stmt) {
+        switch (stmt.kind) {
+            case "var_decl": return this.compileVarDecl(stmt);
+            case "fn_decl": return; // Pass 3에서 처리
+            case "if_stmt": return this.compileIfStmt(stmt);
+            case "match_stmt": return this.compileMatchStmt(stmt);
+            case "for_stmt": return this.compileForStmt(stmt);
+            case "for_of_stmt": return this.compileForOfStmt(stmt);
+            case "while_stmt": return this.compileWhileStmt(stmt);
+            case "break_stmt": return this.compileBreakStmt(stmt);
+            case "continue_stmt": return this.compileContinueStmt(stmt);
+            case "struct_decl": return; // 타입 선언, 런타임 불필요
+            case "spawn_stmt": return this.compileSpawnStmt(stmt);
+            case "return_stmt": return this.compileReturnStmt(stmt);
+            case "expr_stmt": return this.compileExprStmt(stmt);
+            case "import_decl": return; // 모듈 로드는 별도 처리
+            case "export_decl": return; // export는 컴파일 시점에 무시
+        }
+    }
+    compileVarDecl(stmt) {
+        this.compileExpr(stmt.init);
+        const slot = this.declareLocal(stmt.name);
+        this.chunk.emit(Op.STORE_LOCAL, stmt.line);
+        this.chunk.emitI32(slot, stmt.line);
+    }
+    compileFnBody(name, stmt) {
+        // 함수 오프셋 기록
+        const fnInfo = this.chunk.functions.find((f) => f.name === name);
+        if (fnInfo)
+            fnInfo.offset = this.chunk.currentOffset();
+        // 스코프 + 매개변수
+        const prevLocals = this.locals;
+        const prevSlot = this.nextSlot;
+        const prevDepth = this.scopeDepth;
+        this.locals = [];
+        this.nextSlot = 0;
+        this.scopeDepth = 0;
+        for (const p of stmt.params) {
+            this.declareLocal(p.name);
+        }
+        // 본문: 마지막 statement가 expr_stmt/match_stmt이면 값을 반환
+        let lastStmtIsExpr = false;
+        for (let i = 0; i < stmt.body.length; i++) {
+            const s = stmt.body[i];
+            const isLast = i === stmt.body.length - 1;
+            if (isLast && s.kind === "expr_stmt") {
+                // 마지막이 expression statement → expression 값을 스택에 남김
+                this.compileExpr(s.expr);
+                lastStmtIsExpr = true;
+            }
+            else if (isLast && s.kind === "match_stmt") {
+                // 마지막이 match statement → match 값을 반환하도록 컴파일
+                this.compileMatchStmtAsExpr(s);
+                lastStmtIsExpr = true;
+            }
+            else {
+                this.compileStmt(s);
+            }
+        }
+        // void 함수는 암시적 return
+        if (!lastStmtIsExpr) {
+            this.chunk.emit(Op.PUSH_VOID, stmt.line);
+        }
+        this.chunk.emit(Op.RETURN, stmt.line);
+        this.locals = prevLocals;
+        this.nextSlot = prevSlot;
+        this.scopeDepth = prevDepth;
+    }
+    compileIfStmt(stmt) {
+        this.compileExpr(stmt.condition);
+        // JUMP_IF_FALSE → else or end
+        this.chunk.emit(Op.JUMP_IF_FALSE, stmt.line);
+        const elseJump = this.chunk.currentOffset();
+        this.chunk.emitI32(0, stmt.line); // 패치 대상
+        // then
+        this.beginScope();
+        for (const s of stmt.then)
+            this.compileStmt(s);
+        this.endScope(stmt.line);
+        if (stmt.else_) {
+            // JUMP → end (then 끝에서)
+            this.chunk.emit(Op.JUMP, stmt.line);
+            const endJump = this.chunk.currentOffset();
+            this.chunk.emitI32(0, stmt.line);
+            // else 시작 (패치)
+            this.chunk.patchI32(elseJump, this.chunk.currentOffset());
+            this.beginScope();
+            for (const s of stmt.else_)
+                this.compileStmt(s);
+            this.endScope(stmt.line);
+            // end (패치)
+            this.chunk.patchI32(endJump, this.chunk.currentOffset());
+        }
+        else {
+            this.chunk.patchI32(elseJump, this.chunk.currentOffset());
+        }
+    }
+    compileMatchStmt(stmt) {
+        this.compileExpr(stmt.subject);
+        // subject를 로컬 슬롯에 저장 (struct/array 분해 바인딩용)
+        const subjectSlot = this.declareLocal("__match_subject__");
+        this.chunk.emit(Op.STORE_LOCAL, stmt.line);
+        this.chunk.emitI32(subjectSlot, stmt.line);
+        const endJumps = [];
+        for (const arm of stmt.arms) {
+            // subject를 스택에 로드해서 테스트
+            this.chunk.emit(Op.LOAD_LOCAL, stmt.line);
+            this.chunk.emitI32(subjectSlot, stmt.line);
+            // 패턴 매칭 코드
+            this.compilePatternTest(arm.pattern, stmt.line);
+            // JUMP_IF_FALSE → 다음 arm
+            this.chunk.emit(Op.JUMP_IF_FALSE, stmt.line);
+            const nextArm = this.chunk.currentOffset();
+            this.chunk.emitI32(0, stmt.line);
+            // Pattern 매칭 성공 — scope 시작 및 변수 바인딩
+            this.beginScope();
+            this.compilePatternBind(arm.pattern, stmt.line, subjectSlot);
+            // Guard 절이 있으면 추가 조건 검사 (pattern bind 후)
+            let guardJump = null;
+            if (arm.guard) {
+                this.compileExpr(arm.guard);
+                this.chunk.emit(Op.JUMP_IF_FALSE, stmt.line);
+                guardJump = this.chunk.currentOffset();
+                this.chunk.emitI32(0, stmt.line);
+            }
+            // body
+            this.compileExpr(arm.body);
+            this.chunk.emit(Op.POP, stmt.line); // match stmt → 값 버림
+            this.endScope(stmt.line);
+            // JUMP → end
+            this.chunk.emit(Op.JUMP, stmt.line);
+            endJumps.push(this.chunk.currentOffset());
+            this.chunk.emitI32(0, stmt.line);
+            // 다음 arm (패치) - pattern fail과 guard fail 모두 이 위치로
+            this.chunk.patchI32(nextArm, this.chunk.currentOffset());
+            if (guardJump !== null) {
+                this.chunk.patchI32(guardJump, this.chunk.currentOffset());
+            }
+        }
+        // end 패치
+        for (const j of endJumps) {
+            this.chunk.patchI32(j, this.chunk.currentOffset());
+        }
+    }
+    compileMatchStmtAsExpr(stmt) {
+        // match_stmt를 expression처럼 컴파일 (값을 반환)
+        this.compileExpr(stmt.subject);
+        const subjectSlot = this.declareLocal("__match_subject__");
+        this.chunk.emit(Op.STORE_LOCAL, stmt.line);
+        this.chunk.emitI32(subjectSlot, stmt.line);
+        const endJumps = [];
+        for (const arm of stmt.arms) {
+            this.chunk.emit(Op.LOAD_LOCAL, stmt.line);
+            this.chunk.emitI32(subjectSlot, stmt.line);
+            this.compilePatternTest(arm.pattern, stmt.line);
+            this.chunk.emit(Op.JUMP_IF_FALSE, stmt.line);
+            const nextArm = this.chunk.currentOffset();
+            this.chunk.emitI32(0, stmt.line);
+            // Pattern 매칭 성공 — scope 시작 및 변수 바인딩
+            this.beginScope();
+            this.compilePatternBind(arm.pattern, stmt.line, subjectSlot);
+            // Guard 절이 있으면 추가 조건 검사 (pattern bind 후)
+            let guardJump = null;
+            if (arm.guard) {
+                this.compileExpr(arm.guard);
+                this.chunk.emit(Op.JUMP_IF_FALSE, stmt.line);
+                guardJump = this.chunk.currentOffset();
+                this.chunk.emitI32(0, stmt.line);
+            }
+            // body 실행
+            this.compileExpr(arm.body); // 값을 반환 (POP 없음)
+            this.endScope(stmt.line);
+            this.chunk.emit(Op.JUMP, stmt.line);
+            endJumps.push(this.chunk.currentOffset());
+            this.chunk.emitI32(0, stmt.line);
+            // 다음 arm (패치) - pattern fail과 guard fail 모두 이 위치로
+            this.chunk.patchI32(nextArm, this.chunk.currentOffset());
+            if (guardJump !== null) {
+                this.chunk.patchI32(guardJump, this.chunk.currentOffset());
+            }
+        }
+        this.chunk.emit(Op.PUSH_VOID, stmt.line);
+        const afterMatchLabel = this.chunk.currentOffset();
+        for (const j of endJumps) {
+            this.chunk.patchI32(j, afterMatchLabel);
+        }
+    }
+    compileForStmt(stmt) {
+        // iterable 계산
+        this.compileExpr(stmt.iterable);
+        const arrSlot = this.declareLocal("__arr__");
+        this.chunk.emit(Op.STORE_LOCAL, stmt.line);
+        this.chunk.emitI32(arrSlot, stmt.line);
+        // 인덱스 = 0
+        this.chunk.emit(Op.PUSH_I32, stmt.line);
+        this.chunk.emitI32(0, stmt.line);
+        const idxSlot = this.declareLocal("__idx__");
+        this.chunk.emit(Op.STORE_LOCAL, stmt.line);
+        this.chunk.emitI32(idxSlot, stmt.line);
+        // 루프 변수
+        this.chunk.emit(Op.PUSH_VOID, stmt.line);
+        const itemSlot = this.declareLocal(stmt.variable);
+        this.chunk.emit(Op.STORE_LOCAL, stmt.line);
+        this.chunk.emitI32(itemSlot, stmt.line);
+        const loopStart = this.chunk.currentOffset();
+        // 루프 레이블 푸시
+        const loopLabel = { loopStart, breakPatches: [], continuePatches: [] };
+        this.currentLoopLabels.push(loopLabel);
+        // 조건: idx < length(arr)
+        this.chunk.emit(Op.LOAD_LOCAL, stmt.line);
+        this.chunk.emitI32(idxSlot, stmt.line);
+        this.chunk.emit(Op.LOAD_LOCAL, stmt.line);
+        this.chunk.emitI32(arrSlot, stmt.line);
+        this.chunk.emit(Op.CALL_BUILTIN, stmt.line);
+        this.chunk.emitI32(this.chunk.addConstant("length"), stmt.line);
+        this.chunk.emitByte(1, stmt.line); // 1 arg
+        this.chunk.emit(Op.LT, stmt.line);
+        this.chunk.emit(Op.JUMP_IF_FALSE, stmt.line);
+        const exitJump = this.chunk.currentOffset();
+        this.chunk.emitI32(0, stmt.line);
+        // item = arr[idx]
+        this.chunk.emit(Op.LOAD_LOCAL, stmt.line);
+        this.chunk.emitI32(arrSlot, stmt.line);
+        this.chunk.emit(Op.LOAD_LOCAL, stmt.line);
+        this.chunk.emitI32(idxSlot, stmt.line);
+        this.chunk.emit(Op.ARRAY_GET, stmt.line);
+        this.chunk.emit(Op.STORE_LOCAL, stmt.line);
+        this.chunk.emitI32(itemSlot, stmt.line);
+        // body
+        this.beginScope();
+        for (const s of stmt.body)
+            this.compileStmt(s);
+        this.endScope(stmt.line);
+        // idx = idx + 1 (continueTarget 설정)
+        const continueTarget = this.chunk.currentOffset();
+        this.chunk.emit(Op.LOAD_LOCAL, stmt.line);
+        this.chunk.emitI32(idxSlot, stmt.line);
+        this.chunk.emit(Op.PUSH_I32, stmt.line);
+        this.chunk.emitI32(1, stmt.line);
+        this.chunk.emit(Op.ADD_I32, stmt.line);
+        this.chunk.emit(Op.STORE_LOCAL, stmt.line);
+        this.chunk.emitI32(idxSlot, stmt.line);
+        // JUMP → loopStart
+        this.chunk.emit(Op.JUMP, stmt.line);
+        this.chunk.emitI32(loopStart, stmt.line);
+        // exit 주소 결정 및 패치
+        const exitTarget = this.chunk.currentOffset();
+        this.chunk.patchI32(exitJump, exitTarget);
+        // break 문 모두 패치
+        for (const breakPatch of loopLabel.breakPatches) {
+            this.chunk.patchI32(breakPatch, exitTarget);
+        }
+        // continue 문 모두 패치 (for는 idx 증가로)
+        for (const continuePatch of loopLabel.continuePatches) {
+            this.chunk.patchI32(continuePatch, continueTarget);
+        }
+        // 루프 레이블 팝
+        this.currentLoopLabels.pop();
+    }
+    compileForOfStmt(stmt) {
+        // for_of_stmt는 for_stmt와 동일 (변수 선언 방식만 다름)
+        this.compileExpr(stmt.iterable);
+        const arrSlot = this.declareLocal("__arr__");
+        this.chunk.emit(Op.STORE_LOCAL, stmt.line);
+        this.chunk.emitI32(arrSlot, stmt.line);
+        this.chunk.emit(Op.PUSH_I32, stmt.line);
+        this.chunk.emitI32(0, stmt.line);
+        const idxSlot = this.declareLocal("__idx__");
+        this.chunk.emit(Op.STORE_LOCAL, stmt.line);
+        this.chunk.emitI32(idxSlot, stmt.line);
+        this.chunk.emit(Op.PUSH_VOID, stmt.line);
+        const itemSlot = this.declareLocal(stmt.variable);
+        this.chunk.emit(Op.STORE_LOCAL, stmt.line);
+        this.chunk.emitI32(itemSlot, stmt.line);
+        const loopStart = this.chunk.currentOffset();
+        // 루프 레이블 푸시
+        const loopLabel = { loopStart, breakPatches: [], continuePatches: [] };
+        this.currentLoopLabels.push(loopLabel);
+        this.chunk.emit(Op.LOAD_LOCAL, stmt.line);
+        this.chunk.emitI32(idxSlot, stmt.line);
+        this.chunk.emit(Op.LOAD_LOCAL, stmt.line);
+        this.chunk.emitI32(arrSlot, stmt.line);
+        this.chunk.emit(Op.CALL_BUILTIN, stmt.line);
+        this.chunk.emitI32(this.chunk.addConstant("length"), stmt.line);
+        this.chunk.emitByte(1, stmt.line);
+        this.chunk.emit(Op.LT, stmt.line);
+        this.chunk.emit(Op.JUMP_IF_FALSE, stmt.line);
+        const exitJump = this.chunk.currentOffset();
+        this.chunk.emitI32(0, stmt.line);
+        this.chunk.emit(Op.LOAD_LOCAL, stmt.line);
+        this.chunk.emitI32(arrSlot, stmt.line);
+        this.chunk.emit(Op.LOAD_LOCAL, stmt.line);
+        this.chunk.emitI32(idxSlot, stmt.line);
+        this.chunk.emit(Op.ARRAY_GET, stmt.line);
+        this.chunk.emit(Op.STORE_LOCAL, stmt.line);
+        this.chunk.emitI32(itemSlot, stmt.line);
+        this.beginScope();
+        for (const s of stmt.body)
+            this.compileStmt(s);
+        this.endScope(stmt.line);
+        // idx = idx + 1 (continueTarget 설정)
+        const continueTarget = this.chunk.currentOffset();
+        this.chunk.emit(Op.LOAD_LOCAL, stmt.line);
+        this.chunk.emitI32(idxSlot, stmt.line);
+        this.chunk.emit(Op.PUSH_I32, stmt.line);
+        this.chunk.emitI32(1, stmt.line);
+        this.chunk.emit(Op.ADD_I32, stmt.line);
+        this.chunk.emit(Op.STORE_LOCAL, stmt.line);
+        this.chunk.emitI32(idxSlot, stmt.line);
+        this.chunk.emit(Op.JUMP, stmt.line);
+        this.chunk.emitI32(loopStart, stmt.line);
+        // exit 주소 결정 및 패치
+        const exitTarget = this.chunk.currentOffset();
+        this.chunk.patchI32(exitJump, exitTarget);
+        // break 문 모두 패치
+        for (const breakPatch of loopLabel.breakPatches) {
+            this.chunk.patchI32(breakPatch, exitTarget);
+        }
+        // continue 문 모두 패치 (for는 idx 증가로)
+        for (const continuePatch of loopLabel.continuePatches) {
+            this.chunk.patchI32(continuePatch, continueTarget);
+        }
+        // 루프 레이블 팝
+        this.currentLoopLabels.pop();
+    }
+    compileWhileStmt(stmt) {
+        const loopStart = this.chunk.currentOffset();
+        // 루프 레이블 푸시
+        const loopLabel = { loopStart, breakPatches: [], continuePatches: [] };
+        this.currentLoopLabels.push(loopLabel);
+        // 조건 계산
+        this.compileExpr(stmt.condition);
+        this.chunk.emit(Op.JUMP_IF_FALSE, stmt.line);
+        const exitJump = this.chunk.currentOffset();
+        this.chunk.emitI32(0, stmt.line); // 패치 예정
+        // body
+        this.beginScope();
+        for (const s of stmt.body)
+            this.compileStmt(s);
+        this.endScope(stmt.line);
+        // JUMP → loopStart
+        this.chunk.emit(Op.JUMP, stmt.line);
+        this.chunk.emitI32(loopStart, stmt.line);
+        // exit 주소 결정 및 패치
+        const exitTarget = this.chunk.currentOffset();
+        this.chunk.patchI32(exitJump, exitTarget);
+        // break 문 모두 패치
+        for (const breakPatch of loopLabel.breakPatches) {
+            this.chunk.patchI32(breakPatch, exitTarget);
+        }
+        // continue 문 모두 패치 (while은 loopStart로)
+        for (const continuePatch of loopLabel.continuePatches) {
+            this.chunk.patchI32(continuePatch, loopStart);
+        }
+        // 루프 레이블 팝
+        this.currentLoopLabels.pop();
+    }
+    compileSpawnStmt(stmt) {
+        // SPAWN: 본문의 시작 오프셋을 인자로
+        this.chunk.emit(Op.SPAWN, stmt.line);
+        const bodyJump = this.chunk.currentOffset();
+        this.chunk.emitI32(0, stmt.line); // 패치
+        // main은 spawn 다음으로 점프
+        this.chunk.emit(Op.JUMP, stmt.line);
+        const skipJump = this.chunk.currentOffset();
+        this.chunk.emitI32(0, stmt.line);
+        // spawn body 시작 (패치)
+        this.chunk.patchI32(bodyJump, this.chunk.currentOffset());
+        for (const s of stmt.body)
+            this.compileStmt(s);
+        this.chunk.emit(Op.HALT, stmt.line);
+        // skip end (패치)
+        this.chunk.patchI32(skipJump, this.chunk.currentOffset());
+    }
+    compileReturnStmt(stmt) {
+        if (stmt.value) {
+            this.compileExpr(stmt.value);
+        }
+        else {
+            this.chunk.emit(Op.PUSH_VOID, stmt.line);
+        }
+        this.chunk.emit(Op.RETURN, stmt.line);
+    }
+    compileBreakStmt(stmt) {
+        if (this.currentLoopLabels.length === 0) {
+            throw new Error("break 문이 루프 밖에 있습니다");
+        }
+        const loopLabel = this.currentLoopLabels[this.currentLoopLabels.length - 1];
+        this.chunk.emit(Op.JUMP, stmt.line);
+        const breakPatch = this.chunk.currentOffset();
+        this.chunk.emitI32(0, stmt.line); // placeholder
+        loopLabel.breakPatches.push(breakPatch);
+    }
+    compileContinueStmt(stmt) {
+        if (this.currentLoopLabels.length === 0) {
+            throw new Error("continue 문이 루프 밖에 있습니다");
+        }
+        const loopLabel = this.currentLoopLabels[this.currentLoopLabels.length - 1];
+        this.chunk.emit(Op.JUMP, stmt.line);
+        const continuePatch = this.chunk.currentOffset();
+        this.chunk.emitI32(0, stmt.line); // placeholder
+        loopLabel.continuePatches.push(continuePatch);
+    }
+    compileExprStmt(stmt) {
+        this.compileExpr(stmt.expr);
+        // 할당은 이미 STORE_LOCAL을 emit하므로 POP 불필요
+        if (stmt.expr.kind !== "assign") {
+            this.chunk.emit(Op.POP, stmt.line);
+        }
+    }
+    // ============================================================
+    // 식 컴파일
+    // ============================================================
+    compileExpr(expr) {
+        switch (expr.kind) {
+            case "int_lit":
+                this.chunk.emit(Op.PUSH_I32, expr.line);
+                this.chunk.emitI32(expr.value, expr.line);
+                break;
+            case "float_lit":
+                this.chunk.emit(Op.PUSH_F64, expr.line);
+                this.chunk.emitF64(expr.value, expr.line);
+                break;
+            case "string_lit": {
+                const idx = this.chunk.addConstant(expr.value);
+                this.chunk.emit(Op.PUSH_STR, expr.line);
+                this.chunk.emitI32(idx, expr.line);
+                break;
+            }
+            case "bool_lit":
+                this.chunk.emit(expr.value ? Op.PUSH_TRUE : Op.PUSH_FALSE, expr.line);
+                break;
+            case "ident":
+                this.compileIdent(expr);
+                break;
+            case "binary":
+                this.compileBinary(expr);
+                break;
+            case "unary":
+                this.compileUnary(expr);
+                break;
+            case "await": {
+                // Promise 객체를 스택에 push
+                this.compileExpr(expr.expr);
+                // Promise._value 필드 추출
+                this.chunk.emit(Op.STRUCT_GET, expr.line);
+                this.chunk.emitI32(this.chunk.addConstant("_value"), expr.line);
+                // 이제 스택에 추출된 값이 있음
+                break;
+            }
+            case "call":
+                this.compileCall(expr);
+                break;
+            case "index":
+                this.compileExpr(expr.object);
+                this.compileExpr(expr.index);
+                this.chunk.emit(Op.ARRAY_GET, expr.line);
+                break;
+            case "field_access":
+                this.compileExpr(expr.object);
+                this.chunk.emit(Op.STRUCT_GET, expr.line);
+                this.chunk.emitI32(this.chunk.addConstant(expr.field), expr.line);
+                break;
+            case "assign":
+                this.compileAssign(expr);
+                break;
+            case "try":
+                this.compileExpr(expr.operand);
+                this.chunk.emit(Op.UNWRAP, expr.line);
+                break;
+            case "if_expr":
+                this.compileIfExpr(expr);
+                break;
+            case "match_expr":
+                this.compileMatchExpr(expr);
+                break;
+            case "array_lit":
+                for (const el of expr.elements)
+                    this.compileExpr(el);
+                this.chunk.emit(Op.ARRAY_NEW, expr.line);
+                this.chunk.emitI32(expr.elements.length, expr.line);
+                break;
+            case "struct_lit":
+                for (const f of expr.fields) {
+                    this.chunk.emit(Op.PUSH_STR, expr.line);
+                    this.chunk.emitI32(this.chunk.addConstant(f.name), expr.line);
+                    this.compileExpr(f.value);
+                }
+                this.chunk.emit(Op.STRUCT_NEW, expr.line);
+                this.chunk.emitI32(expr.fields.length, expr.line);
+                break;
+            case "block_expr":
+                this.beginScope();
+                for (const s of expr.stmts)
+                    this.compileStmt(s);
+                if (expr.expr)
+                    this.compileExpr(expr.expr);
+                else
+                    this.chunk.emit(Op.PUSH_VOID, expr.line);
+                this.endScope(expr.line);
+                break;
+            case "chan_new":
+                this.chunk.emit(Op.CHAN_NEW, expr.line);
+                break;
+            case "chan_send":
+                this.compileExpr(expr.chan);
+                this.compileExpr(expr.value);
+                this.chunk.emit(Op.CHAN_SEND, expr.line);
+                break;
+            case "chan_recv":
+                this.compileExpr(expr.chan);
+                this.chunk.emit(Op.CHAN_RECV, expr.line);
+                break;
+        }
+    }
+    compileIdent(expr) {
+        const local = this.resolveLocal(expr.name);
+        if (local !== -1) {
+            this.chunk.emit(Op.LOAD_LOCAL, expr.line);
+            this.chunk.emitI32(local, expr.line);
+        }
+        else {
+            // global 또는 함수 이름 — 함수 참조로 처리
+            this.chunk.emit(Op.LOAD_GLOBAL, expr.line);
+            this.chunk.emitI32(this.chunk.addConstant(expr.name), expr.line);
+        }
+    }
+    compileBinary(expr) {
+        // 문자열 + 문자열
+        if (expr.op === "+") {
+            this.compileExpr(expr.left);
+            this.compileExpr(expr.right);
+            // VM이 런타임에 타입 보고 ADD_I32/ADD_F64/STR_CONCAT 결정
+            // 여기서는 일반 ADD로 emit
+            this.chunk.emit(Op.ADD_I32, expr.line);
+            return;
+        }
+        this.compileExpr(expr.left);
+        this.compileExpr(expr.right);
+        switch (expr.op) {
+            case "-":
+                this.chunk.emit(Op.SUB_I32, expr.line);
+                break;
+            case "*":
+                this.chunk.emit(Op.MUL_I32, expr.line);
+                break;
+            case "/":
+                this.chunk.emit(Op.DIV_I32, expr.line);
+                break;
+            case "%":
+                this.chunk.emit(Op.MOD_I32, expr.line);
+                break;
+            case "==":
+                this.chunk.emit(Op.EQ, expr.line);
+                break;
+            case "!=":
+                this.chunk.emit(Op.NEQ, expr.line);
+                break;
+            case "<":
+                this.chunk.emit(Op.LT, expr.line);
+                break;
+            case ">":
+                this.chunk.emit(Op.GT, expr.line);
+                break;
+            case "<=":
+                this.chunk.emit(Op.LTEQ, expr.line);
+                break;
+            case ">=":
+                this.chunk.emit(Op.GTEQ, expr.line);
+                break;
+            case "&&":
+                this.chunk.emit(Op.AND, expr.line);
+                break;
+            case "||":
+                this.chunk.emit(Op.OR, expr.line);
+                break;
+        }
+    }
+    compileUnary(expr) {
+        this.compileExpr(expr.operand);
+        if (expr.op === "-")
+            this.chunk.emit(Op.NEG_I32, expr.line);
+        if (expr.op === "!")
+            this.chunk.emit(Op.NOT, expr.line);
+    }
+    compileCall(expr) {
+        // 내장 함수
+        if (expr.callee.kind === "ident") {
+            const name = expr.callee.name;
+            const builtins = [
+                "println", "print", "read_line", "read_file", "write_file",
+                "i32", "i64", "f64", "str",
+                "push", "pop", "slice", "clone", "length",
+                "char_at", "char_code", "chr", "contains", "split", "trim", "to_upper", "to_lower",
+                "abs", "min", "max", "pow", "sqrt",
+                "range", "channel", "panic", "typeof", "assert",
+                // Bitwise Operations (5) - A-1
+                "bitand", "bitor", "bitxor", "shl", "shr",
+                // Phase 7: 20 Core Libraries
+                // Cryptography & Encoding (6)
+                "md5", "sha256", "sha512", "base64_encode", "base64_decode", "hmac",
+                // JSON (4)
+                "json_parse", "json_stringify", "json_validate", "json_pretty",
+                // Advanced Strings (3)
+                "starts_with", "ends_with", "replace",
+                // Advanced Arrays (3)
+                "reverse", "sort", "unique",
+                // Math (2)
+                "gcd", "lcm",
+                // Utils (2)
+                "uuid", "timestamp",
+                // Channel (2)
+                "send", "recv",
+                // Environment (1)
+                "env",
+                // HTTP Client (4) - Phase 2
+                "http_get", "http_post", "http_post_json", "fetch",
+                // Database SQLite (7) + PostgreSQL (7) + MySQL (7) - Phase 3
+                "sqlite_open", "sqlite_query", "sqlite_execute", "sqlite_close",
+                "sqlite_begin", "sqlite_commit", "sqlite_rollback",
+                "pg_connect", "pg_query", "pg_execute", "pg_close",
+                "pg_begin", "pg_commit", "pg_rollback",
+                "mysql_connect", "mysql_query", "mysql_execute", "mysql_close",
+                "mysql_begin", "mysql_commit", "mysql_rollback",
+                // v4.3 Extensions
+                // Math (7) - B-1
+                "floor", "ceil", "round", "random", "sin", "cos", "log",
+                // String (3) - B-2
+                "index_of", "pad_left", "pad_right",
+                // Regex (3) - B-3
+                "regex_match", "regex_find_all", "regex_replace",
+                // CSV (2) - B-4
+                "csv_parse", "csv_stringify",
+                // DateTime (3) - B-5
+                "now", "format_date", "parse_date",
+                // YAML (2) - v4.3 Extension
+                "yaml_parse", "yaml_stringify",
+                // HTTP Server (3) - gogs-server 지원
+                "http_server_create", "http_server_accept", "http_server_respond",
+                // External Commands (1)
+                "exec_command",
+            ];
+            if (builtins.includes(name)) {
+                for (const arg of expr.args)
+                    this.compileExpr(arg);
+                this.chunk.emit(Op.CALL_BUILTIN, expr.line);
+                this.chunk.emitI32(this.chunk.addConstant(name), expr.line);
+                this.chunk.emitByte(expr.args.length, expr.line);
+                return;
+            }
+            // 사용자 함수
+            const fnIdx = this.chunk.functions.findIndex((f) => f.name === name);
+            if (fnIdx !== -1) {
+                for (const arg of expr.args)
+                    this.compileExpr(arg);
+                this.chunk.emit(Op.CALL, expr.line);
+                this.chunk.emitI32(fnIdx, expr.line);
+                this.chunk.emitByte(expr.args.length, expr.line);
+                return;
+            }
+        }
+        // 메서드 호출: obj.method(args)
+        if (expr.callee.kind === "field_access") {
+            this.compileExpr(expr.callee.object);
+            for (const arg of expr.args)
+                this.compileExpr(arg);
+            this.chunk.emit(Op.CALL_BUILTIN, expr.line);
+            this.chunk.emitI32(this.chunk.addConstant(expr.callee.field), expr.line);
+            this.chunk.emitByte(expr.args.length + 1, expr.line); // +1 for self
+            return;
+        }
+        // fallback: 동적 호출
+        this.compileExpr(expr.callee);
+        for (const arg of expr.args)
+            this.compileExpr(arg);
+        this.chunk.emit(Op.CALL, expr.line);
+        this.chunk.emitI32(-1, expr.line);
+        this.chunk.emitByte(expr.args.length, expr.line);
+    }
+    compileAssign(expr) {
+        if (expr.target.kind === "ident") {
+            this.compileExpr(expr.value);
+            const slot = this.resolveLocal(expr.target.name);
+            if (slot !== -1) {
+                this.chunk.emit(Op.STORE_LOCAL, expr.line);
+                this.chunk.emitI32(slot, expr.line);
+            }
+            else {
+                this.chunk.emit(Op.STORE_GLOBAL, expr.line);
+                this.chunk.emitI32(this.chunk.addConstant(expr.target.name), expr.line);
+            }
+        }
+        else if (expr.target.kind === "index") {
+            // Stack order: array, index, value
+            // VM ARRAY_SET pops: val=pop(), idx=pop(), arr=pop()
+            this.compileExpr(expr.target.object);
+            this.compileExpr(expr.target.index);
+            this.compileExpr(expr.value);
+            this.chunk.emit(Op.ARRAY_SET, expr.line);
+        }
+    }
+    compileIfExpr(expr) {
+        this.compileExpr(expr.condition);
+        this.chunk.emit(Op.JUMP_IF_FALSE, expr.line);
+        const elseJump = this.chunk.currentOffset();
+        this.chunk.emitI32(0, expr.line);
+        // then — 마지막 식이 값
+        for (const e of expr.then)
+            this.compileExpr(e);
+        this.chunk.emit(Op.JUMP, expr.line);
+        const endJump = this.chunk.currentOffset();
+        this.chunk.emitI32(0, expr.line);
+        this.chunk.patchI32(elseJump, this.chunk.currentOffset());
+        // else — 마지막 식이 값
+        for (const e of expr.else_)
+            this.compileExpr(e);
+        this.chunk.patchI32(endJump, this.chunk.currentOffset());
+    }
+    compileMatchExpr(expr) {
+        this.compileExpr(expr.subject);
+        // subject를 로컬 슬롯에 저장 (struct/array 분해 바인딩용)
+        const subjectSlot = this.declareLocal("__match_subject__");
+        this.chunk.emit(Op.STORE_LOCAL, expr.line);
+        this.chunk.emitI32(subjectSlot, expr.line);
+        const endJumps = [];
+        for (const arm of expr.arms) {
+            // subject를 스택에 로드해서 테스트
+            this.chunk.emit(Op.LOAD_LOCAL, expr.line);
+            this.chunk.emitI32(subjectSlot, expr.line);
+            this.compilePatternTest(arm.pattern, expr.line);
+            this.chunk.emit(Op.JUMP_IF_FALSE, expr.line);
+            const nextArm = this.chunk.currentOffset();
+            this.chunk.emitI32(0, expr.line);
+            // Pattern 매칭 성공 — scope 시작 및 변수 바인딩
+            this.beginScope();
+            this.compilePatternBind(arm.pattern, expr.line, subjectSlot);
+            // Guard 절이 있으면 추가 조건 검사
+            let guardJump = null;
+            if (arm.guard) {
+                this.compileExpr(arm.guard);
+                this.chunk.emit(Op.JUMP_IF_FALSE, expr.line);
+                guardJump = this.chunk.currentOffset();
+                this.chunk.emitI32(0, expr.line);
+            }
+            // arm body의 값이 스택에 남음
+            this.compileExpr(arm.body);
+            this.endScope(expr.line); // scope 종료
+            this.chunk.emit(Op.JUMP, expr.line);
+            endJumps.push(this.chunk.currentOffset());
+            this.chunk.emitI32(0, expr.line);
+            // Guard 실패 시 처리 - guard fail 점프를 다음 arm으로 설정
+            this.chunk.patchI32(nextArm, this.chunk.currentOffset());
+            if (guardJump !== null) {
+                // guard fail 시에도 같은 위치(nextArm)로 점프하도록 설정
+                this.chunk.patchI32(guardJump, this.chunk.currentOffset());
+            }
+        }
+        // fallthrough (아무 arm도 매칭 안 됨) - void
+        this.chunk.emit(Op.PUSH_VOID, expr.line);
+        // arm이 성공했으면 여기(PUSH_VOID 이후)로 점프
+        const afterMatchLabel = this.chunk.currentOffset();
+        for (const j of endJumps) {
+            this.chunk.patchI32(j, afterMatchLabel);
+        }
+    }
+    // ============================================================
+    // 패턴 컴파일
+    // ============================================================
+    compilePatternTest(pattern, line) {
+        switch (pattern.kind) {
+            case "wildcard":
+            case "ident":
+                // 항상 매칭
+                this.chunk.emit(Op.PUSH_TRUE, line);
+                break;
+            case "literal":
+                this.compileExpr(pattern.value);
+                this.chunk.emit(Op.EQ, line);
+                break;
+            case "none":
+                this.chunk.emit(Op.IS_NONE, line);
+                break;
+            case "some":
+                this.chunk.emit(Op.IS_SOME, line);
+                break;
+            case "ok":
+                this.chunk.emit(Op.IS_OK, line);
+                break;
+            case "err":
+                this.chunk.emit(Op.IS_ERR, line);
+                break;
+            case "struct":
+                // 구조체 분해: 이름으로 타입 확인
+                this.chunk.emit(Op.POP, line); // 일단 subject 제거
+                this.chunk.emit(Op.PUSH_TRUE, line);
+                break;
+            case "array":
+                // 배열 분해: 배열 타입 확인
+                this.chunk.emit(Op.POP, line); // 일단 subject 제거
+                this.chunk.emit(Op.PUSH_TRUE, line);
+                break;
+            case "tuple":
+                // 튜플은 아직 미지원
+                this.chunk.emit(Op.POP, line);
+                this.chunk.emit(Op.PUSH_FALSE, line);
+                break;
+        }
+    }
+    compilePatternBind(pattern, line, subjectSlot) {
+        // 패턴에서 바인딩 변수 생성
+        switch (pattern.kind) {
+            case "ident": {
+                // pattern test 후 스택에 subject가 있음 — 직접 저장
+                const slot = this.declareLocal(pattern.name);
+                this.chunk.emit(Op.STORE_LOCAL, line);
+                this.chunk.emitI32(slot, line);
+                break;
+            }
+            case "struct": {
+                // 구조체 필드 분해 바인딩
+                // Point { x, y } 패턴에서 각 필드에 대해:
+                // LOAD_LOCAL(subjectSlot) → STRUCT_GET(field) → STORE_LOCAL(field_slot)
+                for (const field of pattern.fields) {
+                    // subject 로드
+                    this.chunk.emit(Op.LOAD_LOCAL, line);
+                    this.chunk.emitI32(subjectSlot, line);
+                    // 필드 접근
+                    this.chunk.emit(Op.STRUCT_GET, line);
+                    this.chunk.emitI32(this.chunk.addConstant(field.name), line);
+                    // 필드 패턴에 바인딩
+                    if (field.pattern.kind === "ident") {
+                        // 간단한 ident 바인딩
+                        const fieldSlot = this.declareLocal(field.pattern.name);
+                        this.chunk.emit(Op.STORE_LOCAL, line);
+                        this.chunk.emitI32(fieldSlot, line);
+                    }
+                    else {
+                        // 복잡한 패턴 (nested struct, array, etc)
+                        const fieldTempSlot = this.declareLocal(`__field_${field.name}__`);
+                        this.chunk.emit(Op.STORE_LOCAL, line);
+                        this.chunk.emitI32(fieldTempSlot, line);
+                        this.compilePatternBind(field.pattern, line, fieldTempSlot);
+                    }
+                }
+                break;
+            }
+            case "array": {
+                // 배열 요소 분해 바인딩
+                // [a, b, c] 패턴에서 각 요소에 대해:
+                // LOAD_LOCAL(subjectSlot) → PUSH_I32(index) → ARRAY_GET → STORE_LOCAL(elem_slot)
+                // [a, .., b] rest 패턴의 경우: 뒤쪽 요소는 배열 길이를 동적으로 계산해서 인덱싱
+                const restIndex = pattern.restIndex ?? pattern.elements.length;
+                const afterRestCount = pattern.elements.length - restIndex;
+                let arrayLenSlot = null;
+                // rest 패턴이 있고 뒤에 요소가 있으면 배열 길이를 미리 저장
+                if (pattern.rest && afterRestCount > 0) {
+                    this.chunk.emit(Op.LOAD_LOCAL, line);
+                    this.chunk.emitI32(subjectSlot, line);
+                    // length() 내장 함수 호출
+                    this.chunk.emit(Op.CALL_BUILTIN, line);
+                    this.chunk.emitI32(this.chunk.addConstant("length"), line);
+                    this.chunk.emitByte(1, line); // argCount = 1
+                    arrayLenSlot = this.declareLocal("__array_len__");
+                    this.chunk.emit(Op.STORE_LOCAL, line);
+                    this.chunk.emitI32(arrayLenSlot, line);
+                }
+                for (let i = 0; i < pattern.elements.length; i++) {
+                    const elem = pattern.elements[i];
+                    // 실제 배열 인덱스 결정
+                    const isAfterRest = i >= restIndex;
+                    // subject 로드
+                    this.chunk.emit(Op.LOAD_LOCAL, line);
+                    this.chunk.emitI32(subjectSlot, line);
+                    // 인덱스 계산 및 로드
+                    if (isAfterRest && arrayLenSlot !== null) {
+                        // rest 뒤: len - (afterRestCount - (i - restIndex))
+                        // [a, .., b, c], restIndex=1, len=5 → i=1: 5-(2-0)=3, i=2: 5-(2-1)=4
+                        const offsetFromEnd = afterRestCount - (i - restIndex);
+                        this.chunk.emit(Op.LOAD_LOCAL, line);
+                        this.chunk.emitI32(arrayLenSlot, line);
+                        this.chunk.emit(Op.PUSH_I32, line);
+                        this.chunk.emitI32(offsetFromEnd, line);
+                        this.chunk.emit(Op.SUB_I32, line);
+                    }
+                    else {
+                        // rest 앞: 순서대로 0, 1, 2, ...
+                        this.chunk.emit(Op.PUSH_I32, line);
+                        this.chunk.emitI32(i, line);
+                    }
+                    // 배열 요소 접근
+                    this.chunk.emit(Op.ARRAY_GET, line);
+                    // 요소 패턴에 바인딩
+                    if (elem.kind === "ident") {
+                        // 간단한 ident 바인딩
+                        const elemSlot = this.declareLocal(elem.name);
+                        this.chunk.emit(Op.STORE_LOCAL, line);
+                        this.chunk.emitI32(elemSlot, line);
+                    }
+                    else if (elem.kind === "wildcard") {
+                        // wildcard는 버림
+                        this.chunk.emit(Op.POP, line);
+                    }
+                    else {
+                        // 복잡한 패턴 (nested struct, array, etc)
+                        const elemTempSlot = this.declareLocal(`__elem_${i}__`);
+                        this.chunk.emit(Op.STORE_LOCAL, line);
+                        this.chunk.emitI32(elemTempSlot, line);
+                        this.compilePatternBind(elem, line, elemTempSlot);
+                    }
+                }
+                break;
+            }
+            case "some":
+            case "ok": {
+                // Option/Result의 inner 패턴 처리
+                if (pattern.inner && subjectSlot !== undefined) {
+                    // LOAD_LOCAL(subjectSlot) → UNWRAP → 임시 슬롯에 저장
+                    this.chunk.emit(Op.LOAD_LOCAL, line);
+                    this.chunk.emitI32(subjectSlot, line);
+                    this.chunk.emit(Op.UNWRAP, line);
+                    if (pattern.inner.kind === "ident") {
+                        const innerSlot = this.declareLocal(pattern.inner.name);
+                        this.chunk.emit(Op.STORE_LOCAL, line);
+                        this.chunk.emitI32(innerSlot, line);
+                    }
+                    else {
+                        const innerTempSlot = this.declareLocal(`__unwrapped__`);
+                        this.chunk.emit(Op.STORE_LOCAL, line);
+                        this.chunk.emitI32(innerTempSlot, line);
+                        this.compilePatternBind(pattern.inner, line, innerTempSlot);
+                    }
+                }
+                break;
+            }
+            case "err": {
+                // Err의 inner 패턴 처리 (same as Ok)
+                if (pattern.inner && subjectSlot !== undefined) {
+                    this.chunk.emit(Op.LOAD_LOCAL, line);
+                    this.chunk.emitI32(subjectSlot, line);
+                    this.chunk.emit(Op.UNWRAP, line);
+                    if (pattern.inner.kind === "ident") {
+                        const innerSlot = this.declareLocal(pattern.inner.name);
+                        this.chunk.emit(Op.STORE_LOCAL, line);
+                        this.chunk.emitI32(innerSlot, line);
+                    }
+                    else {
+                        const innerTempSlot = this.declareLocal(`__unwrapped__`);
+                        this.chunk.emit(Op.STORE_LOCAL, line);
+                        this.chunk.emitI32(innerTempSlot, line);
+                        this.compilePatternBind(pattern.inner, line, innerTempSlot);
+                    }
+                }
+                break;
+            }
+            case "wildcard":
+            case "literal":
+            case "none":
+            case "tuple":
+                // 이들은 바인딩이 필요 없음
+                break;
+        }
+    }
+    // ============================================================
+    // 스코프 관리
+    // ============================================================
+    beginScope() {
+        this.scopeDepth++;
+    }
+    endScope(line) {
+        while (this.locals.length > 0 && this.locals[this.locals.length - 1].depth === this.scopeDepth) {
+            this.locals.pop();
+            this.nextSlot--;
+        }
+        this.scopeDepth--;
+    }
+    declareLocal(name) {
+        const slot = this.nextSlot++;
+        this.locals.push({ name, slot, depth: this.scopeDepth });
+        return slot;
+    }
+    resolveLocal(name) {
+        for (let i = this.locals.length - 1; i >= 0; i--) {
+            if (this.locals[i].name === name)
+                return this.locals[i].slot;
+        }
+        return -1;
+    }
+}
+exports.Compiler = Compiler;
+//# sourceMappingURL=compiler.js.map