@mirascript/mirascript 0.1.19 → 0.1.21

package/src/compiler/compile-fast.ts

@@ -1,11 +1,13 @@
 import { wrapScript, type VmScript } from './create-script.js';
 import type { TranspileOptions } from './types.js';
 import { GlobalFallback } from '../vm/helpers.js';
+import type { VmContext, VmValue } from '../vm/index.js';
 import { isFinite } from '../helpers/utils.js';
+import { keywords } from './keywords.js';
 
-const REG_NUMBER_FULL = /^\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
-// 只识别特殊变量名，其他标识符可能有与关键字冲突等情况，需要编译器处理
-const REG_IDENTIFIER_FAST = /^(?:\$+|@+)[a-zA-Z0-9_]*$/;
+const REG_NUMBER_FULL = /^(?:[+-])?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+// 只识别 ASCII 范围内的标识符，以提升性能
+const REG_IDENTIFIER_FAST = /^(?:\$+|@+|[A-Za-z])[a-zA-Z0-9_]*$/;
 
 // 为避免结果不一致，只对常量进行处理
 
@@ -17,41 +19,103 @@ const REG_IDENTIFIER_FAST = /^(?:\$+|@+)[a-zA-Z0-9_]*$/;
 
 const FAST_SCRIPT_MAX_LEN = 32;
 
