ECMA-262を読んだ日

AssignmentExpression:
  ConditionalExpression
  ...その他の定義...

ConditionalExpression:
  ShortCircuitExpression
  ...その他の定義...

ShortCircuitExpression:
  LogicalORExpression
  ...その他の定義...

LogicalORExpression:
  LogicalANDExpression
  ...その他の定義...

LogicalANDExpression:
  BitwiseORExpression
  ...その他の定義...

BitwiseORExpression:
  BitwiseXORExpression
  ...その他の定義...

BitwiseXORExpression:
  BitwiseANDExpression
  ...その他の定義...

BitwiseANDExpression:
  EqualityExpression
  ...その他の定義...

EqualityExpression:
  RelationalExpression
  ...その他の定義...

RelationalExpression:
  ShiftExpression
  ...その他の定義...

ShiftExpression:
  AdditiveExpression
  ...その他の定義...

AdditiveExpression:
  MultiplicativeExpression
  ...その他の定義...

MultiplicativeExpression:
  ExponentiationExpression
  ...その他の定義...

ExponentiationExpression:
  UnaryExpression
  ...その他の定義...

UnaryExpression:
  UpdateExpression
  ...その他の定義...

UpdateExpression:
  LeftHandSideExpression
  ...その他の定義...

LeftHandSideExpression:
  NewExpression
  CallExpression
  OptionalExpression
  ...その他の定義...

OptionalExpression:
  MemberExpression
  ...その他の定義...

MemberExpression:
  PrimaryExpression
  ...その他の定義...

PrimaryExpression:
  this
  IdentifierReference
  Literal
  ...その他の定義...

Literal:
  NullLiteral
  BooleanLiteral
  NumericLiteral
  StringLiteral（あった）

StringLiteral:
  " DoubleStringCharactersopt "
  ' SingleStringCharactersopt '

// 補足：'?'ショートハンド（ReturnIfAbrupt）は，前の操作結果がabrupt completionであるときそれをreturnする．
// 本記事では簡単のため省略
//// abrupt completion: TypeフィールドがnormalでないCompletion Record
//// Completion Record: 各セマンティクスの実行結果を表すような，仕様書の中でのみ使われるレコード型
//// Typeフィールド: 実行がどのように完了したかを表す．値は次のうちのどれか: normal, break, continue, return, throw
//// see: https://tc39.es/ecma262/#sec-completion-record-specification-type

// 補足：'!'ショートハンドは，前の操作結果がabrupt completionでないことを前提として，その値を即座に取り出す
// 失敗しない操作を簡単に扱うためにあるっぽい
// see: https://tc39.es/ecma262/#sec-completion-record-specification-type

// Vのリファレンスを解決して値を取り出してくれる抽象操作……らしい（よくわかってない）
// see: https://qiita.com/uhyo/items/39750a5359629b3fee05
//// 抽象操作: 仕様書の中でのみ使われる手続きのようなもの
function GetValue(V) {
  // ReturnIfAbrupt(V).
  if (V.Type !== "normal") return Completion(spreadObj);

  // 2. If V is not a Reference Record, return V.
  if (`VがReference Recordタイプではない`) return V; // 今回はVがリファレンスでないので，ここで返るっぽい

  // 3. If IsUnresolvableReference(V) is true, throw a ReferenceError exception.
  // 4. If IsPropertyReference(V) is true, then
  // a. Let baseObj be ? ToObject(V.[[Base]]).
  // b. If IsPrivateReference(V) is true, then
  // i. Return ? PrivateGet(baseObj, V.[[ReferencedName]]).
  // c. Return ? baseObj.[[Get]](V.[[ReferencedName]], GetThisValue(V)).
  // 5. Else,
  // a. Let base be V.[[Base]].
  // b. Assert: base is an Environment Record.
  // c. Return ? base.GetBindingValue(V.[[ReferencedName]], V.[[Strict]]) (see 9.1).
}

