@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/runtime-semantics/RegularExpressionLiteral.mts

@@ -0,0 +1,16 @@
+import { Value } from '../value.mts';
+import { BodyText, FlagText } from '../static-semantics/all.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { RegExpCreate } from '#self';
+
+/** https://tc39.es/ecma262/#sec-regular-expression-literals-runtime-semantics-evaluation */
+//   RegularExpressionLiteral :
+//     `/` RegularExpressionBody `/` RegularExpressionFlags
+export function* Evaluate_RegularExpressionLiteral(RegularExpressionLiteral: ParseNode.RegularExpressionLiteral) {
+  // 1. Let pattern be ! UTF16Encode(BodyText of RegularExpressionLiteral).
+  const pattern = Value(BodyText(RegularExpressionLiteral));
+  // 2. Let flags be ! UTF16Encode(FlagText of RegularExpressionLiteral).
+  const flags = Value(FlagText(RegularExpressionLiteral));
+  // 3. Return RegExpCreate(pattern, flags).
+  return yield* RegExpCreate(pattern, flags);
+}

package/src/runtime-semantics/RelationalExpression.mts

@@ -0,0 +1,150 @@
+import { StringValue } from '../static-semantics/all.mts';
+import {
+  ObjectValue,
+  Value,
+  wellKnownSymbols,
+} from '../value.mts';
+import { Q, X } from '../completion.mts';
+import { Evaluate } from '../evaluator.mts';
+import { OutOfRange } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  IsLessThan,
+  Call,
+  GetMethod,
+  GetValue,
+  HasProperty,
+  IsCallable,
+  OrdinaryHasInstance,
+  ToBoolean,
+  ToPropertyKey,
+  PrivateElementFind,
+  Throw,
+  surroundingAgent,
+} from '#self';
+import { ResolvePrivateIdentifier, type PrivateEnvironmentRecord } from '#self';
+
+/** https://tc39.es/ecma262/#sec-instanceofoperator */
+export function* InstanceofOperator(V: Value, target: Value) {
+  // 1. If Type(target) is not Object, throw a TypeError exception.
+  if (!(target instanceof ObjectValue)) {
+    return Throw.TypeError('Right-hand side of "instanceof" ($1) is not an object', target);
+  }
+  // 2. Let instOfHandler be ? GetMethod(target, @@hasInstance).
+  const instOfHandler = Q(yield* GetMethod(target, wellKnownSymbols.hasInstance));
+  // 3. If instOfHandler is not undefined, then
+  if (instOfHandler !== Value.undefined) {
+    // a. Return ! ToBoolean(? Call(instOfHandler, target, « V »)).
+    return X(ToBoolean(Q(yield* Call(instOfHandler, target, [V]))));
+  }
+  // 4. If IsCallable(target) is false, throw a TypeError exception.
+  if (!IsCallable(target)) {
+    return Throw.TypeError('Right-hand side of "instanceof" ($1) is not a function', target);
+  }
+  // 5. Return ? OrdinaryHasInstance(target, V).
+  return Q(yield* OrdinaryHasInstance(target, V));
+}
+
+// RelationalExpression : PrivateIdentifier `in` ShiftExpression
+export function* Evaluate_RelationalExpression_PrivateIdentifier({ PrivateIdentifier, ShiftExpression }: ParseNode.RelationalExpression) {
+  // 1. Let privateIdentifier be the StringValue of PrivateIdentifier.
+  const privateIdentifier = StringValue(PrivateIdentifier!);
+  // 2. Let rref be the result of evaluating ShiftExpression.
+  const rref = Q(yield* Evaluate(ShiftExpression));
+  // 3. Let rval be ? GetValue(rref).
+  const rval = Q(yield* GetValue(rref));
+  // 4. If Type(rval) is not Object, throw a TypeError exception.
+  if (!(rval instanceof ObjectValue)) {
+    return Throw.TypeError('Right-hand side of "in" ($1) is not an object', rval);
+  }
+  // 5. Let privateEnv be the running execution context's PrivateEnvironment.
+  const privateEnv = surroundingAgent.runningExecutionContext.PrivateEnvironment as PrivateEnvironmentRecord;
+  // 6. Let privateName be ! ResolvePrivateIdentifier(privateEnv, privateIdentifier).
+  const privateName = X(ResolvePrivateIdentifier(privateEnv, privateIdentifier));
+  // 7. If ! PrivateElementFind(privateName, rval) is not empty, return true.
+  if (X(PrivateElementFind(privateName, rval)) !== undefined) {
+    return Value.true;
+  }
+  // 8. Return false.
+  return Value.false;
+}
+
+/** https://tc39.es/ecma262/#sec-relational-operators-runtime-semantics-evaluation */
+//   RelationalExpression :
+//     RelationalExpression `<` ShiftExpression
+//     RelationalExpression `>` ShiftExpression
+//     RelationalExpression `<=` ShiftExpression
+//     RelationalExpression `>=` ShiftExpression
+//     RelationalExpression `instanceof` ShiftExpression
+//     RelationalExpression `in` ShiftExpression
+//     PrivateIdentifier `in` ShiftExpression
+export function* Evaluate_RelationalExpression(expr: ParseNode.RelationalExpression) {
+  if (expr.PrivateIdentifier) {
+    return yield* Evaluate_RelationalExpression_PrivateIdentifier(expr);
+  }
+
+  const { RelationalExpression, operator, ShiftExpression } = expr;
+
+  // 1. Let lref be the result of evaluating RelationalExpression.
+  const lref = Q(yield* Evaluate(RelationalExpression!));
+  // 2. Let lval be ? GetValue(lref).
+  const lval = Q(yield* GetValue(lref));
+  // 3. Let rref be the result of evaluating ShiftExpression.
+  const rref = Q(yield* Evaluate(ShiftExpression));
+  // 4. Let rval be ? GetValue(rref).
+  const rval = Q(yield* GetValue(rref));
+  switch (operator) {
+    case '<': {
+      // 5. Let r be the result of performing Abstract Relational Comparison lval < rval.
+      const r = yield* IsLessThan(lval, rval);
+      Q(r);
+      // 7. If r is undefined, return false. Otherwise, return r.
+      if (r === Value.undefined) {
+        return Value.false;
+      }
+      return r;
+    }
+    case '>': {
+      // 5. Let r be the result of performing Abstract Relational Comparison rval < lval with LeftFirst equal to false.
+      const r = yield* IsLessThan(rval, lval, false);
+      Q(r);
+      // 7. If r is undefined, return false. Otherwise, return r.
+      if (r === Value.undefined) {
+        return Value.false;
+      }
+      return r;
+    }
+    case '<=': {
+      // 5. Let r be the result of performing Abstract Relational Comparison rval < lval with LeftFirst equal to false.
+      const r = yield* IsLessThan(rval, lval, false);
+      Q(r);
+      // 7. If r is true or undefined, return false. Otherwise, return true.
+      if (r === Value.true || r === Value.undefined) {
+        return Value.false;
+      }
+      return Value.true;
+    }
+    case '>=': {
+      // 5. Let r be the result of performing Abstract Relational Comparison lval < rval.
+      const r = yield* IsLessThan(lval, rval);
+      Q(r);
+      // 7. If r is true or undefined, return false. Otherwise, return true.
+      if (r === Value.true || r === Value.undefined) {
+        return Value.false;
+      }
+      return Value.true;
+    }
+    case 'instanceof':
+      // 5. Return ? InstanceofOperator(lval, rval).
+      return Q(yield* InstanceofOperator(lval, rval));
+    case 'in':
+      // 5. Return ? InstanceofOperator(lval, rval).
+      if (!(rval instanceof ObjectValue)) {
+        return Throw.TypeError('Right-hand side of "in" ($1) is not an object', rval);
+      }
+      // 6. Return ? HasProperty(rval, ? ToPropertyKey(lval)).
+      return Q(yield* HasProperty(rval, Q(yield* ToPropertyKey(lval))));
+    default:
+      throw OutOfRange.exhaustive(operator);
+  }
+}

