@aster-cloud/aster-lang-ts 1.0.31 → 1.0.33

package/dist/src/parser/expr-stmt-parser.js

@@ -1,3 +1,5 @@
+import { kw, kwKind, kwKindq, kwq } from './keyword-display.js';
+import { SemanticTokenKind } from '../config/token-kind.js';
 import { kwParts, tokLowerAt, tryReadTranslatedIdent } from './context.js';
 import { TokenKind, KW } from '../frontend/tokens.js';
 import { Node } from '../ast/ast.js';
@@ -225,11 +227,11 @@ function skipInlineElseLayout(ctx) {
 function parseInlineIf(ctx, error, cond) {
     skipInlineThenLayout(ctx);
     if (!ctx.isKeyword(KW.THEN))
-        error("Expected 'then' in inline if");
+        error(`Expected ${kwq(ctx, KW.THEN)} in inline if`);
     ctx.nextWord();
     // then 分支：单个 return（内联，不带句点；句点由整条 inline-if 末尾的 return 承担）。
     if (!ctx.isKeyword(KW.RETURN))
-        error("Expected 'return' after 'then'");
+        error(`Expected ${kwq(ctx, KW.RETURN)} after ${kwq(ctx, KW.THEN)}`);
     const thenRetTok = ctx.peek();
     ctx.nextWord();
     const thenExpr = parseExpr(ctx, error);
@@ -258,7 +260,7 @@ function parseInlineIf(ctx, error, cond) {
         else {
             // else return X.（末尾 return，带句点）。
             if (!ctx.isKeyword(KW.RETURN))
-                error("Expected 'return' or 'if' after 'else'");
+                error(`Expected ${kwq(ctx, KW.RETURN)} or ${kwq(ctx, KW.IF)} after ${kwKindq(ctx, SemanticTokenKind.OTHERWISE, 'else')}`);
             const elseRetTok = ctx.peek();
             ctx.nextWord();
             const elseExpr = parseExpr(ctx, error);
@@ -359,7 +361,7 @@ export function parseStatement(ctx, error, reportOutcomeError = error) {
         ctx.nextWord();
         const nameTok = ctx.peek();
         const name = parseIdent(ctx, error);
-        expectKeyword(ctx, error, KW.BE, "Use 'be' in bindings: 'Let x be ...'.");
+        expectKeyword(ctx, error, KW.BE, `Use ${kwq(ctx, KW.BE)} in bindings: '${kw(ctx, KW.LET, 'Let')} x ${kw(ctx, KW.BE)} ...'.`);
         // Special-case lambda block form to avoid trailing '.'
         if ((ctx.isKeyword('a') && tokLowerAt(ctx, ctx.index + 1) === 'function') || ctx.isKeyword('function')) {
             if (ctx.isKeyword('a'))
@@ -367,7 +369,7 @@ export function parseStatement(ctx, error, reportOutcomeError = error) {
             const functionTok = ctx.nextWord(); // 'function'
             const params = parseParamList(ctx, error);
             expectCommaOr(ctx);
-            expectKeyword(ctx, error, KW.PRODUCE, "Expected 'produce' and return type");
+            expectKeyword(ctx, error, KW.PRODUCE, `Expected ${kwq(ctx, KW.PRODUCE)} and return type`);
             let retType;
             if (ctx.at(TokenKind.COLON)) {
                 retType = Node.TypeName('Unknown');
@@ -403,7 +405,7 @@ export function parseStatement(ctx, error, reportOutcomeError = error) {
         const setTok = ctx.peek();
         ctx.nextWord();
         const name = parseIdent(ctx, error);
-        expectKeyword(ctx, error, KW.TO_WORD, "Use 'to' in assignments: 'Set x to ...'.");
+        expectKeyword(ctx, error, KW.TO_WORD, `Use ${kwq(ctx, KW.TO_WORD)} in assignments: '${kw(ctx, KW.SET, 'Set')} x ${kw(ctx, KW.TO_WORD)} ...'.`);
         const expr = parseExpr(ctx, error);
         expectPeriodEnd(ctx, error);
         const nd = Node.Set(name, expr);
@@ -521,9 +523,9 @@ export function parseStatement(ctx, error, reportOutcomeError = error) {
     }
     if (ctx.isKeyword(KW.WITHIN)) {
         ctx.nextWord();
-        expectKeyword(ctx, error, KW.SCOPE, "Expected 'scope' after 'Within'");
+        expectKeyword(ctx, error, KW.SCOPE, `Expected ${kwq(ctx, KW.SCOPE)} after ${kwq(ctx, KW.WITHIN, 'Within')}`);
         if (!ctx.at(TokenKind.COLON))
-            error("Expected ':' after 'scope'");
+            error(`Expected ':' after ${kwq(ctx, KW.SCOPE)}`);
         ctx.next();
         expectNewline(ctx, error);
         return parseBlock(ctx, error); // Lowering later
@@ -531,8 +533,8 @@ export function parseStatement(ctx, error, reportOutcomeError = error) {
     if (ctx.isKeyword(KW.START)) {
         const startTok = ctx.nextWord();
         const name = parseIdent(ctx, error);
-        expectKeyword(ctx, error, KW.AS, "Expected 'as' after name");
-        expectKeyword(ctx, error, KW.ASYNC, "Expected 'async'");
+        expectKeyword(ctx, error, KW.AS, `Expected ${kwq(ctx, KW.AS)} after name`);
+        expectKeyword(ctx, error, KW.ASYNC, `Expected ${kwq(ctx, KW.ASYNC)}`);
         const expr = parseExpr(ctx, error);
         expectPeriodEnd(ctx, error);
         const nd = Node.Start(name, expr);
@@ -565,9 +567,9 @@ export function parseStatement(ctx, error, reportOutcomeError = error) {
 }
 function parseWorkflow(ctx, error) {
     const workflowTok = ctx.peek();
-    expectKeyword(ctx, error, KW.WORKFLOW, "Expected 'workflow'");
+    expectKeyword(ctx, error, KW.WORKFLOW, `Expected ${kwq(ctx, KW.WORKFLOW)}`);
     if (!ctx.at(TokenKind.COLON))
-        error("Expected ':' after 'workflow'");
+        error(`Expected ':' after ${kwq(ctx, KW.WORKFLOW)}`);
     ctx.next();
     expectNewline(ctx, error);
     if (!ctx.at(TokenKind.INDENT))
@@ -603,14 +605,14 @@ function parseWorkflow(ctx, error) {
 }
 function parseStep(ctx, error) {
     const stepTok = ctx.peek();
-    expectKeyword(ctx, error, KW.STEP, "Expected 'step'");
+    expectKeyword(ctx, error, KW.STEP, `Expected ${kwq(ctx, KW.STEP)}`);
     const name = parseIdent(ctx, error);
     const dependencies = [];
     if (ctx.isKeyword(KW.DEPENDS)) {
         ctx.nextWord();
-        expectKeyword(ctx, error, KW.ON, "Expected 'on' after 'depends'");
+        expectKeyword(ctx, error, KW.ON, `Expected ${kwq(ctx, KW.ON)} after ${kwq(ctx, KW.DEPENDS)}`);
         if (!ctx.at(TokenKind.LBRACKET))
-            error("Expected '[' after 'depends on'");
+            error(`Expected '[' after '${kw(ctx, KW.DEPENDS)} ${kw(ctx, KW.ON)}'`);
         ctx.next();
         if (!ctx.at(TokenKind.RBRACKET)) {
             while (true) {
@@ -642,7 +644,7 @@ function parseStep(ctx, error) {
     if (ctx.isKeyword(KW.COMPENSATE)) {
         ctx.nextWord();
         if (!ctx.at(TokenKind.COLON))
-            error("Expected ':' after 'compensate'");
+            error(`Expected ':' after ${kwq(ctx, KW.COMPENSATE)}`);
         ctx.next();
         expectNewline(ctx, error);
         compensate = parseBlock(ctx, error);
@@ -654,9 +656,9 @@ function parseStep(ctx, error) {
     return step;
 }
 function parseRetryPolicy(ctx, error) {
-    expectKeyword(ctx, error, KW.RETRY, "Expected 'retry'");
+    expectKeyword(ctx, error, KW.RETRY, `Expected ${kwq(ctx, KW.RETRY)}`);
     if (!ctx.at(TokenKind.COLON))
-        error("Expected ':' after 'retry'");
+        error(`Expected ':' after ${kwq(ctx, KW.RETRY)}`);
     ctx.next();
     expectNewline(ctx, error);
     if (!ctx.at(TokenKind.INDENT))
@@ -669,20 +671,20 @@ function parseRetryPolicy(ctx, error) {
         if (ctx.isKeywordSeq(MAX_ATTEMPTS_PARTS)) {
             ctx.nextWords(MAX_ATTEMPTS_PARTS);
             if (!ctx.at(TokenKind.COLON))
-                error("Expected ':' after 'max attempts'");
+                error(`Expected ':' after ${kwq(ctx, KW.MAX_ATTEMPTS)}`);
             ctx.next();
             if (!ctx.at(TokenKind.INT))
-                error("Expected integer after 'max attempts'");
+                error(`Expected integer after ${kwq(ctx, KW.MAX_ATTEMPTS)}`);
             const attempts = ctx.next().value;
             if (attempts <= 0)
-                error("'max attempts' must be greater than zero");
+                error(`${kwq(ctx, KW.MAX_ATTEMPTS)} must be greater than zero`);
             maxAttempts = attempts;
             expectPeriodEnd(ctx, error);
         }
         else if (ctx.isKeyword(KW.BACKOFF)) {
             ctx.nextWord();
             if (!ctx.at(TokenKind.COLON))
-                error("Expected ':' after 'backoff'");
+                error(`Expected ':' after ${kwq(ctx, KW.BACKOFF)}`);
             ctx.next();
             const modeTok = ctx.nextWord();
             const mode = String(modeTok.value ?? '').toLowerCase();
@@ -699,15 +701,15 @@ function parseRetryPolicy(ctx, error) {
     }
     ctx.next();
     if (maxAttempts === null)
-        error("Retry section must include 'max attempts'");
+        error(`Retry section must include ${kwq(ctx, KW.MAX_ATTEMPTS)}`);
     if (backoff === null)
-        error("Retry section must include 'backoff'");
+        error(`Retry section must include ${kwq(ctx, KW.BACKOFF)}`);
     return { maxAttempts, backoff };
 }
 function parseTimeout(ctx, error) {
-    expectKeyword(ctx, error, KW.TIMEOUT, "Expected 'timeout'");
+    expectKeyword(ctx, error, KW.TIMEOUT, `Expected ${kwq(ctx, KW.TIMEOUT)}`);
     if (!ctx.at(TokenKind.COLON))
-        error("Expected ':' after 'timeout'");
+        error(`Expected ':' after ${kwq(ctx, KW.TIMEOUT)}`);
     ctx.next();
     if (!ctx.at(TokenKind.INT))
         error('Expected integer timeout value');
@@ -716,6 +718,8 @@ function parseTimeout(ctx, error) {
     if (seconds < 0)
         error('Timeout value must be non-negative');
     if (!(ctx.isKeyword('seconds') || ctx.isKeyword('second'))) {
+        // 'seconds' 不做本地化：所有 locale 的词表都没有时间单位的本地拼写，
+        // zh/de 作者同样只能写英文 seconds，报错里的 'seconds' 正是作者该写的词。
         error("Timeout must specify time unit 'seconds'");
     }
     ctx.nextWord();
@@ -739,7 +743,7 @@ function parseCases(ctx, error) {
         while (!ctx.at(TokenKind.DEDENT)) {
             if (!ctx.isKeyword(KW.WHEN)) {
                 // 改进的错误消息，提示复合模式关系
-                error("Expected 'When' (若...为 pattern requires '为' after '若')");
+                error(`Expected ${kwq(ctx, KW.WHEN, 'When')} (若...为 pattern requires '为' after '若')`);
             }
             const whenTok = ctx.nextWord();
             const pat = parsePattern(ctx, error);
@@ -816,12 +820,13 @@ function parseIfExpr(ctx, error) {
     const cond = parseOr(ctx, error);
     skipInlineThenLayout(ctx);
     if (!ctx.isKeyword(KW.THEN))
-        error("Expected 'then' in if-expression");
+        error(`Expected ${kwq(ctx, KW.THEN)} in if-expression`);
     ctx.nextWord(); // 消费 THEN
     const thenE = parseExpr(ctx, error);
     skipInlineElseLayout(ctx);
     if (!ctx.isKeyword(KW.ELSE) && !ctx.isKeyword(KW.OTHERWISE)) {
-        error("Expected 'else' in if-expression (else is mandatory for expression-level if)");
+        error(`Expected ${kwKindq(ctx, SemanticTokenKind.OTHERWISE, 'else')} in if-expression ` +
+            `(${kwKind(ctx, SemanticTokenKind.OTHERWISE, 'else')} is mandatory for expression-level if)`);
     }
     ctx.nextWord(); // 消费 ELSE / OTHERWISE
     const elseE = parseExpr(ctx, error);
@@ -1293,7 +1298,7 @@ function parseApplyOrPrimary(ctx, error) {
     if (ctx.isKeyword(KW.APPLY) && applyLooksLikeCall(ctx)) {
         const applyTok = ctx.nextWord();
         const fn = parseCallTargetName(ctx, error);
-        expectKeyword(ctx, error, KW.TO_WORD, "Use 'apply <fn> to <arg>' (expected 'to').");
+        expectKeyword(ctx, error, KW.TO_WORD, `Use '${kw(ctx, KW.APPLY)} <fn> ${kw(ctx, KW.TO_WORD)} <arg>' (expected ${kwq(ctx, KW.TO_WORD)}).`);
         const arg = parseExpr(ctx, error);
         const call = Node.Call(fn, [arg]);
         assignSpan(call, spanFromSources(applyTok, arg));
@@ -1332,7 +1337,7 @@ function applyLooksLikeCall(ctx) {
 function parseCallTargetName(ctx, error) {
     const startTok = ctx.peek();
     if (!ctx.at(TokenKind.IDENT) && !ctx.at(TokenKind.TYPE_IDENT)) {
-        error("Expected a function name after 'apply'.");
+        error(`Expected a function name after ${kwq(ctx, KW.APPLY)}.`);
     }
     const consumed = [ctx.peek()];
     let full = ctx.at(TokenKind.IDENT) ? parseIdent(ctx, error) : ctx.next().value;
@@ -1361,9 +1366,56 @@ const PREFIX_OPERATORS = new Map([
     [TokenKind.STAR, '*'],
     [TokenKind.SLASH, '/'],
 ]);
-/** 前缀运算符调用：恰好 2 个实参，降为与中缀相同的 Call(Name(op), [a, b])。 */
-function parsePrefixOperatorCall(ctx, error, op) {
+// 运算符词 → 非英语词法表下 Java Canonicalizer（OPERATOR_SYMBOL_MAP）把它翻成的符号；
+// null 表示不翻译，词仍是 Java lexer 的硬 token，不能作前缀调用目标。
+const OPERATOR_WORD_SYMBOLS = new Map([
+    [KW.AND, null],
+    [KW.OR, null],
+    [KW.MODULO, null],
+    [KW.INTEGER_DIVIDED_BY, null],
+    [KW.PLUS, '+'],
+    [KW.MINUS, '-'],
+    [KW.TIMES, '*'],
+    [KW.DIVIDED_BY, '/'],
+    [KW.LESS_THAN, '<'],
+    [KW.GREATER_THAN, '>'],
+    [KW.MORE_THAN, '>'],
+    [KW.EQUALS_TO, '=='],
+    [KW.AT_LEAST, '>='],
+    [KW.AT_MOST, '<='],
+    [KW.UNDER, '<'],
+    [KW.OVER, '>'],
+]);
+// en-US 下 under/over 是软关键词（Java 当普通 IDENT），前缀位置就是普通函数调用
+const EN_SOFT_OPERATOR_WORDS = new Set([KW.UNDER, KW.OVER]);
+const PREFIX_SYMBOL_LIST = '< > <= >= != == = + - * /';
+/** 当前位置是否为「运算符词 + (」；按原文大小写精确匹配（Java lexer 区分大小写）。 */
+function operatorWordBeforeParen(ctx, english) {
+    for (const word of OPERATOR_WORD_SYMBOLS.keys()) {
+        const parts = kwParts(word);
+        const matches = parts.every((part, k) => ctx.peek(k).kind === TokenKind.IDENT && ctx.peek(k).value === part);
+        if (matches && ctx.peek(parts.length).kind === TokenKind.LPAREN) {
+            return english && EN_SOFT_OPERATOR_WORDS.has(word) ? undefined : word;
+        }
+    }
+    return undefined;
+}
+/**
+ * 运算符词前缀调用，与 Java 一致：en-US 规范拼写不翻译，词是硬 token → 拒绝；
+ * 非英语词法表下可映射为符号的词按符号前缀调用处理，其余拒绝。
+ */
+function parseOperatorWordCall(ctx, error, word, english) {
+    const symbol = english ? null : OPERATOR_WORD_SYMBOLS.get(word);
+    if (!symbol) {
+        error(`运算符词 ${kwq(ctx, word)} 不能用作前缀调用；只有符号运算符 ${PREFIX_SYMBOL_LIST} 可以写成 op(a, b)`);
+    }
+    return parsePrefixOperatorCall(ctx, error, symbol, kwParts(word).length);
+}
+/** 前缀运算符调用：恰好 2 个实参，降为与中缀相同的 Call(Name(op), [a, b])。运算符可占多个 token。 */
+function parsePrefixOperatorCall(ctx, error, op, opTokenCount = 1) {
     const opTok = ctx.next();
+    for (let k = 1; k < opTokenCount; k++)
+        ctx.next();
     const args = parseArgList(ctx, error);
     if (args.length !== 2)
         error(`前缀操作符调用需要 2 个参数，但实际为 ${args.length}`);
@@ -1375,6 +1427,11 @@ function parsePrimary(ctx, error) {
     if (prefixOp !== undefined && ctx.peek(1).kind === TokenKind.LPAREN) {
         return parsePrefixOperatorCall(ctx, error, prefixOp);
     }
+    const english = ctx.lexicon === undefined || ctx.lexicon.id === 'en-US';
+    const operatorWord = operatorWordBeforeParen(ctx, english);
+    if (operatorWord !== undefined) {
+        return parseOperatorWordCall(ctx, error, operatorWord, english);
+    }
     // Minimal: construction, literals, names, Ok/Err/Some/None, call with dotted names and parens args
     // Lambda (block form): 'a function' (or 'function') ... 'produce' Type ':' \n Block
     if ((ctx.isKeyword('a') && tokLowerAt(ctx, ctx.index + 1) === 'function') || ctx.isKeyword('function')) {
@@ -1382,7 +1439,7 @@ function parsePrimary(ctx, error) {
         const functionTok = ctx.nextWord(); // 'function'
         const params = parseParamList(ctx, error);
         expectCommaOr(ctx);
-        expectKeyword(ctx, error, KW.PRODUCE, "Expected 'produce' and return type");
+        expectKeyword(ctx, error, KW.PRODUCE, `Expected ${kwq(ctx, KW.PRODUCE)} and return type`);
         let retType;
         if (ctx.at(TokenKind.COLON)) {
             retType = Node.TypeName('Unknown');
@@ -1606,11 +1663,11 @@ function parsePrimary(ctx, error) {
                 const nameTok = ctx.peek();
                 const name = parseIdent(ctx, error);
                 if (!ctx.isKeyword(KW.SET))
-                    error("Expected 'set to' in construction");
+                    error(`Expected '${kw(ctx, KW.SET)} ${kw(ctx, KW.TO_WORD)}' in construction`);
                 const equalsTok = ctx.peek();
                 ctx.nextWord();
                 if (!ctx.isKeyword(KW.TO_WORD))
-                    error("Expected 'to' after 'set' in construction");
+                    error(`Expected ${kwq(ctx, KW.TO_WORD)} after ${kwq(ctx, KW.SET)} in construction`);
                 ctx.nextWord();
                 const e = parseExpr(ctx, error);
                 const fld = {
@@ -1666,7 +1723,7 @@ function parsePrimary(ctx, error) {
             // 仅拦截裸类型名（无点链后缀），点链形态（如 SomeType.method(...)）不受影响。
             if (full === typeName && ctx.declaredRecordTypes.has(typeName)) {
                 error(`Cannot construct '${typeName}' with positional arguments. ` +
-                    `Use named fields instead: '${typeName} with <field> set to <value> and ...'`);
+                    `Use named fields instead: '${typeName} ${kw(ctx, KW.WITH)} <field> ${kw(ctx, KW.SET)} ${kw(ctx, KW.TO_WORD)} <value> ${kw(ctx, KW.AND)} ...'`);
             }
             const args = parseArgList(ctx, error);
             const call = Node.Call(target, args);
@@ -1704,7 +1761,7 @@ function parsePrimary(ctx, error) {
             // 同 TYPE_IDENT 分支：拦截对已声明类型的位置式构造（无大小写语言里类型名是 IDENT）。
             if (full === name && ctx.declaredRecordTypes.has(name)) {
                 error(`Cannot construct '${name}' with positional arguments. ` +
-                    `Use named fields instead: '${name} with <field> set to <value> and ...'`);
+                    `Use named fields instead: '${name} ${kw(ctx, KW.WITH)} <field> ${kw(ctx, KW.SET)} ${kw(ctx, KW.TO_WORD)} <value> ${kw(ctx, KW.AND)} ...'`);
             }
             const args = parseArgList(ctx, error);
             const call = Node.Call(target, args);