204 lines
11 KiB
JavaScript
204 lines
11 KiB
JavaScript
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.PossiblyNormalCompletion = exports.JoinedAbruptCompletions = exports.ReturnCompletion = exports.BreakCompletion = exports.ContinueCompletion = exports.ThrowCompletion = exports.AbruptCompletion = exports.NormalCompletion = exports.Completion = undefined;
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _invariant = require("./invariant.js");
|
|
|
|
var _invariant2 = _interopRequireDefault(_invariant);
|
|
|
|
var _index = require("./values/index.js");
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } /**
|
|
* 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.
|
|
*/
|
|
|
|
var Completion = exports.Completion = function Completion(value, location, target) {
|
|
_classCallCheck(this, Completion);
|
|
|
|
this.value = value;
|
|
this.target = target;
|
|
this.location = location;
|
|
};
|
|
|
|
// Normal completions are returned just like spec completions
|
|
|
|
|
|
var NormalCompletion = exports.NormalCompletion = function (_Completion) {
|
|
_inherits(NormalCompletion, _Completion);
|
|
|
|
function NormalCompletion() {
|
|
_classCallCheck(this, NormalCompletion);
|
|
|
|
return _possibleConstructorReturn(this, (NormalCompletion.__proto__ || Object.getPrototypeOf(NormalCompletion)).apply(this, arguments));
|
|
}
|
|
|
|
return NormalCompletion;
|
|
}(Completion);
|
|
|
|
// Abrupt completions are thrown as exeptions, to make it a easier
|
|
// to quickly get to the matching high level construct.
|
|
|
|
|
|
var AbruptCompletion = exports.AbruptCompletion = function (_Completion2) {
|
|
_inherits(AbruptCompletion, _Completion2);
|
|
|
|
function AbruptCompletion() {
|
|
_classCallCheck(this, AbruptCompletion);
|
|
|
|
return _possibleConstructorReturn(this, (AbruptCompletion.__proto__ || Object.getPrototypeOf(AbruptCompletion)).apply(this, arguments));
|
|
}
|
|
|
|
return AbruptCompletion;
|
|
}(Completion);
|
|
|
|
var ThrowCompletion = exports.ThrowCompletion = function (_AbruptCompletion) {
|
|
_inherits(ThrowCompletion, _AbruptCompletion);
|
|
|
|
function ThrowCompletion(value, location, nativeStack) {
|
|
_classCallCheck(this, ThrowCompletion);
|
|
|
|
var _this3 = _possibleConstructorReturn(this, (ThrowCompletion.__proto__ || Object.getPrototypeOf(ThrowCompletion)).call(this, value, location));
|
|
|
|
_this3.nativeStack = nativeStack || new Error().stack;
|
|
return _this3;
|
|
}
|
|
|
|
return ThrowCompletion;
|
|
}(AbruptCompletion);
|
|
|
|
var ContinueCompletion = exports.ContinueCompletion = function (_AbruptCompletion2) {
|
|
_inherits(ContinueCompletion, _AbruptCompletion2);
|
|
|
|
function ContinueCompletion(value, location, target) {
|
|
_classCallCheck(this, ContinueCompletion);
|
|
|
|
return _possibleConstructorReturn(this, (ContinueCompletion.__proto__ || Object.getPrototypeOf(ContinueCompletion)).call(this, value, location, target));
|
|
}
|
|
|
|
return ContinueCompletion;
|
|
}(AbruptCompletion);
|
|
|
|
var BreakCompletion = exports.BreakCompletion = function (_AbruptCompletion3) {
|
|
_inherits(BreakCompletion, _AbruptCompletion3);
|
|
|
|
function BreakCompletion(value, location, target) {
|
|
_classCallCheck(this, BreakCompletion);
|
|
|
|
return _possibleConstructorReturn(this, (BreakCompletion.__proto__ || Object.getPrototypeOf(BreakCompletion)).call(this, value, location, target));
|
|
}
|
|
|
|
return BreakCompletion;
|
|
}(AbruptCompletion);
|
|
|
|
var ReturnCompletion = exports.ReturnCompletion = function (_AbruptCompletion4) {
|
|
_inherits(ReturnCompletion, _AbruptCompletion4);
|
|
|
|
function ReturnCompletion(value, location) {
|
|
_classCallCheck(this, ReturnCompletion);
|
|
|
|
return _possibleConstructorReturn(this, (ReturnCompletion.__proto__ || Object.getPrototypeOf(ReturnCompletion)).call(this, value, location));
|
|
}
|
|
|
|
return ReturnCompletion;
|
|
}(AbruptCompletion);
|
|
|
|
var JoinedAbruptCompletions = exports.JoinedAbruptCompletions = function (_AbruptCompletion5) {
|
|
_inherits(JoinedAbruptCompletions, _AbruptCompletion5);
|
|
|
|
function JoinedAbruptCompletions(realm, joinCondition, consequent, consequentEffects, alternate, alternateEffects) {
|
|
_classCallCheck(this, JoinedAbruptCompletions);
|
|
|
|
var _this7 = _possibleConstructorReturn(this, (JoinedAbruptCompletions.__proto__ || Object.getPrototypeOf(JoinedAbruptCompletions)).call(this, realm.intrinsics.empty, consequent.location));
|
|
|
|
_this7.joinCondition = joinCondition;
|
|
_this7.consequent = consequent;
|
|
_this7.consequentEffects = consequentEffects;
|
|
_this7.alternate = alternate;
|
|
_this7.alternateEffects = alternateEffects;
|
|
return _this7;
|
|
}
|
|
|
|
_createClass(JoinedAbruptCompletions, [{
|
|
key: "containsBreakOrContinue",
|
|
value: function containsBreakOrContinue() {
|
|
if (this.consequent instanceof BreakCompletion || this.consequent instanceof ContinueCompletion) return true;
|
|
if (this.alternate instanceof BreakCompletion || this.alternate instanceof ContinueCompletion) return true;
|
|
if (this.consequent instanceof JoinedAbruptCompletions) {
|
|
if (this.consequent.containsBreakOrContinue()) return true;
|
|
}
|
|
if (this.alternate instanceof JoinedAbruptCompletions) {
|
|
if (this.alternate.containsBreakOrContinue()) return true;
|
|
}
|
|
return false;
|
|
}
|
|
}]);
|
|
|
|
return JoinedAbruptCompletions;
|
|
}(AbruptCompletion);
|
|
|
|
// Possibly normal completions have to be treated like normal completions
|
|
// and are thus never thrown. At the end of a try block or loop body, however,
|
|
// action must be taken to deal with the possibly abrupt case of the completion.
|
|
|
|
|
|
var PossiblyNormalCompletion = exports.PossiblyNormalCompletion = function (_NormalCompletion) {
|
|
_inherits(PossiblyNormalCompletion, _NormalCompletion);
|
|
|
|
function PossiblyNormalCompletion(value, joinCondition, consequent, consequentEffects, alternate, alternateEffects, pathConditions, savedPathConditions) {
|
|
var savedEffects = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : undefined;
|
|
|
|
_classCallCheck(this, PossiblyNormalCompletion);
|
|
|
|
(0, _invariant2.default)(consequent instanceof NormalCompletion || consequent instanceof _index.Value || alternate instanceof NormalCompletion || alternate instanceof _index.Value);
|
|
(0, _invariant2.default)(consequent instanceof AbruptCompletion || alternate instanceof AbruptCompletion);
|
|
(0, _invariant2.default)(value === consequent || consequent instanceof AbruptCompletion || consequent instanceof NormalCompletion && value === consequent.value);
|
|
(0, _invariant2.default)(value === alternate || alternate instanceof AbruptCompletion || alternate instanceof NormalCompletion && value === alternate.value);
|
|
var loc = consequent instanceof AbruptCompletion ? consequent.location : alternate instanceof Completion ? alternate.location : alternate.expressionLocation;
|
|
|
|
var _this8 = _possibleConstructorReturn(this, (PossiblyNormalCompletion.__proto__ || Object.getPrototypeOf(PossiblyNormalCompletion)).call(this, value, loc));
|
|
|
|
_this8.joinCondition = joinCondition;
|
|
_this8.consequent = consequent;
|
|
_this8.consequentEffects = consequentEffects;
|
|
_this8.alternate = alternate;
|
|
_this8.alternateEffects = alternateEffects;
|
|
_this8.savedEffects = savedEffects;
|
|
_this8.pathConditions = pathConditions;
|
|
_this8.savedPathConditions = savedPathConditions;
|
|
return _this8;
|
|
}
|
|
|
|
_createClass(PossiblyNormalCompletion, [{
|
|
key: "containsBreakOrContinue",
|
|
value: function containsBreakOrContinue() {
|
|
if (this.consequent instanceof BreakCompletion || this.consequent instanceof ContinueCompletion) return true;
|
|
if (this.alternate instanceof BreakCompletion || this.alternate instanceof ContinueCompletion) return true;
|
|
if (this.consequent instanceof JoinedAbruptCompletions || this.consequent instanceof PossiblyNormalCompletion) {
|
|
if (this.consequent.containsBreakOrContinue()) return true;
|
|
}
|
|
if (this.alternate instanceof JoinedAbruptCompletions || this.alternate instanceof PossiblyNormalCompletion) {
|
|
if (this.alternate.containsBreakOrContinue()) return true;
|
|
}
|
|
return false;
|
|
}
|
|
}]);
|
|
|
|
return PossiblyNormalCompletion;
|
|
}(NormalCompletion);
|
|
//# sourceMappingURL=completions.js.map
|