@mirascript/mirascript 0.1.42 → 0.1.44

package/src/compiler/emit/sourcemap.ts

@@ -1,7 +1,7 @@
+import { SourceMapGenerator } from 'source-map-js';
 import type { IRange } from '../diagnostic.js';
 import type { ScriptInput, TranspileOptions } from '../types.js';
-import { SourceMapGenerator } from 'source-map-js';
-import { SCRIPT_PREFIX } from './constants.js';
+import type { ScriptPrefix } from './constants.js';
 import { toJsLiteral } from './consts.js';
 
 const ORIGIN = `mira://MiraScript/`;
@@ -38,6 +38,7 @@ let sourceId = 1;
 /** 创建源映射 */
 export function createSourceMap(
     source: ScriptInput | undefined,
+    scriptPrefix: ScriptPrefix,
     sourcemaps: readonly IRange[],
     codeLines: string[],
     functions: readonly number[],
@@ -82,7 +83,7 @@ export function createSourceMap(
         map.addMapping({
             generated: {
                 line: SOURCE_OFFSET,
-                column: SCRIPT_PREFIX.length - 'CpEnter();'.length,
+                column: scriptPrefix.length - 'CpEnter();'.length,
             },
             original: {
                 line: 1,

package/src/vm/lib/global/debug.ts

@@ -62,18 +62,24 @@ function buildFormatString(
     }
 }
 
-/** 默认的格式化函数 */
-const printFormatter: PrintOptions['formatter'] = function (args) {
+/** 默认解析函数 */
+const printParser: PrintOptions['parser'] = function (args) {
     const [format, values] = buildFormatString(this, args);
     const templates: string[] = [];
     const formats: SerializeFormat[] = [];
     let valIndex = 0;
     if (format.includes('%')) {
         const parts = format.split(/(%[%\w])/g);
+        let prevIsTemplate = true;
         for (let i = 0; i < parts.length; i++) {
             if (i % 2 === 0) {
                 // Regular string part
-                templates.push(parts[i]!);
+                if (prevIsTemplate && templates.length) {
+                    templates[templates.length - 1] += parts[i]!;
+                } else {
+                    templates.push(parts[i]!);
+                }
+                prevIsTemplate = true;
                 continue;
             }
             // Specifier part
@@ -85,8 +91,10 @@ const printFormatter: PrintOptions['formatter'] = function (args) {
                 } else {
                     templates[templates.length - 1] += specifier;
                 }
+                prevIsTemplate = true;
                 continue;
             }
+            prevIsTemplate = false;
             formats.push(specifier as SerializeFormat);
             valIndex++;
         }
@@ -97,6 +105,8 @@ const printFormatter: PrintOptions['formatter'] = function (args) {
     if (valIndex < values.length) {
         if (templates.length) {
             templates[templates.length - 1] += ' ';
+        } else {
+            templates.push('');
         }
         for (let i = valIndex; i < values.length; i++) {
             formats.push('');
@@ -111,69 +121,82 @@ const printFormatter: PrintOptions['formatter'] = function (args) {
     };
 };
 
-/** 默认的输出函数 */
-const createPrinter = (consoleMethod: (...args: unknown[]) => void): PrintOptions['printer'] => {
-    return function ({ templates, formats, values }: FormatResult) {
-        let format = '';
-        const formattedValues: unknown[] = [];
-        let needAwait = false;
-        for (let i = 0; i < templates.length; i++) {
-            format += templates[i]!;
-            if (i < values.length) {
-                const f = formats[i] ?? '';
-                const v = values[i]!;
-                const serialized = serializeValue(this, v, f);
-                if (serialized == null) {
-                    format += f || (typeof v == 'string' ? '%s' : '%o');
-                    formattedValues.push(v);
-                } else if (typeof serialized == 'string') {
-                    format += '%s';
-                    formattedValues.push(serialized);
-                } else {
-                    needAwait = true;
-                    format += '%s';
-                    formattedValues.push(serialized);
-                }
+/** 默认格式化函数 */
+const printFormatter: PrintOptions['formatter'] = function ({
+    templates,
+    formats,
+    values,
+}): unknown[] | PromiseLike<unknown[]> {
+    let format = '';
+    const formattedValues: unknown[] = [];
+    let needAwait = false;
+    for (let i = 0; i < templates.length; i++) {
+        format += templates[i]!.replaceAll('%', '%%');
+        if (i < values.length) {
+            const f = formats[i] ?? '';
+            const v = values[i]!;
+            const serialized = serializeValue(this, v, f);
+            if (serialized == null) {
+                format += f || (typeof v == 'string' ? '%s' : '%o');
+                formattedValues.push(v);
+            } else if (typeof serialized == 'string') {
+                format += '%s';
+                formattedValues.push(serialized);
+            } else {
+                needAwait = true;
+                format += '%s';
+                formattedValues.push(serialized);
             }
         }
-        if (!needAwait) {
-            consoleMethod(format, ...formattedValues);
-        } else {
-            void Promise.all(formattedValues).then((resolvedValues) => {
-                consoleMethod(format, ...resolvedValues);
-            });
-        }
+    }
+    if (!needAwait) {
+        return [format, ...formattedValues];
+    } else {
+        return Promise.all(formattedValues).then((resolvedValues) => {
+            return [format, ...resolvedValues];
+        });
+    }
+};
+
+/** 默认的输出选项 */
+const createPrintOptions = (consoleMethod: (...args: unknown[]) => void): PrintOptions => {
+    return {
+        prefix: ['MiraScript'],
+        serializer: defaultSerializer,
+        parser: printParser,
+        formatter: printFormatter,
+        logger: consoleMethod,
     };
 };
 
 /** 打印输出选项 */
-interface PrintOptions {
+type PrintOptions = {
     /** 输出时的固定前缀 */
-    prefix: readonly [prefix: string, ...additional: readonly string[]];
+    prefix: readonly [prefix?: string, ...additional: readonly string[]];
     /**
      * 序列化函数
      * @param arg 要序列化的值
      * @param format 序列化格式
-     * @returns 序列化后的字符串，或 null 表示直接将原值传递给控制台
+     * @returns 序列化后的字符串，或 null 表示直接将原值传递给 {@link printer}
      */
     serializer: (this: PrintOptions, arg: VmAny, format: SerializeFormat) => string | null | PromiseLike<string>;
-    /** 格式化函数 */
-    formatter: (this: PrintOptions, args: readonly VmAny[]) => FormatResult;
-    /** 输出函数 */
-    printer: (this: PrintOptions, format: FormatResult) => void;
-}
-
-const printOptions: PrintOptions = {
-    prefix: ['MiraScript'] as readonly [prefix: string, ...additional: readonly string[]],
-    serializer: defaultSerializer,
-    formatter: printFormatter,
-    printer: () => undefined,
+    /** 解析函数，解析输入并使用 {@link serializer} 序列化值，供 {@link formatter} 使用 */
+    parser: (this: PrintOptions, args: readonly VmAny[]) => FormatResult;
+    /** 格式化函数，进一步处理解析结果，供 {@link logger} 使用 */
+    formatter: (this: PrintOptions, format: FormatResult) => unknown[] | PromiseLike<unknown[]>;
+    /** 打印函数，打印格式化结果 */
+    logger: (this: PrintOptions, ...args: unknown[]) => void;
 };
 
+/** 进行输出 */
+function doPrint(opt: PrintOptions, args: readonly VmAny[]): void {
+    const formatResult = opt.parser(args);
+    void Promise.resolve(opt.formatter(formatResult)).then((printed) => opt.logger(...printed));
+}
+
 export const debug_print = VmLib(
     (...args) => {
-        const formatResult = debug_print.formatter(args);
-        debug_print.printer(formatResult);
+        doPrint(debug_print, args);
     },
     {
         summary: '打印调试信息到控制台',
@@ -182,17 +205,13 @@ export const debug_print = VmLib(
         returnsType: 'nil',
         examples: ['debug_print("value:", 42);'],
     },
-    {
-        ...printOptions,
-        // eslint-disable-next-line no-console
-        printer: createPrinter(console.log),
-    },
+    // eslint-disable-next-line no-console
+    createPrintOptions(console.log.bind(console)),
 );
 
 export const panic = VmLib(
     (message: VmAny) => {
-        const formatResult = message === undefined ? panic.formatter([]) : panic.formatter([message]);
-        panic.printer(formatResult);
+        doPrint(panic, message === undefined ? [] : [message]);
         const mgsStr = toString(message, null);
         const error = !mgsStr ? 'panic' : 'panic: ' + mgsStr;
         throw new VmError(error, undefined);
@@ -204,11 +223,8 @@ export const panic = VmLib(
         returnsType: 'never',
         examples: ['panic("boom");'],
     },
-    {
-        ...printOptions,
-        // eslint-disable-next-line no-console
-        printer: createPrinter(console.error),
-    },
+    // eslint-disable-next-line no-console
+    createPrintOptions(console.error.bind(console)),
 );
 
 if (typeof location != 'undefined') {

package/src/vm/lib/global/json.ts

@@ -21,7 +21,6 @@ export const to_json = VmLib(
         paramsType: { data: 'any' },
         returnsType: 'string',
         examples: ['to_json([1, 2, 3]) // "[1,2,3]"'],
-        injectCp: true,
     },
 );
 
@@ -41,6 +40,5 @@ export const from_json = VmLib(
         paramsType: { json: 'string', fallback: 'any' },
         returnsType: 'any',
         examples: [`from_json('{"a":1}') // (a: 1)`],
-        injectCp: true,
     },
 );

package/src/vm/lib/helpers.ts

@@ -1,4 +1,3 @@
-import type { Writable } from 'type-fest';
 import { VM_ARRAY_MAX_LENGTH } from '../../helpers/constants.js';
 import { isNaN, NotNumber, entries, fromEntries, isSafeInteger, isFinite } from '../../helpers/utils.js';
 import { toBoolean, toNumber, toString } from '../../helpers/convert/index.js';
@@ -274,7 +273,7 @@ export function map(
 /** 库函数选项 */
 export type VmLibOption = Pick<
     VmFunctionOption,
-    'summary' | 'params' | 'paramsType' | 'returns' | 'returnsType' | 'examples' | 'injectCp' | 'deprecated'
+    'summary' | 'params' | 'paramsType' | 'returns' | 'returnsType' | 'examples' | 'deprecated'
 >;
 /** 库函数 */
 export type VmLib<T extends VmFunctionLike | VmConst = VmFunctionLike> = (T extends VmFunctionLike ? T : { value: T }) &
@@ -287,15 +286,17 @@ export function VmLib<
 >(value: T, option: VmLibOption, properties?: P): VmLib<T> & P {
     if (isVmFunction(value)) throw new TypeError('Cannot create VmLib from a VmFunction');
 
-    const ret = (typeof value == 'function' ? value : { value: value }) as unknown as Writable<VmLib<T>> & P;
+    // 后续在 wrapEntry 中会处理函数的包装
+    const ret = (typeof value == 'function' ? value : { __proto__: null, value: value }) as VmLib<T> & P;
+    Object.defineProperties(ret, {
+        summary: { enumerable: true, value: option.summary },
+        params: { enumerable: true, value: option.params },
+        paramsType: { enumerable: true, value: option.paramsType },
+        returns: { enumerable: true, value: option.returns },
+        returnsType: { enumerable: true, value: option.returnsType },
+        examples: { enumerable: true, value: option.examples },
+        deprecated: { enumerable: true, value: option.deprecated ?? undefined },
+    });
     Object.assign(ret, properties);
-    ret.params = option.params;
-    ret.paramsType = option.paramsType;
-    ret.returns = option.returns;
-    ret.returnsType = option.returnsType;
-    ret.summary = option.summary;
-    ret.examples = option.examples;
-    ret.injectCp = option.injectCp ?? false;
-    ret.deprecated = option.deprecated ?? undefined;
-    return ret as VmLib<T> & P;
+    return ret;
 }

package/src/vm/lib/loader.ts

@@ -8,7 +8,7 @@ import {
 } from '../types/index.js';
 import { create, defineProperty, entries } from '../../helpers/utils.js';
 
-import type { VmLib, VmLibOption } from './helpers.js';
+import type { VmLib } from './helpers.js';
 
 /** 内置模块 */
 class VmBuiltinModule<const T extends Record<string, VmImmutable> = Record<string, VmImmutable>> extends VmModule<T> {
@@ -46,20 +46,10 @@ export function wrapEntry<const T extends RawValue>(
     }
     if (value.name !== name) {
         // 如果函数名和导出名不一致，则重命名
-        defineProperty(value, 'name', {
-            value: name,
-            configurable: true,
-        });
+        defineProperty(value, 'name', { value: name });
     }
-    return [
-        VmFunction(value, {
-            isLib: true,
-            injectCp: true,
-            fullName: `${module}.${name}`,
-            ...(value as VmLibOption),
-        }) as ToWrappedValue<T>,
-        value.summary || undefined,
-    ];
+    defineProperty(value, 'fullName', { enumerable: true, value: `${module}.${name}` });
+    return [VmFunction(value, value) as ToWrappedValue<T>, value.summary || undefined];
 }
 
 /** 创建模块 */

package/src/vm/operations/helpers.ts

@@ -1,4 +1,4 @@
-import { create, defineProperty, isFinite } from '../../helpers/utils.js';
+import { create, isFinite } from '../../helpers/utils.js';
 import { VM_ARRAY_MAX_LENGTH, VM_FUNCTION_ANONYMOUS_NAME } from '../../helpers/constants.js';
 import { isVmConst } from '../../helpers/types.js';
 import type { VmFunctionLike } from '../types/function.js';
@@ -25,8 +25,7 @@ export function $ElOpt(key: string, value: VmAny): VmConst {
 
 /** 构造函数和函数表达式 */
 export function $Fn<T extends VmFunctionLike>(name: string | null | undefined, fn: T): VmFunction<T> {
-    defineProperty(fn, 'name', { value: name || VM_FUNCTION_ANONYMOUS_NAME });
-    return VmFunction(fn, { isLib: false, injectCp: false });
+    return VmFunction(fn, { isLib: false, injectCp: false, name: name || VM_FUNCTION_ANONYMOUS_NAME });
 }
 
 /** 读取闭包上值 */

package/src/vm/types/context.ts

@@ -45,6 +45,7 @@ export function defineVmContextValue(
     let v: VmImmutable;
     if (typeof value == 'function') {
         v = VmFunction(value, {
+            name,
             isLib: true,
             fullName: `global.${name}`,
         });

package/src/vm/types/function.ts

@@ -2,9 +2,10 @@ import type { Writable } from 'type-fest';
 import type { DiagnosticCode } from '@mirascript/constants';
 import { defineProperty } from '../../helpers/utils.js';
 import { kVmFunction, VM_FUNCTION_ANONYMOUS_NAME } from '../../helpers/constants.js';
-import type { VmAny, VmValue } from './index.js';
+import { isVmFunction, type VmAny, type VmValue } from './index.js';
 import { fromVmFunctionProxy } from './boundary.js';
 import { CpEnter, CpExit } from '../checkpoint.js';
+import type { VmLib } from '../lib/helpers.js';
 
 /**
  * Mirascript 函数签名
@@ -18,7 +19,7 @@ export type VmFunctionLike = (...args: ReadonlyArray<VmValue | undefined>) => Vm
 export type VmFunction<T extends VmFunctionLike = VmFunctionLike> = T & { readonly [kVmFunction]: VmFunctionInfo };
 
 /** Mirascript 函数信息 */
-export interface VmFunctionInfo {
+export type VmFunctionInfo = {
     /** 完整名称 */
     readonly fullName: string;
     /** 是否为库函数 */
@@ -39,17 +40,27 @@ export interface VmFunctionInfo {
     readonly original?: VmFunctionLike;
     /** 标记为弃用 */
     readonly deprecated?: { use?: string; message: DiagnosticCode };
-}
+};
 
 /** Mirascript 函数创建选项 */
-export type VmFunctionOption = Partial<
-    Omit<VmFunctionInfo, 'original'> & {
-        readonly injectCp: boolean;
-    }
->;
+export type VmFunctionOption = Partial<Omit<VmFunctionInfo, 'original'>> & {
+    /** 函数名称 */
+    readonly name?: string | null | undefined;
+    /** 是否注入检查点 */
+    readonly injectCp?: boolean;
+};
+
+const nameIfNotAnonymous = <T>({ name }: { name: string | undefined }, fallback: T): string | T => {
+    if (!name) return fallback;
+    if (name === VM_FUNCTION_ANONYMOUS_NAME) return fallback;
+    return name;
+};
 
 /** 创建 Mirascript 函数 */
-export function VmFunction<T extends VmFunctionLike>(fn: T, option: VmFunctionOption = {}): VmFunction<T> {
+export function VmFunction<T extends VmFunctionLike>(
+    fn: T,
+    option: VmFunctionOption | VmFunction | VmLib<T> = {},
+): VmFunction<T> {
     if (typeof fn != 'function') {
         throw new TypeError('Invalid function');
     }
@@ -57,19 +68,34 @@ export function VmFunction<T extends VmFunctionLike>(fn: T, option: VmFunctionOp
     const exists = fromVmFunctionProxy(fn);
     // 如果已经是 VmFunction，则直接返回
     if (exists) return exists;
+    let opt: VmFunctionOption;
+    if (isVmFunction(option)) {
+        opt = { ...option[kVmFunction], name: nameIfNotAnonymous(option, null) };
+    } else if (typeof option == 'function') {
+        opt = {
+            ...option,
+            isLib: true,
+            injectCp: false,
+            name: nameIfNotAnonymous(option, null),
+        };
+    } else {
+        opt = option;
+    }
 
-    const info: Writable<VmFunctionInfo> = {
-        fullName: option.fullName ?? (fn.name === VM_FUNCTION_ANONYMOUS_NAME ? '' : fn.name),
-        isLib: option.isLib ?? false,
-        summary: option.summary || undefined,
-        params: option.params,
-        paramsType: option.paramsType,
-        returns: option.returns || undefined,
-        returnsType: option.returnsType || undefined,
-        examples: option.examples?.length ? option.examples : undefined,
-        deprecated: option.deprecated ?? undefined,
+    const info: Writable<VmFunctionInfo & { __proto__: null }> = {
+        __proto__: null,
+        fullName: opt.fullName ?? nameIfNotAnonymous(fn, ''),
+        isLib: opt.isLib ?? false,
+        summary: opt.summary || undefined,
+        params: opt.params,
+        paramsType: opt.paramsType,
+        returns: opt.returns || undefined,
+        returnsType: opt.returnsType || undefined,
+        examples: opt.examples?.length ? opt.examples : undefined,
+        deprecated: opt.deprecated ?? undefined,
     };
-    if (option.injectCp) {
+    const name = opt.name ?? fn.name;
+    if (opt.injectCp) {
         const original = fn;
         info.original = original;
         fn = ((...args) => {
@@ -81,10 +107,8 @@ export function VmFunction<T extends VmFunctionLike>(fn: T, option: VmFunctionOp
                 CpExit();
             }
         }) as typeof fn;
-        defineProperty(fn, 'name', { value: original.name });
     }
-    defineProperty(fn, kVmFunction, {
-        value: Object.freeze(info),
-    });
+    defineProperty(fn, 'name', { value: name, configurable: true });
+    defineProperty(fn, kVmFunction, { value: Object.freeze(info) });
     return fn as VmFunction<T>;
 }

package/src/vm/types/wrapper.ts

@@ -22,10 +22,6 @@ export abstract class VmWrapper<T extends object> {
     describe(key: string): string | undefined {
         return undefined;
     }
-    /** Convert the object to JSON */
-    toJSON(): undefined {
-        return undefined;
-    }
     /** 转为字符串 */
     toString(useBraces: boolean): string {
         const { type, tag } = this;