@aster-cloud/aster-lang-ts 1.0.32 → 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;
@@ -1402,7 +1407,7 @@ function operatorWordBeforeParen(ctx, english) {
 function parseOperatorWordCall(ctx, error, word, english) {
     const symbol = english ? null : OPERATOR_WORD_SYMBOLS.get(word);
     if (!symbol) {
-        error(`运算符词 '${word}' 不能用作前缀调用；只有符号运算符 ${PREFIX_SYMBOL_LIST} 可以写成 op(a, b)`);
+        error(`运算符词 ${kwq(ctx, word)} 不能用作前缀调用；只有符号运算符 ${PREFIX_SYMBOL_LIST} 可以写成 op(a, b)`);
     }
     return parsePrefixOperatorCall(ctx, error, symbol, kwParts(word).length);
 }
@@ -1434,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');
@@ -1658,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 = {
@@ -1718,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);
@@ -1756,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);