@cloudpss/expression 0.6.0-alpha.8 → 0.6.0-beta.1

package/src/migrator/call.ts

@@ -6,14 +6,14 @@ import {
     isObjectNode,
     type FunctionNode,
     type MathNode,
-    isOperatorNode,
 } from 'mathjs';
 import type { Options, Result } from './interface.js';
 import type { State } from './state.js';
-import { constantValue, equalText, symbolName } from './utils.js';
+import { constantValue, equalText, globalFnName, len, symbolName } from './utils.js';
 import { migrateAtomic, migrateExpr, migrateNode } from './node.js';
 import { concat } from './concat.js';
 import { toNumber, toString } from './to-type.js';
+import { isVmArray, isVmPrimitive } from '@mirascript/mirascript';
 
 const EXACT_UNARY_FUNCTION = new Map<string, Result['type']>([
     // 只支持标量的 mathjs 函数
@@ -42,6 +42,9 @@ const EXACT_UNARY_FUNCTION = new Map<string, Result['type']>([
     ['service', 'extern'],
 ]);
 
+/** 只接受一个参数，返回数字的函数 */
+const ENTRYWISE_UNARY_MATH_FUNCTION = new Set<string>(['abs', 'ceil', 'floor', 'round', 'sign']);
+
 /** 兜底 */
 function call(state: State, node: FunctionNode<MathNode>, done: (fn: Result, args: readonly Result[]) => void): Result {
     const { fn, args } = node;
@@ -53,215 +56,305 @@ function call(state: State, node: FunctionNode<MathNode>, done: (fn: Result, arg
     };
 }
 
-/** 转换 AST */
-export function migrateCall(state: State, node: FunctionNode<MathNode>, options: Options): Result {
-    const { fn, args } = node;
-
-    const fnName = symbolName(fn);
-    if (fnName && !state.locals.has(fnName)) {
-        const openE = options.format !== 'no-paren' ? '(' : '';
-        const closeE = options.format !== 'no-paren' ? ')' : '';
+/** 函数调用 */
+function migrateFunctionCall(
+    state: State,
+    node: FunctionNode<MathNode>,
+    fnName: string,
+    args: readonly MathNode[],
+    options: Options,
+): Result {
+    const openE = options.format !== 'no-paren' ? '(' : '';
+    const closeE = options.format !== 'no-paren' ? ')' : '';
+    const g = (fnName: string) => globalFnName(state, fnName);
 
-        if (EXACT_UNARY_FUNCTION.has(fnName) && args.length === 1) {
-            const arg = migrateAtomic(state, args[0]!);
-            return {
-                type: EXACT_UNARY_FUNCTION.get(fnName)!,
-                code: `${fnName}(${arg.code})`,
-            };
-        } else if (fnName === 're' || fnName === 'im') {
-            const m = migrateAtomic(state, args[0]!);
-            state.err(`不支持复数`);
+    if (EXACT_UNARY_FUNCTION.has(fnName) && args.length === 1) {
+        const arg = migrateAtomic(state, args[0]!);
+        return {
+            type: EXACT_UNARY_FUNCTION.get(fnName)!,
+            code: `${fnName}(${arg.code})`,
+        };
+    } else if (fnName === 'random' && args.length === 0) {
+        return {
+            type: 'number',
+            code: `${g('random')}()`,
+        };
+    } else if (ENTRYWISE_UNARY_MATH_FUNCTION.has(fnName) && args.length === 1) {
+        const arg = migrateAtomic(state, args[0]!);
+        if (arg.type === 'number' || arg.type === 'boolean' || arg.type === 'string') {
             return {
                 type: 'number',
-                code: `/* ${fnName} */(${m.code})`,
+                code: `${g(fnName)}(${arg.code})`,
             };
-        } else if (fnName === 'date' && args.length === 1) {
-            return {
-                type: 'number',
-                code: `to_timestamp(${migrateAtomic(state, args[0]!).code})`,
-            };
-        } else if (fnName === 'inv' && args.length === 1) {
-            const arg = migrateAtomic(state, args[0]!);
-            return {
-                type: arg.type,
-                code: `matrix.invert(${arg.code})`,
-            };
-        } else if (fnName === 'transpose' && args.length === 1) {
+        }
+        return {
+            type: arg.type,
+            code: `${g('matrix')}.entrywise(${arg.code}, nil, ${g(fnName)})`,
+        };
+    } else if (fnName === 'max' || fnName === 'min') {
+        if (args.length === 1) {
             const arg = migrateAtomic(state, args[0]!);
             return {
-                type: arg.type,
-                code: `matrix.transpose(${arg.code})`,
+                type: 'number',
+                code: `${g(fnName)}(${arg.code})`,
             };
-        } else if (fnName === 'diag' && (args.length === 1 || args.length === 2)) {
-            const a = args.map((a) => migrateAtomic(state, a).code).join(', ');
+        } else {
+            const argList = args.map((a) => migrateAtomic(state, a));
+            if (!argList.every((a) => a.type === 'number' || a.type === 'boolean' || a.type === 'string')) {
+                state.warn(`函数行为可能不一致: ${fnName}`);
+            }
             return {
-                type: 'array',
-                code: `matrix.diagonal(${a})`,
+                type: 'number',
+                code: `${g(fnName)}(${argList.map((a) => a.code).join(', ')})`,
             };
-        } else if (fnName === 'zeros' || fnName === 'ones' || fnName === 'identity') {
+        }
+    } else if (fnName === 're' || fnName === 'im') {
+        const m = migrateAtomic(state, args[0]!);
+        state.err(`不支持复数`);
+        return {
+            type: 'number',
+            code: `/* ${fnName} */(${m.code})`,
+        };
+    } else if (fnName === 'date' && args.length === 1) {
+        return {
+            type: 'number',
+            code: `${g('to_timestamp')}(${migrateAtomic(state, args[0]!).code})`,
+        };
+    } else if (fnName === 'size' && args.length === 1) {
+        const arg = migrateAtomic(state, args[0]!);
+        return {
+            type: arg.type,
+            code: `${g('matrix')}.size(${arg.code})`,
+        };
+    } else if (fnName === 'inv' && args.length === 1) {
+        const arg = migrateAtomic(state, args[0]!);
+        return {
+            type: arg.type,
+            code: `${g('matrix')}.invert(${arg.code})`,
+        };
+    } else if (fnName === 'count' && args.length === 1) {
+        const arg = migrateAtomic(state, args[0]!);
+        if (arg.type !== 'string') {
+            state.warn(`函数行为可能不一致: count`);
+        }
+        return len(state, arg);
+    } else if (fnName === 'transpose' && args.length === 1) {
+        const arg = migrateAtomic(state, args[0]!);
+        return {
+            type: arg.type,
+            code: `${g('matrix')}.transpose(${arg.code})`,
+        };
+    } else if (fnName === 'diag' && (args.length === 1 || args.length === 2)) {
+        const a = args.map((a) => migrateAtomic(state, a).code).join(', ');
+        return {
+            type: 'array',
+            code: `${g('matrix')}.diagonal(${a})`,
+        };
+    } else if (fnName === 'zeros' || fnName === 'ones' || fnName === 'identity') {
+        return {
+            type: 'array',
+            code: `${g('matrix')}.${fnName}(${args.map((a) => migrateAtomic(state, a).code).join(', ')})`,
+        };
+    } else if (fnName === 'concat') {
+        const results = args.map((a) => migrateAtomic(state, a));
+        if (results.some((r) => r.type === 'string')) return concat(state, results);
+        if (results.some((r) => r.type === 'array')) {
+            state.warn(`矩阵连接时结果可能不一致`);
             return {
                 type: 'array',
-                code: `matrix.${fnName}(${args.map((a) => migrateAtomic(state, a).code).join(', ')})`,
+                code: `${g('flatten')}([` + results.map((r) => r.code).join(', ') + `])`,
             };
-        } else if (fnName === 'concat') {
-            const results = args.map((a) => migrateAtomic(state, a));
-            if (results.some((r) => r.type === 'string')) return concat(state, results);
-        } else if (fnName === 'numeric' && args.length === 1) {
-            return toNumber(state, args[0]!);
-        } else if (fnName === 'flatten' && args.length === 1) {
+        }
+    } else if (fnName === 'numeric' && args.length === 1) {
+        return toNumber(state, args[0]!);
+    } else if (fnName === 'flatten' && args.length === 1) {
+        return {
+            type: 'array',
+            code: `${g('flatten')}(${migrateAtomic(state, args[0]!).code})`,
+        };
+    } else if (fnName === 'norm' && args.length === 1) {
+        if (isArrayNode(args[0])) {
             return {
-                type: 'array',
-                code: `flatten(${migrateAtomic(state, args[0]!).code})`,
+                type: 'number',
+                code: `${g('hypot')}(${args[0].items.map((a) => migrateAtomic(state, a).code).join(', ')})`,
             };
-        } else if (fnName === 'norm' && args.length === 1) {
-            if (isArrayNode(args[0])) {
+        }
+        return {
+            type: 'number',
+            code: `${g('hypot')}(${migrateAtomic(state, args[0]!).code})`,
+        };
+    } else if (fnName === 'equalText' && args.length === 2) {
+        const p = equalText(state, '==', args[0]!, args[1]!);
+        return {
+            type: p.type,
+            code: `${openE}${p.code}${closeE}`,
+        };
+    } else if (fnName === 'toJson' && args.length === 1) {
+        return {
+            type: 'string',
+            code: `${g('to_json')}(${migrateAtomic(state, args[0]!).code})`,
+        };
+    } else if (fnName === 'fromJson' && args.length === 1) {
+        return {
+            code: `${g('from_json')}(${migrateAtomic(state, args[0]!).code})`,
+        };
+    } else if (fnName === 'is' && args.length === 2 && isConstantNode(args[1])) {
+        const t = String((args[1] as ConstantNode<string | number>).value);
+        switch (t) {
+            case 'number':
+            case 'string':
+            case 'boolean':
                 return {
-                    type: 'number',
-                    code: `hypot(${args[0].items.map((a) => migrateAtomic(state, a).code).join(', ')})`,
+                    type: 'boolean',
+                    code: `${openE}type(${migrateAtomic(state, args[0]!).code}) == '${t}'${closeE}`,
                 };
-            }
-            return {
-                type: 'number',
-                code: `hypot(${migrateAtomic(state, args[0]!).code})`,
-            };
-        } else if (fnName === 'equalText' && args.length === 2) {
-            const p = equalText(state, '==', args[0]!, args[1]!);
-            return {
-                type: p.type,
-                code: `${openE}${p.code}${closeE}`,
-            };
-        } else if (fnName === 'toJson' && args.length === 1) {
-            return {
-                type: 'string',
-                code: `to_json(${migrateAtomic(state, args[0]!).code})`,
-            };
-        } else if (fnName === 'fromJson' && args.length === 1) {
-            return {
-                code: `from_json(${migrateAtomic(state, args[0]!).code})`,
-            };
-        } else if (fnName === 'is' && args.length === 2 && isConstantNode(args[1])) {
-            const t = String((args[1] as ConstantNode<string | number>).value);
-            switch (t) {
-                case 'number':
-                case 'string':
-                case 'boolean':
-                    return {
-                        type: 'boolean',
-                        code: `${openE}type(${migrateAtomic(state, args[0]!).code}) == '${t}'${closeE}`,
-                    };
-                case 'null':
-                case 'undefined':
-                    return {
-                        type: 'boolean',
-                        code: `${openE}type(${migrateAtomic(state, args[0]!).code}) == 'nil'${closeE}`,
-                    };
-                case 'Array':
-                case 'array':
-                    state.warn(`'type' 与 'is' 结果可能不同`);
-                    return {
-                        type: 'boolean',
-                        code: `${openE}type(${migrateAtomic(state, args[0]!).code}) == 'array'${closeE}`,
-                    };
-                case 'Object':
-                case 'object':
-                    state.warn(`'type' 与 'is' 结果可能不同`);
+            case 'null':
+            case 'undefined':
+                return {
+                    type: 'boolean',
+                    code: `${openE}type(${migrateAtomic(state, args[0]!).code}) == 'nil'${closeE}`,
+                };
+            case 'Array':
+            case 'array':
+                state.warn(`'type' 与 'is' 结果可能不同`);
+                return {
+                    type: 'boolean',
+                    code: `${openE}type(${migrateAtomic(state, args[0]!).code}) == 'array'${closeE}`,
+                };
+            case 'Object':
+            case 'object': {
+                const arg0 = migrateAtomic(state, args[0]!);
+                if (arg0.code.endsWith('.value.rt_state')) {
                     return {
                         type: 'boolean',
-                        code: `${openE}type(${migrateAtomic(state, args[0]!).code}) == 'record'${closeE}`,
+                        code: `${openE}!!${arg0.code}${closeE}`,
                     };
-                case 'Function':
-                case 'function': {
-                    if (symbolName(args[0]!) === 'service' && !state.locals.has('service')) {
-                        return {
-                            type: 'boolean',
-                            code: `${openE}type(service) == 'extern'${closeE}`,
-                        };
-                    }
-                    state.warn(`'type' 与 'is' 结果可能不同`);
+                }
+                state.warn(`'type' 与 'is' 结果可能不同`);
+                return {
+                    type: 'boolean',
+                    code: `${openE}type(${arg0.code}) == 'record'${closeE}`,
+                };
+            }
+            case 'Function':
+            case 'function': {
+                if (symbolName(args[0]!) === 'service' && !state.locals.has('service')) {
                     return {
                         type: 'boolean',
-                        code: `${openE}type(${migrateAtomic(state, args[0]!).code}) == 'function'${closeE}`,
+                        code: `${openE}type(service) == 'extern'${closeE}`,
                     };
                 }
+                state.warn(`'type' 与 'is' 结果可能不同`);
+                return {
+                    type: 'boolean',
+                    code: `${openE}type(${migrateAtomic(state, args[0]!).code}) == 'function'${closeE}`,
+                };
             }
-        } else if (fnName === 'typeOf' && args.length === 1) {
-            state.warn(`'type' 与 'typeOf' 结果可能不同`);
-            return {
-                type: 'string',
-                code: `type(${migrateAtomic(state, args[0]!).code})`,
-            };
-        } else if (fnName === 'format' && args.length === 1) {
-            return toString(state, args[0]!);
-        } else if (fnName === 'print' && args.length === 1) {
-            state.loose();
-            return toString(state, args[0]!);
-        } else if (
-            fnName === 'print' &&
-            args.length === 2 &&
-            isConstantNode(args[0]) &&
-            (isObjectNode(args[1]) || isArrayNode(args[1]))
-        ) {
-            const template = String(args[0].value);
-            const values = isObjectNode(args[1])
-                ? args[1].properties
-                : (args[1].items as unknown as Record<string, MathNode>);
-            return {
-                type: 'string',
-                code:
-                    '`' +
-                    template.replaceAll(/`|\$([\w.]+)/g, (original, key: string) => {
-                        if (original === '`') return '\\`';
-                        const keys = key.split('.').map((part) => {
-                            const nPart = Number.parseInt(part);
-                            if (!Number.isNaN(nPart) && part.length > 0 && nPart >= 1) {
-                                return nPart - 1;
-                            } else {
-                                return part;
-                            }
-                        });
-                        const value = values[keys.shift()!];
-                        if (value == null) return original.replaceAll('$', String.raw`\$`);
-                        if (!keys.length) {
-                            return `$(${migrateAtomic(state, value).code})`;
+        }
+    } else if (fnName === 'typeOf' && args.length === 1) {
+        state.warn(`'type' 与 'typeOf' 结果可能不同`);
+        return {
+            type: 'string',
+            code: `type(${migrateAtomic(state, args[0]!).code})`,
+        };
+    } else if (fnName === 'format' && args.length === 1) {
+        return toString(state, args[0]!);
+    } else if (fnName === 'print' && args.length === 1) {
+        state.loose();
+        return toString(state, args[0]!);
+    } else if (
+        fnName === 'print' &&
+        args.length === 2 &&
+        isConstantNode(args[0]) &&
+        (isObjectNode(args[1]) || isArrayNode(args[1]))
+    ) {
+        const template = String(args[0].value);
+        const values = isObjectNode(args[1])
+            ? args[1].properties
+            : (args[1].items as unknown as Record<string, MathNode>);
+        return {
+            type: 'string',
+            code:
+                '`' +
+                template.replaceAll(/`|\$([\w.]+)/g, (original, key: string) => {
+                    if (original === '`') return '\\`';
+                    const keys = key.split('.').map((part) => {
+                        const nPart = Number.parseInt(part);
+                        if (!Number.isNaN(nPart) && part.length > 0 && nPart >= 1) {
+                            return nPart - 1;
+                        } else {
+                            return part;
                         }
-                        return `$(${migrateNode(state, value, { format: 'paren' }).code}.${keys.join('.')})`;
-                    }) +
-                    '`',
-            };
-        } else if (fnName === 'string' && args.length === 1) {
-            const inner = migrateAtomic(state, args[0]!);
+                    });
+                    const value = values[keys.shift()!];
+                    if (value == null) return original.replaceAll('$', String.raw`\$`);
+                    if (!keys.length) {
+                        return `$(${migrateAtomic(state, value).code})`;
+                    }
+                    return `$(${migrateNode(state, value, { format: 'paren' }).code}.${keys.join('.')})`;
+                }) +
+                '`',
+        };
+    } else if (fnName === 'string' && args.length === 1) {
+        const inner = migrateAtomic(state, args[0]!);
+        return {
+            type: 'string',
+            code: `${g('to_string')}(${inner.code})`,
+        };
+    } else if (fnName === 'sum' || fnName === 'prod') {
+        const newFnName = fnName === 'sum' ? 'sum' : 'product';
+        if (args.length !== 1) {
             return {
-                type: 'string',
-                code: `to_string(${inner.code})`,
+                type: 'number',
+                code: `${g(newFnName)}(${args.map((a) => migrateAtomic(state, a).code).join(', ')})`,
             };
-        } else if (
-            fnName === 'sum' &&
-            args.length === 1 &&
-            isArrayNode(args[0]) &&
-            args[0].items.length === 1 &&
-            isOperatorNode(args[0].items[0]) &&
-            ['>=', '>', '<=', '<', '==', '!='].includes(args[0].items[0].op) &&
-            typeof constantValue(args[0].items[0].args[1]!) === 'number'
-        ) {
-            // sum([a > v])
-            const a = migrateAtomic(state, args[0].items[0].args[0]!);
-            const v = migrateAtomic(state, args[0].items[0].args[1]!);
+        }
+        const arg = migrateAtomic(state, args[0]!);
+        if (arg.literal) {
+            if (isVmPrimitive(arg.literal)) {
+                return {
+                    type: 'number',
+                    code: `${g(newFnName)}(${arg.code})`,
+                };
+            }
+            if (isVmArray(arg.literal) && arg.literal.every((v) => isVmPrimitive(v))) {
+                return {
+                    type: 'number',
+                    code: `${g(newFnName)}(${arg.code})`,
+                };
+            }
+        }
+        if (arg.type === 'array' || !arg.type) {
             return {
                 type: 'number',
-                code: `sum(map(${a.code}, fn { it ${args[0].items[0].op} ${v.code} }))`,
+                code: `${g(newFnName)}(${arg.code}::${g('flatten')}())`,
             };
         }
+        return {
+            type: 'number',
+            code: `${g(newFnName)}(${arg.code})`,
+        };
+    }
 
-        return call(state, node, (fn, args) => {
-            const fun = state.globals.get(fnName);
-            if (typeof fun === 'function') {
-                if (args.some((a) => a.type !== 'number' && a.type !== 'boolean' && a.type !== 'string')) {
-                    state.warn(`函数行为可能不一致: ${fnName}`);
-                }
-            } else {
-                state.err(`不支持的函数: ${fnName}`);
+    return call(state, node, (fn, args) => {
+        const fun = state.globals.has(fnName) ? state.globals.get(fnName) : undefined;
+        if (typeof fun === 'function') {
+            if (args.some((a) => a.type !== 'number' && a.type !== 'boolean' && a.type !== 'string')) {
+                state.warn(`函数行为可能不一致: ${fnName}`);
             }
-        });
+        } else {
+            state.err(`不支持的函数: ${fnName}`);
+        }
+    });
+}
+
+/** 转换 AST */
+export function migrateCall(state: State, node: FunctionNode<MathNode>, options: Options): Result {
+    const { fn, args } = node;
+
+    const fnName = symbolName(fn);
+    if (fnName && !state.locals.has(fnName)) {
+        return migrateFunctionCall(state, node, fnName, args, options);
     }
 
     if (
@@ -272,10 +365,11 @@ export function migrateCall(state: State, node: FunctionNode<MathNode>, options:
     ) {
         const thisArg = migrateExpr(state, fn.object);
         const fnName = String(fn.index.dimensions[0].value);
+        const g = (fnName: string) => globalFnName(state, fnName);
         if (fnName === 'toString' && args.length === 0) {
             return {
                 type: 'string',
-                code: `${thisArg.code}::to_string()`,
+                code: `${thisArg.code}::${g('to_string')}()`,
             };
         } else if (fnName === 'includes' && args.length === 1) {
             if (thisArg.type === 'array') {
@@ -287,7 +381,7 @@ export function migrateCall(state: State, node: FunctionNode<MathNode>, options:
             if (thisArg.type === 'string') {
                 return {
                     type: 'boolean',
-                    code: `${thisArg.code}::contains(${migrateAtomic(state, args[0]!).code})`,
+                    code: `${thisArg.code}::${g('contains')}(${migrateAtomic(state, args[0]!).code})`,
                 };
             }
             state.helper(
@@ -300,26 +394,26 @@ export function migrateCall(state: State, node: FunctionNode<MathNode>, options:
         } else if ((fnName === 'map' || fnName === 'filter') && args.length === 1) {
             return {
                 type: 'array',
-                code: `${thisArg.code}::${fnName}(${migrateAtomic(state, args[0]!).code})`,
+                code: `${thisArg.code}::${g(fnName)}(${migrateAtomic(state, args[0]!).code})`,
             };
         } else if (fnName === 'find' && args.length === 1) {
             return {
-                code: `${thisArg.code}::find(${migrateAtomic(state, args[0]!).code}).1`,
+                code: `${thisArg.code}::${g('find')}(${migrateAtomic(state, args[0]!).code}).1`,
             };
         } else if (fnName === 'findIndex' && args.length === 1) {
             return {
                 type: 'number',
-                code: `(${thisArg.code}::find(${migrateAtomic(state, args[0]!).code}).0 ?? -1)`,
+                code: `(${thisArg.code}::${g('find')}(${migrateAtomic(state, args[0]!).code}).0 ?? -1)`,
             };
         } else if (fnName === 'flatMap' && args.length === 1) {
             return {
                 type: 'array',
-                code: `${thisArg.code}::map(${migrateAtomic(state, args[0]!).code})::flatten()`,
+                code: `${thisArg.code}::${g('map')}(${migrateAtomic(state, args[0]!).code})::flatten()`,
             };
         } else if (fnName === 'reverse' && args.length === 0) {
             return {
                 type: 'array',
-                code: `${thisArg.code}::reverse()`,
+                code: `${thisArg.code}::${g('reverse')}()`,
             };
         } else if ((fnName === 'replaceAll' || fnName === 'replace') && args.length === 2) {
             if (fnName === 'replace') {
@@ -327,12 +421,12 @@ export function migrateCall(state: State, node: FunctionNode<MathNode>, options:
             }
             return {
                 type: 'string',
-                code: `${thisArg.code}::replace(${migrateAtomic(state, args[0]!).code}, ${migrateAtomic(state, args[1]!).code})`,
+                code: `${thisArg.code}::${g('replace')}(${migrateAtomic(state, args[0]!).code}, ${migrateAtomic(state, args[1]!).code})`,
             };
         } else if (fnName === 'split' && args.length === 1) {
             return {
                 type: 'array',
-                code: `${thisArg.code}::split(${migrateAtomic(state, args[0]!).code})`,
+                code: `${thisArg.code}::${g('split')}(${migrateAtomic(state, args[0]!).code})`,
             };
         } else if (fnName === 'concat') {
             if (thisArg.type === 'string') {
@@ -344,7 +438,10 @@ export function migrateCall(state: State, node: FunctionNode<MathNode>, options:
             }
             return {
                 type: 'array',
-                code: `flatten([` + [fn.object, ...args].map((a) => migrateAtomic(state, a).code).join(', ') + `])`,
+                code:
+                    `${g('flatten')}([` +
+                    [fn.object, ...args].map((a) => migrateAtomic(state, a).code).join(', ') +
+                    `])`,
             };
         } else if (
             fnName === 'toFixed' &&
@@ -353,7 +450,7 @@ export function migrateCall(state: State, node: FunctionNode<MathNode>, options:
             const digits = constantValue(args[0]!) ?? 0;
             return {
                 type: 'string',
-                code: `${thisArg.code}::format('.${digits}')`,
+                code: `${thisArg.code}::${g('format')}('.${digits}')`,
             };
         } else if (isArrayNode(fn.object) && fnName === 'join' && args.length <= 1) {
             let sep = ',';
@@ -382,7 +479,7 @@ export function migrateCall(state: State, node: FunctionNode<MathNode>, options:
         } else if (thisArg.type === 'extern') {
             const argList = args.map((a) => migrateAtomic(state, a).code);
             return {
-                code: `${thisArg.code}(${argList.join(', ')})`,
+                code: `${thisArg.code}.${fnName}(${argList.join(', ')})`,
             };
         }
 

package/src/migrator/concat.ts

@@ -3,18 +3,31 @@ import type { State } from './state.js';
 import { migrateNode } from './node.js';
 import { isResult, type Result } from './interface.js';
 
+/** 生成转义序列 */
+function escapeString(str: string | number): string {
+    return String(str)
+        .replaceAll('\\', String.raw`\\`)
+        .replaceAll('`', '\\`')
+        .replaceAll('$', String.raw`\$`)
+        .replaceAll('\n', String.raw`\n`)
+        .replaceAll('\r', String.raw`\r`)
+        .replaceAll('\t', String.raw`\t`);
+}
+
 /** 连接字符串 */
 export function concat(state: State, args: ReadonlyArray<MathNode | string | number | Result>): Result {
     const parts: string[] = [];
     for (const arg of args) {
         if (typeof arg != 'object') {
-            parts.push(String(arg).replaceAll('`', '\\`'));
+            parts.push(escapeString(arg));
         } else if (isConstantNode(arg)) {
-            const value = String(arg.value).replaceAll('`', '\\`');
+            const value = escapeString(String(arg.value));
             parts.push(value);
         } else if (isResult(arg)) {
             if (arg.literal && typeof arg.literal != 'object') {
                 parts.push(String(arg.literal).replaceAll('`', '\\`'));
+            } else if (arg.type === 'string' && arg.code.startsWith('to_string(') && arg.code.endsWith(')')) {
+                parts.push(`$(${arg.code.slice(10, -1)})`);
             } else {
                 parts.push(`$(${arg.code})`);
             }