// objからイテレータレコードを得る
function GetIterator(obj, hint, method) {
  // If hint is not present, set hint to sync.
  if (hint === undefined) hint = "sync"; // 今回はhintを指定していないのでhintは"syncになる"

  // 2. If method is not present, then
  if (method === undefined) {
    if (hint === "async") {
      // a. If hint is async, then
      //     i. Set method to ? GetMethod(obj, @@asyncIterator).
      //     ii. If method is undefined, then
      //         1. Let syncMethod be ? GetMethod(obj, @@iterator).
      //         2. Let syncIteratorRecord be ? GetIterator(obj, sync, syncMethod).
      //         3. Return CreateAsyncFromSyncIterator(syncIteratorRecord).
    } else {
      // 今回はこちらに入る
      // b. Otherwise, set method to ? GetMethod(obj, @@iterator).
      let method = GetMethod(obj, "@@iterator");
    }
  }

  // 3. Let iterator be ? Call(method, obj).
  let iterator = Call(method, obj); // クロージャからイテレータが作成されて返る（後述）

  // 4. If Type(iterator) is not Object, throw a TypeError exception.
  if (typeof iterator !== "Object") throw "TypeError exception";

  // 5. Let nextMethod be ? GetV(iterator, "next").
  let nextMethod = GetV(iterator, "next");

  // 6. Let iteratorRecord be the Iterator Record { [[Iterator]]: iterator, [[NextMethod]]: nextMethod, [[Done]]: false }.
  let iteratorRecord = {
    Iterator: iterator,
    NextMethod: nextMethod,
    Done: false,
  };

  // 7. Return iteratorRecord.
  return iteratorRecord;
}

// VからメソッドPを得る
function GetMethod(V, P) {
  // 1. Let func be ? GetV(V, P).
  let func = GetV(V, P); // 今回は"@@iterator"プロパティにある関数オブジェクトが得られるはず

  // 2. If func is either undefined or null, return undefined.
  if (func === undefined || func === null) return undefined; // 今回は当てはまらない

  // 3. If IsCallable(func) is false, throw a TypeError exception.
  if (!IsCallable(func)) throw "TypeError exception"; // "@@iterator"関数が呼び出し可能なので今回は該当しない

  // 4. Return func.
  return func;
}

// VからプロパティPの値を得る
function GetV(V, P) {
  // 1. Let O be ? ToObject(V).
  let O = ToObject(V); // Oには文字列が入るっぽい

  // 2. Return ? O.[[Get]](P, V).
  // String Exotic Objectsには[[Get]]の定義はなかったからOrdinary Objectの[[Get]]が適用されるはず
  // see: https://tc39.es/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots-get-p-receiver
  //// Ordinary Object: 普通のオブジェクト
  //// Exotic Object: 普通のオブジェクトを拡張・継承して定義される特別なオブジェクト．ArrayとかStringとか．
  return O.Get(P, V);
}

// argumentをオブジェクトに変換する
function ToObject(argument) {
  // 今回はargumentの値はStringリテラル
  switch (typeof argument.Value) {
    case "Undefined": // Throw a TypeError exception.
    case "Null": // Throw a TypeError exception.
    case "Boolean": // Return a new Boolean object whose [[BooleanData]] internal slot is set to argument. See 20.3 for a description of Boolean objects.
    case "Number": // Return a new Number object whose [[NumberData]] internal slot is set to argument. See 21.1 for a description of Number objects.
    case "String":
      // ここに入る

      // Return a new String object whose [[StringData]] internal slot is set to argument. See 22.1 for a description of String objects.
      // [[StringData]]内部スロットは，Stringのデータ（UFT-16のデータ？）を保持するらしい……．よくわかっていないけど↓みたいなこと？
      return new String(argument.Value);
    case "Symbol": // Return a new Symbol object whose [[SymbolData]] internal slot is set to argument. See 20.4 for a description of Symbol objects.
    case "BigInt": // Return a new BigInt object whose [[BigIntData]] internal slot is set to argument. See 21.2 for a description of BigInt objects.
    case "Object": // Return argument.
  }
}

Object.prototype.Get = function (P, Receiver) {
  let O = this;
  return OrdinaryGet(O, P, Receiver);
};

// この抽象操作以降の操作は深く追わないことにします
function OrdinaryGet(O, P, Receiver) {
  // 1. Let desc be ? O.[[GetOwnProperty]](P).
  let desc = O.GetOwnProperty(P); // Oの"@@iterator"プロパティをGetする

  if (desc === undefined) {
    // 自分がPを持っていなかったら親へプロトタイプチェーンをたどる操作．ここではStringが"@@iterator"を持っているので該当しない
    // 2. If desc is undefined, then
    //     a. Let parent be ? O.[[GetPrototypeOf]]().
    //     b. If parent is null, return undefined.
    //     c. Return ? parent.[[Get]](P, Receiver).
  }

  // 以下の処理では，Getしたい対象のものがdata propertyなのか，accessor propertyなのかによって処理を分けている
  // data property: ふつうの値
  // accessor property: アクセサ関数を通してGetすべき値．Getterとか？
  //// 試しにgetterについてgetOwnPropertyDescriptorしたらget属性が得られたからたぶんそう
  // see: https://tc39.es/ecma262/#sec-object-type

  // 3. If IsDataDescriptor(desc) is true, return desc.[[Value]].
  // descがdata propertyならそのValue（そのものの値）を返す．
  // "@@iterator"は普通の関数オブジェクトでGetterではないからここで返るはず
  if (IsDataDescriptor(desc)) return desc.Value;

  // 以下，descがaccessor propertyならそれを呼び出して得た値を返している
  // 4. Assert: IsAccessorDescriptor(desc) is true.
  // 5. Let getter be desc.[[Get]].
  // 6. If getter is undefined, return undefined.
  // 7. Return ? Call(getter, Receiver).
}

