freelang-v4 4.3.0

package/dist/parser.js

@@ -0,0 +1,1060 @@
+"use strict";
+// FreeLang v4 — Parser (SPEC_05 구현)
+// RD(문) + Pratt(식) 하이브리드
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+const lexer_1 = require("./lexer");
+// ============================================================
+// Binding Power (SPEC_05 Q4)
+// ============================================================
+const BP_ASSIGN = 10;
+const BP_OR = 20;
+const BP_AND = 30;
+const BP_EQUALITY = 40;
+const BP_COMPARISON = 50;
+const BP_ADDITIVE = 60;
+const BP_MULTIPLICATIVE = 70;
+const BP_UNARY = 90;
+const BP_POSTFIX = 100;
+function infixBP(type) {
+    switch (type) {
+        // EQ는 Pratt에서 처리하지 않음 → ExprStmt에서 할당으로 처리
+        case lexer_1.TokenType.OR: return BP_OR;
+        case lexer_1.TokenType.AND: return BP_AND;
+        case lexer_1.TokenType.EQEQ:
+        case lexer_1.TokenType.NEQ: return BP_EQUALITY;
+        case lexer_1.TokenType.LT:
+        case lexer_1.TokenType.GT:
+        case lexer_1.TokenType.LTEQ:
+        case lexer_1.TokenType.GTEQ: return BP_COMPARISON;
+        case lexer_1.TokenType.PLUS:
+        case lexer_1.TokenType.MINUS: return BP_ADDITIVE;
+        case lexer_1.TokenType.STAR:
+        case lexer_1.TokenType.SLASH:
+        case lexer_1.TokenType.PERCENT: return BP_MULTIPLICATIVE;
+        case lexer_1.TokenType.LARROW: return BP_ASSIGN; // 채널 송신
+        case lexer_1.TokenType.LPAREN:
+        case lexer_1.TokenType.LBRACKET:
+        case lexer_1.TokenType.DOT:
+        case lexer_1.TokenType.QUESTION: return BP_POSTFIX;
+        default: return 0;
+    }
+}
+// ============================================================
+// Parser
+// ============================================================
+class Parser {
+    constructor(tokens) {
+        this.pos = 0;
+        this.errors = [];
+        this.tokens = tokens;
+    }
+    parse() {
+        const stmts = [];
+        while (!this.isAtEnd()) {
+            try {
+                stmts.push(this.parseStmt());
+            }
+            catch (e) {
+                // 에러 복구: 다음 문 시작까지 건너뜀
+                this.synchronize();
+            }
+        }
+        return { program: { stmts }, errors: this.errors };
+    }
+    // ============================================================
+    // 문 파싱 — Recursive Descent (SPEC_05 Q1)
+    // ============================================================
+    parseStmt() {
+        const tok = this.peek();
+        switch (tok.type) {
+            case lexer_1.TokenType.IMPORT:
+                return this.parseImportStmt();
+            case lexer_1.TokenType.EXPORT:
+                return this.parseExportStmt();
+            case lexer_1.TokenType.VAR:
+            case lexer_1.TokenType.LET:
+            case lexer_1.TokenType.CONST:
+                return this.parseVarDecl();
+            case lexer_1.TokenType.ASYNC:
+            case lexer_1.TokenType.FN:
+                return this.parseFnDecl();
+            case lexer_1.TokenType.STRUCT:
+                return this.parseStructDecl();
+            case lexer_1.TokenType.TRAIT:
+                return this.parseTraitDecl();
+            case lexer_1.TokenType.IMPL:
+                return this.parseImplDecl();
+            case lexer_1.TokenType.IF:
+                return this.parseIfStmt();
+            case lexer_1.TokenType.MATCH:
+                return this.parseMatchStmt();
+            case lexer_1.TokenType.FOR:
+                return this.parseForStmt();
+            case lexer_1.TokenType.WHILE:
+                return this.parseWhileStmt();
+            case lexer_1.TokenType.BREAK:
+                return this.parseBreakStmt();
+            case lexer_1.TokenType.CONTINUE:
+                return this.parseContinueStmt();
+            case lexer_1.TokenType.SPAWN:
+                return this.parseSpawnStmt();
+            case lexer_1.TokenType.RETURN:
+                return this.parseReturnStmt();
+            default:
+                return this.parseExprStmt();
+        }
+    }
+    // var/let/const 선언
+    parseVarDecl() {
+        const kw = this.advance(); // var/let/const
+        const mutable = kw.type === lexer_1.TokenType.VAR;
+        const name = this.expectIdent("variable name");
+        let type = null;
+        if (this.check(lexer_1.TokenType.COLON)) {
+            this.advance(); // :
+            type = this.parseType();
+        }
+        this.expect(lexer_1.TokenType.EQ, "expected '=' in variable declaration");
+        const init = this.parseExpr(0);
+        this.match(lexer_1.TokenType.SEMICOLON); // optional semicolon
+        return { kind: "var_decl", name, mutable, type, init, line: kw.line, col: kw.col };
+    }
+    // fn 선언 (async fn 지원)
+    parseFnDecl() {
+        let isAsync = false;
+        let kw = this.peek();
+        // async 키워드 확인
+        if (this.match(lexer_1.TokenType.ASYNC)) {
+            isAsync = true;
+        }
+        kw = this.advance(); // fn
+        const name = this.expectIdent("function name");
+        // Generic 타입 파라미터: fn foo<T, K>(...) [STEP B-1]
+        const typeParams = [];
+        if (this.match(lexer_1.TokenType.LT)) {
+            do {
+                typeParams.push(this.expectIdent("type parameter"));
+            } while (this.match(lexer_1.TokenType.COMMA));
+            this.expect(lexer_1.TokenType.GT, "expected '>' after type parameters");
+        }
+        this.expect(lexer_1.TokenType.LPAREN, "expected '(' after function name");
+        const params = [];
+        if (!this.check(lexer_1.TokenType.RPAREN)) {
+            do {
+                const pName = this.expectIdent("parameter name");
+                this.expect(lexer_1.TokenType.COLON, "expected ':' after parameter name");
+                const pType = this.parseType();
+                params.push({ name: pName, type: pType });
+            } while (this.match(lexer_1.TokenType.COMMA));
+        }
+        this.expect(lexer_1.TokenType.RPAREN, "expected ')' after parameters");
+        // 반환 타입 (필수 — SPEC_06: 함수 시그니처 명시)
+        this.expect(lexer_1.TokenType.RARROW, "expected '->' for return type");
+        const returnType = this.parseType();
+        this.expect(lexer_1.TokenType.LBRACE, "expected '{' for function body");
+        const body = this.parseBlock();
+        return { kind: "fn_decl", name, isAsync, typeParams, params, returnType, body, line: kw.line, col: kw.col };
+    }
+    // struct 선언
+    parseStructDecl() {
+        const kw = this.advance(); // struct
+        const name = this.expectIdent("struct name");
+        // Generic 타입 파라미터: struct Box<T> [STEP B-2]
+        const typeParams = [];
+        if (this.match(lexer_1.TokenType.LT)) {
+            do {
+                typeParams.push(this.expectIdent("type parameter"));
+            } while (this.match(lexer_1.TokenType.COMMA));
+            this.expect(lexer_1.TokenType.GT, "expected '>' after type parameters");
+        }
+        this.expect(lexer_1.TokenType.LBRACE, "expected '{' after struct name");
+        const fields = [];
+        if (!this.check(lexer_1.TokenType.RBRACE)) {
+            do {
+                if (this.check(lexer_1.TokenType.RBRACE))
+                    break; // Allow trailing comma
+                const fieldName = this.expectIdent("field name");
+                this.expect(lexer_1.TokenType.COLON, "expected ':' after field name");
+                const fieldType = this.parseType();
+                fields.push({ name: fieldName, type: fieldType });
+            } while (this.match(lexer_1.TokenType.COMMA));
+        }
+        this.expect(lexer_1.TokenType.RBRACE, "expected '}' to close struct");
+        return { kind: "struct_decl", name, typeParams, fields, line: kw.line, col: kw.col };
+    }
+    // trait 선언
+    parseTraitDecl() {
+        const kw = this.advance(); // trait
+        const name = this.expectIdent("trait name");
+        // Generic 타입 파라미터
+        const typeParams = [];
+        if (this.match(lexer_1.TokenType.LT)) {
+            do {
+                typeParams.push(this.expectIdent("type parameter"));
+            } while (this.match(lexer_1.TokenType.COMMA));
+            this.expect(lexer_1.TokenType.GT, "expected '>' after type parameters");
+        }
+        this.expect(lexer_1.TokenType.LBRACE, "expected '{' after trait name");
+        const methods = [];
+        if (!this.check(lexer_1.TokenType.RBRACE)) {
+            while (!this.check(lexer_1.TokenType.RBRACE) && !this.isAtEnd()) {
+                const mLine = this.peek().line;
+                const mCol = this.peek().col;
+                this.expect(lexer_1.TokenType.FN, "expected 'fn' in trait method");
+                const methodName = this.expectIdent("method name");
+                this.expect(lexer_1.TokenType.LPAREN, "expected '(' after method name");
+                const params = [];
+                if (!this.check(lexer_1.TokenType.RPAREN)) {
+                    do {
+                        const pName = this.expectIdent("parameter name");
+                        // self는 타입 명시 없음
+                        if (pName === "self") {
+                            if (this.check(lexer_1.TokenType.COMMA)) {
+                                this.advance(); // consume comma
+                                params.push({ name: pName, type: { kind: "self_type" } });
+                                continue;
+                            }
+                            else if (this.check(lexer_1.TokenType.RPAREN)) {
+                                params.push({ name: pName, type: { kind: "self_type" } });
+                                break;
+                            }
+                        }
+                        // 일반 파라미터
+                        this.expect(lexer_1.TokenType.COLON, "expected ':' after parameter name");
+                        const pType = this.parseType();
+                        params.push({ name: pName, type: pType });
+                    } while (this.match(lexer_1.TokenType.COMMA));
+                }
+                this.expect(lexer_1.TokenType.RPAREN, "expected ')' after method parameters");
+                this.expect(lexer_1.TokenType.RARROW, "expected '->' for return type");
+                const returnType = this.parseType();
+                this.match(lexer_1.TokenType.SEMICOLON);
+                methods.push({ name: methodName, params, returnType, line: mLine, col: mCol });
+            }
+        }
+        this.expect(lexer_1.TokenType.RBRACE, "expected '}' to close trait");
+        return { kind: "trait_decl", name, typeParams, methods, line: kw.line, col: kw.col };
+    }
+    // impl 선언
+    parseImplDecl() {
+        const kw = this.advance(); // impl
+        // Generic 타입 파라미터
+        const typeParams = [];
+        if (this.match(lexer_1.TokenType.LT)) {
+            do {
+                typeParams.push(this.expectIdent("type parameter"));
+            } while (this.match(lexer_1.TokenType.COMMA));
+            this.expect(lexer_1.TokenType.GT, "expected '>' after type parameters");
+        }
+        // Trait name: impl [Drawable] for Circle
+        let trait = null;
+        let forType;
+        // Check if it's "impl Trait for Type" or just "impl Type"
+        const savedPos = this.pos;
+        if (this.peek().type === lexer_1.TokenType.IDENT) {
+            const firstIdent = this.peek().lexeme;
+            this.advance(); // consume identifier
+            if (this.match(lexer_1.TokenType.FOR)) {
+                // It was "impl Trait for Type"
+                trait = firstIdent;
+                forType = this.parseType();
+            }
+            else {
+                // It was "impl Type" (inherent impl) — reset and parse as type
+                this.pos = savedPos;
+                forType = this.parseType();
+            }
+        }
+        else {
+            forType = this.parseType();
+        }
+        this.expect(lexer_1.TokenType.LBRACE, "expected '{' for impl body");
+        const methods = [];
+        if (!this.check(lexer_1.TokenType.RBRACE)) {
+            while (!this.check(lexer_1.TokenType.RBRACE) && !this.isAtEnd()) {
+                const mLine = this.peek().line;
+                const mCol = this.peek().col;
+                this.expect(lexer_1.TokenType.FN, "expected 'fn' in impl method");
+                const methodName = this.expectIdent("method name");
+                this.expect(lexer_1.TokenType.LPAREN, "expected '(' after method name");
+                const params = [];
+                if (!this.check(lexer_1.TokenType.RPAREN)) {
+                    do {
+                        const pName = this.expectIdent("parameter name");
+                        // self는 타입 명시 없음
+                        if (pName === "self") {
+                            if (this.check(lexer_1.TokenType.COMMA)) {
+                                this.advance(); // consume comma
+                                params.push({ name: pName, type: { kind: "self_type" } });
+                                continue;
+                            }
+                            else if (this.check(lexer_1.TokenType.RPAREN)) {
+                                params.push({ name: pName, type: { kind: "self_type" } });
+                                break;
+                            }
+                        }
+                        // 일반 파라미터
+                        this.expect(lexer_1.TokenType.COLON, "expected ':' after parameter name");
+                        const pType = this.parseType();
+                        params.push({ name: pName, type: pType });
+                    } while (this.match(lexer_1.TokenType.COMMA));
+                }
+                this.expect(lexer_1.TokenType.RPAREN, "expected ')' after method parameters");
+                this.expect(lexer_1.TokenType.RARROW, "expected '->' for return type");
+                const returnType = this.parseType();
+                this.expect(lexer_1.TokenType.LBRACE, "expected '{' for method body");
+                const body = this.parseBlock();
+                methods.push({ name: methodName, params, returnType, body, line: mLine, col: mCol });
+            }
+        }
+        this.expect(lexer_1.TokenType.RBRACE, "expected '}' to close impl");
+        return { kind: "impl_decl", trait, forType, typeParams, methods, line: kw.line, col: kw.col };
+    }
+    // if 문 (문 위치)
+    parseIfStmt() {
+        const kw = this.advance(); // if
+        const condition = this.parseExpr(0);
+        this.expect(lexer_1.TokenType.LBRACE, "expected '{' after if condition");
+        const then = this.parseBlock();
+        let else_ = null;
+        if (this.match(lexer_1.TokenType.ELSE)) {
+            if (this.check(lexer_1.TokenType.IF)) {
+                // else if 체인
+                else_ = [this.parseIfStmt()];
+            }
+            else {
+                this.expect(lexer_1.TokenType.LBRACE, "expected '{' after else");
+                else_ = this.parseBlock();
+            }
+        }
+        return { kind: "if_stmt", condition, then, else_, line: kw.line, col: kw.col };
+    }
+    // match 문
+    parseMatchStmt() {
+        const kw = this.advance(); // match
+        const subject = this.parseExpr(0);
+        this.expect(lexer_1.TokenType.LBRACE, "expected '{' after match expression");
+        const arms = this.parseMatchArms();
+        this.expect(lexer_1.TokenType.RBRACE, "expected '}' to close match");
+        return { kind: "match_stmt", subject, arms, line: kw.line, col: kw.col };
+    }
+    // for 문
+    parseForStmt() {
+        const kw = this.advance(); // for
+        const variable = this.expectIdent("loop variable");
+        // for...in or for...of
+        const loopType = this.peek().type;
+        if (loopType === lexer_1.TokenType.IN) {
+            this.advance(); // in
+            const iterable = this.parseExpr(0);
+            this.expect(lexer_1.TokenType.LBRACE, "expected '{' after for...in");
+            const body = this.parseBlock();
+            return { kind: "for_stmt", variable, iterable, body, line: kw.line, col: kw.col };
+        }
+        else if (loopType === lexer_1.TokenType.OF) {
+            this.advance(); // of
+            const iterable = this.parseExpr(0);
+            this.expect(lexer_1.TokenType.LBRACE, "expected '{' after for...of");
+            const body = this.parseBlock();
+            return { kind: "for_of_stmt", variable, iterable, body, line: kw.line, col: kw.col };
+        }
+        else {
+            this.error("expected 'in' or 'of' after loop variable", this.peek());
+            return { kind: "for_stmt", variable, iterable: { kind: "ident", name: "", line: kw.line, col: kw.col }, body: [], line: kw.line, col: kw.col };
+        }
+    }
+    // while 문
+    parseWhileStmt() {
+        const kw = this.advance(); // while
+        const condition = this.parseExpr(0);
+        this.expect(lexer_1.TokenType.LBRACE, "expected '{' after while condition");
+        const body = this.parseBlock();
+        return { kind: "while_stmt", condition, body, line: kw.line, col: kw.col };
+    }
+    // break 문
+    parseBreakStmt() {
+        const kw = this.advance(); // break
+        this.match(lexer_1.TokenType.SEMICOLON); // optional semicolon
+        return { kind: "break_stmt", line: kw.line, col: kw.col };
+    }
+    // continue 문
+    parseContinueStmt() {
+        const kw = this.advance(); // continue
+        this.match(lexer_1.TokenType.SEMICOLON); // optional semicolon
+        return { kind: "continue_stmt", line: kw.line, col: kw.col };
+    }
+    // spawn 문
+    parseSpawnStmt() {
+        const kw = this.advance(); // spawn
+        this.expect(lexer_1.TokenType.LBRACE, "expected '{' after spawn");
+        const body = this.parseBlock();
+        return { kind: "spawn_stmt", body, line: kw.line, col: kw.col };
+    }
+    // import 문 파싱
+    parseImportStmt() {
+        const kw = this.advance(); // import
+        const items = [];
+        let default_ = false;
+        if (this.check(lexer_1.TokenType.LBRACE)) {
+            this.advance(); // {
+            if (!this.check(lexer_1.TokenType.RBRACE)) {
+                do {
+                    const name = this.expectIdent("imported name");
+                    let alias;
+                    if (this.match(lexer_1.TokenType.AS)) {
+                        alias = this.expectIdent("alias");
+                    }
+                    items.push({ name, alias });
+                } while (this.match(lexer_1.TokenType.COMMA));
+            }
+            this.expect(lexer_1.TokenType.RBRACE, "expected '}' after import items");
+        }
+        else {
+            const name = this.expectIdent("module name");
+            items.push({ name });
+            default_ = true;
+        }
+        this.expect(lexer_1.TokenType.FROM, "expected 'from' in import statement");
+        const sourceToken = this.peek();
+        if (sourceToken.type !== lexer_1.TokenType.STRING_LIT) {
+            this.error("expected string literal for module source", sourceToken);
+            throw new Error("expected module path");
+        }
+        const source = this.advance().lexeme;
+        this.match(lexer_1.TokenType.SEMICOLON);
+        return { kind: "import_decl", source, items, default: default_, line: kw.line, col: kw.col };
+    }
+    // export 문 파싱
+    parseExportStmt() {
+        const kw = this.advance(); // export
+        if (this.check(lexer_1.TokenType.FN) || this.check(lexer_1.TokenType.STRUCT)) {
+            const target = this.parseStmt();
+            return { kind: "export_decl", target, line: kw.line, col: kw.col };
+        }
+        if (this.check(lexer_1.TokenType.LBRACE)) {
+            this.advance(); // {
+            const names = [];
+            if (!this.check(lexer_1.TokenType.RBRACE)) {
+                do {
+                    names.push(this.expectIdent("export name"));
+                } while (this.match(lexer_1.TokenType.COMMA));
+            }
+            this.expect(lexer_1.TokenType.RBRACE, "expected '}' after export names");
+            this.match(lexer_1.TokenType.SEMICOLON);
+            return { kind: "export_decl", target: names, line: kw.line, col: kw.col };
+        }
+        this.error("expected 'fn', 'struct', or '{' after 'export'", kw);
+        throw new Error("invalid export syntax");
+    }
+    // return 문
+    parseReturnStmt() {
+        const kw = this.advance(); // return
+        // return 뒤에 식이 있는지 확인
+        let value = null;
+        if (!this.check(lexer_1.TokenType.RBRACE) && !this.isAtEnd() && !this.isStmtStart()) {
+            value = this.parseExpr(0);
+        }
+        this.match(lexer_1.TokenType.SEMICOLON); // optional semicolon
+        return { kind: "return_stmt", value, line: kw.line, col: kw.col };
+    }
+    // 식 문 (ExprStmt)
+    parseExprStmt() {
+        const tok = this.peek();
+        const expr = this.parseExpr(0);
+        // 할당 처리: expr = value
+        if (this.check(lexer_1.TokenType.EQ)) {
+            const eq = this.advance();
+            const value = this.parseExpr(0);
+            this.match(lexer_1.TokenType.SEMICOLON); // optional semicolon
+            return {
+                kind: "expr_stmt",
+                expr: { kind: "assign", target: expr, value, line: eq.line, col: eq.col },
+                line: tok.line,
+                col: tok.col,
+            };
+        }
+        this.match(lexer_1.TokenType.SEMICOLON); // optional semicolon
+        return { kind: "expr_stmt", expr, line: tok.line, col: tok.col };
+    }
+    // ============================================================
+    // 블록 파싱 ({ 이미 소비됨, } 소비함 )
+    // ============================================================
+    parseBlock() {
+        const stmts = [];
+        while (!this.check(lexer_1.TokenType.RBRACE) && !this.isAtEnd()) {
+            try {
+                stmts.push(this.parseStmt());
+            }
+            catch {
+                this.synchronize();
+            }
+        }
+        this.expect(lexer_1.TokenType.RBRACE, "expected '}'");
+        return stmts;
+    }
+    // ============================================================
+    // 식 파싱 — Pratt Parser (SPEC_05 Q3, Q4)
+    // ============================================================
+    parseExpr(minBP) {
+        let left = this.nud();
+        while (!this.isAtEnd()) {
+            const tok = this.peek();
+            // 구조체 리터럴: ident { field: value, ... }
+            // Lookahead: { 다음이 ident: 패턴인지 확인 (while/if 블록과 구분)
+            if (tok.type === lexer_1.TokenType.LBRACE && left.kind === "ident") {
+                // Lookahead: 다음 토큰이 ident이고, 그 다음이 :인지 확인
+                if (this.pos + 1 < this.tokens.length &&
+                    this.tokens[this.pos + 1].type === lexer_1.TokenType.IDENT &&
+                    this.pos + 2 < this.tokens.length &&
+                    this.tokens[this.pos + 2].type === lexer_1.TokenType.COLON) {
+                    this.advance(); // {
+                    const fields = [];
+                    if (!this.check(lexer_1.TokenType.RBRACE)) {
+                        do {
+                            const name = this.expectIdent("field name");
+                            this.expect(lexer_1.TokenType.COLON, "expected ':' after field name");
+                            const value = this.parseExpr(0);
+                            fields.push({ name, value });
+                        } while (this.match(lexer_1.TokenType.COMMA));
+                    }
+                    this.expect(lexer_1.TokenType.RBRACE, "expected '}'");
+                    left = { kind: "struct_lit", structName: left.name, fields, line: left.line, col: left.col };
+                    continue;
+                }
+            }
+            const bp = infixBP(tok.type);
+            if (bp <= minBP)
+                break;
+            left = this.led(left, bp);
+        }
+        return left;
+    }
+    // nud — prefix 위치
+    nud() {
+        const tok = this.peek();
+        // 정수 리터럴
+        if (tok.type === lexer_1.TokenType.INT_LIT) {
+            this.advance();
+            const raw = tok.lexeme.replace(/_/g, "");
+            return { kind: "int_lit", value: parseInt(raw, 10), line: tok.line, col: tok.col };
+        }
+        // 부동소수점 리터럴
+        if (tok.type === lexer_1.TokenType.FLOAT_LIT) {
+            this.advance();
+            const raw = tok.lexeme.replace(/_/g, "");
+            return { kind: "float_lit", value: parseFloat(raw), line: tok.line, col: tok.col };
+        }
+        // 문자열 리터럴
+        if (tok.type === lexer_1.TokenType.STRING_LIT) {
+            this.advance();
+            return { kind: "string_lit", value: tok.lexeme, line: tok.line, col: tok.col };
+        }
+        // 불리언 리터럴
+        if (tok.type === lexer_1.TokenType.TRUE) {
+            this.advance();
+            return { kind: "bool_lit", value: true, line: tok.line, col: tok.col };
+        }
+        if (tok.type === lexer_1.TokenType.FALSE) {
+            this.advance();
+            return { kind: "bool_lit", value: false, line: tok.line, col: tok.col };
+        }
+        // 식별자 또는 channel<T>
+        if (tok.type === lexer_1.TokenType.IDENT || tok.type === lexer_1.TokenType.TYPE_CHANNEL) {
+            const identTok = this.advance();
+            const name = identTok.lexeme;
+            // channel<T> 특별 처리
+            if (name === "channel" && this.check(lexer_1.TokenType.LT)) {
+                this.advance(); // <
+                const element = this.parseType();
+                this.expect(lexer_1.TokenType.GT, "expected '>' after channel type");
+                this.expect(lexer_1.TokenType.LPAREN, "expected '()' after channel<T>");
+                this.expect(lexer_1.TokenType.RPAREN, "expected ')'");
+                return { kind: "chan_new", element, line: identTok.line, col: identTok.col };
+            }
+            return { kind: "ident", name, line: identTok.line, col: identTok.col };
+        }
+        // 단항 연산자: - !
+        if (tok.type === lexer_1.TokenType.MINUS || tok.type === lexer_1.TokenType.NOT) {
+            this.advance();
+            const operand = this.parseExpr(BP_UNARY);
+            return { kind: "unary", op: tok.lexeme, operand, line: tok.line, col: tok.col };
+        }
+        // await 연산자
+        if (tok.type === lexer_1.TokenType.AWAIT) {
+            this.advance();
+            const expr = this.parseExpr(BP_UNARY);
+            return { kind: "await", expr, line: tok.line, col: tok.col };
+        }
+        // 괄호 그룹: ( expr )
+        if (tok.type === lexer_1.TokenType.LPAREN) {
+            this.advance();
+            const expr = this.parseExpr(0);
+            this.expect(lexer_1.TokenType.RPAREN, "expected ')'");
+            return expr;
+        }
+        // 배열 리터럴: [ elem, ... ]
+        if (tok.type === lexer_1.TokenType.LBRACKET) {
+            return this.parseArrayLit();
+        }
+        // if 식 (식 위치)
+        if (tok.type === lexer_1.TokenType.IF) {
+            return this.parseIfExpr();
+        }
+        // match 식 (식 위치)
+        if (tok.type === lexer_1.TokenType.MATCH) {
+            return this.parseMatchExpr();
+        }
+        // 함수 리터럴 (람다): fn(x: i32) -> i32 { x + 1 }
+        if (tok.type === lexer_1.TokenType.FN) {
+            return this.parseFnLit();
+        }
+        // 채널 수신: <- chan
+        if (tok.type === lexer_1.TokenType.LARROW) {
+            this.advance();
+            const chan = this.parseExpr(BP_UNARY);
+            return { kind: "chan_recv", chan, line: tok.line, col: tok.col };
+        }
+        this.error(`unexpected token: ${tok.lexeme}`, tok);
+        this.advance();
+        return { kind: "ident", name: "__error__", line: tok.line, col: tok.col };
+    }
+    // led — infix/postfix 위치
+    led(left, bp) {
+        const tok = this.peek();
+        // 함수 호출: expr(args) 형태만 지원 (generic call은 제한)
+        // 제네릭 호출은 <T> 타입 인자를 파싱하기 위해 복잡한 lookahead가 필요하므로,
+        // 여기서는 skip하고 나중에 추가 개선
+        // 이항 연산자
+        if (tok.type === lexer_1.TokenType.PLUS || tok.type === lexer_1.TokenType.MINUS ||
+            tok.type === lexer_1.TokenType.STAR || tok.type === lexer_1.TokenType.SLASH ||
+            tok.type === lexer_1.TokenType.PERCENT ||
+            tok.type === lexer_1.TokenType.EQEQ || tok.type === lexer_1.TokenType.NEQ ||
+            tok.type === lexer_1.TokenType.LT || tok.type === lexer_1.TokenType.GT ||
+            tok.type === lexer_1.TokenType.LTEQ || tok.type === lexer_1.TokenType.GTEQ ||
+            tok.type === lexer_1.TokenType.AND || tok.type === lexer_1.TokenType.OR) {
+            this.advance();
+            const right = this.parseExpr(bp); // left-associative
+            return { kind: "binary", op: tok.lexeme, left, right, line: tok.line, col: tok.col };
+        }
+        if (tok.type === lexer_1.TokenType.LPAREN) {
+            this.advance();
+            const args = [];
+            if (!this.check(lexer_1.TokenType.RPAREN)) {
+                do {
+                    args.push(this.parseExpr(0));
+                } while (this.match(lexer_1.TokenType.COMMA));
+            }
+            this.expect(lexer_1.TokenType.RPAREN, "expected ')' after arguments");
+            return { kind: "call", callee: left, args, line: tok.line, col: tok.col };
+        }
+        // 인덱스: expr[index]
+        if (tok.type === lexer_1.TokenType.LBRACKET) {
+            this.advance();
+            const index = this.parseExpr(0);
+            this.expect(lexer_1.TokenType.RBRACKET, "expected ']'");
+            return { kind: "index", object: left, index, line: tok.line, col: tok.col };
+        }
+        // 필드 접근: expr.field
+        if (tok.type === lexer_1.TokenType.DOT) {
+            this.advance();
+            const field = this.expectIdent("field name");
+            return { kind: "field_access", object: left, field, line: tok.line, col: tok.col };
+        }
+        // try 연산자: expr?
+        if (tok.type === lexer_1.TokenType.QUESTION) {
+            this.advance();
+            return { kind: "try", operand: left, line: tok.line, col: tok.col };
+        }
+        // 채널 송신: chan <- value
+        if (tok.type === lexer_1.TokenType.LARROW) {
+            this.advance();
+            const value = this.parseExpr(BP_ASSIGN);
+            return { kind: "chan_send", chan: left, value, line: tok.line, col: tok.col };
+        }
+        // 할당은 ExprStmt에서 처리하므로 여기선 패스
+        // EQ가 여기 오면 식 끝으로 처리
+        this.error(`unexpected operator: ${tok.lexeme}`, tok);
+        this.advance();
+        return left;
+    }
+    // ============================================================
+    // 복합 식 파싱
+    // ============================================================
+    // 배열 리터럴: [a, b, c]
+    parseArrayLit() {
+        const tok = this.advance(); // [
+        const elements = [];
+        if (!this.check(lexer_1.TokenType.RBRACKET)) {
+            do {
+                elements.push(this.parseExpr(0));
+            } while (this.match(lexer_1.TokenType.COMMA));
+        }
+        this.expect(lexer_1.TokenType.RBRACKET, "expected ']'");
+        return { kind: "array_lit", elements, line: tok.line, col: tok.col };
+    }
+    // 구조체 리터럴: { name: expr, ... }
+    // if 식 (식 위치, else 필수 — SPEC_06)
+    parseIfExpr() {
+        const tok = this.advance(); // if
+        const condition = this.parseExpr(0);
+        this.expect(lexer_1.TokenType.LBRACE, "expected '{' after if condition");
+        const then = this.parseBlockExprs();
+        this.expect(lexer_1.TokenType.ELSE, "if expression requires else branch");
+        this.expect(lexer_1.TokenType.LBRACE, "expected '{' after else");
+        const else_ = this.parseBlockExprs();
+        return { kind: "if_expr", condition, then, else_, line: tok.line, col: tok.col };
+    }
+    // match 식 (식 위치)
+    parseMatchExpr() {
+        const tok = this.advance(); // match
+        const subject = this.parseExpr(0);
+        this.expect(lexer_1.TokenType.LBRACE, "expected '{' after match expression");
+        const arms = this.parseMatchArms();
+        this.expect(lexer_1.TokenType.RBRACE, "expected '}' to close match");
+        return { kind: "match_expr", subject, arms, line: tok.line, col: tok.col };
+    }
+    // 블록 내 식 목록 (if/match 식의 body) → } 소비
+    parseBlockExprs() {
+        const exprs = [];
+        while (!this.check(lexer_1.TokenType.RBRACE) && !this.isAtEnd()) {
+            exprs.push(this.parseExpr(0));
+        }
+        this.expect(lexer_1.TokenType.RBRACE, "expected '}'");
+        return exprs;
+    }
+    // ============================================================
+    // match arms
+    // ============================================================
+    parseMatchArms() {
+        const arms = [];
+        while (!this.check(lexer_1.TokenType.RBRACE) && !this.isAtEnd()) {
+            const pattern = this.parsePattern();
+            // Guard 절 파싱: if 조건
+            let guard = undefined;
+            if (this.match(lexer_1.TokenType.IF)) {
+                guard = this.parseExpr(0);
+            }
+            this.expect(lexer_1.TokenType.ARROW, "expected '=>' after pattern");
+            let body;
+            if (this.check(lexer_1.TokenType.LBRACE)) {
+                // 블록 body
+                const bTok = this.advance(); // {
+                const stmts = [];
+                while (!this.check(lexer_1.TokenType.RBRACE) && !this.isAtEnd()) {
+                    stmts.push(this.parseStmt());
+                }
+                this.expect(lexer_1.TokenType.RBRACE, "expected '}'");
+                // 블록의 마지막 문이 ExprStmt면 그 식이 반환값
+                const lastExpr = stmts.length > 0 && stmts[stmts.length - 1].kind === "expr_stmt"
+                    ? stmts[stmts.length - 1].expr
+                    : null;
+                body = { kind: "block_expr", stmts: stmts.slice(0, lastExpr ? -1 : stmts.length), expr: lastExpr, line: bTok.line, col: bTok.col };
+            }
+            else {
+                body = this.parseExpr(0);
+            }
+            this.match(lexer_1.TokenType.COMMA); // trailing comma optional
+            arms.push({ pattern, guard, body });
+        }
+        return arms;
+    }
+    // 함수 리터럴: fn(x: i32, y: i32) -> i32 { x + y }
+    parseFnLit() {
+        const kw = this.advance(); // fn
+        this.expect(lexer_1.TokenType.LPAREN, "expected '(' after fn");
+        const params = [];
+        if (!this.check(lexer_1.TokenType.RPAREN)) {
+            do {
+                const name = this.expectIdent("parameter name");
+                let type = undefined;
+                if (this.match(lexer_1.TokenType.COLON)) {
+                    type = this.parseType();
+                }
+                params.push({ name, type });
+            } while (this.match(lexer_1.TokenType.COMMA));
+        }
+        this.expect(lexer_1.TokenType.RPAREN, "expected ')' after parameters");
+        let returnType = undefined;
+        if (this.match(lexer_1.TokenType.RARROW)) {
+            returnType = this.parseType();
+        }
+        // body
+        let body;
+        if (this.check(lexer_1.TokenType.LBRACE)) {
+            const bTok = this.advance(); // {
+            const stmts = [];
+            while (!this.check(lexer_1.TokenType.RBRACE) && !this.isAtEnd()) {
+                stmts.push(this.parseStmt());
+            }
+            this.expect(lexer_1.TokenType.RBRACE, "expected '}'");
+            const lastExpr = stmts.length > 0 && stmts[stmts.length - 1].kind === "expr_stmt"
+                ? stmts[stmts.length - 1].expr
+                : null;
+            body = { kind: "block_expr", stmts: stmts.slice(0, lastExpr ? -1 : stmts.length), expr: lastExpr, line: bTok.line, col: bTok.col };
+        }
+        else {
+            body = this.parseExpr(0);
+        }
+        return { kind: "fn_lit", params, returnType, body, line: kw.line, col: kw.col };
+    }
+    // ============================================================
+    // 패턴 파싱 (SPEC_05 Q8)
+    // ============================================================
+    parsePattern() {
+        const tok = this.peek();
+        // _ (wildcard)
+        if (tok.type === lexer_1.TokenType.IDENT && tok.lexeme === "_") {
+            this.advance();
+            return { kind: "wildcard" };
+        }
+        // Ok(p), Err(p), Some(p), None
+        if (tok.type === lexer_1.TokenType.IDENT) {
+            if (tok.lexeme === "Ok" || tok.lexeme === "Err" || tok.lexeme === "Some") {
+                this.advance();
+                this.expect(lexer_1.TokenType.LPAREN, `expected '(' after ${tok.lexeme}`);
+                const inner = this.parsePattern();
+                this.expect(lexer_1.TokenType.RPAREN, "expected ')'");
+                if (tok.lexeme === "Ok")
+                    return { kind: "ok", inner };
+                if (tok.lexeme === "Err")
+                    return { kind: "err", inner };
+                return { kind: "some", inner };
+            }
+            if (tok.lexeme === "None") {
+                this.advance();
+                return { kind: "none" };
+            }
+            // 구조 분해: Point { x, y }, Point { x as px, y as py }, Point { name, .. }
+            const ident = tok.lexeme;
+            this.advance();
+            if (this.check(lexer_1.TokenType.LBRACE)) {
+                this.advance(); // {
+                const fields = [];
+                let rest = false;
+                // 구조체 필드 파싱 (빈 중괄호도 허용)
+                if (!this.check(lexer_1.TokenType.RBRACE)) {
+                    while (!this.check(lexer_1.TokenType.RBRACE) && !this.isAtEnd()) {
+                        if (this.match(lexer_1.TokenType.DOTDOT)) {
+                            rest = true;
+                            break;
+                        }
+                        const fieldName = this.expectIdent("field name");
+                        let fieldPattern;
+                        let alias = undefined;
+                        if (this.match(lexer_1.TokenType.AS)) {
+                            alias = this.expectIdent("alias name");
+                            fieldPattern = { kind: "ident", name: alias };
+                        }
+                        else {
+                            fieldPattern = { kind: "ident", name: fieldName };
+                        }
+                        fields.push({ name: fieldName, pattern: fieldPattern, alias });
+                        if (!this.match(lexer_1.TokenType.COMMA))
+                            break;
+                    }
+                }
+                this.expect(lexer_1.TokenType.RBRACE, "expected '}'");
+                return { kind: "struct", name: ident, fields, rest };
+            }
+            // 일반 식별자 바인딩
+            return { kind: "ident", name: ident };
+        }
+        // 배열 분해: [a, b, c], [x, .., y]
+        if (tok.type === lexer_1.TokenType.LBRACKET) {
+            this.advance(); // [
+            const elements = [];
+            let rest = false;
+            let restIndex = undefined;
+            while (!this.check(lexer_1.TokenType.RBRACKET) && !this.isAtEnd()) {
+                if (this.check(lexer_1.TokenType.DOTDOT)) {
+                    this.advance(); // ..
+                    rest = true;
+                    restIndex = elements.length;
+                    if (this.match(lexer_1.TokenType.COMMA)) {
+                        // [x, .., y] 형태: 나머지 후 계속
+                        while (!this.check(lexer_1.TokenType.RBRACKET) && !this.isAtEnd()) {
+                            elements.push(this.parsePattern());
+                            if (!this.match(lexer_1.TokenType.COMMA))
+                                break;
+                        }
+                    }
+                    break;
+                }
+                elements.push(this.parsePattern());
+                if (!this.match(lexer_1.TokenType.COMMA))
+                    break;
+            }
+            this.expect(lexer_1.TokenType.RBRACKET, "expected ']'");
+            return { kind: "array", elements, rest, restIndex };
+        }
+        // 리터럴 패턴
+        if (tok.type === lexer_1.TokenType.INT_LIT || tok.type === lexer_1.TokenType.FLOAT_LIT ||
+            tok.type === lexer_1.TokenType.STRING_LIT || tok.type === lexer_1.TokenType.TRUE ||
+            tok.type === lexer_1.TokenType.FALSE) {
+            const expr = this.nud();
+            return { kind: "literal", value: expr };
+        }
+        // 단항 마이너스 (음수 리터럴 패턴)
+        if (tok.type === lexer_1.TokenType.MINUS) {
+            const expr = this.nud(); // unary minus
+            return { kind: "literal", value: expr };
+        }
+        this.error("expected pattern", tok);
+        this.advance();
+        return { kind: "wildcard" };
+    }
+    // ============================================================
+    // 타입 파싱
+    // ============================================================
+    parseType() {
+        const tok = this.peek();
+        // fn(T1, T2) -> R 함수 타입
+        if (tok.type === lexer_1.TokenType.FN) {
+            this.advance(); // fn
+            this.expect(lexer_1.TokenType.LPAREN, "expected '(' after fn");
+            const params = [];
+            if (!this.check(lexer_1.TokenType.RPAREN)) {
+                do {
+                    params.push(this.parseType());
+                } while (this.match(lexer_1.TokenType.COMMA));
+            }
+            this.expect(lexer_1.TokenType.RPAREN, "expected ')' after fn params");
+            this.expect(lexer_1.TokenType.RARROW, "expected '->' in fn type");
+            const returnType = this.parseType();
+            return { kind: "fn", params, returnType };
+        }
+        switch (tok.type) {
+            case lexer_1.TokenType.TYPE_I32:
+                this.advance();
+                return { kind: "i32" };
+            case lexer_1.TokenType.TYPE_I64:
+                this.advance();
+                return { kind: "i64" };
+            case lexer_1.TokenType.TYPE_F64:
+                this.advance();
+                return { kind: "f64" };
+            case lexer_1.TokenType.TYPE_BOOL:
+                this.advance();
+                return { kind: "bool" };
+            case lexer_1.TokenType.TYPE_STRING:
+                this.advance();
+                return { kind: "string" };
+            case lexer_1.TokenType.TYPE_VOID:
+                this.advance();
+                return { kind: "void" };
+            default:
+                break;
+        }
+        // [T] → 배열
+        if (tok.type === lexer_1.TokenType.LBRACKET) {
+            this.advance();
+            const element = this.parseType();
+            this.expect(lexer_1.TokenType.RBRACKET, "expected ']' for array type");
+            return { kind: "array", element };
+        }
+        // channel<T>
+        if (tok.type === lexer_1.TokenType.TYPE_CHANNEL) {
+            this.advance();
+            this.expect(lexer_1.TokenType.LT, "expected '<' after channel");
+            const element = this.parseType();
+            this.expect(lexer_1.TokenType.GT, "expected '>' for channel type");
+            return { kind: "channel", element };
+        }
+        // IDENT: 타입 파라미터(T, K, V) 또는 Generic/Struct 타입 [STEP B-3]
+        if (tok.type === lexer_1.TokenType.IDENT) {
+            const name = tok.lexeme;
+            this.advance();
+            // 단일 대문자 → type_param (T, K, V)
+            if (name.length === 1 && name >= 'A' && name <= 'Z') {
+                return { kind: "type_param", name };
+            }
+            // Option<T>, Result<T,E>, Generic 타입, 커스텀 struct
+            if (this.check(lexer_1.TokenType.LT)) {
+                this.advance(); // LT 소비
+                const typeArgs = [];
+                do {
+                    typeArgs.push(this.parseType());
+                } while (this.match(lexer_1.TokenType.COMMA));
+                this.expect(lexer_1.TokenType.GT, "expected '>' after type arguments");
+                // 내장 제네릭 타입 매핑
+                if (name === "Option")
+                    return { kind: "option", element: typeArgs[0] };
+                if (name === "Result")
+                    return { kind: "result", ok: typeArgs[0], err: typeArgs[1] };
+                if (name === "Promise")
+                    return { kind: "promise", element: typeArgs[0] };
+                return { kind: "generic_ref", name, typeArgs };
+            }
+            return { kind: "struct_ref", name };
+        }
+        this.error(`expected type, got ${tok.lexeme}`, tok);
+        this.advance();
+        return { kind: "i32" }; // fallback
+    }
+    // ============================================================
+    // 유틸리티
+    // ============================================================
+    peek() {
+        return this.tokens[this.pos];
+    }
+    advance() {
+        const tok = this.tokens[this.pos];
+        if (!this.isAtEnd())
+            this.pos++;
+        return tok;
+    }
+    check(type) {
+        return this.peek().type === type;
+    }
+    match(type) {
+        if (this.check(type)) {
+            this.advance();
+            return true;
+        }
+        return false;
+    }
+    expect(type, message) {
+        if (this.check(type)) {
+            return this.advance();
+        }
+        const tok = this.peek();
+        this.error(`${message} (got ${tok.type}: "${tok.lexeme}")`, tok);
+        throw new Error(message);
+    }
+    expectIdent(context) {
+        const tok = this.peek();
+        if (tok.type === lexer_1.TokenType.IDENT) {
+            this.advance();
+            return tok.lexeme;
+        }
+        this.error(`expected ${context} (got ${tok.type}: "${tok.lexeme}")`, tok);
+        throw new Error(`expected ${context}`);
+    }
+    isAtEnd() {
+        return this.peek().type === lexer_1.TokenType.EOF;
+    }
+    isStmtStart() {
+        const t = this.peek().type;
+        return t === lexer_1.TokenType.VAR || t === lexer_1.TokenType.LET || t === lexer_1.TokenType.CONST ||
+            t === lexer_1.TokenType.FN || t === lexer_1.TokenType.STRUCT || t === lexer_1.TokenType.IF || t === lexer_1.TokenType.MATCH ||
+            t === lexer_1.TokenType.FOR || t === lexer_1.TokenType.WHILE || t === lexer_1.TokenType.BREAK || t === lexer_1.TokenType.CONTINUE ||
+            t === lexer_1.TokenType.SPAWN || t === lexer_1.TokenType.RETURN || t === lexer_1.TokenType.IMPORT || t === lexer_1.TokenType.EXPORT;
+    }
+    error(message, tok) {
+        this.errors.push({ message, line: tok.line, col: tok.col });
+    }
+    synchronize() {
+        while (!this.isAtEnd()) {
+            if (this.isStmtStart())
+                return;
+            if (this.check(lexer_1.TokenType.RBRACE)) {
+                this.advance();
+                return;
+            }
+            this.advance();
+        }
+    }
+}
+exports.Parser = Parser;
+//# sourceMappingURL=parser.js.map