@cloudpss/expression 0.6.0-alpha.10 → 0.6.0-alpha.11

package/src/migrator/call.ts

@@ -10,7 +10,7 @@ import {
 } from 'mathjs';
 import type { Options, Result } from './interface.js';
 import type { State } from './state.js';
-import { constantValue, equalText, len, 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';
@@ -63,6 +63,7 @@ function migrateFunctionCall(
 ): 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]!);
@@ -80,19 +81,19 @@ function migrateFunctionCall(
     } else if (fnName === 'date' && args.length === 1) {
         return {
             type: 'number',
-            code: `to_timestamp(${migrateAtomic(state, args[0]!).code})`,
+            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: `matrix.size(${arg.code})`,
+            code: `${g('matrix')}.size(${arg.code})`,
         };
     } else if (fnName === 'inv' && args.length === 1) {
         const arg = migrateAtomic(state, args[0]!);
         return {
             type: arg.type,
-            code: `matrix.invert(${arg.code})`,
+            code: `${g('matrix')}.invert(${arg.code})`,
         };
     } else if (fnName === 'count' && args.length === 1) {
         const arg = migrateAtomic(state, args[0]!);
@@ -104,39 +105,46 @@ function migrateFunctionCall(
         const arg = migrateAtomic(state, args[0]!);
         return {
             type: arg.type,
-            code: `matrix.transpose(${arg.code})`,
+            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: `matrix.diagonal(${a})`,
+            code: `${g('matrix')}.diagonal(${a})`,
         };
     } else if (fnName === 'zeros' || fnName === 'ones' || fnName === 'identity') {
         return {
             type: 'array',
-            code: `matrix.${fnName}(${args.map((a) => migrateAtomic(state, a).code).join(', ')})`,
+            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: `${g('flatten')}([` + results.map((r) => r.code).join(', ') + `])`,
+            };
+        }
     } else if (fnName === 'numeric' && args.length === 1) {
         return toNumber(state, args[0]!);
     } else if (fnName === 'flatten' && args.length === 1) {
         return {
             type: 'array',
-            code: `flatten(${migrateAtomic(state, args[0]!).code})`,
+            code: `${g('flatten')}(${migrateAtomic(state, args[0]!).code})`,
         };
     } else if (fnName === 'norm' && args.length === 1) {
         if (isArrayNode(args[0])) {
             return {
                 type: 'number',
-                code: `hypot(${args[0].items.map((a) => migrateAtomic(state, a).code).join(', ')})`,
+                code: `${g('hypot')}(${args[0].items.map((a) => migrateAtomic(state, a).code).join(', ')})`,
             };
         }
         return {
             type: 'number',
-            code: `hypot(${migrateAtomic(state, args[0]!).code})`,
+            code: `${g('hypot')}(${migrateAtomic(state, args[0]!).code})`,
         };
     } else if (fnName === 'equalText' && args.length === 2) {
         const p = equalText(state, '==', args[0]!, args[1]!);
@@ -147,11 +155,11 @@ function migrateFunctionCall(
     } else if (fnName === 'toJson' && args.length === 1) {
         return {
             type: 'string',
-            code: `to_json(${migrateAtomic(state, args[0]!).code})`,
+            code: `${g('to_json')}(${migrateAtomic(state, args[0]!).code})`,
         };
     } else if (fnName === 'fromJson' && args.length === 1) {
         return {
-            code: `from_json(${migrateAtomic(state, args[0]!).code})`,
+            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);
@@ -254,7 +262,7 @@ function migrateFunctionCall(
         const inner = migrateAtomic(state, args[0]!);
         return {
             type: 'string',
-            code: `to_string(${inner.code})`,
+            code: `${g('to_string')}(${inner.code})`,
         };
     } else if (
         fnName === 'sum' &&
@@ -270,7 +278,7 @@ function migrateFunctionCall(
         const v = migrateAtomic(state, args[0].items[0].args[1]!);
         return {
             type: 'number',
-            code: `sum(map(${a.code}, fn { it ${args[0].items[0].op} ${v.code} }))`,
+            code: `${g('sum')}(${g('map')}(${a.code}, fn { it ${args[0].items[0].op} ${v.code} }))`,
         };
     }
 
@@ -303,10 +311,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') {
@@ -318,7 +327,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(
@@ -331,26 +340,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') {
@@ -358,12 +367,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') {
@@ -375,7 +384,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' &&
@@ -384,7 +396,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 = ',';

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})`);
             }

package/src/migrator/operator.ts

@@ -8,7 +8,7 @@ import {
     isOperatorNode,
     isNode,
 } from 'mathjs';
-import { symbolName, constantValue, equalText, scalar } from './utils.js';
+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';
@@ -19,58 +19,58 @@ import { operations, serialize } from '@mirascript/mirascript/subtle';
 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) => {
+        (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: `matrix.multiply(${l.code}, matrix.invert(${r.code}))`,
+                    code: `${globalFnName(state, 'matrix')}.multiply(${l.code}, ${globalFnName(state, 'matrix')}.invert(${r.code}))`,
                 };
             }
             return {
                 type: l.type === 'array' ? 'array' : l.type ? 'number' : undefined,
-                code: `matrix.entrywise_divide(${l.code}, ${r.code})`,
+                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',
@@ -107,47 +107,47 @@ 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))) {
         return {
             type: 'array',
-            code: `${l.code}::map(fn { ${op({ code: 'it' }, r).code} })`,
+            code: `${l.code}::${globalFnName(state, 'map')}(fn { ${op(state, { code: 'it' }, r).code} })`,
         };
     }
     if (Array.isArray(r.literal) && r.literal.every((e) => !Array.isArray(e))) {
         return {
             type: 'array',
-            code: `${r.code}::map(fn { ${op(l, { code: 'it' }).code} })`,
+            code: `${r.code}::${globalFnName(state, 'map')}(fn { ${op(state, l, { code: 'it' }).code} })`,
         };
     }
     if (alt) {
-        return alt(l, r);
+        return alt(state, l, r);
     }
     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, { code: 'a' }, { code: '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))) {
         return {
             type: 'array',
-            code: `${v.code}::map(fn { ${op({ code: 'it' }).code} })`,
+            code: `${v.code}::${globalFnName(state, 'map')}(fn { ${op(state, { code: '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} })`,
     };
 }
 
@@ -179,14 +179,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,
             );
@@ -205,7 +205,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}`,
             }));
@@ -315,7 +315,7 @@ 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.type === 'boolean' && r.type === 'boolean') {
                     return {
                         type: 'boolean',

package/src/migrator/to-type.ts

@@ -3,11 +3,14 @@ import type { Result } from './interface.js';
 import { serialize } from '@mirascript/mirascript/subtle';
 import type { State } from './state.js';
 import { migrateNode } from './node.js';
+import { globalFnName } from './utils.js';
 
 /** 转换 AST */
 export function toBoolean(state: State, node: MathNode | Result): Result {
     const helper = (): void => {
-        state.helper("fn @@to_boolean { it != '' && it != 0 && it is not nan && !!it }");
+        state.helper(
+            "fn @@to_boolean { if it is nil { return nil; } it != '' && it != '0' && it != 0 && it is not nan && !!it }",
+        );
     };
     if (!isNode(node)) {
         if (node.type === 'boolean') return node;
@@ -56,7 +59,7 @@ export function toString(state: State, node: MathNode | Result): Result {
         }
         return {
             type: 'string',
-            code: `to_string(${node.code})`,
+            code: `${globalFnName(state, 'to_string')}(${node.code})`,
         };
     }
     if (isConstantNode(node)) {
@@ -92,7 +95,7 @@ export function toNumber(state: State, node: MathNode | Result): Result {
         }
         return {
             type: 'number',
-            code: `to_number(${node.code})`,
+            code: `${globalFnName(state, 'to_number')}(${node.code})`,
         };
     }
     if (isConstantNode(node)) {

package/src/migrator/utils.ts

@@ -4,6 +4,14 @@ import type { State } from './state.js';
 import { toString } from './to-type.js';
 import { migrateExpr } from './node.js';
 
+/** 获取全局函数的名字 */
+export function globalFnName(state: State, fnName: string): string {
+    if (state.locals.has(fnName)) {
+        return `global.${fnName}`;
+    }
+    return fnName;
+}
+
 /** 获取 symbol name */
 export function symbolName(node: MathNode): string | undefined {
     if (!isSymbolNode(node)) return undefined;
@@ -79,7 +87,7 @@ export function len(state: State, obj: Result): Result {
             code: `len(${obj.code})`,
         };
     state.helper(
-        `fn @@length(x) { if type(x) == 'string' { len(chars(x)) } else if type(x) == 'array' { len(x) } } else { x.length } }`,
+        `fn @@length(x) { if type(x) == 'string' { len(chars(x)) } else if type(x) == 'array' { len(x) } else { x.length } }`,
     );
     return {
         type: 'number',