@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

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

@@ -0,0 +1,211 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  ReferenceRecord,
+  Value,
+  PrivateName,
+  JSStringValue,
+  NullValue,
+} from '../value.mts';
+import {
+  Q,
+  ReturnIfAbrupt,
+  X,
+  type PlainCompletion,
+} from '../completion.mts';
+import { EnvironmentRecord, PrivateEnvironmentRecord } from '../environment.mts';
+import { __ts_cast__ } from '../helpers.mts';
+import {
+  Assert,
+  GetGlobalObject,
+  ToObject,
+  Set,
+  PrivateGet,
+  PrivateSet,
+} from './all.mts';
+
+/** 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) {
+  // 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 ? Value.true : Value.false;
+}
+
+/** https://tc39.es/ecma262/#sec-getvalue */
+export function GetValue(V: PlainCompletion<ReferenceRecord | Value>): PlainCompletion<Value> {
+  // 1. ReturnIfAbrupt(V).
+  V = ReturnIfAbrupt(V);
+  // 2. If V is not a Reference Record, return V.
+  if (!(V instanceof ReferenceRecord)) {
+    return V;
+  }
+  // 3. If IsUnresolvableReference(V) is true, throw a ReferenceError exception.
+  if (IsUnresolvableReference(V) === Value.true) {
+    return surroundingAgent.Throw('ReferenceError', 'NotDefined', V.ReferencedName);
+  }
+  // 4. 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) === Value.true) {
+      // i. Return ? PrivateGet(V.[[ReferencedName]], baseObj).
+      return Q(PrivateGet(V.ReferencedName as PrivateName, baseObj));
+    }
+    // c. Return ? baseObj.[[Get]](V.[[ReferencedName]], GetThisValue(V)).
+    return Q(baseObj.Get(V.ReferencedName as JSStringValue, 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(base.GetBindingValue(V.ReferencedName as JSStringValue, V.Strict));
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-putvalue */
+export function PutValue(V: PlainCompletion<ReferenceRecord | Value>, W: PlainCompletion<Value>): PlainCompletion<void> {
+  // 1. ReturnIfAbrupt(V).
+  V = ReturnIfAbrupt(V);
+  // 2. ReturnIfAbrupt(W).
+  W = ReturnIfAbrupt(W);
+  // 3. If V is not a Reference Record, throw a ReferenceError exception.
+  if (!(V instanceof ReferenceRecord)) {
+    return surroundingAgent.Throw('ReferenceError', 'InvalidAssignmentTarget');
+  }
+  // 4. 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 surroundingAgent.Throw('ReferenceError', 'NotDefined', V.ReferencedName);
+    }
+    // b. Let globalObj be GetGlobalObject().
+    const globalObj = GetGlobalObject();
+    // c. Return ? Set(globalObj, V.[[ReferencedName]], W, false).
+    Q(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 = X(ToObject(V.Base as JSStringValue));
+    // b. If IsPrivateReference(V) is true, then
+    if (IsPrivateReference(V) === Value.true) {
+      // i. Return ? PrivateSet(V.[[ReferencedName]], baseObj, W).
+      return Q(PrivateSet(V.ReferencedName as PrivateName, baseObj, W));
+    }
+    // c. Let succeeded be ? baseObj.[[Set]](V.[[ReferencedName]], W, GetThisValue(V)).
+    const succeeded = Q(baseObj.Set(V.ReferencedName as JSStringValue, 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 surroundingAgent.Throw('TypeError', 'CannotSetProperty', V.ReferencedName, V.Base);
+    }
+    // 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(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): PlainCompletion<void> {
+  // 1. ReturnIfAbrupt(V).
+  ReturnIfAbrupt(V);
+  // 2. ReturnIfAbrupt(W).
+  ReturnIfAbrupt(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 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.
+  Assert(!(privEnv instanceof NullValue));
+  // 3. Let privateName be ! ResolvePrivateIdentifier(privEnv, privateIdentifier).
+  const privateName = X(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,
+  });
+}
+
+/** https://tc39.es/ecma262/#sec-resolve-private-identifier */
+export function ResolvePrivateIdentifier(privEnv: PrivateEnvironmentRecord, identifier: JSStringValue) {
+  // 1. Let names be privEnv.[[Names]].
+  const names = privEnv.Names;
+  // 2. If names contains a Private Name whose [[Description]] is identifier, then
+  const name = names.find((n) => n.Description.stringValue() === identifier.stringValue());
+  if (name) {
+    // a. Let name be that Private Name.
+    // b. Return name.
+    return name;
+  } else { // 3. Else,
+    // a. Let outerPrivEnv be privEnv.[[OuterPrivateEnvironment]].
+    const outerPrivEnv = privEnv.OuterPrivateEnvironment;
+    // b. Assert: outerPrivEnv is not null.
+    Assert(!(outerPrivEnv instanceof NullValue));
+    // c. Return ResolvePrivateIdentifier(outerPrivEnv, identifier).
+    return ResolvePrivateIdentifier(outerPrivEnv, identifier);
+  }
+}

package/src/abstract-ops/regexp-objects.mts

@@ -0,0 +1,299 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  Descriptor, Value, ObjectValue, BooleanValue, JSStringValue,
+  UndefinedValue,
+} from '../value.mts';
+import { Q, X, type ExpressionCompletion } from '../completion.mts';
+import { Evaluate_Pattern } from '../runtime-semantics/all.mts';
+import { ParsePattern } from '../parse.mts';
+import { isLineTerminator } from '../parser/Lexer.mts';
+import type { Mutable } from '../helpers.mts';
+import type { RegExpObject } from '../intrinsics/RegExp.mts';
+import {
+  ArrayCreate,
+  Assert,
+  CreateArrayFromList,
+  CreateDataPropertyOrThrow,
+  DefinePropertyOrThrow,
+  OrdinaryCreateFromConstructor,
+  OrdinaryObjectCreate,
+  SameValue,
+  Set,
+  ToString,
+  F as toNumberValue,
+  type FunctionObject,
+} from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-regexpalloc */
+export function RegExpAlloc(newTarget: FunctionObject): ExpressionCompletion<RegExpObject> {
+  const obj = Q(OrdinaryCreateFromConstructor(newTarget, '%RegExp.prototype%', ['RegExpMatcher', 'OriginalSource', 'OriginalFlags'])) as Mutable<RegExpObject>;
+  X(DefinePropertyOrThrow(obj, Value('lastIndex'), Descriptor({
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+  return obj;
+}
+
+/** https://tc39.es/ecma262/#sec-regexpinitialize */
+export function RegExpInitialize(obj: Mutable<RegExpObject>, pattern: Value, flags: Value) {
+  let P;
+  // 1. If pattern is undefined, let P be the empty String.
+  if (pattern === Value.undefined) {
+    P = Value('');
+  } else { // 2. Else, let P be ? ToString(pattern).
+    P = Q(ToString(pattern));
+  }
+  let F;
+  // 3. If flags is undefined, let F be the empty String.
+  if (flags === Value.undefined) {
+    F = Value('');
+  } else { // 4. Else, let F be ? ToString(flags).
+    F = Q(ToString(flags));
+  }
+  const f = F.stringValue();
+  // 5. If F contains any code unit other than "d", "g", "i", "m", "s", "u", or "y" or if it contains the same code unit more than once, throw a SyntaxError exception.
+  if (/^[dgimsuy]*$/.test(f) === false || (new globalThis.Set(f).size !== f.length)) {
+    return surroundingAgent.Throw('SyntaxError', 'InvalidRegExpFlags', f);
+  }
+  // 6. If F contains "u", let u be true; else let u be false.
+  const u = f.includes('u');
+  // 7. If u is true, then
+  //   a. Let patternText be ! UTF16DecodeString(P).
+  //   b. Let patternCharacters be a List whose elements are the code points of patternText.
+  // 8. Else,
+  //   a. Let patternText be the result of interpreting each of P's 16-bit elements as a Unicode BMP code point. UTF-16 decoding is not applied to the elements.
+  //   b. Let patternCharacters be a List whose elements are the code unit elements of P.
+  // 9. Let parseResult be ParsePattern(patternText, u).
+  const patternText = P.stringValue();
+  const parseResult = ParsePattern(patternText, u);
+  // 10. If parseResult is a non-empty List of SyntaxError objects, throw a SyntaxError exception.
+  if (Array.isArray(parseResult)) {
+    return surroundingAgent.Throw(parseResult[0], 'Raw', parseResult[0]);
+  }
+  obj.parsedPattern = parseResult;
+  // 11. Assert: parseResult is a Parse Node for Pattern.
+  Assert(parseResult.type === 'Pattern');
+  // 12. Set obj.[[OriginalSource]] to P.
+  obj.OriginalSource = P;
+  // 13. Set obj.[[OriginalFlags]] to F.
+  obj.OriginalFlags = F;
+  // 14. Set obj.[[RegExpMatcher]] to the Abstract Closure that evaluates parseResult by
+  //     applying the semantics provided in 21.2.2 using patternCharacters as the pattern's
+  //     List of SourceCharacter values and F as the flag parameters.
+  const evaluatePattern = surroundingAgent.hostDefinedOptions.boost?.evaluatePattern || Evaluate_Pattern;
+  obj.RegExpMatcher = evaluatePattern(parseResult, F.stringValue());
+  // 15. Perform ? Set(obj, "lastIndex", +0𝔽, true).
+  Q(Set(obj, Value('lastIndex'), toNumberValue(+0), Value.true));
+  // 16. Return obj.
+  return obj;
+}
+
+/** https://tc39.es/ecma262/#sec-regexpcreate */
+export function RegExpCreate(P: Value, F: Value): ExpressionCompletion<RegExpObject> {
+  const obj = Q(RegExpAlloc(surroundingAgent.intrinsic('%RegExp%')));
+  return Q(RegExpInitialize(obj, P, F));
+}
+
+/** https://tc39.es/ecma262/#sec-escaperegexppattern */
+export function EscapeRegExpPattern(P: JSStringValue, _F: Value) {
+  const source = P.stringValue();
+  if (source === '') {
+    return Value('(:?)');
+  }
+  let index = 0;
+  let escaped = '';
+  let inClass = false;
+  while (index < source.length) {
+    const c = source[index];
+    switch (c) {
+      case '\\':
+        index += 1;
+        if (isLineTerminator(source[index])) {
+          // nothing
+        } else {
+          escaped += '\\';
+        }
+        break;
+      case '/':
+        index += 1;
+        if (inClass) {
+          escaped += '/';
+        } else {
+          escaped += '\\/';
+        }
+        break;
+      case '[':
+        inClass = true;
+        index += 1;
+        escaped += '[';
+        break;
+      case ']':
+        inClass = false;
+        index += 1;
+        escaped += ']';
+        break;
+      case '\n':
+        index += 1;
+        escaped += '\\n';
+        break;
+      case '\r':
+        index += 1;
+        escaped += '\\r';
+        break;
+      case '\u2028':
+        index += 1;
+        escaped += '\\u2028';
+        break;
+      case '\u2029':
+        index += 1;
+        escaped += '\\u2029';
+        break;
+      default:
+        index += 1;
+        escaped += c;
+        break;
+    }
+  }
+  return Value(escaped);
+}
+
+/** https://tc39.es/ecma262/#sec-getstringindex */
+export function GetStringIndex(S: JSStringValue, Input: readonly string[], e: number) {
+  // 1. Assert: Type(S) is String.
+  Assert(S instanceof JSStringValue);
+  // 2. Assert: Input is a List of the code points of S interpreted as a UTF-16 encoded string.
+  Assert(Array.isArray(Input));
+  // 3. Assert: e is an integer value ≥ 0.
+  Assert(e >= 0);
+  // 4. If S is the empty String, return 0.
+  if (S.stringValue() === '') {
+    return 0;
+  }
+  // 5. Let eUTF be the smallest index into S that corresponds to the character at element e of Input.
+  //    If e is greater than or equal to the number of elements in Input, then eUTF is the number of code units in S.
+  let eUTF = 0;
+  if (e >= Input.length) {
+    eUTF = S.stringValue().length;
+  } else {
+    for (let i = 0; i < e; i += 1) {
+      eUTF += Input[i].length;
+    }
+  }
+  // 6. Return eUTF.
+  return eUTF;
+}
+
+export interface MatchRecord {
+  readonly StartIndex: number;
+  readonly EndIndex: number;
+}
+/** https://tc39.es/ecma262/#sec-getmatchstring */
+export function GetMatchString(S: JSStringValue, match: MatchRecord) {
+  // 1. Assert: Type(S) is String.
+  Assert(S instanceof JSStringValue);
+  // 2. Assert: match is a Match Record.
+  Assert('StartIndex' in match && 'EndIndex' in match);
+  // 3. Assert: match.[[StartIndex]] is an integer value ≥ 0 and ≤ the length of S.
+  Assert(match.StartIndex >= 0 && match.StartIndex <= S.stringValue().length);
+  // 4. Assert: match.[[EndIndex]] is an integer value ≥ match.[[StartIndex]] and ≤ the length of S.
+  Assert(match.EndIndex >= match.StartIndex && match.EndIndex <= S.stringValue().length);
+  // 5. Return the portion of S between offset match.[[StartIndex]] inclusive and offset match.[[EndIndex]] exclusive.
+  return Value(S.stringValue().slice(match.StartIndex, match.EndIndex));
+}
+
+/** https://tc39.es/ecma262/#sec-getmatchindexpair */
+export function GetMatchIndexPair(S: JSStringValue, match: MatchRecord) {
+  // 1. Assert: Type(S) is String.
+  Assert(S instanceof JSStringValue);
+  // 2. Assert: match is a Match Record.
+  Assert('StartIndex' in match && 'EndIndex' in match);
+  // 3. Assert: match.[[StartIndex]] is an integer value ≥ 0 and ≤ the length of S.
+  Assert(match.StartIndex >= 0 && match.StartIndex <= S.stringValue().length);
+  // 4. Assert: match.[[EndIndex]] is an integer value ≥ match.[[StartIndex]] and ≤ the length of S.
+  Assert(match.EndIndex >= match.StartIndex && match.EndIndex <= S.stringValue().length);
+  // 1. Return CreateArrayFromList(« 𝔽(match.[[StartIndex]]), 𝔽(match.[[EndIndex]]) »).
+  return CreateArrayFromList([
+    toNumberValue(match.StartIndex),
+    toNumberValue(match.EndIndex),
+  ]);
+}
+
+/** https://tc39.es/ecma262/#sec-makematchindicesindexpairarray */
+export function MakeMatchIndicesIndexPairArray(S: JSStringValue, indices: readonly (MatchRecord | UndefinedValue)[], groupNames: readonly (JSStringValue | UndefinedValue)[], hasGroups: BooleanValue) {
+  // 1. Assert: Type(S) is String.
+  Assert(S instanceof JSStringValue);
+  // 2. Assert: indices is a List.
+  Assert(Array.isArray(indices));
+  // 3. Let n be the number of elements in indices.
+  const n = indices.length;
+  // 4. Assert: n < 2**32-1.
+  Assert(n < (2 ** 32) - 1);
+  // 5. Assert: groupNames is a List with _n_ - 1 elements.
+  Assert(Array.isArray(groupNames) && groupNames.length === n - 1);
+  // 6. NOTE: The groupNames List contains elements aligned with the indices List starting at indices[1].
+  // 7. Assert: Type(hasGroups) is Boolean.
+  Assert(hasGroups instanceof BooleanValue);
+  // 8. Set A to ! ArrayCreate(n).
+  // 9. Assert: The value of A's "length" property is n.
+  const A = X(ArrayCreate(n));
+  // 10. If hasGroups is true, then
+  let groups: ObjectValue | UndefinedValue;
+  if (hasGroups === Value.true) {
+    // a. Let groups be ! ObjectCreate(null).
+    groups = X(OrdinaryObjectCreate(Value.null));
+  } else { // 9. Else,
+    // b. Let groups be undefined.
+    groups = Value.undefined;
+  }
+  // 11. Perform ! CreateDataProperty(A, "groups", groups).
+  X(CreateDataPropertyOrThrow(A, Value('groups'), groups));
+  // 12. For each integer i such that i ≥ 0 and i < n, do
+  for (let i = 0; i < n; i += 1) {
+    // a. Let matchIndices be indices[i].
+    const matchIndices = indices[i];
+    // b. If matchIndices is not undefined, then
+    let matchIndicesArray;
+    if (matchIndices !== Value.undefined) {
+      // i. Let matchIndicesArray be ! GetMatchIndexPair(S, matchIndices).
+      matchIndicesArray = X(GetMatchIndexPair(S, matchIndices as MatchRecord));
+    } else { // c. Else,
+      // i. Let matchIndicesArray be undefined.
+      matchIndicesArray = Value.undefined;
+    }
+    // d. Perform ! CreateDataProperty(A, ! ToString(𝔽(i)), matchIndicesArray).
+    X(CreateDataPropertyOrThrow(A, X(ToString(toNumberValue(i))), matchIndicesArray));
+    // e. If i > 0 and groupNames[i - 1] is not undefined, then
+    if (i > 0 && groupNames[i - 1] !== Value.undefined) {
+      // i. Perform ! CreateDataProperty(groups, groupNames[i - 1], matchIndicesArray).
+      X(CreateDataPropertyOrThrow(groups as ObjectValue, groupNames[i - 1] as JSStringValue, matchIndicesArray));
+    }
+  }
+  // 13. Return A.
+  return A;
+}
+
+/** https://tc39.es/ecma262/#sec-regexphasflag */
+export function RegExpHasFlag(R: Value, codeUnit: string) {
+  // 1. If Type(R) is not Object, throw a TypeError exception.
+  if (!(R instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotATypeObject', 'RegExp', R);
+  }
+  // 2. If R does not have an [[OriginalFlags]] internal slot, then
+  if (!('OriginalFlags' in R)) {
+    // a. If SameValue(R, %RegExp.prototype%) is true, return undefined.
+    if (SameValue(R, surroundingAgent.intrinsic('%RegExp.prototype%')) === Value.true) {
+      return Value.undefined;
+    }
+    // b. Otherwise, throw a TypeError exception.
+    return surroundingAgent.Throw('TypeError', 'NotATypeObject', 'RegExp', R);
+  }
+  // 3. Let flags be R.[[OriginalFlags]].
+  const flags = (R as RegExpObject).OriginalFlags.stringValue();
+  // 4. If flags contains codeUnit, return true.
+  if (flags.includes(codeUnit)) {
+    return Value.true;
+  }
+  // 5. Return false.
+  return Value.false;
+}