@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/abstract-ops/realms.mts

@@ -0,0 +1,209 @@
+import {
+  Descriptor,
+  Value,
+} from '../value.mts';
+import { X } from '../completion.mts';
+import {
+  ObjectValue, type BuiltinFunctionObject, type FunctionObject
+  ,
+} from '../index.mts';
+import type { Realm } from '../execution-context/Realm.mts';
+import {
+  Assert,
+  DefinePropertyOrThrow,
+} from './all.mts';
+
+/** https://tc39.es/ecma262/#table-well-known-intrinsic-objects */
+interface Intrinsics_Table6 {
+  '%AbstractModuleSource%': FunctionObject;
+  '%AggregateError%': FunctionObject;
+  '%AsyncDisposableStack%': FunctionObject;
+  '%Array%': FunctionObject;
+  '%ArrayBuffer%': FunctionObject;
+  '%ArrayIteratorPrototype%': ObjectValue;
+  '%AsyncFromSyncIteratorPrototype%': ObjectValue;
+  '%AsyncFunction%': FunctionObject;
+  '%AsyncGeneratorFunction%': FunctionObject;
+  '%AsyncGeneratorPrototype%': ObjectValue;
+  '%AsyncIteratorPrototype%': ObjectValue;
+  '%Atomics%': ObjectValue;
+  '%BigInt%': FunctionObject;
+  '%BigInt64Array%': FunctionObject;
+  '%BigUint64Array%': FunctionObject;
+  '%Boolean%': FunctionObject;
+  '%DataView%': FunctionObject;
+  '%Date%': FunctionObject;
+  '%DisposableStack%': FunctionObject;
+  '%decodeURI%': FunctionObject;
+  '%decodeURIComponent%': FunctionObject;
+  '%encodeURI%': FunctionObject;
+  '%encodeURIComponent%': FunctionObject;
+  '%Error%': FunctionObject;
+  '%eval%': FunctionObject;
+  '%EvalError%': FunctionObject;
+  '%FinalizationRegistry%': FunctionObject;
+  '%Float16Array%': FunctionObject;
+  '%Float32Array%': FunctionObject;
+  '%Float64Array%': FunctionObject;
+  '%ForInIteratorPrototype%': ObjectValue;
+  '%Function%': FunctionObject;
+  '%GeneratorFunction%': FunctionObject;
+  '%GeneratorPrototype%': ObjectValue;
+  '%Int8Array%': FunctionObject;
+  '%Int16Array%': FunctionObject;
+  '%Int32Array%': FunctionObject;
+  '%isFinite%': FunctionObject;
+  '%isNaN%': FunctionObject;
+  '%Iterator%': FunctionObject;
+  '%IteratorHelperPrototype%': ObjectValue;
+  '%JSON%': ObjectValue;
+  '%Map%': FunctionObject;
+  '%MapIteratorPrototype%': ObjectValue;
+  '%Math%': ObjectValue;
+  '%Number%': FunctionObject;
+  '%Object%': FunctionObject;
+  '%parseFloat%': FunctionObject;
+  '%parseInt%': FunctionObject;
+  '%Promise%': FunctionObject;
+  '%Proxy%': FunctionObject;
+  '%RangeError%': FunctionObject;
+  '%ReferenceError%': FunctionObject;
+  '%Reflect%': ObjectValue;
+  '%RegExp%': FunctionObject;
+  '%RegExpStringIteratorPrototype%': ObjectValue;
+  '%Set%': FunctionObject;
+  '%SetIteratorPrototype%': ObjectValue;
+  '%SharedArrayBuffer%': FunctionObject;
+  '%String%': FunctionObject;
+  '%StringIteratorPrototype%': ObjectValue;
+  '%Symbol%': FunctionObject;
+  '%SuppressedError%': FunctionObject;
+  '%SyntaxError%': FunctionObject;
+  '%ThrowTypeError%': FunctionObject;
+  '%TypedArray%': FunctionObject;
+  '%TypeError%': FunctionObject;
+  '%Uint8Array%': FunctionObject;
+  '%Uint8ClampedArray%': FunctionObject;
+  '%Uint16Array%': FunctionObject;
+  '%Uint32Array%': FunctionObject;
+  '%URIError%': FunctionObject;
+  '%WeakMap%': FunctionObject;
+  '%WeakRef%': FunctionObject;
+  '%WeakSet%': FunctionObject;
+  '%WrapForValidIteratorPrototype%': ObjectValue;
+}
+export interface Intrinsics extends Intrinsics_Table6 {
+  '%AbstractModuleSource.prototype%': ObjectValue;
+  '%AggregateError.prototype%': ObjectValue;
+  '%Array.prototype.values%': FunctionObject;
+  '%Array.prototype%': ObjectValue;
+  '%ArrayBuffer.prototype%': ObjectValue;
+  '%AsyncDisposableStack.prototype%': ObjectValue;
+  '%AsyncFunction.prototype%': ObjectValue;
+  '%AsyncGeneratorFunction.prototype.prototype%': ObjectValue;
+  '%AsyncGeneratorFunction.prototype%': ObjectValue;
+  '%BigInt.prototype%': ObjectValue;
+  '%BigInt64Array.prototype%': ObjectValue;
+  '%BigInt64Array%': FunctionObject;
+  '%BigUint64Array.prototype%': ObjectValue;
+  '%BigUint64Array%': FunctionObject;
+  '%Boolean.prototype%': ObjectValue;
+  '%DataView.prototype%': ObjectValue;
+  '%Date.prototype%': ObjectValue;
+  '%DisposableStack.prototype%': ObjectValue;
+  '%Error.prototype%': ObjectValue;
+  '%Error.prototype.toString%': BuiltinFunctionObject;
+  '%EvalError.prototype%': ObjectValue;
+  '%EvalError%': FunctionObject;
+  '%FinalizationRegistry.prototype%': ObjectValue;
+  '%Float16Array.prototype%': ObjectValue;
+  '%Float32Array.prototype%': ObjectValue;
+  '%Float32Array%': FunctionObject;
+  '%Float64Array.prototype%': ObjectValue;
+  '%Float64Array%': FunctionObject;
+  '%Function.prototype%': FunctionObject;
+  '%GeneratorFunction.prototype.prototype.next%': FunctionObject;
+  '%GeneratorFunction.prototype.prototype%': ObjectValue;
+  '%GeneratorFunction.prototype%': ObjectValue;
+  '%Int16Array.prototype%': ObjectValue;
+  '%Int16Array%': FunctionObject;
+  '%Int32Array.prototype%': ObjectValue;
+  '%Int32Array%': FunctionObject;
+  '%Int8Array.prototype%': ObjectValue;
+  '%Int8Array%': FunctionObject;
+  '%Iterator.prototype%': ObjectValue;
+  '%JSON.parse%': FunctionObject;
+  '%JSON.stringify%': FunctionObject;
+  '%Map.prototype%': ObjectValue;
+  '%Number.prototype%': ObjectValue;
+  '%Object.prototype.toString%': BuiltinFunctionObject;
+  '%Object.prototype.valueOf%': FunctionObject;
+  '%Object.prototype%': ObjectValue;
+  '%Promise.prototype.then%': FunctionObject;
+  '%Promise.prototype%': ObjectValue;
+  '%Promise.resolve%': FunctionObject;
+  '%RangeError.prototype%': ObjectValue;
+  '%RangeError%': FunctionObject;
+  '%ReferenceError.prototype%': ObjectValue;
+  '%ReferenceError%': FunctionObject;
+  '%RegExp.prototype%': ObjectValue;
+  '%Set.prototype%': ObjectValue;
+  '%ShadowRealm%': FunctionObject;
+  '%ShadowRealm.prototype%': ObjectValue;
+  '%String.prototype%': ObjectValue;
+  // Note: do not add any well known symbols here, use wellKnownSymbols.*
+  '%Symbol.prototype%': ObjectValue;
+  '%SuppressedError.prototype%': ObjectValue;
+  '%SyntaxError.prototype%': ObjectValue;
+  '%SyntaxError%': FunctionObject;
+  '%Temporal%': ObjectValue;
+  '%Temporal.Duration%': FunctionObject;
+  '%Temporal.Duration.prototype%': ObjectValue;
+  '%Temporal.Instant%': FunctionObject;
+  '%Temporal.Instant.prototype%': ObjectValue;
+  '%Temporal.PlainDate%': FunctionObject;
+  '%Temporal.PlainDate.prototype%': ObjectValue;
+  '%Temporal.PlainDateTime%': FunctionObject;
+  '%Temporal.PlainDateTime.prototype%': ObjectValue;
+  '%Temporal.PlainMonthDay%': FunctionObject;
+  '%Temporal.PlainMonthDay.prototype%': ObjectValue;
+  '%Temporal.PlainYearMonth%': FunctionObject;
+  '%Temporal.PlainYearMonth.prototype%': ObjectValue;
+  '%Temporal.PlainTime%': FunctionObject;
+  '%Temporal.PlainTime.prototype%': ObjectValue;
+  '%Temporal.ZonedDateTime%': FunctionObject;
+  '%Temporal.ZonedDateTime.prototype%': ObjectValue;
+  '%TypedArray.prototype%': ObjectValue;
+  '%TypeError.prototype%': ObjectValue;
+  '%TypeError%': FunctionObject;
+  '%Uint16Array.prototype%': ObjectValue;
+  '%Uint16Array%': FunctionObject;
+  '%Uint32Array.prototype%': ObjectValue;
+  '%Uint32Array%': FunctionObject;
+  '%Uint8Array.prototype%': ObjectValue;
+  '%Uint8Array%': FunctionObject;
+  '%Uint8ClampedArray.prototype%': ObjectValue;
+  '%Uint8ClampedArray%': FunctionObject;
+  '%URIError.prototype%': ObjectValue;
+  '%URIError%': FunctionObject;
+  '%WeakMap.prototype%': ObjectValue;
+  '%WeakRef.prototype%': ObjectValue;
+  '%WeakSet.prototype%': ObjectValue;
+}
+
+export function AddRestrictedFunctionProperties(F: ObjectValue, realm: Realm) {
+  Assert(!!realm.Intrinsics['%ThrowTypeError%']);
+  const thrower = realm.Intrinsics['%ThrowTypeError%'];
+  X(DefinePropertyOrThrow(F, Value('caller'), Descriptor({
+    Getter: thrower,
+    Setter: thrower,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+  X(DefinePropertyOrThrow(F, Value('arguments'), Descriptor({
+    Getter: thrower,
+    Setter: thrower,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+}

package/src/abstract-ops/reference-operations.mts

@@ -0,0 +1,211 @@
+import {
+  ReferenceRecord,
+  Value,
+  PrivateName,
+  JSStringValue,
+  ObjectValue,
+} from '../value.mts';
+import {
+  Q,
+  type PlainCompletion,
+} from '../completion.mts';
+import { __ts_cast__ } from '../utils/language.mts';
+import type { PlainEvaluator } from '../evaluator.mts';
+import { ResolvePrivateIdentifier } from '../execution-context/PrivateEnvironment.mts';
+import {
+  Assert,
+  ToObject,
+  Set,
+  PrivateGet,
+  PrivateSet,
+  IsPropertyKey,
+  ToPropertyKey,
+  getActiveScriptId,
+} from './all.mts';
+import {
+  DynamicParsedCodeRecord, surroundingAgent, EnvironmentRecord, GetGlobalObject, Throw,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-ispropertyreference */
+export function IsPropertyReference(V: ReferenceRecord) {
+  // 1. If V.[[Base]] is unresolvable, return false.
+  if (V.Base === 'unresolvable') {
+    return Value.false;
+  }
+  // 2. If V.[[Base]] is an Environment Record, return false; otherwise return true.
+  return V.Base instanceof EnvironmentRecord ? Value.false : Value.true;
+}
+export type PropertyReference = ReferenceRecord & {
+  readonly Base: Exclude<ReferenceRecord['Base'], 'unresolvable' | EnvironmentRecord>,
+};
+
+/** https://tc39.es/ecma262/#sec-isunresolvablereference */
+export function IsUnresolvableReference(V: ReferenceRecord) {
+  // 1. Assert: V is a Reference Record.
+  Assert(V instanceof ReferenceRecord);
+  // 2. If V.[[Base]] is unresolvable, return true; otherwise return false.
+  return V.Base === 'unresolvable' ? Value.true : Value.false;
+}
+
+/** https://tc39.es/ecma262/#sec-issuperreference */
+export function IsSuperReference(V: ReferenceRecord) {
+  // 1. Assert: V is a Reference Record.
+  Assert(V instanceof ReferenceRecord);
+  // 2. If V.[[ThisValue]] is not empty, return true; otherwise return false.
+  return V.ThisValue !== undefined ? Value.true : Value.false;
+}
+
+/** https://tc39.es/ecma262/#sec-isprivatereference */
+export function IsPrivateReference(V: ReferenceRecord): V is ReferenceRecord & { readonly ReferencedName: PrivateName } {
+  // 1. Assert: V is a Reference Record.
+  Assert(V instanceof ReferenceRecord);
+  // 2. If V.[[ReferencedName]] is a Private Name, return true; otherwise return false.
+  return V.ReferencedName instanceof PrivateName;
+}
+
+/** https://tc39.es/ecma262/#sec-getvalue */
+export function* GetValue(V: ReferenceRecord | Value): PlainEvaluator<Value> {
+  // 1. If V is not a Reference Record, return V.
+  if (!(V instanceof ReferenceRecord)) {
+    return V;
+  }
+  // 2. If IsUnresolvableReference(V) is true, throw a ReferenceError exception.
+  if (IsUnresolvableReference(V) === Value.true) {
+    return Throw.ReferenceError('$1 is not defined', V.ReferencedName);
+  }
+  // 3. If IsPropertyReference(V) is true, then
+  if (IsPropertyReference(V) === Value.true) {
+    __ts_cast__<PropertyReference>(V);
+    // a. Let baseObj be ? ToObject(V.[[Base]]).
+    const baseObj = Q(ToObject(V.Base));
+    // b. If IsPrivateReference(V) is true, then
+    if (IsPrivateReference(V)) {
+      // i. Return ? PrivateGet(baseObj, V.[[ReferencedName]]).
+      return Q(yield* PrivateGet(baseObj, V.ReferencedName));
+    }
+    if (!IsPropertyKey(V.ReferencedName)) {
+      V.ReferencedName = Q(yield* ToPropertyKey(V.ReferencedName as Value));
+    }
+    // c. Return ? baseObj.[[Get]](V.[[ReferencedName]], GetThisValue(V)).
+    return Q(yield* baseObj.Get(V.ReferencedName, GetThisValue(V)));
+  } else { // 5. Else,
+    // a. Let base be V.[[Base]].
+    const base = V.Base;
+    // b. Assert: base is an Environment Record.
+    Assert(base instanceof EnvironmentRecord);
+    // c. Return ? base.GetBindingValue(V.[[ReferencedName]], V.[[Strict]]).
+    return Q(yield* base.GetBindingValue(V.ReferencedName as JSStringValue, V.Strict));
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-putvalue */
+export function* PutValue(V: ReferenceRecord | Value, W: Value): PlainEvaluator {
+  // 1. If V is not a Reference Record, throw a ReferenceError exception.
+  if (!(V instanceof ReferenceRecord)) {
+    return Throw.ReferenceError('Invalid assignment target');
+  }
+  // 2. If IsUnresolvableReference(V) is true, then
+  if (IsUnresolvableReference(V) === Value.true) {
+    // a. If V.[[Strict]] is true, throw a ReferenceError exception.
+    if (V.Strict === Value.true) {
+      return Throw.ReferenceError('$1 is not defined', V.ReferencedName);
+    }
+    // b. Let globalObj be GetGlobalObject().
+    const globalObj = GetGlobalObject();
+    // c. Return ? Set(globalObj, V.[[ReferencedName]], W, false).
+    Q(yield* Set(globalObj, V.ReferencedName as JSStringValue, W, Value.false));
+    return undefined;
+  }
+  // 5. If IsPropertyReference(V) is true, then
+  if (IsPropertyReference(V) === Value.true) {
+    // a. Let baseObj be ? ToObject(V.[[Base]]).
+    const baseObj = Q(ToObject(V.Base as JSStringValue));
+    // b. If IsPrivateReference(V) is true, then
+    if (IsPrivateReference(V)) {
+      // i. Return ? PrivateSet(baseObj, V.[[ReferencedName]], W).
+      return Q(yield* PrivateSet(baseObj, V.ReferencedName, W));
+    }
+    if (!IsPropertyKey(V.ReferencedName)) {
+      V.ReferencedName = Q(yield* ToPropertyKey(V.ReferencedName as Value));
+    }
+    // c. Let succeeded be ? baseObj.[[Set]](V.[[ReferencedName]], W, GetThisValue(V)).
+    const succeeded = Q(yield* baseObj.Set(V.ReferencedName, W, GetThisValue(V)));
+    // d. If succeeded is false and V.[[Strict]] is true, throw a TypeError exception.
+    if (succeeded === Value.false && V.Strict === Value.true) {
+      return Throw.TypeError('Cannot set property $1 on $2', V.ReferencedName, baseObj);
+    }
+    // e. Return.
+    return undefined;
+  } else { // 6. Else,
+    // a. Let base be V.[[Base]].
+    const base = V.Base;
+    // b. Assert: base is an Environment Record.
+    Assert(base instanceof EnvironmentRecord);
+    // c. Return ? base.SetMutableBinding(V.[[ReferencedName]], W, V.[[Strict]]) (see 9.1).
+    return Q(yield* base.SetMutableBinding(V.ReferencedName as JSStringValue, W, V.Strict));
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-getthisvalue */
+export function GetThisValue(V: ReferenceRecord) {
+  // 1. Assert: IsPropertyReference(V) is true.
+  Assert(IsPropertyReference(V) === Value.true);
+  // 2. If IsSuperReference(V) is true, return V.[[ThisValue]]; otherwise return V.[[Base]].
+  if (IsSuperReference(V) === Value.true) {
+    return V.ThisValue!;
+  } else {
+    return V.Base as Value;
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-initializereferencedbinding */
+export function* InitializeReferencedBinding(V: PlainCompletion<ReferenceRecord>, W: Value): PlainEvaluator {
+  Q(V);
+  Q(W);
+  // 3. Assert: V is a Reference Record.
+  Assert(V instanceof ReferenceRecord);
+  // 4. Assert: IsUnresolvableReference(V) is false.
+  Assert(IsUnresolvableReference(V) === Value.false);
+  // 5. Let base be V.[[Base]].
+  const base = V.Base;
+  // 6. Assert: base is an Environment Record.
+  Assert(base instanceof EnvironmentRecord);
+  // 7. Return base.InitializeBinding(V.[[ReferencedName]], W).
+  return yield* base.InitializeBinding(V.ReferencedName as JSStringValue, W);
+}
+
+/** https://tc39.es/ecma262/#sec-makeprivatereference */
+export function MakePrivateReference(baseValue: Value, privateIdentifier: JSStringValue) {
+  // 1. Let privEnv be the running execution context's PrivateEnvironment.
+  const privEnv = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  // 2. Assert: privEnv is not null.
+  // but we allow private reference to be accessed directly in the inspector eval
+  if (privEnv === null) {
+    const scriptId = getActiveScriptId();
+    const script = surroundingAgent.parsedSources.get(scriptId!);
+    if (script instanceof DynamicParsedCodeRecord && script?.HostDefined?.isInspectorEval) {
+      let privateName;
+      if (baseValue instanceof ObjectValue) {
+        privateName = baseValue.PrivateElements.find((elem) => elem.Key.Description.stringValue() === privateIdentifier.stringValue())?.Key;
+      }
+      privateName ??= new PrivateName(privateIdentifier);
+      return new ReferenceRecord({
+        Base: baseValue,
+        ReferencedName: privateName,
+        Strict: Value.true,
+        ThisValue: undefined,
+      });
+    } else {
+      Assert(privEnv !== null);
+    }
+  }
+  // 3. Let privateName be ! ResolvePrivateIdentifier(privEnv, privateIdentifier).
+  const privateName = ResolvePrivateIdentifier(privEnv!, privateIdentifier);
+  // 4. Return the Reference Record { [[Base]]: baseValue, [[ReferencedName]]: privateName, [[Strict]]: true, [[ThisValue]]: empty }.
+  return new ReferenceRecord({
+    Base: baseValue,
+    ReferencedName: privateName,
+    Strict: Value.true,
+    ThisValue: undefined,
+  });
+}