package/src/runtime-semantics/RestBindingInitialization.mts

@@ -0,0 +1,29 @@
+import { Value } from '../value.mts';
+import { StringValue } from '../static-semantics/all.mts';
+import { Q } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  surroundingAgent,
+  CopyDataProperties,
+  InitializeReferencedBinding,
+  OrdinaryObjectCreate,
+  PutValue,
+  ResolveBinding,
+} from '#self';
+import type { EnvironmentRecord, PropertyKeyValue, UndefinedValue } from '#self';
+
+// BindingRestProperty : `...` BindingIdentifier
+export function* RestBindingInitialization({ BindingIdentifier }: ParseNode.BindingRestProperty, value: Value, environment: EnvironmentRecord | UndefinedValue, excludedNames: readonly PropertyKeyValue[]) {
+  // 1. Let lhs be ? ResolveBinding(StringValue of BindingIdentifier, environment).
+  const lhs = Q(yield* ResolveBinding(StringValue(BindingIdentifier), environment, BindingIdentifier.strict));
+  // 2. Let restObj be OrdinaryObjectCreate(%Object.prototype%).
+  const restObj = OrdinaryObjectCreate(surroundingAgent.intrinsic('%Object.prototype%'));
+  // 3. Perform ? CopyDataProperties(restObj, value, excludedNames).
+  Q(yield* CopyDataProperties(restObj, value, excludedNames));
+  // 4. If environment is undefined, return PutValue(lhs, restObj).
+  if (environment === Value.undefined) {
+    return yield* PutValue(lhs, restObj);
+  }
+  // 5. Return InitializeReferencedBinding(lhs, restObj).
+  return yield* InitializeReferencedBinding(lhs, restObj);
+}