+/** 构造返回常量的函数 */
+function constantFiniteNumber(value: number): () => number {
+    if (value === 0) {
+        if (Object.is(value, -0)) {
+            return () => -0;
+        } else {
+            return () => 0;
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval, @typescript-eslint/no-unsafe-call
+    return new Function(`return () => ${value};`)() as () => number;
+}
+/** 构造返回常量的函数 */
+function constantString(value: string): () => string {
+    const code = JSON.stringify(value);
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval, @typescript-eslint/no-unsafe-call
+    return new Function(`return () => ${code};`)() as () => string;
+}
+
+/** 构造返回常量的函数 */
+function nan(): () => number {
+    return () => 0 / 0;
+}
+
+/** 构造返回常量的函数 */
+function posInf(): () => number {
+    return () => +1 / 0;
+}
+
+/** 构造返回常量的函数 */
+function negInf(): () => number {
+    return () => -1 / 0;
+}
+
+/** 构造返回常量的函数 */
+function constantBoolean(value: boolean): () => boolean {
+    if (value) {
+        return () => true;
+    } else {
+        return () => false;
+    }
+}
+
+/** 构造返回常量的函数 */
+function nil(): () => null {
+    return () => null;
+}
+
+/** 构造返回全局变量的函数 */
+function globalVariable(id: string): (global: VmContext | undefined) => VmValue {
+    const code = `return (global = GlobalFallback()) => global.get(\`${id}\`);`;
+
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval, @typescript-eslint/no-unsafe-call
+    return new Function('GlobalFallback', code)(GlobalFallback) as (global: VmContext | undefined) => VmValue;
+}
+
+let kw: Set<string> | undefined;
+
 /**
  * 对短代码进行编译
  */
 function compileScriptFast(code: string, options: TranspileOptions): VmScript | undefined {
     if (code.length > FAST_SCRIPT_MAX_LEN) return undefined; // 超过长度限制，直接返回 undefined
-
+    const mode = options.input_mode ?? 'Script';
     const trimmedCode = code.trim();
     if (!trimmedCode) {
-        return wrapScript(code, () => null);
+        return wrapScript(code, mode, nil());
     }
     switch (trimmedCode) {
         case 'nil':
-            return wrapScript(code, () => null);
+            return wrapScript(code, mode, nil());
         case 'true':
-            return wrapScript(code, () => true);
+            return wrapScript(code, mode, constantBoolean(true));
         case 'false':
-            return wrapScript(code, () => false);
+            return wrapScript(code, mode, constantBoolean(false));
         case 'nan':
-            return wrapScript(code, () => 0 / 0);
+            return wrapScript(code, mode, nan());
         case 'inf':
         case '+inf':
-            return wrapScript(code, () => 1 / 0);
+            return wrapScript(code, mode, posInf());
         case '-inf':
-            return wrapScript(code, () => -1 / 0);
+            return wrapScript(code, mode, negInf());
     }
     if (REG_IDENTIFIER_FAST.test(trimmedCode)) {
         // 直接返回标识符
         const id = trimmedCode;
-        return wrapScript(code, (global = GlobalFallback()) => global.get(id));
+        kw ??= new Set(keywords());
+        if (kw.has(id)) {
+            return undefined; // 关键字不处理
+        }
+        return wrapScript(code, mode, globalVariable(id));
     }
     if (REG_NUMBER_FULL.test(trimmedCode)) {
         const num = Number(trimmedCode);
         if (!isFinite(num)) return undefined;
         // 直接返回数字
-        return wrapScript(code, () => num);
+        return wrapScript(code, mode, constantFiniteNumber(num));
     }
     return undefined;
 }
@@ -65,8 +129,9 @@ function compileTemplateFast(code: string, options: TranspileOptions): VmScript
     if (code.length > FAST_TEMPLATE_MAX_LEN) return undefined; // 超过长度限制，直接返回 undefined
 
     if (!code.includes('$')) {
+        const mode = options.input_mode ?? 'Template';
         // 不包含插值的模板
-        return wrapScript(code, () => code);
+        return wrapScript(code, mode, constantString(code));
     }
     return undefined;
 }

package/src/compiler/create-script.ts

@@ -2,36 +2,36 @@ import { kVmScript, VM_SCRIPT_NAME } from '../helpers/constants.js';
 import { defineProperty } from '../helpers/utils.js';
 import { keys, values } from '../vm/env.js';
 import type { VmValue, VmContext } from '../vm/types/index.js';
-import type { ScriptInput } from './types.js';
+import type { InputMode, ScriptInput } from './types.js';
 
 /** Mirascript 脚本 */
 export type VmScriptLike = (global?: VmContext) => VmValue;
 
 /** Mirascript 脚本 */
 export type VmScript = VmScriptLike & {
-    readonly [kVmScript]: true;
+    readonly [kVmScript]: InputMode;
     /** 原始代码 */
     readonly source: string;
 };
 
 /** 生成 JS 函数 */
-export function wrapScript(source: ScriptInput, script: VmScriptLike): VmScript {
+export function wrapScript(source: ScriptInput, mode: InputMode, script: VmScriptLike): VmScript {
     /* c8 ignore next 3 */
     if (kVmScript in script) {
         return script as VmScriptLike as VmScript;
     }
     defineProperty(script, 'name', { value: VM_SCRIPT_NAME });
-    defineProperty(script, kVmScript, { value: true });
+    defineProperty(script, kVmScript, { value: mode });
     if (typeof source === 'string') {
-        defineProperty(script, 'source', { value: source, configurable: true });
+        defineProperty(script, 'source', { value: source });
     } else if (source instanceof Uint8Array) {
-        defineProperty(script, 'source', { value: '<buffer>', configurable: true });
+        defineProperty(script, 'source', { value: '<buffer>' });
     }
     return script as VmScript;
 }
 
 /** 生成 JS 函数 */
-export function createScript(source: ScriptInput, code: string): VmScript {
+export function createScript(source: ScriptInput, mode: InputMode, code: string): VmScript {
     let script;
     try {
         // eslint-disable-next-line @typescript-eslint/no-implied-eval, @typescript-eslint/no-unsafe-call
@@ -40,5 +40,5 @@ export function createScript(source: ScriptInput, code: string): VmScript {
     } catch (error) {
         throw new Error(`Failed to create script`, { cause: error });
     }
-    return wrapScript(source, script);
+    return wrapScript(source, mode, script);
 }

package/src/compiler/emit/constants.ts

@@ -1,2 +1 @@
-export const SCRIPT_PREFIX = `'use strict'; return ((global = GlobalFallback()) => { try { CpEnter();`;
-export const GLOBAL_HINT = `/* globals */`;
+export const SCRIPT_PREFIX = `return ((global = GlobalFallback()) => { try { CpEnter();`;

package/src/compiler/emit/consts.ts

@@ -1,12 +1,12 @@
 import type { VmPrimitive } from '../../vm/index.js';
-
+const { stringify } = JSON;
 /** 将值转为 JS 字面量 */
 export function toJsLiteral(value: VmPrimitive | undefined): string {
     /* c8 ignore next 2 */
     if (value === null) return 'null';
     if (value === undefined) return 'undefined';
     if (typeof value == 'string') {
-        return JSON.stringify(value);
+        return stringify(value);
     }
     // JSON 无法处理 NaN 等特殊数字
     if (value === 0) {
@@ -16,32 +16,169 @@ export function toJsLiteral(value: VmPrimitive | undefined): string {
     return String(value satisfies number | boolean);
 }
 
-/** 解析常量 */
-export function readConst(reader: DataView, offset: number): [value: VmPrimitive, consumed: number] {
-    const type = reader.getUint8(offset);
-    switch (type) {
-        /* c8 ignore next 2 */
-        case 0:
-            return [null, 1];
-        case 1:
-            return [true, 1];
-        case 2:
-            return [false, 1];
-        case 3: {
-            const ordinal = reader.getInt32(offset + 1, true);
-            return [ordinal, 5];
-        }
-        case 4: {
-            const num = reader.getFloat64(offset + 1, true);
-            return [num, 9];
-        }
-        case 5: {
-            const len = reader.getUint32(offset + 1, true);
-            const str = new TextDecoder().decode(new Uint8Array(reader.buffer, reader.byteOffset + offset + 5, len));
-            return [str, 5 + len];
-        }
-        /* c8 ignore next 2 */
-        default:
-            throw new Error(`Unknown constant type: ${type}`);
+const DECODER = new TextDecoder();
+const { fromCharCode } = String;
+/** 解码 Ascii */
+function shortStringInJS(buf: Uint8Array, begin: number, length: number): string | undefined {
+    if (length < 4) {
+        if (length < 2) {
+            if (length === 0) return '';
+            const a = buf[begin]!;
+            if ((a & 0x80) > 0) {
+                return;
+            }
+            return fromCharCode(a);
+        }
+        const a = buf[begin++]!;
+        const b = buf[begin++]!;
+        if ((a & 0x80) > 0 || (b & 0x80) > 0) {
+            return;
+        }
+        if (length < 3) return fromCharCode(a, b);
+        const c = buf[begin++]!;
+        if ((c & 0x80) > 0) {
+            return;
+        }
+        return fromCharCode(a, b, c);
+    }
+    const a = buf[begin++]!;
+    const b = buf[begin++]!;
+    const c = buf[begin++]!;
+    const d = buf[begin++]!;
+    if ((a & 0x80) > 0 || (b & 0x80) > 0 || (c & 0x80) > 0 || (d & 0x80) > 0) {
+        return;
+    }
+    if (length < 6) {
+        if (length === 4) return fromCharCode(a, b, c, d);
+        const e = buf[begin++]!;
+        if ((e & 0x80) > 0) {
+            return;
+        }
+        return fromCharCode(a, b, c, d, e);
+    }
+    const e = buf[begin++]!;
+    const f = buf[begin++]!;
+    if ((e & 0x80) > 0 || (f & 0x80) > 0) {
+        return;
+    }
+    if (length < 8) {
+        if (length < 7) return fromCharCode(a, b, c, d, e, f);
+        const g = buf[begin++]!;
+        if ((g & 0x80) > 0) {
+            return;
+        }
+        return fromCharCode(a, b, c, d, e, f, g);
+    }
+    const g = buf[begin++]!;
+    const h = buf[begin++]!;
+    if ((g & 0x80) > 0 || (h & 0x80) > 0) {
+        return;
+    }
+    if (length < 10) {
+        if (length === 8) return fromCharCode(a, b, c, d, e, f, g, h);
+        const i = buf[begin++]!;
+        if ((i & 0x80) > 0) {
+            return;
+        }
+        return fromCharCode(a, b, c, d, e, f, g, h, i);
+    }
+    const i = buf[begin++]!;
+    const j = buf[begin++]!;
+    if ((i & 0x80) > 0 || (j & 0x80) > 0) {
+        return;
+    }
+    if (length < 12) {
+        if (length < 11) return fromCharCode(a, b, c, d, e, f, g, h, i, j);
+        const k = buf[begin++]!;
+        if ((k & 0x80) > 0) {
+            return;
+        }
+        return fromCharCode(a, b, c, d, e, f, g, h, i, j, k);
+    }
+    const k = buf[begin++]!;
+    const l = buf[begin++]!;
+    if ((k & 0x80) > 0 || (l & 0x80) > 0) {
+        return;
+    }
+    if (length < 14) {
+        if (length === 12) return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l);
+        const m = buf[begin++]!;
+        if ((m & 0x80) > 0) {
+            begin -= 13;
+            return;
+        }
+        return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m);
+    }
+    const m = buf[begin++]!;
+    const n = buf[begin++]!;
+    if ((m & 0x80) > 0 || (n & 0x80) > 0) {
+        return;
+    }
+    if (length < 15) return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
+    const o = buf[begin++]!;
+    if ((o & 0x80) > 0) {
+        return;
+    }
+    return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
+}
+
+/** 解码字符串 */
+function decodeStr(buffer: Uint8Array, offset: number, length: number): string {
+    // Fast path for short ascii strings
+    if (length < 16) {
+        const shortStr = shortStringInJS(buffer, offset, length);
+        if (shortStr !== undefined) {
+            return shortStr;
+        }
+    }
+    return DECODER.decode(buffer.subarray(offset, offset + length));
+}
+
+/** 读取常量表 */
+export function readConsts(constChunk: Uint8Array): VmPrimitive[] {
+    const reader = new DataView(constChunk.buffer, constChunk.byteOffset, constChunk.byteLength);
+    const consts: VmPrimitive[] = [];
+    let offset = 0;
+    const length = reader.byteLength;
+    while (offset < length) {
+        const type = reader.getUint8(offset);
+        switch (type) {
+            /* c8 ignore next 2 */
+            case 0:
+                consts.push(null);
+                offset += 1;
+                break;
+            case 1:
+                consts.push(true);
+                offset += 1;
+                break;
+            case 2:
+                consts.push(false);
+                offset += 1;
+                break;
+            case 3: {
+                const ordinal = reader.getInt32(offset + 1, true);
+                consts.push(ordinal);
+                offset += 5;
+                break;
+            }
+            case 4: {
+                const num = reader.getFloat64(offset + 1, true);
+                consts.push(num);
+                offset += 9;
+                break;
+            }
+            case 5: {
+                const len = reader.getUint32(offset + 1, true);
+                const str = decodeStr(constChunk, offset + 5, len);
+                consts.push(str);
+                offset += 5 + len;
+                break;
+            }
+            /* c8 ignore next 2 */
+            default:
+                throw new Error(`Unknown constant type: ${type}`);
+        }
     }
+    return consts;
 }

package/src/compiler/emit/index.ts

@@ -1,10 +1,11 @@
 import { OpCode } from '@mirascript/bindings';
+import { toString } from '../../helpers/convert/to-string.js';
 import type { VmPrimitive } from '../../vm/index.js';
 import type { ScriptInput, TranspileOptions } from '../types.js';
 import type { IRange } from '../diagnostic.js';
-import { readGlobal, type GlobalMap } from './globals.js';
-import { readConst, toJsLiteral } from './consts.js';
+import { readConsts, toJsLiteral } from './consts.js';
 import { createSourceMap } from './sourcemap.js';
+import { SCRIPT_PREFIX } from './constants.js';
 
 /** 生成代码 */
 export function emit(
@@ -29,8 +30,6 @@ function createArray<T>(length: number, fn: (index: number) => T): T[] {
     return result;
 }
 
-const SCRIPT_PREFIX = `'use strict'; return ((global = GlobalFallback()) => { try { CpEnter();`;
-const GLOBAL_HINT = `/* globals */`;
 /** 代码生成 */
 export class Emitter {
     constructor(
@@ -47,22 +46,21 @@ export class Emitter {
         this.constSize = reader.getUint32(8 + this.codeSize, true);
 
         this.codeReader = new DataView(chunk.buffer, chunk.byteOffset + 8, this.codeSize);
-        this.constReader = new DataView(chunk.buffer, chunk.byteOffset + 12 + this.codeSize, this.constSize);
+        this.constVals = readConsts(
+            new Uint8Array(chunk.buffer, chunk.byteOffset + 12 + this.codeSize, this.constSize),
+        );
     }
-    readonly pretty;
+    readonly pretty: boolean;
     readonly chunkSize: number;
     readonly codeSize: number;
-    private readonly constReader: DataView;
     /** 读取常量表 */
     private readConsts(): void {
-        for (let i = 0, index = 0; i < this.constSize; index++) {
-            const [constant, size] = readConst(this.constReader, i);
-            this.constVals.push(constant);
-            this.constLits.push(toJsLiteral(constant));
-            i += size;
+        const { constVals, constLits } = this;
+        for (let i = 0, len = constVals.length; i < len; i++) {
+            constLits.push(toJsLiteral(constVals[i]));
         }
     }
-    readonly constVals: VmPrimitive[] = [];
+    readonly constVals: VmPrimitive[];
     readonly constLits: string[] = [];
 
     readonly constSize: number;
@@ -70,6 +68,8 @@ export class Emitter {
     private codeOffset = 0;
     private closureCounter = 0;
     private identCounter = 0;
+    /** 记录函数声明所在位置 */
+    private readonly functions: number[] = [];
 
     /** 制造缩进 */
     private ident(len = 0): string {
@@ -77,10 +77,16 @@ export class Emitter {
         return '  '.repeat(this.identCounter + len);
     }
 
-    readonly globals: GlobalMap = new Map();
     /** 读取全局变量 */
-    private rg(constIdx: number, eager: boolean): string {
-        return readGlobal(this, constIdx).e;
+    private rg(constIdx: number): string {
+        const constName = this.constVals[constIdx]!;
+        let lit;
+        if (typeof constName == 'string') {
+            lit = this.constLits[constIdx]!;
+        } else {
+            lit = toJsLiteral(toString(constName, undefined));
+        }
+        return `global.get(${lit})`;
     }
 
     readonly codeLines: string[] = [];
@@ -327,14 +333,21 @@ export class Emitter {
                     }
                     return `${wv} = null`;
                 });
-                const regs = createArray(regn - argn + 1, (i) => (i ? this.wv(i + argn, -1) : this.wv(0, -1))).join(
-                    ', ',
-                );
+                let regs = '_';
+                for (let i = 1 + argn; i < regn + 1; i++) {
+                    regs += ',' + this.wv(i, -1);
+                }
                 const script = startFunc && !varg && argn === 0;
                 if (script) {
                     code = `${SCRIPT_PREFIX} var ${regs};`;
                 } else {
-                    code = `${this.wv(reg)} = Function((${args.join(', ')}) => { try { CpEnter(); var ${regs};`;
+                    if (!this.options.sourceMap) {
+                        code = `${this.wv(reg)} = Function(null ,(${args.join(', ')}) => { try { CpEnter(); var ${regs};`;
+                    } else {
+                        const index = this.functions.length;
+                        this.functions.push(this.codeLines.length);
+                        code = `${this.wv(reg)} = Function(fnName_${index} ,(${args.join(', ')}) => { try { CpEnter(); var ${regs};`;
+                    }
                 }
                 if (varg) {
                     code += ` var ${this.wv(argn, -1)} = Vargs(vargs);`;
@@ -415,7 +428,7 @@ export class Emitter {
                 const args = createArray(n, () => read());
                 const ns = read();
                 const spreads = createArray(ns, () => read());
-                const callTarget = opcode === OpCode.Call ? this.rg(func, false) : this.rv(func);
+                const callTarget = opcode === OpCode.Call ? this.rg(func) : this.rv(func);
                 code = `${this.wv(reg)} = $Call(${callTarget}, [${args
                     .map((a, i) => {
                         if (spreads.includes(i)) return `...$ArraySpread(${this.rv(a)})`;
@@ -520,7 +533,7 @@ export class Emitter {
             case OpCode.GetGlobal: {
                 reg = read();
                 const i = read();
-                code = `${this.wv(reg)} = ${this.rg(i, false)};`;
+                code = `${this.wv(reg)} = ${this.rg(i)};`;
                 break;
             }
             case OpCode.GetGlobalDyn: {
@@ -705,19 +718,14 @@ export class Emitter {
     read(): void {
         this.readConsts();
         this.readCode();
-        if (this.globals.size > 0) {
-            let globalsInit = '';
-            for (const { v } of this.globals.values()) {
-                globalsInit += globalsInit ? `, ${v}` : `var ${GLOBAL_HINT} ${v}`;
-            }
-            this.codeLines[0] += globalsInit + ';';
-        }
         this.addSourceMap();
     }
     /** 添加源映射 */
     addSourceMap(): void {
-        if (!this.options.sourceMap) return;
-        const mapLines = createSourceMap(this.source, this.sourcemaps, this.codeLines, this.globals, this.options);
-        this.codeLines.push(...mapLines);
+        if (this.options.sourceMap) {
+            createSourceMap(this.source, this.sourcemaps, this.codeLines, this.functions, this.options);
+        } else {
+            this.codeLines.unshift(`'use strict';`);
+        }
     }
 }