deukpack 1.0.0

package/dist/ast/DeukPackASTBuilder.js

@@ -0,0 +1,931 @@
+"use strict";
+/**
+ * DeukPack AST Builder
+ * Builds Abstract Syntax Tree from tokens
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeukPackASTBuilder = void 0;
+const DeukPackTypes_1 = require("../types/DeukPackTypes");
+class DeukPackASTBuilder {
+    constructor() {
+        this.tokens = [];
+        this.position = 0;
+        this.currentFile = '';
+        /** Collected doc comments for the next declaration (struct/enum/field etc.) */
+        this.leadingCommentBuffer = '';
+        this.deukMode = false;
+    }
+    /**
+     * Collect consecutive LINE_COMMENT/BLOCK_COMMENT tokens and return combined text (trimmed). Consumes tokens.
+     */
+    collectLeadingComments() {
+        const parts = [];
+        while (this.check(DeukPackTypes_1.TokenType.LINE_COMMENT) || this.check(DeukPackTypes_1.TokenType.BLOCK_COMMENT)) {
+            const t = this.advance();
+            const text = (t.value || '').trim();
+            if (text)
+                parts.push(text);
+        }
+        return parts.join('\n').trim();
+    }
+    /**
+     * Split leading comment into docComment and C# attribute lines.
+     * Lines that look like [AttrName] or [AttrName("arg")] are treated as csharpAttributes (DeukPack extension).
+     */
+    parseDocCommentAndCSharpAttributes(comment) {
+        if (!comment || !comment.trim())
+            return {};
+        const attrLineRe = /^\[.+\]$/;
+        const docLines = [];
+        const attrLines = [];
+        for (const line of comment.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            if (attrLineRe.test(trimmed)) {
+                attrLines.push(trimmed);
+            }
+            else {
+                docLines.push(line);
+            }
+        }
+        const out = {};
+        if (docLines.length)
+            out.docComment = docLines.join('\n').trim();
+        if (attrLines.length)
+            out.csharpAttributes = attrLines;
+        return out;
+    }
+    /**
+     * Parse IDL annotations: ( key = "value", key2 = "value2" ) or ( key ). Consumes tokens.
+     */
+    tryParseAnnotations() {
+        if (!this.check(DeukPackTypes_1.TokenType.LEFT_PAREN))
+            return undefined;
+        this.advance();
+        const ann = {};
+        while (!this.check(DeukPackTypes_1.TokenType.RIGHT_PAREN) && !this.isAtEnd()) {
+            const key = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+            let val = 'true';
+            if (this.check(DeukPackTypes_1.TokenType.EQUALS)) {
+                this.advance();
+                if (this.check(DeukPackTypes_1.TokenType.STRING_LITERAL)) {
+                    val = this.advance().value;
+                }
+                else if (this.check(DeukPackTypes_1.TokenType.IDENTIFIER)) {
+                    val = this.advance().value;
+                }
+                else if (this.check(DeukPackTypes_1.TokenType.NUMBER)) {
+                    val = this.advance().value;
+                }
+            }
+            ann[key] = val;
+            if (this.check(DeukPackTypes_1.TokenType.COMMA))
+                this.advance();
+        }
+        if (this.check(DeukPackTypes_1.TokenType.RIGHT_PAREN))
+            this.advance();
+        return Object.keys(ann).length ? ann : undefined;
+    }
+    /**
+     * Build AST from tokens
+     */
+    build(tokens, fileName, options) {
+        this.tokens = tokens;
+        this.position = 0;
+        this.currentFile = fileName;
+        this.leadingCommentBuffer = '';
+        this.deukMode = options?.deuk ?? false;
+        const ast = {
+            namespaces: [],
+            structs: [],
+            enums: [],
+            services: [],
+            typedefs: [],
+            constants: [],
+            includes: [],
+            annotations: {}
+        };
+        while (!this.isAtEnd()) {
+            const token = this.peek();
+            switch (token.type) {
+                case DeukPackTypes_1.TokenType.NAMESPACE:
+                    this.leadingCommentBuffer = '';
+                    const namespace = this.parseNamespace();
+                    namespace.sourceFile = this.currentFile;
+                    ast.namespaces.push(namespace);
+                    break;
+                case DeukPackTypes_1.TokenType.RECORD: {
+                    const doc = this.leadingCommentBuffer;
+                    this.leadingCommentBuffer = '';
+                    const struct = this.parseStruct(doc);
+                    struct.sourceFile = this.currentFile;
+                    ast.structs.push(struct);
+                    break;
+                }
+                case DeukPackTypes_1.TokenType.IDENTIFIER:
+                    if (token.value === 'message' && this.tokens[this.position + 1]?.type === DeukPackTypes_1.TokenType.LEFT_BRACKET) {
+                        const doc = this.leadingCommentBuffer;
+                        this.leadingCommentBuffer = '';
+                        const struct = this.parseMessage(doc);
+                        struct.sourceFile = this.currentFile;
+                        ast.structs.push(struct);
+                    }
+                    else {
+                        this.leadingCommentBuffer = '';
+                        this.advance();
+                    }
+                    break;
+                case DeukPackTypes_1.TokenType.ENUM: {
+                    const doc = this.leadingCommentBuffer;
+                    this.leadingCommentBuffer = '';
+                    const enumDef = this.parseEnum(doc);
+                    enumDef.sourceFile = this.currentFile;
+                    ast.enums.push(enumDef);
+                    break;
+                }
+                case DeukPackTypes_1.TokenType.SERVICE: {
+                    const doc = this.leadingCommentBuffer;
+                    this.leadingCommentBuffer = '';
+                    const service = this.parseService(doc);
+                    service.sourceFile = this.currentFile;
+                    ast.services.push(service);
+                    break;
+                }
+                case DeukPackTypes_1.TokenType.INCLUDE:
+                    this.leadingCommentBuffer = '';
+                    ast.includes.push(this.parseInclude());
+                    break;
+                case DeukPackTypes_1.TokenType.TYPEDEF: {
+                    const doc = this.leadingCommentBuffer;
+                    this.leadingCommentBuffer = '';
+                    const typedef = this.parseTypedef(doc);
+                    typedef.sourceFile = this.currentFile;
+                    ast.typedefs.push(typedef);
+                    break;
+                }
+                case DeukPackTypes_1.TokenType.CONST: {
+                    const doc = this.leadingCommentBuffer;
+                    this.leadingCommentBuffer = '';
+                    const constant = this.parseConst(doc);
+                    constant.sourceFile = this.currentFile;
+                    ast.constants.push(constant);
+                    break;
+                }
+                case DeukPackTypes_1.TokenType.TABLE: {
+                    this.leadingCommentBuffer = '';
+                    const tableStruct = this.parseTableDefinition();
+                    tableStruct.sourceFile = this.currentFile;
+                    ast.structs.push(tableStruct);
+                    break;
+                }
+                case DeukPackTypes_1.TokenType.LINE_COMMENT:
+                case DeukPackTypes_1.TokenType.BLOCK_COMMENT:
+                    this.leadingCommentBuffer = this.collectLeadingComments();
+                    break;
+                default:
+                    this.leadingCommentBuffer = '';
+                    this.advance();
+                    break;
+            }
+        }
+        return ast;
+    }
+    /**
+     * Parse namespace declaration
+     */
+    parseNamespace() {
+        this.advance(); // consume 'namespace'
+        if (this.deukMode) {
+            const name = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+            return { language: '*', name };
+        }
+        // Handle namespace * syntax
+        let language = '*';
+        if (this.check(DeukPackTypes_1.TokenType.ASTERISK)) {
+            this.advance(); // consume '*'
+        }
+        else {
+            language = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+        }
+        const name = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+        return { language, name };
+    }
+    /**
+     * Parse struct declaration
+     */
+    parseStruct(docComment) {
+        this.advance(); // consume 'struct' or 'record'
+        const name = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+        const annotations = this.tryParseAnnotations();
+        while (this.check(DeukPackTypes_1.TokenType.LINE_COMMENT) || this.check(DeukPackTypes_1.TokenType.BLOCK_COMMENT)) {
+            this.advance();
+        }
+        this.expect(DeukPackTypes_1.TokenType.LEFT_BRACE);
+        const fields = [];
+        while (!this.check(DeukPackTypes_1.TokenType.RIGHT_BRACE)) {
+            if (this.check(DeukPackTypes_1.TokenType.LINE_COMMENT) || this.check(DeukPackTypes_1.TokenType.BLOCK_COMMENT)) {
+                this.advance();
+                continue;
+            }
+            const field = this.parseField();
+            if (field) {
+                fields.push(field);
+            }
+        }
+        this.expect(DeukPackTypes_1.TokenType.RIGHT_BRACE);
+        const result = { name, fields };
+        if (docComment) {
+            const parsed = this.parseDocCommentAndCSharpAttributes(docComment);
+            if (parsed.docComment)
+                result.docComment = parsed.docComment;
+            if (parsed.csharpAttributes?.length)
+                result.csharpAttributes = parsed.csharpAttributes;
+        }
+        if (annotations)
+            result.annotations = annotations;
+        if (annotations && annotations['key']) {
+            const raw = String(annotations['key']).replace(/^["']|["']$/g, '').trim();
+            if (raw) {
+                result.keyFieldNames = raw.split(',').map((s) => s.trim()).filter(Boolean);
+            }
+        }
+        return result;
+    }
+    /**
+     * Parse message<id> name { fields } — 득팩 프로토콜 메시지.
+     * IDL에는 사용자 필드만 적고, 파서가 예약 ID(31000)로 msgInfo 필드를 자동 주입.
+     */
+    parseMessage(docComment) {
+        this.advance(); // consume 'message'
+        this.expect(DeukPackTypes_1.TokenType.LEFT_BRACKET);
+        const msgIdStr = this.expect(DeukPackTypes_1.TokenType.NUMBER).value;
+        this.expect(DeukPackTypes_1.TokenType.RIGHT_BRACKET);
+        const name = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+        const annotations = this.tryParseAnnotations();
+        while (this.check(DeukPackTypes_1.TokenType.LINE_COMMENT) || this.check(DeukPackTypes_1.TokenType.BLOCK_COMMENT)) {
+            this.advance();
+        }
+        this.expect(DeukPackTypes_1.TokenType.LEFT_BRACE);
+        const userFields = [];
+        while (!this.check(DeukPackTypes_1.TokenType.RIGHT_BRACE)) {
+            if (this.check(DeukPackTypes_1.TokenType.LINE_COMMENT) || this.check(DeukPackTypes_1.TokenType.BLOCK_COMMENT)) {
+                this.advance();
+                continue;
+            }
+            const field = this.parseField();
+            if (field)
+                userFields.push(field);
+        }
+        this.expect(DeukPackTypes_1.TokenType.RIGHT_BRACE);
+        const syntheticMsgInfo = {
+            id: DeukPackASTBuilder.MSGINFO_FIELD_ID,
+            name: 'msgInfo',
+            type: 'MsgInfo',
+            required: false,
+            annotations: { msgId: msgIdStr }
+        };
+        const fields = [syntheticMsgInfo, ...userFields];
+        const result = { name, fields };
+        if (docComment) {
+            const parsed = this.parseDocCommentAndCSharpAttributes(docComment);
+            if (parsed.docComment)
+                result.docComment = parsed.docComment;
+            if (parsed.csharpAttributes?.length)
+                result.csharpAttributes = parsed.csharpAttributes;
+        }
+        if (annotations)
+            result.annotations = annotations;
+        result.annotations = result.annotations ?? {};
+        result.annotations['msgId'] = msgIdStr;
+        return result;
+    }
+    /**
+     * Parse table<rowType> = { version: "...", key?: "..." } — 득팩 테이블 정의.
+     * Produces a synthetic struct named "table" with header + infos for existing codegen (IDeukMetaContainer).
+     */
+    parseTableDefinition() {
+        this.advance(); // consume 'table'
+        this.expect(DeukPackTypes_1.TokenType.LEFT_BRACKET);
+        const rowTypeName = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+        this.expect(DeukPackTypes_1.TokenType.RIGHT_BRACKET);
+        this.expect(DeukPackTypes_1.TokenType.EQUALS);
+        this.expect(DeukPackTypes_1.TokenType.LEFT_BRACE);
+        const annotations = {};
+        let keyFieldNames;
+        while (!this.check(DeukPackTypes_1.TokenType.RIGHT_BRACE)) {
+            const key = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+            this.expect(DeukPackTypes_1.TokenType.COLON);
+            if (this.check(DeukPackTypes_1.TokenType.STRING_LITERAL)) {
+                const val = this.advance().value;
+                const unquoted = val.replace(/^["']|["']$/g, '').trim();
+                if (key === 'version')
+                    annotations['version'] = unquoted;
+                else if (key === 'key')
+                    keyFieldNames = [unquoted];
+            }
+            else if (this.check(DeukPackTypes_1.TokenType.LEFT_BRACKET)) {
+                this.advance();
+                const list = [];
+                while (!this.check(DeukPackTypes_1.TokenType.RIGHT_BRACKET)) {
+                    const t = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER);
+                    list.push(t.value);
+                    if (this.check(DeukPackTypes_1.TokenType.COMMA))
+                        this.advance();
+                }
+                this.expect(DeukPackTypes_1.TokenType.RIGHT_BRACKET);
+                if (key === 'key')
+                    keyFieldNames = list;
+            }
+            if (this.check(DeukPackTypes_1.TokenType.COMMA))
+                this.advance();
+        }
+        this.expect(DeukPackTypes_1.TokenType.RIGHT_BRACE);
+        // 테이블 헤더 타입명: 프로젝트 IDL에 해당 이름의 record/typedef 필요. 레거시 호환용 기본명.
+        const headerType = 'MetaHeader';
+        const infosType = {
+            type: 'map',
+            keyType: 'int64',
+            valueType: rowTypeName
+        };
+        const tableStruct = {
+            name: 'container',
+            fields: [
+                { id: 1, name: 'header', type: headerType, required: false, defaultValue: {} },
+                { id: 2, name: 'infos', type: infosType, required: false, defaultValue: {} }
+            ]
+        };
+        if (Object.keys(annotations).length)
+            tableStruct.annotations = annotations;
+        if (keyFieldNames?.length)
+            tableStruct.keyFieldNames = keyFieldNames;
+        return tableStruct;
+    }
+    /**
+     * Parse field declaration. Deuk: id> [Attr]… type name [= default]. Legacy .thrift: id: [required|optional] type name [= default]
+     */
+    parseField() {
+        const rawComment = this.collectLeadingComments();
+        if (this.check(DeukPackTypes_1.TokenType.RIGHT_BRACE)) {
+            return null;
+        }
+        const id = parseInt(this.expect(DeukPackTypes_1.TokenType.NUMBER).value);
+        if (this.deukMode) {
+            this.expect(DeukPackTypes_1.TokenType.RIGHT_BRACKET); // '>'
+            const inlineAttrs = [];
+            while (this.check(DeukPackTypes_1.TokenType.LEFT_BRACKET)) {
+                inlineAttrs.push(this.parseOneDeukInlineAttribute());
+            }
+            const type = this.parseType();
+            const name = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+            let defaultValue = undefined;
+            if (this.check(DeukPackTypes_1.TokenType.EQUALS)) {
+                this.advance();
+                defaultValue = this.parseDefaultValue();
+            }
+            if (this.check(DeukPackTypes_1.TokenType.COMMA))
+                this.advance();
+            if (this.check(DeukPackTypes_1.TokenType.SEMICOLON))
+                this.advance();
+            const result = { id, name, type, required: false };
+            if (defaultValue !== undefined)
+                result.defaultValue = defaultValue;
+            if (rawComment) {
+                const parsed = this.parseDocCommentAndCSharpAttributes(rawComment);
+                if (parsed.docComment)
+                    result.docComment = parsed.docComment;
+                if (parsed.csharpAttributes?.length)
+                    result.csharpAttributes = parsed.csharpAttributes;
+            }
+            if (inlineAttrs.length) {
+                result.csharpAttributes = result.csharpAttributes || [];
+                result.csharpAttributes.push(...inlineAttrs);
+            }
+            return result;
+        }
+        this.expect(DeukPackTypes_1.TokenType.COLON);
+        let required = false;
+        if (this.check(DeukPackTypes_1.TokenType.REQUIRED)) {
+            required = true;
+            this.advance();
+        }
+        else if (this.check(DeukPackTypes_1.TokenType.OPTIONAL)) {
+            this.advance();
+        }
+        const type = this.parseType();
+        const name = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+        const annotations = this.tryParseAnnotations();
+        let defaultValue = undefined;
+        if (this.check(DeukPackTypes_1.TokenType.EQUALS)) {
+            this.advance();
+            defaultValue = this.parseDefaultValue();
+        }
+        if (this.check(DeukPackTypes_1.TokenType.COMMA))
+            this.advance();
+        if (this.check(DeukPackTypes_1.TokenType.SEMICOLON))
+            this.advance();
+        const result = { id, name, type, required };
+        if (defaultValue !== undefined)
+            result.defaultValue = defaultValue;
+        if (rawComment) {
+            const parsed = this.parseDocCommentAndCSharpAttributes(rawComment);
+            if (parsed.docComment)
+                result.docComment = parsed.docComment;
+            if (parsed.csharpAttributes?.length)
+                result.csharpAttributes = parsed.csharpAttributes;
+        }
+        if (annotations)
+            result.annotations = annotations;
+        return result;
+    }
+    /** Parse one [Attr] or [Attr("v")] or [Attr(K=V)] in .deuk; return string for csharpAttributes */
+    parseOneDeukInlineAttribute() {
+        this.expect(DeukPackTypes_1.TokenType.LEFT_BRACKET);
+        let piece = '[';
+        piece += this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+        if (this.check(DeukPackTypes_1.TokenType.LEFT_PAREN)) {
+            this.advance();
+            piece += '(';
+            while (!this.check(DeukPackTypes_1.TokenType.RIGHT_PAREN) && !this.isAtEnd()) {
+                piece += this.peek().value;
+                this.advance();
+            }
+            if (this.check(DeukPackTypes_1.TokenType.RIGHT_PAREN)) {
+                this.advance();
+                piece += ')';
+            }
+        }
+        this.expect(DeukPackTypes_1.TokenType.RIGHT_BRACKET);
+        return piece + ']';
+    }
+    /**
+     * Parse type declaration
+     */
+    parseType() {
+        const token = this.peek();
+        switch (token.type) {
+            case DeukPackTypes_1.TokenType.BOOL:
+                this.advance();
+                return 'bool';
+            case DeukPackTypes_1.TokenType.BYTE: {
+                const v = token.value;
+                this.advance();
+                return v === 'byte' ? 'byte' : 'int8';
+            }
+            case DeukPackTypes_1.TokenType.I16:
+                this.advance();
+                return 'int16';
+            case DeukPackTypes_1.TokenType.I32:
+                this.advance();
+                return 'int32';
+            case DeukPackTypes_1.TokenType.I64:
+                this.advance();
+                return 'int64';
+            case DeukPackTypes_1.TokenType.DOUBLE: {
+                const v = token.value;
+                this.advance();
+                return v === 'float' ? 'float' : 'double';
+            }
+            case DeukPackTypes_1.TokenType.STRING:
+                this.advance();
+                return 'string';
+            case DeukPackTypes_1.TokenType.BINARY:
+                this.advance();
+                return 'binary';
+            case DeukPackTypes_1.TokenType.IDENTIFIER:
+                return this.parseIdentifierType();
+            case DeukPackTypes_1.TokenType.LIST:
+                return this.parseListType();
+            case DeukPackTypes_1.TokenType.SET:
+                return this.parseSetType();
+            case DeukPackTypes_1.TokenType.MAP:
+                return this.parseMapType();
+            case DeukPackTypes_1.TokenType.TABLELINK:
+                return this.parseTableLinkType();
+            default:
+                throw new Error(`Unexpected token: ${token.type}`);
+        }
+    }
+    /**
+     * Parse identifier type (handles namespaced types like mo_define.projectile_type_e)
+     */
+    parseIdentifierType() {
+        let typeName = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+        // Handle namespaced types: . or :: (DeukPack uses :: in .deuk; store as . in AST)
+        while (this.check(DeukPackTypes_1.TokenType.DOT) || this.check(DeukPackTypes_1.TokenType.COLON)) {
+            if (this.check(DeukPackTypes_1.TokenType.DOT))
+                this.advance();
+            else {
+                this.advance();
+                this.expect(DeukPackTypes_1.TokenType.COLON);
+            }
+            const nextPart = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+            typeName += '.' + nextPart;
+        }
+        // 득팩 테이블 프리미티브(id, tid, mname, mnote) — 단일 식별자일 때만
+        const primitive = DeukPackASTBuilder.META_PRIMITIVES[typeName];
+        if (primitive !== undefined)
+            return primitive;
+        // 레거시 식별자(i32 등) → 득팩 타입으로 정규화 (단일 식별자일 때만)
+        const normalized = DeukPackASTBuilder.THRIFT_TYPE_TO_DEUKPACK[typeName];
+        if (normalized !== undefined)
+            return normalized;
+        return typeName;
+    }
+    /**
+     * Parse list type
+     */
+    parseListType() {
+        this.advance(); // consume 'list'
+        this.expect(DeukPackTypes_1.TokenType.LEFT_BRACKET);
+        const elementType = this.parseType();
+        this.expect(DeukPackTypes_1.TokenType.RIGHT_BRACKET);
+        return {
+            type: 'list',
+            elementType
+        };
+    }
+    /**
+     * Parse set type
+     */
+    parseSetType() {
+        this.advance(); // consume 'set'
+        this.expect(DeukPackTypes_1.TokenType.LEFT_BRACKET);
+        const elementType = this.parseType();
+        this.expect(DeukPackTypes_1.TokenType.RIGHT_BRACKET);
+        return {
+            type: 'set',
+            elementType
+        };
+    }
+    /**
+     * Parse tablelink<TableCategory, KeyField> — 득팩 테이블 행 참조.
+     */
+    parseTableLinkType() {
+        this.advance(); // consume 'tablelink'
+        this.expect(DeukPackTypes_1.TokenType.LEFT_BRACKET);
+        const tableCategory = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+        this.expect(DeukPackTypes_1.TokenType.COMMA);
+        const keyField = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+        this.expect(DeukPackTypes_1.TokenType.RIGHT_BRACKET);
+        return { type: 'tablelink', tableCategory, keyField };
+    }
+    /**
+     * Parse map type
+     */
+    parseMapType() {
+        this.advance(); // consume 'map'
+        this.expect(DeukPackTypes_1.TokenType.LEFT_BRACKET);
+        const keyType = this.parseType();
+        this.expect(DeukPackTypes_1.TokenType.COMMA);
+        const valueType = this.parseType();
+        this.expect(DeukPackTypes_1.TokenType.RIGHT_BRACKET);
+        return {
+            type: 'map',
+            keyType,
+            valueType
+        };
+    }
+    /**
+     * Parse default value
+     */
+    parseDefaultValue() {
+        const token = this.peek();
+        switch (token.type) {
+            case DeukPackTypes_1.TokenType.NUMBER:
+                this.advance();
+                return parseFloat(token.value);
+            case DeukPackTypes_1.TokenType.STRING_LITERAL:
+                this.advance();
+                return token.value;
+            case DeukPackTypes_1.TokenType.BOOLEAN:
+                this.advance();
+                return token.value === 'true';
+            case DeukPackTypes_1.TokenType.IDENTIFIER:
+                return this.parseIdentifierDefaultValue();
+            case DeukPackTypes_1.TokenType.LEFT_BRACE:
+                return this.parseObjectDefaultValue();
+            case DeukPackTypes_1.TokenType.LEFT_BRACKET:
+                return this.parseArrayDefaultValue();
+            default:
+                throw new Error(`Unexpected default value: ${token.type}`);
+        }
+    }
+    /**
+     * Parse identifier default value (handles namespaced values; . or :: in .deuk, stored as . in AST)
+     */
+    parseIdentifierDefaultValue() {
+        let value = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+        while (this.check(DeukPackTypes_1.TokenType.DOT) || this.check(DeukPackTypes_1.TokenType.COLON)) {
+            if (this.check(DeukPackTypes_1.TokenType.DOT))
+                this.advance();
+            else {
+                this.advance();
+                this.expect(DeukPackTypes_1.TokenType.COLON);
+            }
+            const nextPart = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+            value += '.' + nextPart;
+        }
+        return value;
+    }
+    /**
+     * Parse array default value (handles values like [{"weight":30}, {"weight":30}] or [])
+     */
+    parseArrayDefaultValue() {
+        this.expect(DeukPackTypes_1.TokenType.LEFT_BRACKET);
+        // Handle empty array []
+        if (this.check(DeukPackTypes_1.TokenType.RIGHT_BRACKET)) {
+            this.advance();
+            return [];
+        }
+        // Parse array content
+        const arr = [];
+        while (!this.check(DeukPackTypes_1.TokenType.RIGHT_BRACKET) && !this.isAtEnd()) {
+            // Skip whitespace and comments
+            if (this.check(DeukPackTypes_1.TokenType.LINE_COMMENT) || this.check(DeukPackTypes_1.TokenType.BLOCK_COMMENT)) {
+                this.advance();
+                continue;
+            }
+            // Parse array element
+            let element = undefined;
+            if (this.check(DeukPackTypes_1.TokenType.STRING_LITERAL)) {
+                element = this.expect(DeukPackTypes_1.TokenType.STRING_LITERAL).value;
+            }
+            else if (this.check(DeukPackTypes_1.TokenType.NUMBER)) {
+                element = parseFloat(this.expect(DeukPackTypes_1.TokenType.NUMBER).value);
+            }
+            else if (this.check(DeukPackTypes_1.TokenType.BOOLEAN)) {
+                element = this.expect(DeukPackTypes_1.TokenType.BOOLEAN).value === 'true';
+            }
+            else if (this.check(DeukPackTypes_1.TokenType.LEFT_BRACE)) {
+                element = this.parseObjectDefaultValue();
+            }
+            else if (this.check(DeukPackTypes_1.TokenType.LEFT_BRACKET)) {
+                element = this.parseArrayDefaultValue();
+            }
+            if (element !== undefined) {
+                arr.push(element);
+            }
+            // Skip comma if present
+            if (this.check(DeukPackTypes_1.TokenType.COMMA)) {
+                this.advance();
+            }
+        }
+        this.expect(DeukPackTypes_1.TokenType.RIGHT_BRACKET);
+        return arr;
+    }
+    /**
+     * Parse object default value (handles values like { "version": 20250802 } or {})
+     */
+    parseObjectDefaultValue() {
+        this.expect(DeukPackTypes_1.TokenType.LEFT_BRACE);
+        // Handle empty object {}
+        if (this.check(DeukPackTypes_1.TokenType.RIGHT_BRACE)) {
+            this.advance();
+            return {};
+        }
+        // Parse object content
+        const obj = {};
+        while (!this.check(DeukPackTypes_1.TokenType.RIGHT_BRACE) && !this.isAtEnd()) {
+            // Skip whitespace and comments
+            if (this.check(DeukPackTypes_1.TokenType.LINE_COMMENT) || this.check(DeukPackTypes_1.TokenType.BLOCK_COMMENT)) {
+                this.advance();
+                continue;
+            }
+            // Parse key-value pairs
+            if (this.check(DeukPackTypes_1.TokenType.STRING_LITERAL)) {
+                const key = this.expect(DeukPackTypes_1.TokenType.STRING_LITERAL).value;
+                // Skip colon
+                if (this.check(DeukPackTypes_1.TokenType.COLON)) {
+                    this.advance();
+                }
+                // Parse value (string, number, boolean, object, or identifier e.g. id_e.req_login)
+                let value = undefined;
+                if (this.check(DeukPackTypes_1.TokenType.STRING_LITERAL)) {
+                    value = this.expect(DeukPackTypes_1.TokenType.STRING_LITERAL).value;
+                }
+                else if (this.check(DeukPackTypes_1.TokenType.NUMBER)) {
+                    value = parseFloat(this.expect(DeukPackTypes_1.TokenType.NUMBER).value);
+                }
+                else if (this.check(DeukPackTypes_1.TokenType.BOOLEAN)) {
+                    value = this.expect(DeukPackTypes_1.TokenType.BOOLEAN).value === 'true';
+                }
+                else if (this.check(DeukPackTypes_1.TokenType.LEFT_BRACE)) {
+                    value = this.parseObjectDefaultValue();
+                }
+                else if (this.check(DeukPackTypes_1.TokenType.IDENTIFIER)) {
+                    value = this.parseIdentifierDefaultValue();
+                }
+                obj[key] = value;
+                // Skip comma if present
+                if (this.check(DeukPackTypes_1.TokenType.COMMA)) {
+                    this.advance();
+                }
+            }
+            else {
+                this.advance(); // Skip unknown tokens
+            }
+        }
+        if (this.check(DeukPackTypes_1.TokenType.RIGHT_BRACE)) {
+            this.advance();
+        }
+        return obj;
+    }
+    /**
+     * Parse enum declaration
+     */
+    parseEnum(docComment) {
+        this.advance(); // consume 'enum'
+        const name = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+        const annotations = this.tryParseAnnotations();
+        this.expect(DeukPackTypes_1.TokenType.LEFT_BRACE);
+        const values = {};
+        const valueComments = {};
+        let currentValue = 0;
+        while (!this.check(DeukPackTypes_1.TokenType.RIGHT_BRACE)) {
+            const memberComment = this.collectLeadingComments();
+            if (this.check(DeukPackTypes_1.TokenType.RIGHT_BRACE))
+                break;
+            const enumName = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+            if (this.check(DeukPackTypes_1.TokenType.EQUALS)) {
+                this.advance();
+                currentValue = parseInt(this.expect(DeukPackTypes_1.TokenType.NUMBER).value);
+            }
+            values[enumName] = currentValue;
+            if (memberComment)
+                valueComments[enumName] = memberComment;
+            currentValue++;
+            if (this.check(DeukPackTypes_1.TokenType.COMMA))
+                this.advance();
+            while (this.check(DeukPackTypes_1.TokenType.WHITESPACE) || this.check(DeukPackTypes_1.TokenType.NEWLINE)) {
+                this.advance();
+            }
+        }
+        this.expect(DeukPackTypes_1.TokenType.RIGHT_BRACE);
+        const result = { name, values };
+        if (docComment) {
+            const parsed = this.parseDocCommentAndCSharpAttributes(docComment);
+            if (parsed.docComment)
+                result.docComment = parsed.docComment;
+            if (parsed.csharpAttributes?.length)
+                result.csharpAttributes = parsed.csharpAttributes;
+        }
+        if (Object.keys(valueComments).length)
+            result.valueComments = valueComments;
+        if (annotations)
+            result.annotations = annotations;
+        return result;
+    }
+    /**
+     * Parse service declaration
+     */
+    parseService(docComment) {
+        this.advance(); // consume 'service'
+        const name = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+        const annotations = this.tryParseAnnotations();
+        this.expect(DeukPackTypes_1.TokenType.LEFT_BRACE);
+        const methods = [];
+        while (!this.check(DeukPackTypes_1.TokenType.RIGHT_BRACE)) {
+            if (this.check(DeukPackTypes_1.TokenType.LINE_COMMENT) || this.check(DeukPackTypes_1.TokenType.BLOCK_COMMENT)) {
+                this.advance(); // skip comments
+                continue;
+            }
+            methods.push(this.parseServiceMethod());
+            if (this.check(DeukPackTypes_1.TokenType.COMMA) || this.check(DeukPackTypes_1.TokenType.SEMICOLON)) {
+                this.advance();
+            }
+        }
+        this.expect(DeukPackTypes_1.TokenType.RIGHT_BRACE);
+        const result = { name, methods };
+        if (docComment)
+            result.docComment = docComment;
+        if (annotations)
+            result.annotations = annotations;
+        return result;
+    }
+    /**
+     * Parse a single service method: returnType methodName( [ params ] )
+     */
+    parseServiceMethod() {
+        const returnType = this.parseType();
+        const methodName = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+        this.expect(DeukPackTypes_1.TokenType.LEFT_PAREN);
+        const parameters = [];
+        while (this.check(DeukPackTypes_1.TokenType.NUMBER) && !this.isAtEnd()) {
+            const idToken = this.advance();
+            const fieldId = typeof idToken.value === 'number' ? idToken.value : parseInt(String(idToken.value), 10);
+            if (this.check(DeukPackTypes_1.TokenType.COLON))
+                this.advance();
+            const paramType = this.parseType();
+            const paramName = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+            parameters.push({ id: fieldId, name: paramName, type: paramType, required: true });
+            if (this.check(DeukPackTypes_1.TokenType.COMMA))
+                this.advance();
+        }
+        if (this.check(DeukPackTypes_1.TokenType.RIGHT_PAREN))
+            this.advance();
+        return { name: methodName, returnType, parameters, oneway: false };
+    }
+    /**
+     * Parse include statement
+     */
+    parseInclude() {
+        this.advance(); // consume 'include'
+        const fileName = this.expect(DeukPackTypes_1.TokenType.STRING_LITERAL).value;
+        // Include statements don't require semicolons
+        return fileName;
+    }
+    /**
+     * Parse typedef declaration
+     */
+    parseTypedef(docComment) {
+        this.advance(); // consume 'typedef'
+        const type = this.parseType();
+        const name = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+        const annotations = this.tryParseAnnotations();
+        const result = { name, type };
+        if (docComment)
+            result.docComment = docComment;
+        if (annotations)
+            result.annotations = annotations;
+        return result;
+    }
+    /**
+     * Parse const declaration
+     */
+    parseConst(docComment) {
+        this.advance(); // consume 'const'
+        const type = this.parseType();
+        const name = this.expect(DeukPackTypes_1.TokenType.IDENTIFIER).value;
+        const annotations = this.tryParseAnnotations();
+        this.expect(DeukPackTypes_1.TokenType.EQUALS);
+        const value = this.parseDefaultValue();
+        const result = { name, type, value };
+        if (docComment)
+            result.docComment = docComment;
+        if (annotations)
+            result.annotations = annotations;
+        return result;
+    }
+    /**
+     * Check if current token matches expected type
+     */
+    check(type) {
+        if (this.isAtEnd())
+            return false;
+        return this.peek().type === type;
+    }
+    /**
+     * Expect token of specific type and advance
+     */
+    expect(type) {
+        if (this.check(type)) {
+            return this.advance();
+        }
+        const current = this.peek();
+        throw new Error(`Expected ${type}, got ${current.type} (value: "${current.value}") at line ${current.line}, column ${current.column}`);
+    }
+    /**
+     * Advance and return current token
+     */
+    advance() {
+        if (!this.isAtEnd()) {
+            this.position++;
+        }
+        return this.previous();
+    }
+    /**
+     * Get current token without advancing
+     */
+    peek() {
+        return this.tokens[this.position] || { type: DeukPackTypes_1.TokenType.EOF, value: '', position: 0, line: 0, column: 0 };
+    }
+    /**
+     * Get previous token
+     */
+    previous() {
+        return this.tokens[this.position - 1] || { type: DeukPackTypes_1.TokenType.EOF, value: '', position: 0, line: 0, column: 0 };
+    }
+    /**
+     * Check if at end of tokens
+     */
+    isAtEnd() {
+        return this.peek().type === DeukPackTypes_1.TokenType.EOF;
+    }
+}
+exports.DeukPackASTBuilder = DeukPackASTBuilder;
+/** 예약 필드 ID: message<> 자동 주입 msgInfo (IDL에는 적지 않음, 코드젠에서만 사용). DEUKPACK_MESSAGE_INFO_KEYWORD §5. */
+DeukPackASTBuilder.MSGINFO_FIELD_ID = 31000;
+/** 레거시 식별자 타입(i32 등) → 득팩 이름 정규화 (Protobuf와 동일하게 AST에는 득팩 타입만 저장) */
+DeukPackASTBuilder.THRIFT_TYPE_TO_DEUKPACK = {
+    i8: 'int8',
+    i16: 'int16',
+    i32: 'int32',
+    i64: 'int64'
+};
+/** 득팩 테이블 프리미티브(DEUKPACK_IDL_DESIGN §5.1): name/note는 string 별칭. id/tid는 int64와 동일해 타입 구분 불필요. */
+DeukPackASTBuilder.META_PRIMITIVES = {
+    mname: 'string',
+    mnote: 'string'
+};
+//# sourceMappingURL=DeukPackASTBuilder.js.map