// argumentが呼び出し可能か判定する
function IsCallable(argument) {
  // 1. If Type(argument) is not Object, return false.
  if (typeof argument !== "Object") return false;

  // 2. If argument has a [[Call]] internal method, return true.
  if (`argumentが[[Call]]内部メソッドを持っている`) return true;

  // 3. Return false.
  return false;
}

// 内部メソッドを呼び出すために使用される
function Call(F, V, argumentsList) {
  // 1. If argumentsList is not present, set argumentsList to a new empty List.
  if (argumentsList === undefined) argumentsList = [];

  // 2. If IsCallable(F) is false, throw a TypeError exception.
  if (!IsCallable(F)) throw "TypeError exception";

  // 3. Return ? F.[[Call]](V, argumentsList).
  // Fが呼び出し可能だとわかったので，実際に呼び出しを行って結果を返す．
  return F.Call(V, argumentsList);
}

// イテレータの次の結果を得る
function IteratorStep(iteratorRecord) {
  // 1. Let result be ? IteratorNext(iteratorRecord).
  let result = IteratorNext(iteratorRecord); // 値を得る

  // 2. Let done be ? IteratorComplete(result).
  let done = IteratorComplete(result); // 完了状態を得る

  // 3. If done is true, return false.
  if (done) return false; // 既にイテレーターが完了していばfalseを返す

  // 4. Return result.
  return result;
}

// イテレーターのNextを実行して結果を返す
function IteratorNext(iteratorRecord, value) {
  // 1. If value is not present, then
  let result;
  if (value === undefined) {
    // 今回の呼び出しでは多くの場合こちら
    // a. Let result be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]]).
    let result = Call(iteratorRecord.NextMethod, iteratorRecord.Iterator); // NextMethodをIteratorで実行し，次の値を得る
  } else {
    // 2. Else,
    //     a. Let result be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]], « value »).
  }

  // 3. If Type(result) is not Object, throw a TypeError exception.
  if (typeof argument !== "Object") throw "TypeError exception";

  // 4. Return result.
  return result;
}

// イテレーターが完了しているか判定する
function IteratorComplete(iterResult) {
  // 1. Return ToBoolean(? Get(iterResult, "done")).
  return Boolean(Get(iterResult, "done")); // iterResultオブジェクトのdoneプロパティを得て，Booleanに変換して返す
}

// イテレータの結果から値を得る
function IteratorValue(iterResult) {
  // 1. Return ? Get(iterResult, "value").
  return Get(iterResult, "value");
}

function Get(O, P) {
  // 1. Return ? O.[[Get]](P, O).
  // Oの種類によって適切な[[Get]]が呼ばれる．
  // 例えば，OがOrdinary Objectの場合は上述したObject.prototype.Getが呼ばれるはず
  return O.Get(P, o);
}

// オブジェクトOにプロパティPを生やしてVをセットする．無理そうなら例外を投げる
function CreateDataPropertyOrThrow(O, P, V) {
  // 1. Let success be ? CreateDataProperty(O, P, V).
  let success = CreateDataProperty(O, P, V);

  // 2. If success is false, throw a TypeError exception.
  if (!success) throw "TypeError exception";

  // 3. Return success.
  return success;
}

function CreateDataProperty(O, P, V) {
  // 1. Let newDesc be the PropertyDescriptor { [[Value]]: V, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true }.
  // 新しいPropertyDescriptorを作成する．これはdata property用のDescriptor
  let newDesc = {
    Value: V,
    Writable: true,
    Enumerable: true,
    Configurable: true,
  };

  // 2. Return ? O.[[DefineOwnProperty]](P, newDesc).
  return O.DefineOwnProperty(P, newDesc); // プロパティを登録．詳細は割愛
}

// completionRecordがCompletion Recordタイプであることを強調する目的．
// アサーションに失敗した時になにかしたいわけではない．
function Completion(completionRecord) {
  // 1. Assert: completionRecord is a Completion Record.
  assert(`completionRecordがCompletion Recordタイプであること`);
  // 2. Return completionRecord.
  return completionRecord;
}