meaoiu 0.1.2 → 0.1.4

package/dist/core/parser.js

@@ -1,21 +1,21 @@
 // src/core/parser.ts
 import { MeaoiuError, errorFrom } from './error.js';
-import { newToken, } from './lexer/tokenizer.js';
+import { newToken } from './lexer/tokenizer.js';
 const blockKindInfo = [
     {
         name: '想法',
-        startKind: 22 /* TokenKind.BLOCK_START */,
+        startKind: 26 /* TokenKind.BLOCK_START */,
         startValue: '[#',
-        separatorKind: 24 /* TokenKind.TERMINATOR */,
-        endKind: 23 /* TokenKind.BLOCK_END */,
+        separatorKind: 3 /* TokenKind.TERMINATOR */,
+        endKind: 27 /* TokenKind.BLOCK_END */,
         endValue: '#]',
     },
     {
         name: '纸箱',
-        startKind: 20 /* TokenKind.COLLECTION_START */,
+        startKind: 24 /* TokenKind.COLLECTION_START */,
         startValue: '[=',
-        separatorKind: 36 /* TokenKind.COMMA */,
-        endKind: 21 /* TokenKind.COLLECTION_END */,
+        separatorKind: 4 /* TokenKind.COMMA */,
+        endKind: 25 /* TokenKind.COLLECTION_END */,
         endValue: '=]',
     },
 ]; // 0: 想法, 1: 纸箱
@@ -23,42 +23,36 @@ const syntaxErrorFrom = (ele, message) => errorFrom(ele, message, 3 /* Phase.SYN
 function errorNodeWith({ message, line, col, endLine, endCol }) {
     return { kind: 0 /* NodeKind.ErrorNode */, message, line, col, endLine, endCol };
 }
-function isAdditiveToken(token) {
-    return token.kind === 26 /* TokenKind.ARITHMETIC_PLUS */ || token.kind === 27 /* TokenKind.ARITHMETIC_MINUS */;
-}
-function isMultiplicativeToken(token) {
-    return token.kind === 28 /* TokenKind.ARITHMETIC_MULTIPLY */ || token.kind === 29 /* TokenKind.ARITHMETIC_DIVIDE */;
-}
 function isComparisonToken(token) {
     switch (token.kind) {
-        case 32 /* TokenKind.COMPARISON_GREATER */:
-        case 33 /* TokenKind.COMPARISON_LESS */:
-        case 34 /* TokenKind.COMPARISON_GREATER_EQUAL */:
-        case 35 /* TokenKind.COMPARISON_LESS_EQUAL */:
-        case 30 /* TokenKind.COMPARISON_EQUAL */:
-        case 31 /* TokenKind.COMPARISON_NOT_EQUAL */:
+        case 35 /* TokenKind.COMPARISON_GREATER */:
+        case 36 /* TokenKind.COMPARISON_LESS */:
+        case 37 /* TokenKind.COMPARISON_GREATER_EQUAL */:
+        case 38 /* TokenKind.COMPARISON_LESS_EQUAL */:
+        case 33 /* TokenKind.COMPARISON_EQUAL */:
+        case 34 /* TokenKind.COMPARISON_NOT_EQUAL */:
             return true;
         default:
             return false;
     }
 }
