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

package/dist/migrator/call.js

@@ -1,8 +1,9 @@
-import { isAccessorNode, isArrayNode, isConstantNode, isObjectNode, isOperatorNode, } from 'mathjs';
-import { constantValue, equalText, symbolName } from './utils.js';
+import { isAccessorNode, isArrayNode, isConstantNode, isObjectNode, } from 'mathjs';
+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([
     // 只支持标量的 mathjs 函数
     ['sin', 'number'],
@@ -27,6 +28,8 @@ const EXACT_UNARY_FUNCTION = new Map([
     // XStudio 提供的函数
     ['service', 'extern'],
 ]);
+/** 只接受一个参数，返回数字的函数 */
+const ENTRYWISE_UNARY_MATH_FUNCTION = new Set(['abs', 'ceil', 'floor', 'round', 'sign']);
 /** 兜底 */
 function call(state, node, done) {
     const { fn, args } = node;
@@ -37,232 +40,323 @@ function call(state, node, done) {
         code: `${fnRet.code}(${argList.map((a) => a.code).join(', ')})`,
     };
 }
-/** 转换 AST */
-export function migrateCall(state, node, options) {
-    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' ? ')' : '';
-        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(`不支持复数`);
-            return {
-                type: 'number',
-                code: `/* ${fnName} */(${m.code})`,
-            };
-        }
-        else if (fnName === 'date' && args.length === 1) {
+/** 函数调用 */
+function migrateFunctionCall(state, node, fnName, args, options) {
+    const openE = options.format !== 'no-paren' ? '(' : '';
+    const closeE = options.format !== 'no-paren' ? ')' : '';
+    const g = (fnName) => 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 === '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: `to_timestamp(${migrateAtomic(state, args[0]).code})`,
+                code: `${g(fnName)}(${arg.code})`,
             };
         }
-        else if (fnName === 'inv' && 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.invert(${arg.code})`,
+                type: 'number',
+                code: `${g(fnName)}(${arg.code})`,
             };
         }
-        else if (fnName === 'transpose' && args.length === 1) {
-            const arg = migrateAtomic(state, args[0]);
+        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: arg.type,
-                code: `matrix.transpose(${arg.code})`,
+                type: 'number',
+                code: `${g(fnName)}(${argList.map((a) => a.code).join(', ')})`,
             };
         }
-        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})`,
-            };
+    }
+    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`);
         }
-        else if (fnName === 'zeros' || fnName === 'ones' || fnName === 'identity') {
+        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].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].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;
-            return {
-                type: 'string',
-                code: '`' +
-                    template.replaceAll(/`|\$([\w.]+)/g, (original, key) => {
-                        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;
+        return {
+            type: 'string',
+            code: '`' +
+                template.replaceAll(/`|\$([\w.]+)/g, (original, key) => {
+                    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;
                         }
-                        return `$(${migrateNode(state, value, { format: 'paren' }).code}.${keys.join('.')})`;
-                    }) +
-                    '`',
-            };
-        }
-        else if (fnName === 'string' && args.length === 1) {
-            const inner = migrateAtomic(state, args[0]);
+                        else {
+                            return part;
+                        }
+                    });
+                    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 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 {
+            type: 'number',
+            code: `${g(newFnName)}(${arg.code})`,
+        };
+    }
+    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, node, options) {
+    const { fn, args } = node;
+    const fnName = symbolName(fn);
+    if (fnName && !state.locals.has(fnName)) {
+        return migrateFunctionCall(state, node, fnName, args, options);
     }
     if (isAccessorNode(fn) &&
         fn.index.dimensions.length === 1 &&
@@ -270,10 +364,11 @@ export function migrateCall(state, node, options) {
         typeof fn.index.dimensions[0].value == 'string') {
         const thisArg = migrateExpr(state, fn.object);
         const fnName = String(fn.index.dimensions[0].value);
+        const g = (fnName) => 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) {
@@ -286,7 +381,7 @@ export function migrateCall(state, node, 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(`fn @@includes(it, el) { match it::type() { case 'string' { it::contains(el) } case 'array' { el in it } case _ { false } } }`);
@@ -298,30 +393,30 @@ export function migrateCall(state, node, 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) {
@@ -330,13 +425,13 @@ export function migrateCall(state, node, 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') {
@@ -349,7 +444,9 @@ export function migrateCall(state, node, 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' &&
@@ -357,7 +454,7 @@ export function migrateCall(state, node, 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) {
@@ -391,7 +488,7 @@ export function migrateCall(state, node, 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(', ')})`,
             };
         }
         state.err(`不支持的方法: ${fnName}`);