@engine262/engine262 0.0.1-0574c6b92a2925de851f895445b7cfd7e97cc0ba

package/src/intrinsics/Symbol.mts

@@ -0,0 +1,103 @@
+import {
+  Descriptor,
+  type JSStringValue,
+  SymbolValue,
+  Value,
+  wellKnownSymbols,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import {
+  surroundingAgent,
+} from '../host-defined/engine.mts';
+import {
+  KeyForSymbol,
+  Realm,
+  SameValue,
+  ToString,
+  type FunctionObject,
+  type OrdinaryObject,
+} from '../abstract-ops/all.mts';
+import { Q, X, type ValueEvaluator } from '../completion.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+
+export interface GlobalSymbolRegistryRecord {
+  readonly Key: JSStringValue;
+  readonly Symbol: SymbolValue;
+}
+export const GlobalSymbolRegistry: GlobalSymbolRegistryRecord[] = [];
+
+export interface SymbolObject extends OrdinaryObject {
+  readonly SymbolData: SymbolValue;
+}
+/** https://tc39.es/ecma262/#sec-symbol-description */
+function* SymbolConstructor(this: FunctionObject, [description = Value.undefined]: Arguments, { NewTarget }: FunctionCallContext): ValueEvaluator {
+  // 1. If NewTarget is not undefined, throw a TypeError exception.
+  if (NewTarget !== Value.undefined) {
+    return surroundingAgent.Throw('TypeError', 'NotAConstructor', this);
+  }
+  // 2. If description is undefined, let descString be undefined.
+  let descString;
+  if (description === Value.undefined) {
+    descString = Value.undefined;
+  } else { // 3. Else, let descString be ? ToString(description).
+    descString = Q(yield* ToString(description));
+  }
+  // 4. Return a new unique Symbol value whose [[Description]] value is descString.
+  return new SymbolValue(descString);
+}
+
+/** https://tc39.es/ecma262/#sec-symbol.for */
+function* Symbol_for([key = Value.undefined]: Arguments): ValueEvaluator {
+  // 1. Let stringKey be ? ToString(key).
+  const stringKey = Q(yield* ToString(key));
+  // 2. For each element e of the GlobalSymbolRegistry List, do
+  for (const e of GlobalSymbolRegistry) {
+    // a. If SameValue(e.[[Key]], stringKey) is true, return e.[[Symbol]].
+    if (SameValue(e.Key, stringKey) === Value.true) {
+      return e.Symbol;
+    }
+  }
+  // 3. Assert: GlobalSymbolRegistry does not currently contain an entry for stringKey.
+  // 4. Let newSymbol be a new unique Symbol value whose [[Description]] value is stringKey.
+  const newSymbol = new SymbolValue(stringKey);
+  // 5. Append the Record { [[Key]]: stringKey, [[Symbol]]: newSymbol } to the GlobalSymbolRegistry List.
+  GlobalSymbolRegistry.push({ Key: stringKey, Symbol: newSymbol });
+  // 6. Return newSymbol.
+  return newSymbol;
+}
+
+/** https://tc39.es/ecma262/#sec-symbol.keyfor */
+function Symbol_keyFor([sym = Value.undefined]: Arguments) {
+  // 1. If Type(sym) is not Symbol, throw a TypeError exception.
+  if (!(sym instanceof SymbolValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotASymbol', sym);
+  }
+  // 2. Return KeyForSymbol(sym).
+  return KeyForSymbol(sym);
+}
+
+export function bootstrapSymbol(realmRec: Realm) {
+  const symbolConstructor = bootstrapConstructor(realmRec, SymbolConstructor, 'Symbol', 0, realmRec.Intrinsics['%Symbol.prototype%'], [
+    ['for', Symbol_for, 1],
+    ['keyFor', Symbol_keyFor, 1],
+  ]);
+
+  for (const [name, sym] of Object.entries(wellKnownSymbols)) {
+    X(symbolConstructor.DefineOwnProperty(Value(name), Descriptor({
+      Value: sym,
+      Writable: Value.false,
+      Enumerable: Value.false,
+      Configurable: Value.false,
+    })));
+  }
+
+  X(symbolConstructor.DefineOwnProperty(Value('prototype'), Descriptor({
+    Value: realmRec.Intrinsics['%Symbol.prototype%'],
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+
+  realmRec.Intrinsics['%Symbol%'] = symbolConstructor;
+}

package/src/intrinsics/SymbolPrototype.mts

@@ -0,0 +1,83 @@
+import {
+  ObjectValue,
+  SymbolValue,
+  Value,
+  wellKnownSymbols,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import {
+  surroundingAgent,
+} from '../host-defined/engine.mts';
+import {
+  Assert,
+  Realm,
+  SymbolDescriptiveString,
+} from '../abstract-ops/all.mts';
+import { Q, type ValueCompletion } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+
+/** https://tc39.es/ecma262/#sec-thissymbolvalue */
+function thisSymbolValue(value: Value) {
+  // 1. If Type(value) is Symbol, return value.
+  if (value instanceof SymbolValue) {
+    return value;
+  }
+  // 2. If Type(value) is Object and value has a [[SymbolData]] internal slot, then
+  if (value instanceof ObjectValue && 'SymbolData' in value) {
+    // a. Let s be value.[[SymbolData]].
+    const s = value.SymbolData;
+    // b. Assert: Type(s) is Symbol.
+    Assert(s instanceof SymbolValue);
+    // c. Return s.
+    return s;
+  }
+  // 3. Throw a TypeError exception.
+  return surroundingAgent.Throw('TypeError', 'NotATypeObject', 'Symbol', value);
+}
+
+/** https://tc39.es/ecma262/#sec-symbol.prototype.description */
+function SymbolProto_descriptionGetter(_argList: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let s be the this value.
+  const s = thisValue;
+  // 2. Let sym be ? thisSymbolValue(s).
+  const sym = Q(thisSymbolValue(s));
+  // 3. Return sym.[[Description]].
+  return sym.Description;
+}
+
+/** https://tc39.es/ecma262/#sec-symbol.prototype.tostring */
+function SymbolProto_toString(_argList: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let sym be ? thisSymbolValue(this value).
+  const sym = Q(thisSymbolValue(thisValue));
+  // 2. Return SymbolDescriptiveString(sym).
+  return SymbolDescriptiveString(sym);
+}
+
+/** https://tc39.es/ecma262/#sec-symbol.prototype.valueof */
+function SymbolProto_valueOf(_argList: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Return ? thisSymbolValue(this value).
+  return Q(thisSymbolValue(thisValue));
+}
+
+/** https://tc39.es/ecma262/#sec-symbol.prototype-@@toprimitive */
+function SymbolProto_toPrimitive(_argList: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Return ? thisSymbolValue(this value).
+  return Q(thisSymbolValue(thisValue));
+}
+
+export function bootstrapSymbolPrototype(realmRec: Realm) {
+  const override = {
+    Writable: Value.false,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  };
+  const proto = bootstrapPrototype(realmRec, [
+    ['toString', SymbolProto_toString, 0],
+    ['description', [SymbolProto_descriptionGetter]],
+    ['valueOf', SymbolProto_valueOf, 0],
+    [wellKnownSymbols.toPrimitive, SymbolProto_toPrimitive, 1, override],
+  ], realmRec.Intrinsics['%Object.prototype%'], 'Symbol');
+
+  realmRec.Intrinsics['%Symbol.prototype%'] = proto;
+}

package/src/intrinsics/ThrowTypeError.mts

@@ -0,0 +1,21 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import {
+  Assert,
+  CreateBuiltinFunction,
+  Realm,
+  SetIntegrityLevel,
+} from '../abstract-ops/all.mts';
+import { Value } from '../value.mts';
+import { X } from '../completion.mts';
+
+/** https://tc39.es/ecma262/#sec-%throwtypeerror% */
+function ThrowTypeError() {
+  // 1. Throw a TypeError exception.
+  return surroundingAgent.Throw('TypeError', 'StrictPoisonPill');
+}
+
+export function bootstrapThrowTypeError(realmRec: Realm) {
+  const f = X(CreateBuiltinFunction(ThrowTypeError, 0, Value(''), [], realmRec));
+  Assert(X(SetIntegrityLevel(f, 'frozen')) === Value.true);
+  realmRec.Intrinsics['%ThrowTypeError%'] = f;
+}