@aster-cloud/aster-lang-ts 1.0.27 → 1.0.29

package/dist/src/core/interpreter.js

@@ -69,6 +69,56 @@ function decimalScale(scale) {
     }
     return n;
 }
+/**
+ * 严格整型换算——与 truffle `Builtins.toInt` 等价（issue #144）。
+ *
+ * ★为什么不能用裸 `Number()`：`Number("x")` 得 `NaN` 后**所有防线同时失效**——
+ * `NaN < MIN || NaN > MAX` 两侧都是 false 于是放行；`size > MAX_RANGE_SIZE` 同理，
+ * 然后循环零次返回 `[]`。非法输入不报错，反而产出「看起来正常」的决策值。
+ *
+ * 实测（修复前）：
+ *
+ *     Date.daysBetween("x","b")            → success:true, value:NaN
+ *     Date.addDays("x",5) greater than 0   → success:true, value:false
+ *     List.length(List.range("a",5))       → success:true, value:0
+ *
+ * 而 truffle 同输入抛 `NumberFormatException`——**同一条规则两引擎一个静默出错答案、
+ * 一个响亮失败**。对合规引擎，静默的那个远更危险。
+ *
+ * 语义逐条对齐 truffle `toInt`：
+ * - number  → 截断取整（对齐 Java `Number.intValue()`），但拒绝 NaN/Infinity；
+ * - bigint  → 精确转换，超出安全整数范围拒绝（Long 已是 BigInt 表示，见 issue #142）；
+ * - string  → 严格整数解析（对齐 `Integer.parseInt`：不接受小数、十六进制、空串）；
+ * - 其他    → 抛错。
+ */
+function toInt(v, ctx) {
+    const bad = () => {
+        throw new InterpreterError(`${ctx}: expected Int, got ${JSON.stringify(v) ?? String(v)}`);
+    };
+    if (typeof v === 'number') {
+        if (!Number.isFinite(v))
+            return bad();
+        return Math.trunc(v);
+    }
+    if (typeof v === 'bigint') {
+        if (v > BigInt(Number.MAX_SAFE_INTEGER) || v < BigInt(Number.MIN_SAFE_INTEGER))
+            return bad();
+        return Number(v);
+    }
+    if (typeof v === 'string') {
+        // ★只接受**整数**字面量，与 Integer.parseInt 一致：
+        //   "5" 收；"5.0"/"0x10"/""/" "/"5x" 拒。前后空白由 trim 容忍（parseInt 亦然）。
+        //   正则无歧义分支，线性匹配（避免 decimalScale 注释里记录过的 ReDoS）。
+        const t = v.trim();
+        if (!/^[+-]?\d+$/.test(t))
+            return bad();
+        const n = Number(t);
+        if (!Number.isSafeInteger(n))
+            return bad();
+        return n;
+    }
+    return bad();
+}
 /** 把任意操作数转成 Decimal（Int/Long 精确提升；Double 禁；已是 Decimal 原样）。 */
 function toDecimalArg(v, ctx) {
     if (v instanceof Decimal)
@@ -201,6 +251,12 @@ export function serializeGuestValue(v, depth = 0) {
     if (depth > SERIALIZE_MAX_DEPTH) {
         throw new InterpreterError('serializeGuestValue: value nesting exceeds max depth (cycle?)');
     }
+    // ★BigInt（Long 的运行时表示）必须在委托 JSON.stringify 之前拦下——
+    //   JSON.stringify(1n) 直接抛错。输出为无引号十进制字面量，与 JVM 侧
+    //   Jackson 序列化 `long` 的形态一致（9223372036854775807，非 "…" 字符串）。
+    if (typeof v === 'bigint') {
+        return v.toString();
+    }
     if (v instanceof GuestMap) {
         const parts = [];
         for (const [k, val] of v) {
@@ -305,8 +361,42 @@ function mapKey(k) {
         throw new InterpreterError('Map key must not be null: null and the string "null" would collapse to the same key, '
             + 'silently overwriting each other. Use a non-null key, or Maybe/Option to express absence.');
     }
+    // ★变体（Some/None/Ok/Err）作键时必须按**内容**归一，不能用 `String(obj)`
+    //   ——JS 里它恒为 `"[object Object]"`，于是 `Some("null")` 与 `None`
+    //   塌陷到同一个槽位（`List.groupBy` 上实测两桶并成一桶）。这正是本函数
+    //   开头的 null 守卫要消灭的那类**静默丢数据**，只是发生在变体上。
+    //
+    //   truffle 侧 `String.valueOf(map)` 天然渲染内容（`{__type=None}` /
+    //   `{__type=Some, value=null}`），两键本就不同——故此前 TS 得 1 桶、
+    //   Java 得 2 桶，是双引擎分叉（aster-lang-ts#137 统一 None 表示后暴露）。
+    if (isVariantValue(k)) {
+        const v = k;
+        return 'value' in v ? `{__type=${v.__type}, value=${mapKeyPart(v.value)}}` : `{__type=${v.__type}}`;
+    }
     return String(k);
 }
+/**
+ * 变体载荷的字符串化：载荷本身可能又是变体，递归走同一条归一。
+ *
+ * ★已知缺口（两引擎**一致地**存在，非本次引入，故不在此修）：
+ *   载荷为真 null 时渲染成 `null`，与载荷为字符串 `"null"` 撞键——
+ *   `Map.put(m, Some(null), 1)` 与 `Map.put(m, Some("null"), 2)` 塌陷成同一槽位。
+ *   实测两引擎同为 1 桶（truffle 走 `String.valueOf`，同样得 `value=null`），
+ *   故不是分叉，而是 mapKey 开头那条 null 守卫**没有下沉到载荷层**。
+ *   修它需先与 truffle 商定载荷 null 的规范渲染并同步改两侧，属独立议题。
+ */
+function mapKeyPart(v) {
+    if (v === null || v === undefined)
+        return 'null';
+    return isVariantValue(v) ? mapKey(v) : String(v);
+}
+/** 是否为 Maybe/Result 变体（带 `__type` 标签且标签值属四者之一）。 */
+function isVariantValue(v) {
+    if (v === null || typeof v !== 'object')
+        return false;
+    const t = v.__type;
+    return t === 'Some' || t === 'None' || t === 'Ok' || t === 'Err';
+}
 /**
  * 值相等（value equality），与 JVM `equals` 契约对齐——**不是** JS 引用相等。
  * - Decimal↔Decimal 用 `.equals`（`1.5m === 1.5m` 引用不等但值相等）。
@@ -338,9 +428,35 @@ function valueEquals(x, y, depth = 0) {
                 return false;
         return true;
     }
+    // ★Map 结构相等（issue #143）。此前这里把 Map **排除**在结构比较之外
+    //   （下面的条件带 `&& !(x instanceof Map)`），GuestMap 落回引用相等：
+    //     Map.put(Map.empty(),"a",1) == Map.put(Map.empty(),"a",1)  → false
+    //   而同样内容的列表 [1,2] == [1,2] → true——**TS 自身就不自洽**；
+    //   truffle 侧 valueEquals 对映射逐键递归 → 内容相同的 map JVM 判 true，
+    //   同一规则跨引擎决策翻转，且不报错。
+    //
+    //   镜像 truffle Builtins.valueEquals 的语义：先比 size，再逐键递归；
+    //   一侧是 Map 另一侧不是 → false（载体不同即不等）。
+    //   GuestMap extends Map，故 `instanceof Map` 同时覆盖两者。
+    const xm = x instanceof Map;
+    const ym = y instanceof Map;
+    if (xm && ym) {
+        const mx = x;
+        const my = y;
+        if (mx.size !== my.size)
+            return false;
+        for (const [k, v] of mx) {
+            if (!my.has(k))
+                return false;
+            if (!valueEquals(v, my.get(k), depth + 1))
+                return false;
+        }
+        return true;
+    }
+    if (xm || ym)
+        return false;
     if (x && y && typeof x === 'object' && typeof y === 'object'
-        && !Array.isArray(x) && !Array.isArray(y)
-        && !(x instanceof Map) && !(y instanceof Map)) {
+        && !Array.isArray(x) && !Array.isArray(y)) {
         const kx = Object.keys(x);
         const ky = Object.keys(y);
         if (kx.length !== ky.length)
@@ -742,12 +858,25 @@ class Interpreter {
             case 'String':
                 return expr.value;
             case 'Long':
-                // Long 值存储为 string，尝试转为 number
-                return Number(expr.value);
+                // ★Long 运行时表示 = BigInt（issue #142）。此前是 `Number(expr.value)`，
+                //   把词法层专门用 BigInt 保住的精度又丢了回去：
+                //     9223372036854775807L → 9223372036854776000（差 193，静默错答案）
+                //   而 JVM 侧 CoreModel.LongE 是精确 `long` → 同一源码两引擎结果不同。
+                //   改用 BigInt 后与 JVM 逐位一致。
+                //
+                //   ★BigInt 的三个坑（已实测，见 evalBinaryOp / serializeGuestValue）：
+                //     · JSON.stringify(1n) 抛 "Do not know how to serialize a BigInt"
+                //     · 1n + 1 抛 "Cannot mix BigInt and other types"
+                //     · 1n === 1 为 false（== 才为 true）
+                return BigInt(expr.value);
             case 'Null':
                 return null;
+            // ★None 的运行期表示是 `{__type:'None'}`，与 truffle 的 `maybeNone()` 对齐
+            // （aster-lang-ts#137）。此前返回裸 `null`：同一份 IR 两引擎产出不同 JSON，
+            // 宿主一边拿到 `null`、一边拿到 `{"__type":"None"}`，等价性按值比较判为不等；
+            // 且 `null` 无法与「真的没有值」区分——None 是**有值的变体**，只是不含载荷。
             case 'None':
-                return null;
+                return { __type: 'None' };
             case 'Name':
                 return this.resolveName(expr.name, env);
             case 'Call':
@@ -834,7 +963,8 @@ class Interpreter {
                 return { __type: ctor, value: this.evalExpr(call.args[0], env) };
             }
             if (ctor === 'None' && call.args.length === 0) {
-                return null;
+                // 与 evalExpr 的 case 'None' 同一表示（aster-lang-ts#137）。
+                return { __type: 'None' };
             }
         }
         // stdlib namespaced builtin（Text.* 等），与 Java Builtins 对齐。
@@ -1006,11 +1136,11 @@ class Interpreter {
             case 'Text.substring': {
                 const args = a();
                 const s = text(args[0]);
-                const start = Number(args[1]);
+                const start = toInt(args[1], 'Text.substring');
                 if (start < 0)
                     throw new InterpreterError(`Text.substring: index out of range: ${start}`);
                 if (args.length >= 3) {
-                    const end = Number(args[2]);
+                    const end = toInt(args[2], 'Text.substring');
                     if (end < 0)
                         throw new InterpreterError(`Text.substring: index out of range: ${end}`);
                     // Java String.substring(start,end) 对 start>end 或 end>length 抛异常。
@@ -1033,8 +1163,8 @@ class Interpreter {
             case 'List.slice': {
                 const args = a();
                 const l = reqList('List.slice', args[0]);
-                const start = Number(args[1]);
-                const end = args.length >= 3 ? Number(args[2]) : l.length;
+                const start = toInt(args[1], 'List.slice');
+                const end = args.length >= 3 ? toInt(args[2], 'List.slice') : l.length;
                 // 镜像 Java List.subList 的越界语义。
                 if (start < 0 || end > l.length || start > end) {
                     throw new InterpreterError(`List.slice: index out of range: begin ${start}, end ${end}, size ${l.length}`);
@@ -1061,8 +1191,19 @@ class Interpreter {
                 return reqList('List.isEmpty', l).length === 0;
             }
             case 'List.get': {
+                // ★越界必须抛错，不得静默返回 undefined（issue aster-dev#32）。
+                //   JS 的 `arr[99]` 是 undefined，而 truffle Builtins.List.get 有显式
+                //   边界检查并抛 BuiltinException——同一段源码两引擎一个静默产
+                //   undefined、一个响亮失败，且文档声称「越界报错且双引擎一致」。
+                //   undefined 随后会一路流进裁决结果，是最危险的一类静默错答案。
+                //   消息对齐 truffle ErrorMessages.collectionIndexOutOfBounds 的英文形式。
                 const [l, i] = a();
-                return reqList('List.get', l)[Number(i)];
+                const list = reqList('List.get', l);
+                const idx = toInt(i, 'List.get');
+                if (idx < 0 || idx >= list.length) {
+                    throw new InterpreterError(`List.get: index out of bounds: ${idx} (size=${list.length})`);
+                }
+                return list[idx];
             }
             case 'List.contains': {
                 const [l, x] = a();
@@ -1084,16 +1225,16 @@ class Interpreter {
             //   此前返回裸值/null，于是 `Map.get(m,k) plus 1` 能**编译通过、运行才炸**。
             //   ★这是对 Stable 集的语义变更，明知破坏 spec-1.0-freeze 承诺，由用户拍板接受。
             //
-            //   ★TS 侧 None 的运行期表示**就是 null**（见 evalExpr 的 case 'None'），
-            //   故缺键分支保持返回 null 即等价于 None——Maybe.isNone/withDefault 都已认它。
-            //   真正变的是**命中**分支：现在包一层 Some，与 Java 的 {_type:"Some"} 对齐。
+            //   ★None 的运行期表示是 `{__type:'None'}`（见 evalExpr 的 case 'None'，
+            //   aster-lang-ts#137 起与 truffle 的 maybeNone() 对齐）；缺键分支返回它。
+            //   命中分支包一层 Some，与 Java 的 {__type:"Some"} 对齐。
             //   命中值本身为 null 时仍返回 Some(null)：「键存在但值为 null」与「键不存在」
             //   是两件事，不能塌陷。
             case 'Map.get': {
                 const [m, k] = a();
                 const g = asGuestMap('Map.get', m);
                 const key = mapKey(k);
-                return g.has(key) ? { __type: 'Some', value: g.get(key) } : null;
+                return g.has(key) ? { __type: 'Some', value: g.get(key) } : { __type: 'None' };
             }
             case 'Map.contains': {
                 const [m, k] = a();
@@ -1122,11 +1263,11 @@ class Interpreter {
             case 'Date.fromISO': return dateFromISO(a()[0]);
             case 'Date.daysBetween': {
                 const [d1, d2] = a();
-                return Number(d2) - Number(d1);
+                return toInt(d2, 'Date.daysBetween') - toInt(d1, 'Date.daysBetween');
             }
             case 'Date.addDays': {
                 const [d, n] = a();
-                const r = Number(d) + Number(n);
+                const r = toInt(d, 'Date.addDays') + toInt(n, 'Date.addDays');
                 if (r < DATE_MIN_EPOCH || r > DATE_MAX_EPOCH)
                     throw new InterpreterError(`Date.OutOfRange: epoch-day ${r}`);
                 return r;
@@ -1179,13 +1320,13 @@ class Interpreter {
             // Ok/Err/Int/Text 四格分叉（共 8 格），isSome/isOk/isErr 全对齐。
             // JVM 那侧是对的——isNone 不该对 `Ok(1)`、`42` 返回 true。
             //
-            // ★两种 None 表示都要认：`None` 字面量求值为裸 `null`（evalExpr 的 case 'None'），
-            // 而 Maybe.map 等返回 `{__type:'None'}`。只认后者会让 `Maybe.isNone(None)` 变 false。
+            // ★None 只有一种运行期表示 `{__type:'None'}`（aster-lang-ts#137 起统一）。
+            // 此前 `None` 字面量求值为裸 `null`，故这里额外把 `null`/`undefined` 判为 None；
+            // 现已不需要——truffle 侧 `"None".equals(m.get("__type"))` 对 null 返回 false，
+            // 继续放行会让 `Maybe.isNone(null)` 两引擎分叉（TS true / JVM false）。
             case 'Maybe.isNone':
             case 'Option.isNone': {
                 const [x] = a();
-                if (x === null || x === undefined)
-                    return true;
                 return x?.__type === 'None';
             }
             case 'Result.isOk': {
@@ -1296,9 +1437,11 @@ class Interpreter {
             }
             case 'List.range': {
                 const [s, e] = a();
-                const start = Number(s);
-                const end = Number(e);
+                const start = toInt(s, 'List.range');
+                const end = toInt(e, 'List.range');
                 // 红队 P0-B：先按长度判上限，超限即抛（不先生成，防 DoS）。
+                // ★start/end 走 toInt 后不可能是 NaN——此前裸 Number() 下 NaN 会让
+                //   `size > MAX_RANGE_SIZE` 为 false 直接放行，循环零次静默返回 []。
                 const size = end - start;
                 if (size > MAX_RANGE_SIZE) {
                     throw new InterpreterError(`List.range: 长度过大（${size} > ${MAX_RANGE_SIZE}），拒绝以防内存耗尽 DoS`);
@@ -1426,9 +1569,10 @@ class Interpreter {
             // `operationExpectedType("Maybe.map", "Maybe (Some or None)", …)`）。
             // 既是双引擎分叉，也是静默错答案，与 #123 的 arity 缺口同一模式。
             //
-            // 注意 TS 侧 None 有**两种**运行期表示，都要认：`None` 字面量求值为 `null`
-            // （evalExpr 的 case 'None'），而 Maybe.map 自身返回 `{__type:'None'}`。
-            // 只认后者会误伤 `Maybe.map(None, f)`。
+            // ★None 只有一种运行期表示 `{__type:'None'}`（aster-lang-ts#137 起统一）。
+            // 此前 `None` 字面量求值为裸 `null`，故这里额外放行 `null`；现已不需要——
+            // 且 truffle 的 `Maybe.map` 要求带标签的 map、对裸 null 直接报错，
+            // 继续放行 `null` 本身就是新的分叉。
             //
             // ★不在放行之列（有意为之）：`undefined`、以及 JVM 形的 `{_type:'None'}`
             // （单下划线——truffle 用 `_type`，TS 全仓用 `__type`）。后者若从跨引擎
@@ -1442,7 +1586,7 @@ class Interpreter {
                     const fn = callableArg(1);
                     return { __type: 'Some', value: this.applyCallable(fn, [o.value]) };
                 }
-                if (o !== null && o?.__type !== 'None') {
+                if (o?.__type !== 'None') {
                     // 消息**主体**与 truffle 的 operationExpectedType 对齐
                     // （`Maybe.map: expected Maybe (Some or None), got X`），但**类型名词汇表
                     // 两侧不同**，不止大小写：本引擎用 JS `typeof`（7 值域），truffle 用
@@ -1559,6 +1703,56 @@ class Interpreter {
                     throw new InterpreterError(`Decimal: unsupported operator '${op}'`);
             }
         }
+        // ★BigInt（Long）分派——必须在下面的原生算术之前。
+        //   JS 不允许 BigInt 与 number 混算（`1n + 1` 抛错），故：
+        //     · 两侧都是 BigInt      → 用 BigInt 运算，精确 64 位，与 JVM long 一致
+        //     · 一侧 BigInt 一侧 Int → 把整数值 number 提升为 BigInt（精确，无损）
+        //     · 一侧 BigInt 一侧非整数 Double → 响亮失败，不静默降级
+        //   与 Decimal 分派同构（见上），理由相同：静默错答案比响亮失败危险得多。
+        if (typeof left === 'bigint' || typeof right === 'bigint') {
+            const toBig = (v, side) => {
+                if (typeof v === 'bigint')
+                    return v;
+                if (typeof v === 'number') {
+                    if (!Number.isInteger(v)) {
+                        throw new InterpreterError(`Cannot combine Long and non-integer Double (${side}). Long arithmetic is exact 64-bit.`);
+                    }
+                    if (!Number.isSafeInteger(v)) {
+                        // >2^53 的 number 本身已不精确，提升过去只会把错误带进精确域
+                        throw new InterpreterError(`Cannot combine Long and unsafe integer ${v} (${side}); value already lost precision as a JS number.`);
+                    }
+                    return BigInt(v);
+                }
+                throw new InterpreterError(`Long ${op}: expected Long/Int operand, got ${typeof v}`);
+            };
+            const lb = toBig(left, 'left'), rb = toBig(right, 'right');
+            switch (op) {
+                case '+': return lb + rb;
+                case '-': return lb - rb;
+                case '*': return lb * rb;
+                case '/':
+                    if (rb === 0n)
+                        throw new InterpreterError('Division by zero');
+                    // Long 除法与 JVM 一致：向零截断的整数除法
+                    return lb / rb;
+                case '//':
+                    if (rb === 0n)
+                        throw new InterpreterError('Division by zero');
+                    return lb / rb;
+                case '%':
+                    if (rb === 0n)
+                        throw new InterpreterError('Division by zero');
+                    return lb % rb;
+                case '==': return lb === rb;
+                case '!=': return lb !== rb;
+                case '<': return lb < rb;
+                case '<=': return lb <= rb;
+                case '>': return lb > rb;
+                case '>=': return lb >= rb;
+                default:
+                    throw new InterpreterError(`Long: unsupported operator '${op}'`);
+            }
+        }
         // 算术运算
         switch (op) {
             case '+': {