package/src/runtime-semantics/ReturnStatement.mts

@@ -0,0 +1,32 @@
+import { Value } from '../value.mts';
+import { Evaluate, type Evaluator } from '../evaluator.mts';
+import {
+  Completion,
+  Await,
+  Q, X,
+  ReturnCompletion,
+  ThrowCompletion,
+} from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { GetValue, GetGeneratorKind } from '#self';
+
+/** https://tc39.es/ecma262/#sec-return-statement-runtime-semantics-evaluation */
+//  ReturnStatement :
+//    `return` `;`
+//    `return` Expression `;`
+export function* Evaluate_ReturnStatement({ Expression }: ParseNode.ReturnStatement): Evaluator<ReturnCompletion | ThrowCompletion> {
+  if (!Expression) {
+    // 1. Return Completion { [[Type]]: return, [[Value]]: undefined, [[Target]]: empty }.
+    return new Completion({ Type: 'return', Value: Value.undefined, Target: undefined });
+  }
+  // 1. Let exprRef be the result of evaluating Expression.
+  const exprRef = Q(yield* Evaluate(Expression));
+  // 1. Let exprValue be ? GetValue(exprRef).
+  let exprValue = Q(yield* GetValue(exprRef));
+  // 1. If ! GetGeneratorKind() is async, set exprValue to ? Await(exprValue).
+  if (X(GetGeneratorKind()) === 'async') {
+    exprValue = Q(yield* Await(exprValue));
+  }
+  // 1. Return Completion { [[Type]]: return, [[Value]]: exprValue, [[Target]]: empty }.
+  return new Completion({ Type: 'return', Value: exprValue, Target: undefined });
+}

package/src/runtime-semantics/Script.mts

@@ -0,0 +1,15 @@
+import { Value } from '../value.mts';
+import { NormalCompletion } from '../completion.mts';
+import { Evaluate } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-script-semantics-runtime-semantics-evaluation */
+// Script :
+//   [empty]
+//   ScriptBody
+export function* Evaluate_Script({ ScriptBody }: ParseNode.Script) {
+  if (!ScriptBody) {
+    return NormalCompletion(Value.undefined);
+  }
+  return yield* Evaluate(ScriptBody);
+}

package/src/runtime-semantics/ScriptBody.mts