-function isStartToken(kind) {
+function isStartKind(kind) {
     switch (kind) {
-        case 1 /* TokenKind.KEYWORD_USE */:
-        case 9 /* TokenKind.KEYWORD_LOOP */:
-        case 10 /* TokenKind.KEYWORD_BREAK */:
-        case 11 /* TokenKind.KEYWORD_AMBUSH */:
-        case 12 /* TokenKind.KEYWORD_DEF */:
-        case 13 /* TokenKind.KEYWORD_CALL */:
-        case 14 /* TokenKind.KEYWORD_RETURN */:
-        case 22 /* TokenKind.BLOCK_START */:
+        case 5 /* TokenKind.KEYWORD_USE */:
+        case 13 /* TokenKind.KEYWORD_LOOP */:
+        case 14 /* TokenKind.KEYWORD_BREAK */:
+        case 15 /* TokenKind.KEYWORD_AMBUSH */:
+        case 16 /* TokenKind.KEYWORD_DEF */:
+        case 17 /* TokenKind.KEYWORD_CALL */:
+        case 18 /* TokenKind.KEYWORD_RETURN */:
+        case 26 /* TokenKind.BLOCK_START */:
             return true;
         default:
             return false;
     }
 }
 function isAssignmentOperator(kind) {
-    return kind === 2 /* TokenKind.ASSIGNMENT_IS */ || kind === 3 /* TokenKind.ASSIGNMENT_LIKE */ || kind === 4 /* TokenKind.ASSIGNMENT_ONLY */;
+    return kind === 6 /* TokenKind.ASSIGNMENT_IS */ || kind === 7 /* TokenKind.ASSIGNMENT_LIKE */ || kind === 8 /* TokenKind.ASSIGNMENT_ONLY */;
 }
 class Parser {
     tokens;
@@ -67,56 +61,35 @@ class Parser {
     blockDepth = new Int16Array(2); // 0: 想法, 1: 纸箱
     errors = [];
     position = 0;
-    // 悄悄话缓存：advance / drainCommentsAhead 会把遇到的 COMMENT 放进这里
-    commentBuffer = [];
+    prevOne; // 上一个非悄悄话词元
+    commentBuffer = []; // 悄悄话缓存：drainCommentsAhead 会把遇到的 COMMENT 放进这里
     constructor(tokens, mode = 0 /* ParseMode.STRICT */) {
         this.MODE = mode;
         // 确保有 EOF 哨兵，避免边界问题
-        if (!tokens.length || tokens[tokens.length - 1].kind !== 44 /* TokenKind.EOF */) {
-            const EOF = newToken(44 /* TokenKind.EOF */, 'EndOfFile', -1, -1, -1, -1);
+        if (!tokens.length || tokens[tokens.length - 1].kind !== 1 /* TokenKind.EOF */) {
+            const EOF = newToken(1 /* TokenKind.EOF */, 'EndOfFile', -1, -1, -1, -1);
             tokens.push((this.reportError(errorFrom(EOF, '分词器可能坏了喵~', 1 /* Phase.INVARIANT */)), EOF));
         }
         this.tokens = tokens;
         this.MAX_POS = tokens.length - 1;
+        this.prevOne = this.drainCommentsAhead(); // 收集前导悄悄话，确保起步位置可食用
     }
-    // 当前 token（安全！）
     current() {
         return this.tokens[this.position];
     }
-    // 安全前视 n 个 token
-    peek(n = 1) {
-        return this.tokens[Math.min(this.position + n, this.MAX_POS)];
+    // 前视一位
+    peek() {
+        return this.tokens[Math.min(this.position + 1, this.MAX_POS)];
     }
     /**
-     * 返回当前位置的「非悄悄话 token」，并将位置推进到下一个 token（非悄悄话或 EOF），
-     * 同时把遇到的悄悄话收集到 commentBuffer
-     * @returns 当前位置的 token（非 COMMENT）
+     * 推进位置并取得下一词元，同时将途经悄悄话收入 commentBuffer
+     * @returns 下一个非悄悄话词元（可能为 EOF）
      */
-    advance() {
-        const current = this.drainCommentsAhead(); // 当前非悄悄话 token（或 EOF）
+    next() {
+        this.prevOne = this.current();
         if (this.position < this.MAX_POS)
             this.position++;
-        return current;
-    }
-    /**
-     * 推进位置（同时掠取悄悄话）并取得下一 token
-     * @returns 悄悄话之后一个 token 的再下一 token
-     */
-    next() {
-        this.advance();
-        return this.current();
-    }
-    /**
-     * 返回上一个非悄悄话 token（不动位置）
-     * @returns 上一个非悄悄话 token
-     */
-    lookBack() {
-        if (this.position < 1)
-            return this.current();
-        let token;
-        for (let pos = this.position; (token = this.tokens[--pos]).kind === 43 /* TokenKind.COMMENT */ && pos > 0;)
-            ;
-        return token;
+        return this.drainCommentsAhead();
     }
     /**
      * 取得当前非悄悄话 token，若当前为悄悄话则连续推进至目标（同时收集悄悄话到 commentBuffer）
@@ -124,17 +97,17 @@ class Parser {
      */
     drainCommentsAhead() {
         let token = this.current();
-        while (token.kind === 43 /* TokenKind.COMMENT */ && this.position < this.MAX_POS) {
+        while (token.kind === 2 /* TokenKind.COMMENT */ && this.position < this.MAX_POS) {
             this.commentBuffer.push(token);
             token = this.tokens[++this.position];
         }
         return token;
     }
     /**
-     * 从缓存中拿走所有待分配的 leading 悄悄话（并清空缓存）
+     * 从缓存中拿走所有待分配的悄悄话并清空缓存
      * @returns 所有待分配的悄悄话
      */
-    takeLeadingComments() {
+    takeUnclaimedComments() {
         const comments = this.commentBuffer;
         this.commentBuffer = [];
         return comments;
@@ -155,10 +128,9 @@ class Parser {
             (comment.line === anchorToken.line ? trailing : remaining).push(comment);
         if (trailing.length)
             (node.trailingComments ??= []).push(...trailing);
-        // 将非 trailing 的悄悄话保留为新的 commentBuffer
-        this.commentBuffer = remaining;
+        this.commentBuffer = remaining; // 将非 trailing 的悄悄话保留为新 commentBuffer
     }
-    endLoc({ endLine, endCol } = this.lookBack()) {
+    endLoc({ endLine, endCol } = this.prevOne) {
         return { endLine, endCol };
     }
     reportError(error) {
@@ -172,29 +144,25 @@ class Parser {
      * @returns 虚构 token
      */
     makeErrorTail(kind, why, where) {
-        // 找到前一个 token 做锚点
-        const { endLine, endCol, value } = this.lookBack();
+        const { endLine, endCol, value } = this.prevOne; // 前一词做锚点
         const fakeTermToken = newToken(kind, '', endLine, endCol, endLine, endCol);
         const errMsg = `${where ?? `在「${value}」后`}${why}`;
         this.reportError(syntaxErrorFrom(fakeTermToken, errMsg));
         return fakeTermToken;
     }
     expect(kind, why, where) {
-        const token = this.current();
-        if (token.kind === kind)
-            return this.advance();
-        // 返回合成 token（但不移动 position），解析器会以为期望的 token 存在于此锚点
-        return this.makeErrorTail(kind, why, where);
+        // 当前词元符合期望即前进并取走，否则在原地用假词元迎合解析器的期望
+        return this.current().kind === kind ? (this.next(), this.prevOne) : this.makeErrorTail(kind, why, where);
     }
     synchronize() {
         // 首先尝试找到 TERMINATOR 或语句开始，跳过闭块符，顺便捕获块配对问题
-        for (let tokenKind = this.current().kind; tokenKind !== 44 /* TokenKind.EOF */; tokenKind = this.next().kind) {
-            if (tokenKind === 24 /* TokenKind.TERMINATOR */)
-                return void this.advance();
-            if (isStartToken(tokenKind))
+        for (let tokenKind = this.current().kind; tokenKind !== 1 /* TokenKind.EOF */; tokenKind = this.next().kind) {
+            if (tokenKind === 3 /* TokenKind.TERMINATOR */)
+                return void this.next();
+            if (isStartKind(tokenKind))
                 return;
-            const depthIndex = +(tokenKind === 21 /* TokenKind.COLLECTION_END */);
-            if (!depthIndex && tokenKind !== 23 /* TokenKind.BLOCK_END */)
+            const depthIndex = +(tokenKind === 25 /* TokenKind.COLLECTION_END */);
+            if (!depthIndex && tokenKind !== 27 /* TokenKind.BLOCK_END */)
                 continue;
             if (this.blockDepth[depthIndex] > 0)
                 return;
@@ -205,52 +173,49 @@ class Parser {
     }
     // 用于 parseExpression 内部：跳到 terminator / statement start / EOF
     consumeToRecoveryPoint() {
-        for (let tokenKind = this.current().kind; tokenKind !== 44 /* TokenKind.EOF */ && tokenKind !== 24 /* TokenKind.TERMINATOR */ && !isStartToken(tokenKind); tokenKind = this.next().kind)
+        for (let tokenKind = this.current().kind; tokenKind !== 1 /* TokenKind.EOF */ && tokenKind !== 3 /* TokenKind.TERMINATOR */ && !isStartKind(tokenKind); tokenKind = this.next().kind)
             ;
     }
     parse() {
-        const { kind: startKind, line, col, endLine, endCol } = this.current();
-        const program = { kind: 1 /* NodeKind.Program */, body: [], line, col, endLine, endCol };
-        for (let tokenKind = startKind; tokenKind !== 44 /* TokenKind.EOF */; tokenKind = this.current().kind) {
-            if (tokenKind === 24 /* TokenKind.TERMINATOR */)
-                this.advance();
+        const body = [];
+        for (let tokenKind; (tokenKind = this.current().kind) !== 1 /* TokenKind.EOF */;) {
+            if (tokenKind === 3 /* TokenKind.TERMINATOR */)
+                this.next();
             else
-                program.body.push(this.parseStatement());
-        }
-        // 如果文件结束后仍有悄悄话缓存在 buffer，把它当成最后一个语句的 trailing（如果存在）
-        if (this.commentBuffer.length > 0 && program.body.length > 0) {
-            const lastStatement = program.body[program.body.length - 1];
-            (lastStatement.trailingComments ??= []).push(...this.commentBuffer);
-            this.commentBuffer = [];
+                body.push(this.parseStatement());
         }
-        ({ endLine: program.endLine, endCol: program.endCol } = this.tokens[Math.max(0, this.position - 1)]);
+        const { line, col } = this.tokens[0];
+        const { endLine, endCol } = this.tokens[this.MAX_POS];
+        const program = { kind: 1 /* NodeKind.Program */, body, line, col, endLine, endCol };
+        // 遗留在缓存的悄悄话挂到根节点
+        if (this.commentBuffer.length > 0)
+            program.trailingComments = this.takeUnclaimedComments();
         return { program, errors: this.errors };
     }
     parseStatement() {
-        // 先把当前位置连续的悄悄话收进 buffer（避免 current() 是 COMMENT 的情况）
-        const startToken = this.drainCommentsAhead();
-        const leading = this.takeLeadingComments(); // 取走当前节点的 leading 悄悄话（如果有）
+        const startToken = this.current();
+        const leading = this.takeUnclaimedComments(); // 取走当前节点的 leading 悄悄话（如果有）
         try {
             let node;
             switch (startToken.kind) {
-                case 1 /* TokenKind.KEYWORD_USE */:
+                case 5 /* TokenKind.KEYWORD_USE */:
                     node = this.parseVariableDeclaration(true);
                     break;
-                case 12 /* TokenKind.KEYWORD_DEF */:
+                case 16 /* TokenKind.KEYWORD_DEF */:
                     node = this.parseFunctionDeclaration();
                     break;
-                case 14 /* TokenKind.KEYWORD_RETURN */:
+                case 18 /* TokenKind.KEYWORD_RETURN */:
                     node = this.parseReturnOrAmbushStatement(5 /* NodeKind.ReturnStatement */);
                     break;
-                case 11 /* TokenKind.KEYWORD_AMBUSH */:
+                case 15 /* TokenKind.KEYWORD_AMBUSH */:
                     node = this.parseReturnOrAmbushStatement(6 /* NodeKind.AmbushStatement */);
                     break;
-                case 10 /* TokenKind.KEYWORD_BREAK */:
-                    this.advance();
+                case 14 /* TokenKind.KEYWORD_BREAK */:
+                    this.next();
                     node = { kind: 7 /* NodeKind.BreakStatement */, line: startToken.line, col: startToken.col, ...this.endLoc() };
                     break;
-                case 21 /* TokenKind.COLLECTION_END */:
-                case 23 /* TokenKind.BLOCK_END */:
+                case 25 /* TokenKind.COLLECTION_END */:
+                case 27 /* TokenKind.BLOCK_END */:
                     throw syntaxErrorFrom(startToken, '假的语句喵！');
                 default:
                     const expression = this.parseExpression();
@@ -263,11 +228,8 @@ class Parser {
                         node = { kind: 8 /* NodeKind.ExpressionStatement */, expression, line, col, ...this.endLoc() };
                     }
             }
-            // 检查终结符但不消耗，消耗的工作交给 parse 和 parseBlockExpression
-            const trailingToken = this.current();
-            const termToken = trailingToken.kind !== 24 /* TokenKind.TERMINATOR */
-                ? this.makeErrorTail(24 /* TokenKind.TERMINATOR */, '必须有尾巴「~」喵！')
-                : trailingToken;
+            // 检查并消耗终结符
+            const termToken = this.expect(3 /* TokenKind.TERMINATOR */, '必须有尾巴「~」喵！');
             if (leading.length)
                 (node.leadingComments ??= []).push(...leading);
             // 收集并分配 terminator 后面的悄悄话（同一行视为 trailing）
@@ -282,7 +244,7 @@ class Parser {
         }
     }
     parseVariableDeclaration(hasUse) {
-        const { line, col } = hasUse ? this.advance() : this.current();
+        const { line, col } = hasUse ? (this.next(), this.prevOne) : this.current();
         const identifier = this.parseIdentifier();
         // 检查后面是否紧跟赋值关键字
         const tokenKind = this.current().kind;
@@ -292,30 +254,33 @@ class Parser {
         return { kind: 2 /* NodeKind.VariableDeclaration */, identifier, initialization, line, col, ...this.endLoc() };
     }
     parseAssignmentStatement(assignee, operator) {
-        this.advance();
+        this.next();
         const value = this.parseExpression();
         const { line, col } = assignee;
         return { kind: 3 /* NodeKind.AssignmentStatement */, assignee, value, operator, line, col, ...this.endLoc() };
     }
     parseFunctionDeclaration() {
-        const { line, col } = this.advance();
+        const { line, col } = (this.next(), this.prevOne);
         const parameters = this.parseBlockExpression(true);
         const name = this.parseIdentifier();
         const body = this.parseBlockExpression(false);
         return { kind: 4 /* NodeKind.FunctionDeclaration */, name, parameters, body, line, col, ...this.endLoc() };
     }
     parseReturnOrAmbushStatement(nodeKind) {
-        const { line, col } = this.advance();
-        const argument = this.current().kind !== 24 /* TokenKind.TERMINATOR */ ? this.parseExpression() : undefined;
+        const { line, col } = (this.next(), this.prevOne);
+        const argument = this.current().kind !== 3 /* TokenKind.TERMINATOR */ ? this.parseExpression() : undefined;
         return { kind: nodeKind, argument, line, col, ...this.endLoc() };
     }
     parseIdentifier() {
-        this.drainCommentsAhead(); // identifier 也应接收可能的 leading 悄悄话
-        const leading = this.takeLeadingComments();
-        const { line, col, value: symbol } = this.expect(19 /* TokenKind.IDENTIFIER */, '需要一个标识符喵！');
+        const leading = this.takeUnclaimedComments();
+        const { line, col, value: symbol } = this.expect(23 /* TokenKind.IDENTIFIER */, '需要一个标识符喵！');
         const node = { kind: 13 /* NodeKind.Identifier */, symbol, line, col, ...this.endLoc() };
-        if (leading.length)
-            node.leadingComments = leading;
+        if (leading.length) {
+            if (symbol)
+                node.leadingComments = leading;
+            else
+                this.commentBuffer = (leading.push(...this.commentBuffer), leading); // 用不了，归还
+        }
         return node;
     }
     parseExpression() {
@@ -332,37 +297,37 @@ class Parser {
     parseLogicalExpression() {
         let left = this.parseSequenceExpression();
         // 循环处理连续的逻辑操作：A 和 B 都好 或 C 不坏
-        for (let tokenKind = this.current().kind, isOr; (isOr = tokenKind === 38 /* TokenKind.LOGIC_OR */) || tokenKind === 37 /* TokenKind.LOGIC_AND */; tokenKind = this.current().kind) {
-            this.advance();
+        for (let tokenKind, isOr; (isOr = (tokenKind = this.current().kind) === 40 /* TokenKind.LOGIC_OR */) || tokenKind === 39 /* TokenKind.LOGIC_AND */;) {
+            this.next();
             const right = this.parseLogicalExpression();
             const closeToken = this.current();
             const operator = closeToken.kind;
             switch (operator) {
-                case 40 /* TokenKind.LOGIC_CLOSE_OR */:
+                case 42 /* TokenKind.LOGIC_CLOSE_OR */:
                     if (!isOr)
                         this.reportError(syntaxErrorFrom(closeToken, '逻辑「和」不能用「不坏」闭合喵！'));
                     break;
-                case 42 /* TokenKind.LOGIC_CLOSE_NAND */:
+                case 44 /* TokenKind.LOGIC_CLOSE_NAND */:
                     if (!isOr)
                         this.reportError(syntaxErrorFrom(closeToken, '逻辑「和」不能用「不好」闭合喵！'));
                     break;
-                case 39 /* TokenKind.LOGIC_CLOSE_AND */:
+                case 41 /* TokenKind.LOGIC_CLOSE_AND */:
                     if (isOr)
                         this.reportError(syntaxErrorFrom(closeToken, '逻辑「或」不能用「都好」闭合喵！'));
                     break;
-                case 41 /* TokenKind.LOGIC_CLOSE_NOR */:
+                case 43 /* TokenKind.LOGIC_CLOSE_NOR */:
                     if (isOr)
                         this.reportError(syntaxErrorFrom(closeToken, '逻辑「或」不能用「都坏」闭合喵！'));
                     break;
-                case 38 /* TokenKind.LOGIC_OR */:
-                case 37 /* TokenKind.LOGIC_AND */:
+                case 40 /* TokenKind.LOGIC_OR */:
+                case 39 /* TokenKind.LOGIC_AND */:
                     throw errorFrom(closeToken, '你不该看到这个喵！', 1 /* Phase.INVARIANT */);
                 default:
                     const [logic, close, nClose] = isOr ? ['或', '不坏', '不好'] : ['和', '都好', '都坏'];
                     this.makeErrorTail(0 /* TokenKind.ERROR */, `逻辑「${logic}」要有「${close}」或「${nClose}」闭合喵！`);
                     continue;
             }
-            this.advance();
+            this.next();
             const { line, col } = left;
             left = { kind: 23 /* NodeKind.LogicalExpression */, left, right, operator, line, col, ...this.endLoc() };
         }
@@ -372,30 +337,30 @@ class Parser {
         const { line, col } = this.current();
         const sections = [this.parseComparisonExpression()];
         const operators = [];
-        sequence: for (let isArithmeticMode = true; this.peek().kind === 36 /* TokenKind.COMMA */;) {
+        sequence: for (let isArithmeticMode = true; this.peek().kind === 4 /* TokenKind.COMMA */;) {
             const token = this.current();
             switch (token.kind) {
-                case 26 /* TokenKind.ARITHMETIC_PLUS */:
-                case 27 /* TokenKind.ARITHMETIC_MINUS */:
-                case 28 /* TokenKind.ARITHMETIC_MULTIPLY */:
-                case 29 /* TokenKind.ARITHMETIC_DIVIDE */:
+                case 29 /* TokenKind.ARITHMETIC_PLUS */:
+                case 30 /* TokenKind.ARITHMETIC_MINUS */:
+                case 31 /* TokenKind.ARITHMETIC_MULTIPLY */:
+                case 32 /* TokenKind.ARITHMETIC_DIVIDE */:
                     if (isArithmeticMode)
                         break; // 模式正确
                     throw syntaxErrorFrom(token, '比较之后就不能做算术了喵！');
-                case 30 /* TokenKind.COMPARISON_EQUAL */:
-                case 31 /* TokenKind.COMPARISON_NOT_EQUAL */:
+                case 33 /* TokenKind.COMPARISON_EQUAL */:
+                case 34 /* TokenKind.COMPARISON_NOT_EQUAL */:
                     isArithmeticMode = false; // 禁用算术模式
                     break;
-                case 32 /* TokenKind.COMPARISON_GREATER */:
-                case 33 /* TokenKind.COMPARISON_LESS */:
-                case 34 /* TokenKind.COMPARISON_GREATER_EQUAL */:
-                case 35 /* TokenKind.COMPARISON_LESS_EQUAL */:
+                case 35 /* TokenKind.COMPARISON_GREATER */:
+                case 36 /* TokenKind.COMPARISON_LESS */:
+                case 37 /* TokenKind.COMPARISON_GREATER_EQUAL */:
+                case 38 /* TokenKind.COMPARISON_LESS_EQUAL */:
                     throw syntaxErrorFrom(token, `'${token.value}' 不能用在节之间喵！`);
                 default:
                     break sequence;
             }
-            this.advance(); // 消费操作符
-            this.advance(); // 跳过逗号
+            this.next(); // 消费操作符
+            this.next(); // 跳过逗号
             operators.push(token);
             sections.push(this.parseComparisonExpression());
         }
@@ -405,12 +370,12 @@ class Parser {
     }
     parseComparisonExpression() {
         const { line, col } = this.current();
-        const expressions = [this.parseAdditiveExpression()];
+        const expressions = [this.parseArithmeticExpression(0 /* ArithmeticPrecedence.NONE */)];
         const operators = [];
-        for (let token; isComparisonToken((token = this.current())) && this.peek().kind !== 36 /* TokenKind.COMMA */;) {
-            this.advance();
+        for (let token; isComparisonToken((token = this.current())) && this.peek().kind !== 4 /* TokenKind.COMMA */;) {
+            this.next();
             operators.push(token);
-            expressions.push(this.parseAdditiveExpression());
+            expressions.push(this.parseArithmeticExpression(0 /* ArithmeticPrecedence.NONE */));
         }
         // 如果没有比较（只有一个操作数），就返回那个操作数本身
         if (expressions.length === 1)
@@ -418,21 +383,28 @@ class Parser {
         // 否则，创建一个链式比较节点
         return { kind: 21 /* NodeKind.ComparisonExpression */, expressions, operators, line, col, ...this.endLoc() };
     }
-    parseAdditiveExpression() {
-        let left = this.parseMultiplicativeExpression();
-        for (let token; isAdditiveToken((token = this.current())) && this.peek().kind !== 36 /* TokenKind.COMMA */;) {
-            const { line, col } = this.advance();
-            const right = this.parseMultiplicativeExpression();
-            left = { kind: 20 /* NodeKind.ArithmeticExpression */, left, operator: token, right, line, col, ...this.endLoc(token) };
-        }
-        return left;
-    }
-    parseMultiplicativeExpression() {
+    parseArithmeticExpression(minPrecedence) {
         let left = this.parseUnaryExpression();
-        for (let token; isMultiplicativeToken((token = this.current())) && this.peek().kind !== 36 /* TokenKind.COMMA */;) {
-            const { line, col } = this.advance();
-            const right = this.parseUnaryExpression();
-            left = { kind: 20 /* NodeKind.ArithmeticExpression */, left, operator: token, right, line, col, ...this.endLoc(token) };
+        arithmetic: for (let precedence = minPrecedence; this.peek().kind !== 4 /* TokenKind.COMMA */;) {
+            const operator = this.current();
+            switch (operator.kind) {
+                case 31 /* TokenKind.ARITHMETIC_MULTIPLY */:
+                case 32 /* TokenKind.ARITHMETIC_DIVIDE */:
+                    precedence = 2 /* ArithmeticPrecedence.MULTIPLICATIVE */;
+                    break;
+                case 29 /* TokenKind.ARITHMETIC_PLUS */:
+                case 30 /* TokenKind.ARITHMETIC_MINUS */:
+                    precedence = 1 /* ArithmeticPrecedence.ADDITIVE */;
+                    break;
+                default:
+                    break arithmetic;
+            }
+            if (precedence <= minPrecedence)
+                break arithmetic;
+            this.next();
+            const right = this.parseArithmeticExpression(precedence);
+            const { line, col } = left;
+            left = { kind: 20 /* NodeKind.ArithmeticExpression */, left, operator, right, line, col, ...this.endLoc() };
         }
         return left;
     }
@@ -440,16 +412,16 @@ class Parser {
         const { kind: tokenKind, line, col } = this.current();
         let operator;
         switch (tokenKind) {
-            case 5 /* TokenKind.KEYWORD_CLONE */:
-                operator = 3 /* TokenKind.ASSIGNMENT_LIKE */;
+            case 9 /* TokenKind.KEYWORD_CLONE */:
+                operator = 7 /* TokenKind.ASSIGNMENT_LIKE */;
                 break;
-            case 6 /* TokenKind.KEYWORD_MOVE */:
-                operator = 4 /* TokenKind.ASSIGNMENT_ONLY */;
+            case 10 /* TokenKind.KEYWORD_MOVE */:
+                operator = 8 /* TokenKind.ASSIGNMENT_ONLY */;
                 break;
             default:
                 return this.parseMemberAccessExpression();
         }
-        this.advance();
+        this.next();
         // 递归调用，这样就可以处理像“高仿 高仿 a”这样的写法
         const argument = this.parseUnaryExpression();
         return { kind: 19 /* NodeKind.UnaryExpression */, operator, argument, line, col, ...this.endLoc() };
@@ -457,9 +429,9 @@ class Parser {
     parseMemberAccessExpression() {
         let object = this.parsePrimaryExpression();
         // 循环处理连续的 @ 访问
-        for (let startToken; (startToken = this.current()).kind === 25 /* TokenKind.ACCESSOR */;) {
+        for (let startToken; (startToken = this.current()).kind === 28 /* TokenKind.ACCESSOR */;) {
             const { kind: tokenKind, value } = this.next();
-            if (tokenKind === 25 /* TokenKind.ACCESSOR */) {
+            if (tokenKind === 28 /* TokenKind.ACCESSOR */) {
                 this.makeErrorTail(0 /* TokenKind.ERROR */, `不能连着写一长串「${value}」喵！`);
                 continue;
             }
@@ -470,73 +442,86 @@ class Parser {
         return object;
     }
     parsePrimaryExpression() {
-        const startToken = this.drainCommentsAhead();
-        const leading = this.takeLeadingComments();
+        const startToken = this.current();
+        const leading = this.takeUnclaimedComments();
         const { kind: tokenKind, value, line, col } = startToken;
         let node;
         switch (tokenKind) {
-            case 15 /* TokenKind.NUMBER */:
-                node = {
-                    kind: 9 /* NodeKind.NumericLiteral */,
-                    value: Number.parseFloat(value),
-                    line,
-                    col,
-                    ...this.endLoc(startToken),
-                };
+            case 19 /* TokenKind.NUMBER */:
+                node = { kind: 9 /* NodeKind.NumericLiteral */, value: +value, line, col, ...this.endLoc(startToken) };
                 break;
-            case 16 /* TokenKind.STRING */:
+            case 20 /* TokenKind.STRING */:
                 node = { kind: 10 /* NodeKind.StringLiteral */, value, line, col, ...this.endLoc(startToken) };
                 break;
-            case 17 /* TokenKind.BOOLEAN */:
+            case 21 /* TokenKind.BOOLEAN */:
                 node = { kind: 11 /* NodeKind.BooleanLiteral */, value: value === '好喵', line, col, ...this.endLoc(startToken) };
                 break;
-            case 18 /* TokenKind.NULL */:
+            case 22 /* TokenKind.NULL */:
                 node = { kind: 12 /* NodeKind.NullLiteral */, value: null, line, col, ...this.endLoc(startToken) };
                 break;
-            case 19 /* TokenKind.IDENTIFIER */:
+            case 23 /* TokenKind.IDENTIFIER */:
                 node = { kind: 13 /* NodeKind.Identifier */, symbol: value, line, col, ...this.endLoc(startToken) };
                 break;
-            case 13 /* TokenKind.KEYWORD_CALL */:
+            case 17 /* TokenKind.KEYWORD_CALL */:
                 return this.parseCallExpression();
-            case 22 /* TokenKind.BLOCK_START */:
+            case 26 /* TokenKind.BLOCK_START */:
                 return this.parseBlockOrIfExpression();
-            case 20 /* TokenKind.COLLECTION_START */:
+            case 24 /* TokenKind.COLLECTION_START */:
                 return this.parseBlockExpression(true);
-            case 9 /* TokenKind.KEYWORD_LOOP */:
+            case 13 /* TokenKind.KEYWORD_LOOP */:
                 return this.parseLoopExpression();
-            case 24 /* TokenKind.TERMINATOR */:
-            case 44 /* TokenKind.EOF */:
+            case 3 /* TokenKind.TERMINATOR */:
+            case 1 /* TokenKind.EOF */:
                 throw syntaxErrorFrom(startToken, '只说半句看不懂喵！');
             case 0 /* TokenKind.ERROR */:
                 throw errorFrom(startToken, `这个词不对劲喵：${value}`, 2 /* Phase.LEXICAL */);
             default:
                 throw syntaxErrorFrom(startToken, `看不懂的把戏喵：${value}`);
         }
-        this.advance();
+        this.next();
         if (leading.length)
             (node.leadingComments ??= []).push(...leading);
         return node;
     }
     parseBlockOrIfExpression() {
         const block = this.parseBlockExpression(false);
-        return this.current().kind === 7 /* TokenKind.KEYWORD_CONFIRM */ ? this.parseIfExpression(block) : block;
+        return this.current().kind === 11 /* TokenKind.KEYWORD_CONFIRM */ ? this.parseIfExpression(block) : block;
     }
     parseBlockExpression(isCollection) {
         const modeSwitch = +isCollection;
         const { name, startKind, startValue, separatorKind, endKind, endValue } = blockKindInfo[modeSwitch];
         const { line, col } = this.expect(startKind, `${name}需要以「${startValue}」开头喵！`);
-        const statementParser = isCollection ? () => this.parseCollectionElement() : () => this.parseStatement();
         const body = [];
         this.blockDepth[modeSwitch]++;
-        for (let tokenKind = this.current().kind; tokenKind !== endKind && tokenKind !== 44 /* TokenKind.EOF */; tokenKind = this.next().kind) {
-            if (tokenKind === separatorKind) {
-                if (isCollection)
+        if (isCollection) {
+            collection: for (let tokenKind; (tokenKind = this.current().kind) !== endKind &&
+                tokenKind !== 3 /* TokenKind.TERMINATOR */ &&
+                tokenKind !== 1 /* TokenKind.EOF */;) {
+                if (tokenKind === separatorKind) {
                     this.makeErrorTail(0 /* TokenKind.ERROR */, `这个「${this.current().value}」是多余的喵！`);
-                continue;
+                    this.next();
+                    continue;
+                }
+                body.push(this.parseCollectionElement());
+                const trailingKind = this.current().kind;
+                switch (trailingKind) {
+                    case 16 /* TokenKind.KEYWORD_DEF */:
+                    case 18 /* TokenKind.KEYWORD_RETURN */:
+                    case 15 /* TokenKind.KEYWORD_AMBUSH */:
+                    case 14 /* TokenKind.KEYWORD_BREAK */:
+                    case 25 /* TokenKind.COLLECTION_END */:
+                        break collection;
+                    default:
+                        this.expect(separatorKind, `要用「,」隔开才好看喵！`);
+                }
+            }
+        }
+        else {
+            for (let tokenKind; (tokenKind = this.current().kind) !== endKind && tokenKind !== 1 /* TokenKind.EOF */;) {
+                if (tokenKind === separatorKind && (this.next(), true))
+                    continue;
+                body.push(this.parseStatement());
             }
-            body.push(statementParser());
-            if (this.current().kind !== separatorKind)
-                break;
         }
         this.expect(endKind, `${name}需要以「${endValue}」结尾喵！`);
         this.blockDepth[modeSwitch]--;
@@ -544,10 +529,10 @@ class Parser {
     }
     parseCollectionElement() {
         const tokenKind = this.current().kind;
-        let hasUse = tokenKind === 1 /* TokenKind.KEYWORD_USE */;
+        let hasUse = tokenKind === 5 /* TokenKind.KEYWORD_USE */;
         // 模式一: 显式声明，例如 `蹭 a 就是 1`
         // 模式二: 隐式声明，例如 `a 就是 1`
-        if (hasUse || (tokenKind === 19 /* TokenKind.IDENTIFIER */ && isAssignmentOperator(this.peek().kind))) {
+        if (hasUse || (tokenKind === 23 /* TokenKind.IDENTIFIER */ && isAssignmentOperator(this.peek().kind))) {
             return this.parseVariableDeclaration(hasUse);
         }
         // 模式三：其他所有情况，都是一个独立的表达式
@@ -556,29 +541,29 @@ class Parser {
         return { kind: 8 /* NodeKind.ExpressionStatement */, expression, line, col, ...this.endLoc() };
     }
     parseIfExpression(consequent) {
-        this.advance();
+        this.next();
         const condition = this.parseExpression();
         let alternate;
         const tokenKind = this.current().kind;
-        if (tokenKind === 8 /* TokenKind.KEYWORD_ELSE */ ||
-            (tokenKind === 24 /* TokenKind.TERMINATOR */ &&
-                this.peek().kind === 8 /* TokenKind.KEYWORD_ELSE */ &&
+        if (tokenKind === 12 /* TokenKind.KEYWORD_ELSE */ ||
+            (tokenKind === 3 /* TokenKind.TERMINATOR */ &&
+                this.peek().kind === 12 /* TokenKind.KEYWORD_ELSE */ &&
                 (this.next() /* 吃掉可选「~」*/, true))) {
-            if (this.next().kind === 22 /* TokenKind.BLOCK_START */)
+            if (this.next().kind === 26 /* TokenKind.BLOCK_START */)
                 alternate = this.parseBlockOrIfExpression();
             else
-                this.makeErrorTail(22 /* TokenKind.BLOCK_START */, `要有想法「[#...#]」喵！`);
+                this.makeErrorTail(26 /* TokenKind.BLOCK_START */, `要有想法「[#...#]」喵！`);
         }
         const { line, col } = consequent;
         return { kind: 15 /* NodeKind.IfExpression */, consequent, condition, alternate, line, col, ...this.endLoc() };
     }
     parseLoopExpression() {
-        const { line, col } = this.advance();
+        const { line, col } = (this.next(), this.prevOne);
         const body = this.parseBlockExpression(false);
         return { kind: 16 /* NodeKind.LoopExpression */, body, line, col, ...this.endLoc() };
     }
     parseCallExpression() {
-        const { line, col } = this.advance();
+        const { line, col } = (this.next(), this.prevOne);
         const args = this.parseExpression();
         const callee = this.parseIdentifier();
         return { kind: 17 /* NodeKind.CallExpression */, args, callee, line, col, ...this.endLoc() };