461 lines
19 KiB
JavaScript
461 lines
19 KiB
JavaScript
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.DestructuringAssignmentEvaluation = DestructuringAssignmentEvaluation;
|
|
exports.IteratorDestructuringAssignmentEvaluation = IteratorDestructuringAssignmentEvaluation;
|
|
exports.KeyedDestructuringAssignmentEvaluation = KeyedDestructuringAssignmentEvaluation;
|
|
|
|
var _invariant = require("../invariant.js");
|
|
|
|
var _invariant2 = _interopRequireDefault(_invariant);
|
|
|
|
var _environment = require("../environment.js");
|
|
|
|
var _index = require("../values/index.js");
|
|
|
|
var _completions = require("../completions.js");
|
|
|
|
var _ObjectExpression = require("../evaluators/ObjectExpression.js");
|
|
|
|
var _index2 = require("./index.js");
|
|
|
|
var _singletons = require("../singletons.js");
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
// ECMA262 12.15.5.2
|
|
function DestructuringAssignmentEvaluation(realm, pattern, value, strictCode, env) {
|
|
if (pattern.type === "ObjectPattern") {
|
|
// 1. Perform ? RequireObjectCoercible(value).
|
|
(0, _index2.RequireObjectCoercible)(realm, value);
|
|
|
|
// 2. Return the result of performing DestructuringAssignmentEvaluation for AssignmentPropertyList using value as the argument.
|
|
|
|
var _iteratorNormalCompletion = true;
|
|
var _didIteratorError = false;
|
|
var _iteratorError = undefined;
|
|
|
|
try {
|
|
for (var _iterator = pattern.properties[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
var property = _step.value;
|
|
|
|
// 1. Let name be the result of evaluating PropertyName.
|
|
var name = (0, _ObjectExpression.EvalPropertyName)(property, env, realm, strictCode);
|
|
|
|
// 2. ReturnIfAbrupt(name).
|
|
|
|
// 3. Return the result of performing KeyedDestructuringAssignmentEvaluation of AssignmentElement with value and name as the arguments.
|
|
KeyedDestructuringAssignmentEvaluation(realm, property.value, value, name, strictCode, env);
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError = true;
|
|
_iteratorError = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion && _iterator.return) {
|
|
_iterator.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError) {
|
|
throw _iteratorError;
|
|
}
|
|
}
|
|
}
|
|
} else if (pattern.type === "ArrayPattern") {
|
|
// 1. Let iterator be ? GetIterator(value).
|
|
var iterator = (0, _index2.GetIterator)(realm, value);
|
|
|
|
// 2. Let iteratorRecord be Record {[[Iterator]]: iterator, [[Done]]: false}.
|
|
var iteratorRecord = {
|
|
$Iterator: iterator,
|
|
$Done: false
|
|
};
|
|
|
|
// 3. Let result be the result of performing IteratorDestructuringAssignmentEvaluation of AssignmentElementList using iteratorRecord as the argument.
|
|
var result = void 0;
|
|
try {
|
|
result = IteratorDestructuringAssignmentEvaluation(realm, pattern.elements, iteratorRecord, strictCode, env);
|
|
} catch (error) {
|
|
// 4. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, result).
|
|
if (iteratorRecord.$Done === false && error instanceof _completions.AbruptCompletion) {
|
|
throw (0, _index2.IteratorClose)(realm, iterator, error);
|
|
}
|
|
throw error;
|
|
}
|
|
|
|
// 4. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, result).
|
|
if (iteratorRecord.$Done === false) {
|
|
var completion = (0, _index2.IteratorClose)(realm, iterator, new _completions.NormalCompletion(realm.intrinsics.undefined));
|
|
if (completion instanceof _completions.AbruptCompletion) {
|
|
throw completion;
|
|
}
|
|
}
|
|
|
|
// 5. Return result.
|
|
return result;
|
|
}
|
|
}
|
|
|
|
// ECMA262 12.15.5.3
|
|
/**
|
|
* Copyright (c) 2017-present, Facebook, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This source code is licensed under the BSD-style license found in the
|
|
* LICENSE file in the root directory of this source tree. An additional grant
|
|
* of patent rights can be found in the PATENTS file in the same directory.
|
|
*/
|
|
|
|
function IteratorDestructuringAssignmentEvaluation(realm, elements, iteratorRecord, strictCode, env) {
|
|
// Check if the last element is a rest element. If so then we want to save the
|
|
// element and handle it separately after we iterate through the other
|
|
// formals. This also enforces that a rest element may only ever be in the
|
|
// last position.
|
|
var restEl = void 0;
|
|
if (elements.length > 0) {
|
|
var lastEl = elements[elements.length - 1];
|
|
if (lastEl !== null && lastEl.type === "RestElement") {
|
|
restEl = lastEl;
|
|
elements = elements.slice(0, -1);
|
|
}
|
|
}
|
|
|
|
var _iteratorNormalCompletion2 = true;
|
|
var _didIteratorError2 = false;
|
|
var _iteratorError2 = undefined;
|
|
|
|
try {
|
|
for (var _iterator2 = elements[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
|
|
var element = _step2.value;
|
|
|
|
if (element === null) {
|
|
// Elision handling
|
|
|
|
// 1. If iteratorRecord.[[Done]] is false, then
|
|
if (iteratorRecord.$Done === false) {
|
|
// a. Let next be IteratorStep(iteratorRecord.[[Iterator]]).
|
|
var _next = void 0;
|
|
try {
|
|
_next = (0, _index2.IteratorStep)(realm, iteratorRecord.$Iterator);
|
|
} catch (e) {
|
|
// b. If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
|
|
if (e instanceof _completions.AbruptCompletion) {
|
|
iteratorRecord.$Done = true;
|
|
}
|
|
// c. ReturnIfAbrupt(next).
|
|
throw e;
|
|
}
|
|
// d. If next is false, set iteratorRecord.[[Done]] to true.
|
|
if (_next === false) {
|
|
iteratorRecord.$Done = true;
|
|
}
|
|
}
|
|
// 2. Return NormalCompletion(empty).
|
|
continue;
|
|
}
|
|
|
|
// AssignmentElement : DestructuringAssignmentTarget Initializer
|
|
|
|
var DestructuringAssignmentTarget = void 0;
|
|
var Initializer = void 0;
|
|
|
|
if (element.type === "AssignmentPattern") {
|
|
Initializer = element.right;
|
|
DestructuringAssignmentTarget = element.left;
|
|
} else {
|
|
DestructuringAssignmentTarget = element;
|
|
}
|
|
|
|
var lref = void 0;
|
|
|
|
// 1. If DestructuringAssignmentTarget is neither an ObjectLiteral nor an ArrayLiteral, then
|
|
//
|
|
// The spec assumes we haven't yet distinguished between literals and
|
|
// patterns, but our parser does that work for us. That means we check for
|
|
// "*Pattern" instead of "*Literal" like the spec text suggests.
|
|
if (DestructuringAssignmentTarget.type !== "ObjectPattern" && DestructuringAssignmentTarget.type !== "ArrayPattern") {
|
|
// a. Let lref be the result of evaluating DestructuringAssignmentTarget.
|
|
lref = env.evaluate(DestructuringAssignmentTarget, strictCode);
|
|
|
|
// b. ReturnIfAbrupt(lref).
|
|
}
|
|
|
|
var value = void 0;
|
|
|
|
// 2. If iteratorRecord.[[Done]] is false, then
|
|
if (iteratorRecord.$Done === false) {
|
|
// a. Let next be IteratorStep(iteratorRecord.[[Iterator]]).
|
|
var _next2 = void 0;
|
|
try {
|
|
_next2 = (0, _index2.IteratorStep)(realm, iteratorRecord.$Iterator);
|
|
} catch (e) {
|
|
// b. If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
|
|
if (e instanceof _completions.AbruptCompletion) {
|
|
iteratorRecord.$Done = true;
|
|
}
|
|
// c. ReturnIfAbrupt(next).
|
|
throw e;
|
|
}
|
|
|
|
// d. If next is false, set iteratorRecord.[[Done]] to true.
|
|
if (_next2 === false) {
|
|
iteratorRecord.$Done = true;
|
|
// Normally this assignment would be done in step 3, but we do it
|
|
// here so that Flow knows `value` will always be initialized by step 4.
|
|
value = realm.intrinsics.undefined;
|
|
} else {
|
|
// e. Else,
|
|
// i. Let value be IteratorValue(next).
|
|
try {
|
|
value = (0, _index2.IteratorValue)(realm, _next2);
|
|
} catch (e) {
|
|
// ii. If value is an abrupt completion, set iteratorRecord.[[Done]] to true.
|
|
if (e instanceof _completions.AbruptCompletion) {
|
|
iteratorRecord.$Done = true;
|
|
}
|
|
// iii. ReturnIfAbrupt(v).
|
|
throw e;
|
|
}
|
|
}
|
|
} else {
|
|
// 3. If iteratorRecord.[[Done]] is true, let value be undefined.
|
|
value = realm.intrinsics.undefined;
|
|
}
|
|
|
|
var v = void 0;
|
|
|
|
// 4. If Initializer is present and value is undefined, then
|
|
if (Initializer && value instanceof _index.UndefinedValue) {
|
|
// a. Let defaultValue be the result of evaluating Initializer.
|
|
var defaultValue = env.evaluate(Initializer, strictCode);
|
|
|
|
// b. Let v be ? GetValue(defaultValue).
|
|
v = _singletons.Environment.GetValue(realm, defaultValue);
|
|
} else {
|
|
// 5. Else, let v be value.
|
|
v = value;
|
|
}
|
|
|
|
// 6. If DestructuringAssignmentTarget is an ObjectLiteral or an ArrayLiteral, then
|
|
//
|
|
// The spec assumes we haven't yet distinguished between literals and
|
|
// patterns, but our parser does that work for us. That means we check for
|
|
// "*Pattern" instead of "*Literal" like the spec text suggests.
|
|
if (DestructuringAssignmentTarget.type === "ObjectPattern" || DestructuringAssignmentTarget.type === "ArrayPattern") {
|
|
// a. Let nestedAssignmentPattern be the parse of the source text corresponding to DestructuringAssignmentTarget using either AssignmentPattern or AssignmentPattern[Yield] as the goal symbol depending upon whether this AssignmentElement has the [Yield] parameter.
|
|
var _nestedAssignmentPattern = DestructuringAssignmentTarget;
|
|
|
|
// b. Return the result of performing DestructuringAssignmentEvaluation of nestedAssignmentPattern with v as the argument.
|
|
DestructuringAssignmentEvaluation(realm, _nestedAssignmentPattern, v, strictCode, env);
|
|
continue;
|
|
}
|
|
|
|
// We know `lref` exists because of how the algorithm is setup, but tell
|
|
// Flow that `lref` exists with an `invariant()`.
|
|
(0, _invariant2.default)(lref);
|
|
|
|
// 7. If Initializer is present and value is undefined and IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of DestructuringAssignmentTarget are both true, then
|
|
if (Initializer && value instanceof _index.UndefinedValue && (0, _index2.IsAnonymousFunctionDefinition)(realm, Initializer) && (0, _index2.IsIdentifierRef)(realm, DestructuringAssignmentTarget) && v instanceof _index.ObjectValue) {
|
|
// a. Let hasNameProperty be ? HasOwnProperty(v, "name").
|
|
var hasNameProperty = (0, _index2.HasOwnProperty)(realm, v, "name");
|
|
|
|
// b. If hasNameProperty is false, perform SetFunctionName(v, GetReferencedName(lref)).
|
|
if (hasNameProperty === false) {
|
|
// All of the nodes that may be evaluated to produce lref create
|
|
// references. Assert this with an invariant as GetReferencedName may
|
|
// not be called with a value.
|
|
(0, _invariant2.default)(lref instanceof _environment.Reference);
|
|
|
|
_singletons.Functions.SetFunctionName(realm, v, _singletons.Environment.GetReferencedName(realm, lref));
|
|
}
|
|
}
|
|
|
|
// 8. Return ? PutValue(lref, v).
|
|
_singletons.Properties.PutValue(realm, lref, v);
|
|
continue;
|
|
}
|
|
|
|
// Handle the rest element if we have one.
|
|
} catch (err) {
|
|
_didIteratorError2 = true;
|
|
_iteratorError2 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion2 && _iterator2.return) {
|
|
_iterator2.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError2) {
|
|
throw _iteratorError2;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (restEl) {
|
|
// AssignmentRestElement : ...DestructuringAssignmentTarget
|
|
var DestructuringAssignmentTarget = restEl.argument;
|
|
|
|
var lref = void 0;
|
|
|
|
// 1. If DestructuringAssignmentTarget is neither an ObjectLiteral nor an ArrayLiteral, then
|
|
//
|
|
// The spec assumes we haven't yet distinguished between literals and
|
|
// patterns, but our parser does that work for us. That means we check for
|
|
// "*Pattern" instead of "*Literal" like the spec text suggests.
|
|
if (DestructuringAssignmentTarget.type !== "ObjectPattern" && DestructuringAssignmentTarget.type !== "ArrayPattern") {
|
|
// a. Let lref be the result of evaluating DestructuringAssignmentTarget.
|
|
lref = env.evaluate(DestructuringAssignmentTarget, strictCode);
|
|
|
|
// b. ReturnIfAbrupt(lref).
|
|
}
|
|
|
|
// 2. Let A be ArrayCreate(0).
|
|
var A = _singletons.Create.ArrayCreate(realm, 0);
|
|
|
|
// 3. Let n be 0.
|
|
var n = 0;
|
|
|
|
// 4. Repeat while iteratorRecord.[[Done]] is false,
|
|
while (iteratorRecord.$Done === false) {
|
|
// a. Let next be IteratorStep(iteratorRecord.[[Iterator]]).
|
|
var next = void 0;
|
|
try {
|
|
next = (0, _index2.IteratorStep)(realm, iteratorRecord.$Iterator);
|
|
} catch (e) {
|
|
// b. If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
|
|
if (e instanceof _completions.AbruptCompletion) {
|
|
iteratorRecord.$Done = true;
|
|
}
|
|
// c. ReturnIfAbrupt(next).
|
|
throw e;
|
|
}
|
|
|
|
// d. If next is false, set iteratorRecord.[[Done]] to true.
|
|
if (next === false) {
|
|
iteratorRecord.$Done = true;
|
|
} else {
|
|
// e. Else,
|
|
// i. Let nextValue be IteratorValue(next).
|
|
var nextValue = void 0;
|
|
try {
|
|
nextValue = (0, _index2.IteratorValue)(realm, next);
|
|
} catch (e) {
|
|
// ii. If nextValue is an abrupt completion, set iteratorRecord.[[Done]] to true.
|
|
if (e instanceof _completions.AbruptCompletion) {
|
|
iteratorRecord.$Done = true;
|
|
}
|
|
// iii. ReturnIfAbrupt(nextValue).
|
|
throw e;
|
|
}
|
|
|
|
// iv. Let status be CreateDataProperty(A, ! ToString(n), nextValue).
|
|
var status = _singletons.Create.CreateDataProperty(realm, A, n.toString(), nextValue);
|
|
|
|
// v. Assert: status is true.
|
|
(0, _invariant2.default)(status, "expected to create data property");
|
|
|
|
// vi. Increment n by 1.
|
|
n += 1;
|
|
}
|
|
}
|
|
|
|
// 5. If DestructuringAssignmentTarget is neither an ObjectLiteral nor an ArrayLiteral, then
|
|
if (DestructuringAssignmentTarget.type !== "ObjectPattern" && DestructuringAssignmentTarget.type !== "ArrayPattern") {
|
|
// `lref` will always be defined at this point. Let Flow know with an
|
|
// invariant.
|
|
(0, _invariant2.default)(lref);
|
|
|
|
// a. Return ? PutValue(lref, A).
|
|
_singletons.Properties.PutValue(realm, lref, A);
|
|
} else {
|
|
// 6. Let nestedAssignmentPattern be the parse of the source text corresponding to DestructuringAssignmentTarget using either AssignmentPattern or AssignmentPattern[Yield] as the goal symbol depending upon whether this AssignmentElement has the [Yield] parameter.
|
|
var nestedAssignmentPattern = DestructuringAssignmentTarget;
|
|
|
|
// 7. Return the result of performing DestructuringAssignmentEvaluation of nestedAssignmentPattern with A as the argument.
|
|
DestructuringAssignmentEvaluation(realm, nestedAssignmentPattern, A, strictCode, env);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ECMA262 12.15.5.4
|
|
function KeyedDestructuringAssignmentEvaluation(realm, node, value, propertyName, strictCode, env) {
|
|
var DestructuringAssignmentTarget = void 0;
|
|
var Initializer = void 0;
|
|
|
|
if (node.type === "AssignmentPattern") {
|
|
Initializer = node.right;
|
|
DestructuringAssignmentTarget = node.left;
|
|
} else {
|
|
DestructuringAssignmentTarget = node;
|
|
}
|
|
|
|
var lref = void 0;
|
|
|
|
// 1. If DestructuringAssignmentTarget is neither an ObjectLiteral nor an ArrayLiteral, then
|
|
//
|
|
// The spec assumes we haven't yet distinguished between literals and
|
|
// patterns, but our parser does that work for us. That means we check for
|
|
// "*Pattern" instead of "*Literal" like the spec text suggests.
|
|
if (DestructuringAssignmentTarget.type !== "ObjectPattern" && DestructuringAssignmentTarget.type !== "ArrayPattern") {
|
|
// a. Let lref be the result of evaluating DestructuringAssignmentTarget.
|
|
lref = env.evaluate(DestructuringAssignmentTarget, strictCode);
|
|
|
|
// b. ReturnIfAbrupt(lref).
|
|
}
|
|
|
|
var rhsValue = void 0;
|
|
|
|
// 2. Let v be ? GetV(value, propertyName).
|
|
var v = (0, _index2.GetV)(realm, value, propertyName);
|
|
|
|
// 3. If Initializer is present and v is undefined, then
|
|
if (Initializer && v instanceof _index.UndefinedValue) {
|
|
// a. Let defaultValue be the result of evaluating Initializer.
|
|
var defaultValue = env.evaluate(Initializer, strictCode);
|
|
|
|
// b. Let rhsValue be ? GetValue(defaultValue).
|
|
rhsValue = _singletons.Environment.GetValue(realm, defaultValue);
|
|
} else {
|
|
// 4. Else, let rhsValue be v.
|
|
rhsValue = v;
|
|
}
|
|
|
|
// 5. If DestructuringAssignmentTarget is an ObjectLiteral or an ArrayLiteral, then
|
|
//
|
|
// The spec assumes we haven't yet distinguished between literals and
|
|
// patterns, but our parser does that work for us. That means we check for
|
|
// "*Pattern" instead of "*Literal" like the spec text suggests.
|
|
if (DestructuringAssignmentTarget.type === "ObjectPattern" || DestructuringAssignmentTarget.type === "ArrayPattern") {
|
|
// a. Let assignmentPattern be the parse of the source text corresponding to DestructuringAssignmentTarget using either AssignmentPattern or AssignmentPattern[Yield] as the goal symbol depending upon whether this AssignmentElement has the [Yield] parameter.
|
|
var assignmentPattern = DestructuringAssignmentTarget;
|
|
|
|
// b. Return the result of performing DestructuringAssignmentEvaluation of assignmentPattern with rhsValue as the argument.
|
|
return DestructuringAssignmentEvaluation(realm, assignmentPattern, rhsValue, strictCode, env);
|
|
}
|
|
|
|
// `lref` will always be defined at this point. Let Flow know with an
|
|
// invariant.
|
|
(0, _invariant2.default)(lref);
|
|
|
|
// 6. If Initializer is present and v is undefined and IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of DestructuringAssignmentTarget are both true, then
|
|
if (Initializer && v instanceof _index.UndefinedValue && (0, _index2.IsAnonymousFunctionDefinition)(realm, Initializer) && (0, _index2.IsIdentifierRef)(realm, DestructuringAssignmentTarget) && rhsValue instanceof _index.ObjectValue) {
|
|
// a. Let hasNameProperty be ? HasOwnProperty(rhsValue, "name").
|
|
var hasNameProperty = (0, _index2.HasOwnProperty)(realm, rhsValue, "name");
|
|
|
|
// b. If hasNameProperty is false, perform SetFunctionName(rhsValue, GetReferencedName(lref)).
|
|
if (hasNameProperty === false) {
|
|
// All of the nodes that may be evaluated to produce lref create
|
|
// references. Assert this with an invariant as GetReferencedName may
|
|
// not be called with a value.
|
|
(0, _invariant2.default)(lref instanceof _environment.Reference);
|
|
|
|
_singletons.Functions.SetFunctionName(realm, rhsValue, _singletons.Environment.GetReferencedName(realm, lref));
|
|
}
|
|
}
|
|
|
|
// 7. Return ? PutValue(lref, rhsValue).
|
|
return _singletons.Properties.PutValue(realm, lref, rhsValue);
|
|
}
|
|
//# sourceMappingURL=destructuring.js.map
|