@@ -0,0 +1,7 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { Evaluate_StatementList } from './all.mts';
+
+// ScriptBody : StatementList
+export function Evaluate_ScriptBody(ScriptBody: ParseNode.ScriptBody) {
+  return Evaluate_StatementList(ScriptBody.StatementList);
+}

package/src/runtime-semantics/ShiftExpression.mts

@@ -0,0 +1,17 @@
+import { Q } from '../completion.mts';
+import type { ValueEvaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { EvaluateStringOrNumericBinaryExpression } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-left-shift-operator-runtime-semantics-evaluation */
+//  ShiftExpression :
+//    ShiftExpression `<<` AdditiveExpression
+/** https://tc39.es/ecma262/#sec-signed-right-shift-operator-runtime-semantics-evaluation */
+//  ShiftExpression :
+//    ShiftExpression `>>` AdditiveExpression
+/** https://tc39.es/ecma262/#sec-unsigned-right-shift-operator-runtime-semantics-evaluation */
+//  ShiftExpression :
+//    ShiftExpression `>>>` AdditiveExpression
+export function* Evaluate_ShiftExpression({ ShiftExpression, operator, AdditiveExpression }: ParseNode.ShiftExpression): ValueEvaluator {
+  return Q(yield* EvaluateStringOrNumericBinaryExpression(ShiftExpression, operator, AdditiveExpression));
+}

package/src/runtime-semantics/StatementList.mts

@@ -0,0 +1,33 @@
+import { Evaluate } from '../evaluator.mts';
+import {
+  EnsureCompletion,
+  Q,
+  UpdateEmpty,
+  NormalCompletion,
+} from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { surroundingAgent, type Completion, type Value } from '#self';
+
+/** https://tc39.es/ecma262/#sec-block-runtime-semantics-evaluation */
+export function* Evaluate_StatementList(StatementList: ParseNode.StatementList) {
+  if (StatementList.length === 0) {
+    return NormalCompletion(undefined);
+  }
+
+  let blockCompletion: Completion<void | Value> = NormalCompletion(undefined);
+
+  for (let index = 0; index < StatementList.length; index += 1) {
+    const StatementListItem = StatementList[index];
+
+    if (surroundingAgent.hostDefinedOptions.onDebugger) {
+      const NextStatementListItem = StatementList[index + 1];
+      surroundingAgent.runningExecutionContext.callSite.setNextLocation(NextStatementListItem);
+    }
+
+    Q(blockCompletion);
+    const itemCompletion = EnsureCompletion(yield* Evaluate(StatementListItem));
+    blockCompletion = UpdateEmpty(itemCompletion, blockCompletion);
+  }
+
+  return blockCompletion;
+}

package/src/runtime-semantics/StringIndexOf.mts

@@ -0,0 +1,43 @@
+import { JSStringValue } from '../value.mts';
+import { Assert, F, isNonNegativeInteger } from '#self';
+
+// https://tc39.es/proposal-string-replaceall/#sec-stringindexof
+export function StringIndexOf(string: JSStringValue, searchValue: JSStringValue, fromIndex: number) {
+  // 1. Assert: Type(string) is String.
+  Assert(string instanceof JSStringValue);
+  // 2. Assert: Type(searchValue) is String.
+  Assert(searchValue instanceof JSStringValue);
+  // 3. Assert: fromIndex is a non-negative integer.
+  Assert(isNonNegativeInteger(fromIndex));
+  const stringStr = string.stringValue();
+  const searchStr = searchValue.stringValue();
+  // 4. Let len be the length of string.
+  const len = stringStr.length;
+  // 5. If searchValue is the empty string, and fromIndex <= len, return 𝔽(fromIndex).
+  if (searchStr === '' && fromIndex <= len) {
+    return F(fromIndex);
+  }
+  // 6. Let searchLen be the length of searchValue.
+  const searchLen = searchStr.length;
+  // 7. If there exists any integer k such that fromIndex ≤ k ≤ len - searchLen and for all nonnegative integers j less than searchLen,
+  //    the code unit at index k + j within string is the same as the code unit at index j within searchValue, let pos be the smallest (closest to -∞) such integer.
+  //    Otherwise, let pos be -1.
+  let k = fromIndex;
+  let pos = -1;
+  while (k + searchLen <= len) {
+    let match = true;
+    for (let j = 0; j < searchLen; j += 1) {
+      if (searchStr[j] !== stringStr[k + j]) {
+        match = false;
+        break;
+      }
+    }
+    if (match) {
+      pos = k;
+      break;
+    }
+    k += 1;
+  }
+  // 8. Return 𝔽(pos).
+  return F(pos);
+}

package/src/runtime-semantics/StringPad.mts

@@ -0,0 +1,34 @@
+import { JSStringValue, Value } from '../value.mts';
+import { Q } from '../completion.mts';
+import type { ValueEvaluator } from '../evaluator.mts';
+import {
+  Assert, ToString, ToLength, R,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-stringpad */
+export function* StringPad(O: Value, maxLength: Value, fillString: Value, placement: 'start' | 'end'): ValueEvaluator<JSStringValue> {
+  Assert(placement === 'start' || placement === 'end');
+  const S = Q(yield* ToString(O));
+  const intMaxLength = R(Q(yield* ToLength(maxLength)));
+  const stringLength = S.stringValue().length;
+  if (intMaxLength <= stringLength) {
+    return S;
+  }
+  let filler;
+  if (fillString === Value.undefined) {
+    filler = ' ';
+  } else {
+    filler = Q(yield* ToString(fillString)).stringValue();
+  }
+  if (filler === '') {
+    return S;
+  }
+  const fillLen = intMaxLength - stringLength;
+  const stringFiller = filler.repeat(Math.ceil(fillLen / filler.length));
+  const truncatedStringFiller = stringFiller.slice(0, fillLen);
+  if (placement === 'start') {
+    return Value(truncatedStringFiller + S.stringValue());
+  } else {
+    return Value(S.stringValue() + truncatedStringFiller);
+  }
+}

package/src/runtime-semantics/SuperCall.mts

@@ -0,0 +1,65 @@
+import { ObjectValue } from '../value.mts';
+import { Q, X } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { ArgumentListEvaluation } from './all.mts';
+import {
+  Assert,
+  Construct,
+  GetNewTarget,
+  GetThisEnvironment,
+  IsConstructor,
+  InitializeInstanceElements,
+  isECMAScriptFunctionObject,
+  Throw,
+  type FunctionObject,
+} from '#self';
+import { FunctionEnvironmentRecord } from '#self';
+
+/** https://tc39.es/ecma262/#sec-super-keyword-runtime-semantics-evaluation */
+// SuperCall : `super` Arguments
+export function* Evaluate_SuperCall({ Arguments }: ParseNode.SuperCall) {
+  // 1. Let newTarget be GetNewTarget().
+  const newTarget = GetNewTarget();
+  // 2. Assert: Type(newTarget) is Object.
+  Assert(newTarget instanceof ObjectValue);
+  // 3. Let func be ! GetSuperConstructor().
+  const func = X(GetSuperConstructor());
+  // 4. Let argList be ? ArgumentListEvaluation of Arguments.
+  const argList = Q(yield* ArgumentListEvaluation(Arguments));
+  // 5. If IsConstructor(func) is false, throw a TypeError exception.
+  if (!IsConstructor(func)) {
+    return Throw.TypeError('super ($1) is not a constructor', func);
+  }
+  // 6. Let result be ? Construct(func, argList, newTarget).
+  const result = Q(yield* Construct(func, argList, newTarget as FunctionObject));
+  // 7. Let thisER be GetThisEnvironment().
+  const thisER = GetThisEnvironment();
+  // 8. Assert: thisER is a Function Environment Record.
+  Assert(thisER instanceof FunctionEnvironmentRecord);
+  // 8. Perform ? thisER.BindThisValue(result).
+  Q(thisER.BindThisValue(result));
+  // 9. Let F be thisER.[[FunctionObject]].
+  const F = thisER.FunctionObject;
+  // 10. Assert: F is an ECMAScript function object.
+  Assert(isECMAScriptFunctionObject(F));
+  // 11. Perform ? InitializeInstanceElements(result, F).
+  Q(yield* InitializeInstanceElements(result, F));
+  // 12. Return result.
+  return result;
+}
+
+/** https://tc39.es/ecma262/#sec-getsuperconstructor */
+function GetSuperConstructor() {
+  // 1. Let envRec be GetThisEnvironment().
+  const envRec = GetThisEnvironment();
+  // 2. Assert: envRec is a function Environment Record.
+  Assert(envRec instanceof FunctionEnvironmentRecord);
+  // 3. Let activeFunction be envRec.[[FunctionObject]].
+  const activeFunction = envRec.FunctionObject;
+  // 4. Assert: activeFunction is an ECMAScript function object.
+  Assert(isECMAScriptFunctionObject(activeFunction));
+  // 5. Let superConstructor be ! activeFunction.[[GetPrototypeOf]]().
+  const superConstructor = X(activeFunction.GetPrototypeOf());
+  // 6. Return superConstructor.
+  return superConstructor;
+}

package/src/runtime-semantics/SuperProperty.mts

@@ -0,0 +1,58 @@
+import { Evaluate, type ExpressionEvaluator } from '../evaluator.mts';
+import {
+  ReferenceRecord, Value,
+} from '../value.mts';
+import { StringValue } from '../static-semantics/all.mts';
+import { Q } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  Assert,
+  GetThisEnvironment,
+  GetValue,
+  FunctionEnvironmentRecord,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-makesuperpropertyreference */
+function MakeSuperPropertyReference(actualThis: Value, propertyKey: Value, strict: boolean) {
+  // 1. Let env be GetThisEnvironment().
+  const env = GetThisEnvironment();
+  // 2. Assert: env.HasSuperBinding() is true.
+  Assert(env.HasSuperBinding() === Value.true);
+  // 3. Assert: env is a Function Environment Record.
+  Assert(env instanceof FunctionEnvironmentRecord);
+  // 4. Let baseValue be ? env.GetSuperBase().
+  const baseValue = Q(env.GetSuperBase());
+  // 5. Return the Reference Record { [[Base]]: baseValue, [[ReferencedName]]: propertyKey, [[Strict]]: strict, [[ThisValue]]: actualThis }.
+  return new ReferenceRecord({
+    Base: baseValue,
+    ReferencedName: propertyKey,
+    Strict: strict ? Value.true : Value.false,
+    ThisValue: actualThis,
+  });
+}
+
+/** https://tc39.es/ecma262/#sec-super-keyword-runtime-semantics-evaluation */
+//  SuperProperty :
+//    `super` `[` Expression `]`
+//    `super` `.` IdentifierName
+export function* Evaluate_SuperProperty({ Expression, IdentifierName, strict }: ParseNode.SuperProperty): ExpressionEvaluator {
+  // 1. Let env be GetThisEnvironment().
+  const env = GetThisEnvironment();
+  // 2. Let actualThis be ? env.GetThisBinding().
+  const actualThis = Q(env.GetThisBinding());
+  if (Expression) {
+    // 3. Let propertyNameReference be the result of evaluating Expression.
+    const propertyNameReference = Q(yield* Evaluate(Expression));
+    // 4. Let propertyNameReference be the result of evaluating Expression.
+    const propertyNameValue = Q(yield* GetValue(propertyNameReference));
+    // 6. If the code matched by this SuperProperty is strict mode code, let strict be true; else let strict be false.
+    // 7. Return ? MakeSuperPropertyReference(actualThis, propertyKey, strict).
+    return Q(MakeSuperPropertyReference(actualThis, propertyNameValue, strict));
+  } else {
+    // 3. Let propertyKey be StringValue of IdentifierName.
+    const propertyKey = StringValue(IdentifierName!);
+    // 4. const strict = SuperProperty.strict;
+    // 5. Return ? MakeSuperPropertyReference(actualThis, propertyKey, strict).
+    return Q(MakeSuperPropertyReference(actualThis, propertyKey, strict));
+  }
+}