@cloudpss/expression 0.6.0-alpha.2 → 0.6.0-alpha.20

package/src/migrator/function.ts

@@ -0,0 +1,27 @@
+import type { FunctionAssignmentNode } from 'mathjs';
+import type { Result } from './interface.js';
+import { migrateAtomic } from './node.js';
+import { type State, FunctionState } from './state.js';
+import { migrateSymbolName } from './utils.js';
+
+/** 转换函数定义语句 */
+export function migrateFunctionAssignment(state: State, node: FunctionAssignmentNode): Result {
+    state.loose();
+    const { name, params, expr } = node;
+    const fState = new FunctionState(state, params);
+    let body = migrateAtomic(fState, expr);
+    if (!(body.code.startsWith('{') && body.code.endsWith('}'))) {
+        body = { ...body, code: `{ ${body.code} }` };
+    }
+    if (state.locals.has(name)) {
+        state.err(`重复定义函数: '${name}'`);
+    }
+    state.locals.set(name, {
+        type: 'function',
+        code: body.code,
+    });
+    return {
+        type: 'function',
+        code: `fn ${migrateSymbolName(name, true)}(${params.join(', ')}) ${body.code}`,
+    };
+}

package/src/migrator/interface.ts

@@ -1,4 +1,4 @@
-import type { TypeName, VmConst } from '@mirascript/mirascript';
+import type { TypeName, VmConst, VmValue } from '@mirascript/mirascript';
 
 /** 转换选项 */
 export interface Options {
@@ -12,6 +12,8 @@ export interface Result {
     readonly type?: TypeName;
     /** 为字面量 */
     readonly literal?: VmConst;
+    /** 为全局变量 */
+    readonly global?: VmValue;
     /** 转换后的代码 */
     readonly code: string;
     /** 转换后的代码 */

package/src/migrator/node.ts

@@ -1,4 +1,4 @@
-import { serialize, serializePropName } from '@mirascript/mirascript/subtle';
+import { serializeRecordKey } from '@mirascript/mirascript/subtle';
 import {
     type MathNode,
     isAccessorNode,
@@ -12,16 +12,20 @@ import {
     isRelationalNode,
     type OperatorNodeFn,
     isSymbolNode,
+    isFunctionAssignmentNode,
 } from 'mathjs';
 import type { State } from './state.js';
 import type { Options, Result } from './interface.js';
 import type { VmConst } from '@mirascript/mirascript';
-import { unsupportedNode } from './utils.js';
+import { constantValue, unsupportedNode } from './utils.js';
 import { migrateAccess } from './access.js';
 import { migrateCall } from './call.js';
 import { migrateOperator } from './operator.js';
 import { migrateSymbol } from './symbol.js';
 import { migrateCondition } from './condition.js';
+import { migrateFunctionAssignment } from './function.js';
+import { serialize } from './serialize.js';
+import { toNumber } from './to-type.js';
 
 /** 转换 AST */
 export function migrateAtomic(state: State, node: MathNode): Result {
@@ -79,7 +83,7 @@ export function migrateNode(state: State, node: MathNode, options: Options): Res
             } else {
                 literals[key] = item.literal;
             }
-            code.push(`${serializePropName(key)}: ${item.code}`);
+            code.push(`${serializeRecordKey(key)}: ${item.code}`);
         }
         return {
             type: 'record',
@@ -110,6 +114,26 @@ export function migrateNode(state: State, node: MathNode, options: Options): Res
     }
     if (isRelationalNode(node)) {
         const { conditionals, params } = node;
+        // 优化范围判断 a <= b <= c
+        if (
+            conditionals.length === 2 &&
+            params.length === 3 &&
+            conditionals[0] === 'smallerEq' &&
+            conditionals[1] === 'smallerEq'
+        ) {
+            // 模式匹配只支持常量
+            const l = constantValue(params[0]!);
+            const r = constantValue(params[2]!);
+            if (typeof l == 'number' && typeof r == 'number' && l < r) {
+                const v = toNumber(state, migrateNode(state, params[1]!, options));
+                let code = `${v.code} is ${l}..${r}`;
+                if (options.format !== 'no-paren') code = `(${code})`;
+                return {
+                    type: 'boolean',
+                    code,
+                };
+            }
+        }
         const exprs = [];
         for (let i = 0; i < conditionals.length; i++) {
             const fn = conditionals[i]! as OperatorNodeFn;
@@ -117,15 +141,22 @@ export function migrateNode(state: State, node: MathNode, options: Options): Res
             const r = params[i + 1]!;
             exprs.push(migrateOperator(state, { fn, args: [l, r] }, options));
         }
-        let code = exprs.join(' && ');
+        let code = exprs.map((e) => e.code).join(' && ');
         if (options.format !== 'no-paren') code = `(${code})`;
         return {
             type: 'boolean',
             code,
         };
     }
+    if (isFunctionAssignmentNode(node)) {
+        const result = migrateFunctionAssignment(state, node);
+        state.helper(result.code);
+        return {
+            type: 'function',
+            code: node.name,
+        };
+    }
     // if (isRangeNode(node)) {
     // if (isIndexNode(node)) {
-    // if (isFunctionAssignmentNode(node)) {
     return unsupportedNode(state, node);
 }

package/src/migrator/operator.ts

@@ -8,61 +8,71 @@ import {
     isOperatorNode,
     isNode,
 } from 'mathjs';
-import { symbolName, constantValue, equalText, scalar } from './utils.js';
+import { isVmArray, type TypeName, type VmAny } from '@mirascript/mirascript';
+import { operations } from '@mirascript/mirascript/subtle';
+import { symbolName, constantValue, equalText, scalar, globalFnName } from './utils.js';
 import type { State } from './state.js';
 import type { Options, Result } from './interface.js';
-import { migrateAtomic, migrateExpr } from './node.js';
+import { migrateAtomic, migrateExpr, migrateParen } from './node.js';
 import { toBoolean, toNumber } from './to-type.js';
 import { migrateSymbol } from './symbol.js';
-import { operations, serialize } from '@mirascript/mirascript/subtle';
+import { serialize } from './serialize.js';
 
 const BINARY_MATH_OPERATORS = {
     add: [
         ' + ',
-        (l, r) => ({
+        (state, l, r) => ({
             type: l.type === 'array' || r.type === 'array' ? 'array' : l.type && r.type ? 'number' : undefined,
-            code: `matrix.add(${l.code}, ${r.code})`,
+            code: `${globalFnName(state, 'matrix')}.add(${l.code}, ${r.code})`,
         }),
     ],
     subtract: [
         ' - ',
-        (l, r) => ({
+        (state, l, r) => ({
             type: l.type === 'array' || r.type === 'array' ? 'array' : l.type && r.type ? 'number' : undefined,
-            code: `matrix.subtract(${l.code}, ${r.code})`,
+            code: `${globalFnName(state, 'matrix')}.subtract(${l.code}, ${r.code})`,
         }),
     ],
     multiply: [
         ' * ',
-        (l, r) => ({
+        (state, l, r) => ({
             type: l.type === 'array' || r.type === 'array' ? 'array' : l.type && r.type ? 'number' : undefined,
-            code: `matrix.multiply(${l.code}, ${r.code})`,
+            code: `${globalFnName(state, 'matrix')}.multiply(${l.code}, ${r.code})`,
         }),
     ],
     dotMultiply: [
         ' * ',
-        (l, r) => ({
+        (state, l, r) => ({
             type: l.type === 'array' || r.type === 'array' ? 'array' : l.type && r.type ? 'number' : undefined,
-            code: `matrix.entrywise_multiply(${l.code}, ${r.code})`,
+            code: `${globalFnName(state, 'matrix')}.entrywise_multiply(${l.code}, ${r.code})`,
         }),
     ],
     divide: [
         ' / ',
-        (l, r) => ({
-            type: l.type === 'array' || r.type === 'array' ? 'array' : l.type && r.type ? 'number' : undefined,
-            code: `matrix.multiply(${l.code}, matrix.invert(${r.code}))`,
-        }),
+        (state, l, r) => {
+            if (r.type === 'array' || !r.type) {
+                return {
+                    type: l.type === 'array' || r.type === 'array' ? 'array' : l.type && r.type ? 'number' : undefined,
+                    code: `${globalFnName(state, 'matrix')}.multiply(${l.code}, ${globalFnName(state, 'matrix')}.invert(${r.code}))`,
+                };
+            }
+            return {
+                type: l.type === 'array' ? 'array' : l.type ? 'number' : undefined,
+                code: `${globalFnName(state, 'matrix')}.entrywise_divide(${l.code}, ${r.code})`,
+            };
+        },
     ],
     dotDivide: [
         ' / ',
-        (l, r) => ({
+        (state, l, r) => ({
             type: l.type === 'array' || r.type === 'array' ? 'array' : l.type && r.type ? 'number' : undefined,
-            code: `matrix.entrywise_divide(${l.code}, ${r.code})`,
+            code: `${globalFnName(state, 'matrix')}.entrywise_divide(${l.code}, ${r.code})`,
         }),
     ],
     mod: [' % '],
     pow: ['^', false],
     dotPow: ['^'],
-} satisfies Record<string, [op: string, alt?: ((l: Result, r: Result) => Result) | false]>;
+} satisfies Record<string, [op: string, alt?: ((state: State, l: Result, r: Result) => Result) | false]>;
 
 const MATH_FUNCTIONS = {
     factorial: 'factorial',
@@ -76,70 +86,92 @@ const MATH_FUNCTIONS = {
 } as const;
 
 const BIT_OPS_TO_BOOL_OPS = {
-    bitAnd: '&&',
-    bitOr: '||',
-    bitXor: '!=',
+    bitAnd: ['&&', false],
+    bitOr: ['||', false],
+    bitXor: ['!=', true],
 } as const;
 
 const COMPARE_OPERATORS = {
-    smaller: '<',
-    smallerEq: '<=',
-    larger: '>',
-    largerEq: '>=',
+    smaller: ['<'],
+    smallerEq: ['<='],
+    larger: ['>'],
+    largerEq: ['>='],
+    equal: ['=~', '=='],
+    unequal: ['!~', '!='],
 } as const;
 
 /** 转换为 boolean */
-function b(op: string, state: State, node: MathNode): string {
-    const re = migrateExpr(state, node);
+function b(op: string, state: State, node: MathNode, migrator = migrateExpr): string {
+    const re = migrator(state, node);
     return toBoolean(state, scalar(op, state, re)).code;
 }
 
+/** 数组元素类型 */
+function elementType(lit: VmAny): TypeName | undefined {
+    if (!isVmArray(lit) || !lit.length) return undefined;
+    let type: TypeName | undefined = undefined;
+    for (const e of lit) {
+        const t = operations.$Type(e as VmAny);
+        if (!type) {
+            type = t;
+        } else if (type !== t) {
+            return undefined;
+        }
+    }
+    return type;
+}
+
 /** 二元操作 */
 function binary(
     state: State,
     l: Result,
     r: Result,
-    op: (l: Result, r: Result) => Result,
-    alt?: (l: Result, r: Result) => Result,
+    op: (state: State, l: Result, r: Result) => Result,
+    alt?: (state: State, l: Result, r: Result) => Result,
 ): Result {
     if (l.type && r.type && l.type !== 'array' && r.type !== 'array') {
-        return op(l, r);
+        return op(state, l, r);
     }
     if (Array.isArray(l.literal) && l.literal.every((e) => !Array.isArray(e))) {
+        const it = { code: 'it', type: elementType(l.literal) };
         return {
             type: 'array',
-            code: `${l.code}::map(fn { ${op({ code: 'it' }, r).code} })`,
+            code: `${l.code}::${globalFnName(state, 'map')}(fn { ${op(state, it, r).code} })`,
         };
     }
     if (Array.isArray(r.literal) && r.literal.every((e) => !Array.isArray(e))) {
+        const it = { code: 'it', type: elementType(r.literal) };
         return {
             type: 'array',
-            code: `${r.code}::map(fn { ${op(l, { code: 'it' }).code} })`,
+            code: `${r.code}::${globalFnName(state, 'map')}(fn { ${op(state, l, it).code} })`,
         };
     }
     if (alt) {
-        return alt(l, r);
+        return alt(state, l, r);
     }
+    const a = { code: 'a', type: l.type === 'array' ? elementType(l.literal) : l.type };
+    const b = { code: 'b', type: r.type === 'array' ? elementType(r.literal) : r.type };
     return {
         type: l.type === 'array' || r.type === 'array' ? 'array' : undefined,
-        code: `matrix.entrywise(${l.code}, ${r.code}, fn (a, b) { ${op({ code: 'a' }, { code: 'b' }).code} })`,
+        code: `${globalFnName(state, 'matrix')}.entrywise(${l.code}, ${r.code}, fn (a, b) { ${op(state, a, b).code} })`,
     };
 }
 
 /** 一元操作 */
-function unary(state: State, v: Result, op: (v: Result) => Result): Result {
+function unary(state: State, v: Result, op: (state: State, v: Result) => Result): Result {
     if (v.type && v.type !== 'array') {
-        return op(v);
+        return op(state, v);
     }
     if (Array.isArray(v.literal) && v.literal.every((e) => !Array.isArray(e))) {
+        const it = { code: 'it', type: elementType(v.literal) };
         return {
             type: 'array',
-            code: `${v.code}::map(fn { ${op({ code: 'it' }).code} })`,
+            code: `${v.code}::${globalFnName(state, 'map')}(fn { ${op(state, it).code} })`,
         };
     }
     return {
         type: 'array',
-        code: `matrix.entrywise(${v.code}, nil, fn { ${op({ code: 'it' }).code} })`,
+        code: `${globalFnName(state, 'matrix')}.entrywise(${v.code}, nil, fn { ${op(state, { code: 'it' }).code} })`,
     };
 }
 
@@ -171,14 +203,14 @@ export function migrateOperator(
                 state,
                 migrateExpr(state, a0),
                 migrateExpr(state, a1),
-                (l, r) => ({
+                (state, l, r) => ({
                     type: 'number',
                     code: `${l.code}${op}${r.code}`,
                 }),
                 alt === false
-                    ? (l, r) => {
+                    ? (state, l, r) => {
                           state.warn(`'${op.trim()}' 不支持矩阵，计算结果可能不一致`);
-                          return { code: `${l.code} ^ ${r.code}` };
+                          return { code: `${l.code}${op}${r.code}` };
                       }
                     : alt,
             );
@@ -187,9 +219,9 @@ export function migrateOperator(
         case 'unaryMinus':
         case 'unaryPlus': {
             const op = fn === 'unaryMinus' ? '-' : '+';
-            const f = fn === 'unaryMinus' ? operations.$Neg : operations.$Pos;
             const exp = migrateExpr(state, a0);
             if (typeof exp.literal == 'number') {
+                const f = fn === 'unaryMinus' ? operations.$Neg : operations.$Pos;
                 const v = f(exp.literal);
                 return {
                     type: 'number',
@@ -197,7 +229,7 @@ export function migrateOperator(
                     code: serialize(v),
                 };
             }
-            return unary(state, migrateExpr(state, a0), (v) => ({
+            return unary(state, migrateExpr(state, a0), (state, v) => ({
                 type: 'number',
                 code: `${op}${v.code}`,
             }));
@@ -217,8 +249,10 @@ export function migrateOperator(
                 return scalar(f, state, r);
             });
             if (codes.every((c) => c.type === 'boolean' || c.as_boolean) && fn in BIT_OPS_TO_BOOL_OPS) {
-                const boolOp = BIT_OPS_TO_BOOL_OPS[fn as keyof typeof BIT_OPS_TO_BOOL_OPS];
-                const code = codes.map((c) => toBoolean(state, c).code).join(` ${boolOp} `);
+                const [boolOp, needParen] = BIT_OPS_TO_BOOL_OPS[fn as keyof typeof BIT_OPS_TO_BOOL_OPS];
+                const code = args
+                    .map((a) => toBoolean(state, (needParen ? migrateParen : migrateExpr)(state, a)).code)
+                    .join(` ${boolOp} `);
                 return {
                     type: 'number',
                     code: `to_number(${code})`,
@@ -253,7 +287,7 @@ export function migrateOperator(
         case 'xor': {
             return {
                 type: 'boolean',
-                code: `${open}${b('!=', state, a0)} != ${b('!=', state, a1)}${close}`,
+                code: `${open}${b('!=', state, a0, migrateParen)} != ${b('!=', state, a1, migrateParen)}${close}`,
             };
         }
         case 'not': {
@@ -279,17 +313,21 @@ export function migrateOperator(
         }
 
         case 'equal':
-        case 'unequal': {
-            const op = fn === 'equal' ? '==' : '!=';
+        case 'unequal':
+        case 'smaller':
+        case 'smallerEq':
+        case 'larger':
+        case 'largerEq': {
+            const [op, eqOp] = COMPARE_OPERATORS[fn];
             const c0 = constantValue(a0);
             const c1 = constantValue(a1);
-            if (c0 === null || c1 === null) {
-                state.loose();
-                const p0 = c0 === null ? { code: `nil` } : scalar(op, state, migrateExpr(state, a0));
-                const p1 = c1 === null ? { code: `nil` } : scalar(op, state, migrateExpr(state, a1));
+            if (eqOp && (c0 === null || c1 === null)) {
+                // Mathjs 只支持标量与 null 比较
+                const p0 = c0 === null ? { code: `nil` } : migrateExpr(state, a0);
+                const p1 = c1 === null ? { code: `nil` } : migrateExpr(state, a1);
                 return {
                     type: 'boolean',
-                    code: `${open}${p0.code} ${op} ${p1.code}${close}`,
+                    code: `${open}${p0.code} ${eqOp} ${p1.code}${close}`,
                 };
             }
             // PI, E 与常量比较时，不进行转换
@@ -307,23 +345,31 @@ export function migrateOperator(
                 return r;
             };
 
-            return binary(state, a(a0), a(a1), (l, r) => {
+            return binary(state, a(a0), a(a1), (state, l, r) => {
+                if (l.literal !== undefined) {
+                    return {
+                        type: 'boolean',
+                        code: `${toNumber(state, l).code} ${op} ${r.code}`,
+                    };
+                }
+                if (r.literal !== undefined) {
+                    return {
+                        type: 'boolean',
+                        code: `${l.code} ${op} ${toNumber(state, r).code}`,
+                    };
+                }
+                if (l.type === 'number' || r.type === 'number') {
+                    return {
+                        type: 'boolean',
+                        code: `${l.code} ${op} ${r.code}`,
+                    };
+                }
                 return {
                     type: 'boolean',
                     code: `${toNumber(state, l).code} ${op} ${toNumber(state, r).code}`,
                 };
             });
         }
-        case 'smaller':
-        case 'smallerEq':
-        case 'larger':
-        case 'largerEq': {
-            const op = COMPARE_OPERATORS[fn];
-            return {
-                type: 'boolean',
-                code: `${open}${scalar(op, state, migrateExpr(state, a0)).code} ${op} ${scalar(op, state, migrateExpr(state, a1)).code}${close}`,
-            };
-        }
 
         default: {
             state.err(`不支持的运算符: ${fn}`);

package/src/migrator/serialize.ts

@@ -0,0 +1,21 @@
+import type { VmValue } from '@mirascript/mirascript';
+import { serialize as s, serializeNumber } from '@mirascript/mirascript/subtle';
+
+/** 序列化 */
+export function serialize(value: VmValue): string {
+    return s(value, {
+        serializeNumber: (value: number): string => {
+            if (!Number.isFinite(value) || value === 0) {
+                return serializeNumber(value);
+            }
+            const p1 = value.toString();
+            const p2 = value.toExponential();
+            // 还是优先选择默认的形式，除非指数形式更短很多
+            if (p2.length + 2 < p1.length) {
+                return p2;
+            } else {
+                return p1;
+            }
+        },
+    });
+}

package/src/migrator/special.ts

@@ -12,6 +12,37 @@ const pairs: ReadonlyArray<{ find: string; mathjs: MathNode; mira: string }> = (
             let d2 = matrix.diagonal([$yc, $yc, $yc], +3);
             d0::matrix.add(d1)::matrix.add(d2)`,
         ],
+        // 长导线校正移到后台处理
+        [
+            'sinh(gamma',
+            `rpl = $R1pu * $Vbase * $Vbase / $Sbase; xpl = $X1pu * $Vbase * $Vbase / $Sbase;bpl = $B1pu / $Vbase / $Vbase * $Sbase; zp = rpl + i * xpl; yp = i * bpl; gamma = sqrt(zp * yp); z = $Length * zp * (gamma == 0 ? 1 : (sinh(gamma * $Length)/(gamma * $Length))); re(z)`,
+            '$R1pu * $Vbase * $Vbase / $Sbase * $Length',
+        ],
+        [
+            'sinh(gamma',
+            `rpl = $R1pu * $Vbase * $Vbase / $Sbase; xpl = $X1pu * $Vbase * $Vbase / $Sbase;bpl = $B1pu / $Vbase / $Vbase * $Sbase; zp = rpl + i * xpl; yp = i * bpl; gamma = sqrt(zp * yp); z = $Length * zp * (gamma == 0 ? 1 : (sinh(gamma * $Length)/(gamma * $Length))); im(z)`,
+            '$X1pu * $Vbase * $Vbase / $Sbase * $Length',
+        ],
+        [
+            'tanh(gamma',
+            `rpl = $R1pu * $Vbase * $Vbase / $Sbase; xpl = $X1pu * $Vbase * $Vbase / $Sbase;bpl = $B1pu / $Vbase / $Vbase * $Sbase; zp = rpl + i * xpl; yp = i * bpl; gamma = sqrt(zp * yp); y = $Length * yp * (gamma == 0 ? 1 : (tanh(gamma * $Length / 2) / (gamma * $Length / 2))); im(y)`,
+            '$B1pu / $Vbase / $Vbase * $Sbase * $Length',
+        ],
+        [
+            'sinh(gamma',
+            `rpl = $R1; xpl = $Xl1; bpl = 1e-6 / $Xc1; zp = rpl + i * xpl; yp = i * bpl; gamma = sqrt(zp * yp); z = $Length * zp * (gamma == 0 ? 1 : (sinh(gamma * $Length)/(gamma * $Length))); re(z)`,
+            '$R1 * $Length',
+        ],
+        [
+            'sinh(gamma',
+            `rpl = $R1; xpl = $Xl1; bpl = 1e-6 / $Xc1; zp = rpl + i * xpl; yp = i * bpl; gamma = sqrt(zp * yp); z = $Length * zp * (gamma == 0 ? 1 : (sinh(gamma * $Length)/(gamma * $Length))); im(z)`,
+            '$Xl1 * $Length',
+        ],
+        [
+            'tanh(gamma',
+            `rpl = $R1; xpl = $Xl1; bpl = 1e-6 / $Xc1; zp = rpl + i * xpl; yp = i * bpl; gamma = sqrt(zp * yp); y = $Length * yp * (gamma == 0 ? 1 : (tanh(gamma * $Length / 2) / (gamma * $Length / 2))); im(y)`,
+            '1e-6 / $Xc1 * $Length',
+        ],
     ] satisfies ReadonlyArray<[find: string, mathjs: string, mira: string]>
 ).map(([find, mathjs, mira]) => ({
     find,

package/src/migrator/state.ts

@@ -1,10 +1,10 @@
-import { createVmContext, type VmContext } from '@mirascript/mirascript';
+import type { VmContext } from '@mirascript/mirascript';
 import { parse } from './parser.js';
 import {
     type AssignmentNode,
-    type FunctionAssignmentNode,
     isAssignmentNode,
     isBlockNode,
+    isConstantNode,
     isFunctionAssignmentNode,
     isSymbolNode,
     type MathNode,
@@ -12,9 +12,10 @@ import {
 import type { Result } from './interface.js';
 import { migrateAtomic } from './node.js';
 import { toBoolean } from './to-type.js';
-import { constantValue, symbolName, unsupportedNode } from './utils.js';
+import { constantValue, migrateSymbolName, symbolName, unsupportedNode } from './utils.js';
 import { migrateAccess } from './access.js';
 import { specialMigrate } from './special.js';
+import { migrateFunctionAssignment } from './function.js';
 
 /** 转换 AST */
 function migrateLast(state: State, node: MathNode): Result {
@@ -38,17 +39,20 @@ function migrateAssignment(state: State, node: AssignmentNode): Result {
     const { object, index, value } = node;
     const name = symbolName(object);
     if (name && index == null) {
-        // name = xxx;
+        const localName = migrateSymbolName(name, true);
         if (state.locals.has(name)) {
-            state.err(`不支持局部变量重新赋值: ${name}'`);
+            state.err(`不支持局部变量重新赋值: '${name}'`);
             return {
-                code: `${name} = ${migrateAtomic(state, value).code}`,
+                code: `${localName} = ${migrateAtomic(state, value).code}`,
             };
         }
         const expr = migrateAtomic(state, value);
         state.locals.set(name, expr);
+        if (name !== localName) {
+            state.warn(`变量名 '${name}' 是 MiraScript 关键字，已转换为 '${localName}'`);
+        }
         return {
-            code: `let ${name} = ${expr.code};`,
+            code: `let ${localName} = ${expr.code};`,
         };
     }
     if (index != null) {
@@ -60,26 +64,6 @@ function migrateAssignment(state: State, node: AssignmentNode): Result {
     }
     return unsupportedNode(state, node);
 }
-/** 转换函数定义语句 */
-function migrateFunctionAssignment(state: State, node: FunctionAssignmentNode): Result {
-    state.loose();
-    const { name, params, expr } = node;
-    if (state.locals.has(name)) {
-        state.err(`重复定义函数: ${name}`);
-    }
-    const fState = new FunctionState(state, params);
-    let body = migrateAtomic(fState, expr);
-    if (!(body.code.startsWith('{') && body.code.endsWith('}'))) {
-        body = { ...body, code: `{ ${body.code} }` };
-    }
-    state.locals.set(name, {
-        type: 'function',
-        code: body.code,
-    });
-    return {
-        code: `fn ${name}(${params.join(', ')}) ${body.code}`,
-    };
-}
 
 /** 转换状态 */
 export class BaseState {
@@ -87,7 +71,7 @@ export class BaseState {
         private readonly expr: string,
         readonly condition: boolean,
         /** 可识别的全局环境 */
-        readonly globals: VmContext = createVmContext(),
+        readonly globals: VmContext,
     ) {}
     /** 帮助函数 */
     private readonly helpers = new Set<string>();
@@ -126,7 +110,7 @@ export class BaseState {
         const r = isFunc ? migrateFunctionAssignment(this, node) : migrator(this, node);
         let { code } = r;
         if (stmt && !isFunc && !code.endsWith(';')) code += ';';
-        if (node.comment) code += ' //' + node.comment;
+        if (node.comment) code += ' //' + node.comment.slice(1);
         this.ret.push(code);
     }
     /** 转换 */
@@ -143,7 +127,6 @@ export class BaseState {
             const sp = specialMigrate(this.expr, ast);
             if (sp != null) {
                 this.ret.push(sp);
-                this.loose();
                 return;
             }
             if (isBlockNode(ast)) {
@@ -160,6 +143,8 @@ export class BaseState {
                     }
                 }
                 return;
+            } else if (isConstantNode(ast) && ast.value === undefined && ast.comment) {
+                this.ret.push(`//${ast.comment.slice(1)}`);
             } else {
                 this.migrateStmt(migrateLast, false, ast);
                 return;
@@ -178,21 +163,33 @@ export class BaseState {
         // 写入原始 math.js 作为注释
         const lines = this.expr.split('\n').map((line) => `// ${line}`);
         lines.unshift(`// # 原始 math.js 表达式`);
+        const addComment = (prefix: string, item: string) => {
+            if (!item.includes('\n')) {
+                lines.unshift(`// ${prefix}: ${item}`);
+                return;
+            }
+            const l = item.split('\n');
+            const indent = ' '.repeat(prefix.length + 2);
+            for (let i = l.length - 1; i >= 1; i--) {
+                lines.unshift(`// ${indent}${l[i]}`);
+            }
+            lines.unshift(`// ${prefix}: ${l[0]}`);
+        };
         if (this.errors.size || this.warnings.size || this.critical.size) {
             const warnings = [...this.warnings];
             for (let i = warnings.length - 1; i >= 0; i--) {
                 const warn = warnings[i]!;
-                lines.unshift(`// - W: ${warn}`);
+                addComment('- W', warn);
             }
             const errors = [...this.errors];
             for (let i = errors.length - 1; i >= 0; i--) {
                 const err = errors[i]!;
-                lines.unshift(`// - E: ${err}`);
+                addComment('- E', err);
             }
             const critical = [...this.critical];
             for (let i = critical.length - 1; i >= 0; i--) {
                 const crit = critical[i]!;
-                lines.unshift(`// - C: ${crit}`);
+                addComment('- C', crit);
             }
             lines.unshift(`// # 转换日志`);
         }