@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/host-defined/inspect.mts

@@ -0,0 +1,250 @@
+import {
+  JSStringValue, ObjectValue, Value, wellKnownSymbols, BooleanValue, NumberValue, BigIntValue, SymbolValue, UndefinedValue,
+} from '../value.mts';
+import { Completion, X } from '../completion.mts';
+import { isRegExpObject } from '../intrinsics/RegExp.mts';
+import type { DateObject } from '../intrinsics/Date.mts';
+import type { BooleanObject } from '../intrinsics/Boolean.mts';
+import type { NumberObject } from '../intrinsics/Number.mts';
+import type { BigIntObject } from '../intrinsics/BigInt.mts';
+import type { StringObject } from '../intrinsics/String.mts';
+import type { SymbolObject } from '../intrinsics/Symbol.mts';
+import { isTypedArrayObject } from '../intrinsics/TypedArray.mts';
+import { isShadowRealmObject } from '../intrinsics/ShadowRealm.mts';
+import { surroundingAgent } from '#self';
+import {
+  Call, IsArray, Get, LengthOfArrayLike,
+  EscapeRegExpPattern, R, type BuiltinFunctionObject,
+
+  Realm,
+  type Descriptor, type ValueCompletion, type PromiseObject, CyclicModuleRecord,
+} from '#self';
+
+const bareKeyRe = /^[a-zA-Z_][a-zA-Z_0-9]*$/;
+
+function getObjectTag(value: ObjectValue, wrap = false): string {
+  let s = '';
+  try {
+    s = (X(Get(value, wellKnownSymbols.toStringTag)) as JSStringValue).stringValue();
+  } catch { }
+  try {
+    const c = X(Get(value, Value('constructor')));
+    s = (X(Get(c as ObjectValue, Value('name'))) as JSStringValue).stringValue();
+  } catch { }
+  if (s) {
+    if (wrap) {
+      return `[${s}] `;
+    }
+    return s;
+  }
+  return '';
+}
+
+const compactObject = (realm: Realm, value: ObjectValue) => {
+  try {
+    const toString = X(Get(value, Value('toString'))) as BuiltinFunctionObject;
+    const objectToString = realm.Intrinsics['%Object.prototype.toString%'];
+    if (toString.nativeFunction === objectToString.nativeFunction) {
+      return (X(Call(toString, value)) as JSStringValue).stringValue();
+    } else {
+      const tag = getObjectTag(value, false) || 'Unknown';
+      const ctor = X(Get(value, Value('constructor')));
+      if (ctor instanceof ObjectValue) {
+        const ctorName = (X(Get(ctor, Value('name'))) as JSStringValue).stringValue();
+        if (ctorName !== '') {
+          return `#<${ctorName}>`;
+        }
+        return `[object ${tag}]`;
+      }
+      return `[object ${tag}]`;
+    }
+  } catch (e) {
+    return '[object Unknown]';
+  }
+};
+
+interface InspectContext {
+  realm: Realm;
+  indent: number;
+  inspected: Value[];
+  compact: boolean;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Inspector = (value: any, context: InspectContext, inner: (v: Value) => string) => string;
+
+const INSPECTORS = {
+  Null: () => 'null',
+  Undefined: () => 'undefined',
+  Boolean: (v: BooleanValue) => v.booleanValue().toString(),
+  Number: (v: NumberValue) => {
+    const n = R(v);
+    if (n === 0 && Object.is(n, -0)) {
+      return '-0';
+    }
+    return n.toString();
+  },
+  BigInt: (v: BigIntValue) => `${R(v)}n`,
+  String: (v: JSStringValue) => {
+    const s = JSON.stringify(v.stringValue()).slice(1, -1);
+    return `'${s}'`;
+  },
+  Symbol: (v: SymbolValue) => `Symbol(${v.Description instanceof UndefinedValue ? '' : v.Description.stringValue()})`,
+  Object: (v: ObjectValue, ctx, i) => {
+    if (ctx.inspected.includes(v)) {
+      return '[Circular]';
+    }
+    if ('PromiseState' in v) {
+      ctx.indent += 1;
+      const result = v.PromiseState === 'pending' ? 'undefined' : i((v as PromiseObject).PromiseResult!);
+      ctx.indent -= 1;
+      return `Promise {
+  [[PromiseState]]: ${v.PromiseState}
+  [[PromiseResult]]: ${result}
+}`;
+    }
+    if (
+      'Module' in v
+      && v.Module instanceof CyclicModuleRecord
+      && v.Module.Status === 'linked'
+      && v.Module.DeferredNamespace === v
+    ) {
+      // Do not read the namespace to avoid triggering the module evaluation.
+      return 'Deferred Module { ... }';
+    }
+
+    if ('Call' in v) {
+      const name = v.properties.get('name');
+      if (name && (name.Value! as JSStringValue).stringValue() !== '') {
+        return `[Function: ${(name.Value as JSStringValue).stringValue()}]`;
+      }
+      return '[Function]';
+    }
+
+    if ('ErrorData' in v) {
+      let e = X(Get(v, Value('stack')));
+      if (!(e as JSStringValue).stringValue) {
+        const toString = X(Get(v, Value('toString')));
+        e = X(Call(toString, v));
+      }
+      return (e as JSStringValue).stringValue();
+    }
+
+    if (isRegExpObject(v)) {
+      const P = EscapeRegExpPattern(v.OriginalSource, v.OriginalFlags).stringValue();
+      const F = v.OriginalFlags.stringValue();
+      return `/${P}/${F}`;
+    }
+
+    if ('DateValue' in v) {
+      const d = new Date((v as DateObject).DateValue);
+      if (Number.isNaN(d.getTime())) {
+        return '[Date Invalid]';
+      }
+      return `[Date ${d.toISOString()}]`;
+    }
+
+    if ('BooleanData' in v) {
+      return `[Boolean ${i((v as BooleanObject).BooleanData)}]`;
+    }
+    if ('NumberData' in v) {
+      return `[Number ${i((v as NumberObject).NumberData)}]`;
+    }
+    if ('BigIntData' in v) {
+      return `[BigInt ${i((v as BigIntObject).BigIntData)}]`;
+    }
+    if ('StringData' in v) {
+      return `[String ${i((v as StringObject).StringData)}]`;
+    }
+    if ('SymbolData' in v) {
+      return `[Symbol ${i((v as SymbolObject).SymbolData)}]`;
+    }
+    if (isShadowRealmObject(v)) {
+      return '[ShadowRealm]';
+    }
+
+    ctx.indent += 1;
+    ctx.inspected.push(v);
+
+    try {
+      const isArray = IsArray(v) === Value.true;
+      const isTypedArray = isTypedArrayObject(v);
+      if (isArray || isTypedArray) {
+        const length = X(LengthOfArrayLike(v));
+        let holes = 0;
+        const flushHoles = () => {
+          if (holes > 0) {
+            out.push(`<${holes} empty items>`);
+            holes = 0;
+          }
+        };
+        const out = [];
+        for (let j = 0; j < length; j += 1) {
+          const elem = X(v.GetOwnProperty(Value(j.toString())));
+          if (elem instanceof UndefinedValue) {
+            holes += 1;
+          } else {
+            flushHoles();
+            if (elem.Value) {
+              out.push(i(elem.Value));
+            } else {
+              out.push('<accessor>');
+            }
+          }
+        }
+        flushHoles();
+        return `${isTypedArray ? `${v.TypedArrayName.stringValue()} ` : ''}[${out.join(', ')}]`;
+      }
+
+      const keys = X(v.OwnPropertyKeys());
+      const cache = [];
+      for (const key of keys) {
+        const C = X(v.GetOwnProperty(key)) as Descriptor;
+        if (C.Enumerable === Value.true) {
+          cache.push([
+            key instanceof JSStringValue && bareKeyRe.test(key.stringValue()) ? key.stringValue() : i(key),
+            C.Value ? i(C.Value) : '<accessor>',
+          ]);
+        }
+      }
+
+      const tag = getObjectTag(v);
+      let out = tag && tag !== 'Object' ? `${tag} {` : '{';
+      if (cache.length > 5) {
+        cache.forEach((c) => {
+          out = `${out}\n${'  '.repeat(ctx.indent)}${c[0]}: ${c[1]},`;
+        });
+        return `${out}\n${'  '.repeat(ctx.indent - 1)}}`;
+      } else {
+        const oc = ctx.compact;
+        ctx.compact = true;
+        cache.forEach((c, index) => {
+          out = `${out}${index === 0 ? '' : ','} ${c[0]}: ${c[1]}`;
+        });
+        ctx.compact = oc;
+        return `${out} }`;
+      }
+    } catch {
+      return compactObject(ctx.realm, v);
+    } finally {
+      ctx.indent -= 1;
+      ctx.inspected.pop();
+    }
+  },
+} satisfies Partial<Record<Value['type'], Inspector>>;
+
+// TODO: add an option to inspect so it can return string with color.
+export function inspect(value: Value | ValueCompletion): string {
+  const context: InspectContext = {
+    realm: surroundingAgent.currentRealmRecord,
+    indent: 0,
+    inspected: [],
+    compact: false,
+  };
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const inner = (v: Value) => (INSPECTORS[v.type] as any)(v, context, inner);
+  if (value instanceof Completion) {
+    value = value.Value;
+  }
+  return inner(value);
+}

package/src/host-defined/job-queue.mts

@@ -0,0 +1,191 @@
+import { callCallback } from '../utils/callback.mts';
+import {
+  AbruptCompletion, Assert, ClearKeptObjects, ExecutionContext, type GCMarker, type Job, type Markable, ThrowCompletion, Value, type ValueEvaluator, skipDebugger, surroundingAgent,
+} from '#self';
+
+
+/** https://tc39.es/ecma262/#sec-jobs */
+export function runSingleJobInQueue(job: Job, onError: (error: Value) => void, finished: () => void) {
+  // At some future point in time, when there is no running context in the agent for which the job is scheduled and that agent's execution context stack is empty, the implementation must:
+  Assert(!surroundingAgent.executionContextStack.length);
+
+  // 1. Perform any implementation-defined preparation steps.
+  const { callerRealm, callerScriptOrModule, job: evaluator } = job;
+  if (callerRealm) {
+    // Spec: If a Realm Record is provided, these operations schedule the job to be performed at some future time in the provided realm, in the agent that owns the realm.
+    const newContext = new ExecutionContext();
+    surroundingAgent.executionContextStack.push(newContext);
+    newContext.Function = Value.null;
+    newContext.Realm = callerRealm;
+    newContext.ScriptOrModule = callerScriptOrModule;
+    surroundingAgent.evaluate((function* job(): ValueEvaluator {
+      // 2. Invoke the Job Abstract Closure.
+      const completion = yield* evaluator();
+      surroundingAgent.executionContextStack.pop(newContext);
+      continuation(completion);
+      return Value.undefined;
+    }()), () => {});
+  } else {
+    // Spec: If null is provided instead for the realm, then the job does not evaluate ECMAScript code.
+    // 2. Invoke the Job Abstract Closure.
+    const completion = skipDebugger(evaluator());
+    continuation(completion);
+  }
+
+  function continuation(completion: unknown) {
+    // 3. Perform any host-defined cleanup steps, after which the execution context stack must be empty.
+    Assert(!surroundingAgent.executionContextStack.length);
+    ClearKeptObjects();
+    // The Abstract Closure must return a normal completion, implementing its own handling of errors.
+    if (completion instanceof AbruptCompletion) {
+      Assert(completion instanceof ThrowCompletion);
+      onError(completion.Value);
+    }
+    finished();
+  }
+}
+
+export interface JobQueue extends Markable {
+  enqueueFinalizationRegistryCleanupJob(job: Job): void;
+  enqueuePromiseJob(job: Job): void;
+  enqueueTimeoutJob(job: Job): void;
+  enqueueGenericJob(job: Job): void;
+  onNewJob: Set<(job: Job) => void>;
+
+  shift(): Job | undefined;
+  shiftFinalizationRegistryCleanupJob?(): Job | undefined;
+  shiftPromiseJob?(): Job | undefined;
+  shiftTimeoutJob?(): Job | undefined;
+  shiftGenericJob?(): Job | undefined;
+  get length(): number;
+}
+
+export class BasicJobQueue extends Set<Job> implements JobQueue, Markable {
+  enqueueFinalizationRegistryCleanupJob(job: Job): void {
+    this.add(job);
+    callCallback(this.onNewJob, job);
+  }
+
+  enqueuePromiseJob(job: Job): void {
+    this.add(job);
+    callCallback(this.onNewJob, job);
+  }
+
+  enqueueTimeoutJob(job: Job): void {
+    this.add(job);
+    callCallback(this.onNewJob, job);
+  }
+
+  enqueueGenericJob(job: Job): void {
+    this.add(job);
+    callCallback(this.onNewJob, job);
+  }
+
+  onNewJob: JobQueue['onNewJob'] = new Set();
+
+  shift(): Job | undefined {
+    const [job] = this;
+    this.delete(job);
+    return job;
+  }
+
+  get length(): number {
+    return this.size;
+  }
+
+  mark(marker: GCMarker): void {
+    for (const job of this) {
+      marker(job.job);
+      marker(job.callerRealm);
+      marker(job.callerScriptOrModule);
+    }
+  }
+}
+
+export class ByTypeJobQueue implements JobQueue, Markable {
+  #all = new Set<Job>();
+
+  #finalizationRegistryCleanupJobs = new Set<Job>();
+
+  #promiseJobs = new Set<Job>();
+
+  #timeoutJobs = new Set<Job>();
+
+  #genericJobs = new Set<Job>();
+
+  enqueueFinalizationRegistryCleanupJob(job: Job): void {
+    this.#finalizationRegistryCleanupJobs.add(job);
+    this.#all.add(job);
+    callCallback(this.onNewJob, job);
+  }
+
+  enqueuePromiseJob(job: Job): void {
+    this.#promiseJobs.add(job);
+    this.#all.add(job);
+    callCallback(this.onNewJob, job);
+  }
+
+  enqueueTimeoutJob(job: Job): void {
+    this.#timeoutJobs.add(job);
+    this.#all.add(job);
+    callCallback(this.onNewJob, job);
+  }
+
+  enqueueGenericJob(job: Job): void {
+    this.#genericJobs.add(job);
+    this.#all.add(job);
+    callCallback(this.onNewJob, job);
+  }
+
+  onNewJob: JobQueue['onNewJob'] = new Set();
+
+  shift(): Job | undefined {
+    const [job] = this.#all;
+    this.#all.delete(job);
+    this.#finalizationRegistryCleanupJobs.delete(job);
+    this.#promiseJobs.delete(job);
+    this.#timeoutJobs.delete(job);
+    this.#genericJobs.delete(job);
+    return job;
+  }
+
+  shiftFinalizationRegistryCleanupJob(): Job | undefined {
+    const [job] = this.#finalizationRegistryCleanupJobs;
+    this.#finalizationRegistryCleanupJobs.delete(job);
+    this.#all.delete(job);
+    return job;
+  }
+
+  shiftPromiseJob(): Job | undefined {
+    const [job] = this.#promiseJobs;
+    this.#promiseJobs.delete(job);
+    this.#all.delete(job);
+    return job;
+  }
+
+  shiftTimeoutJob(): Job | undefined {
+    const [job] = this.#timeoutJobs;
+    this.#timeoutJobs.delete(job);
+    this.#all.delete(job);
+    return job;
+  }
+
+  shiftGenericJob(): Job | undefined {
+    const [job] = this.#genericJobs;
+    this.#genericJobs.delete(job);
+    this.#all.delete(job);
+    return job;
+  }
+
+  get length(): number {
+    return this.#all.size;
+  }
+
+  mark(marker: GCMarker): void {
+    for (const job of this.#all) {
+      marker(job.job);
+      marker(job.callerRealm);
+      marker(job.callerScriptOrModule);
+    }
+  }
+}