prepack/lib/completions.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.PossiblyNormalCompletion = exports.ForkedAbruptCompletion = exports.ReturnCompletion = exports.BreakCompletion = exports.ContinueCompletion = exports.ThrowCompletion = exports.AbruptCompletion = exports.SimpleNormalCompletion = exports.NormalCompletion = exports.Completion = void 0;

var _invariant = _interopRequireDefault(require("./invariant.js"));

var _realm = require("./realm.js");

var _index = require("./values/index.js");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * 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.
 */
class Completion {
  constructor(value, precedingEffects, location, target) {
    let e = precedingEffects;

    if (e !== undefined) {
      if (e.result === undefined) e.result = this;else e = e.shallowCloneWithResult(this);
    }

    this.value = value;
    this.effects = e;
    this.target = target;
    this.location = location;
    (0, _invariant.default)(this.constructor !== Completion, "Completion is an abstract base class");
  }

  shallowCloneWithoutEffects() {
    (0, _invariant.default)(false, "Completion.shallowCloneWithoutEffects is an abstract base method and should not be called");
  }

  toDisplayString() {
    return "[" + this.constructor.name + " value " + (this.value ? this.value.toDisplayString() : "undefined") + "]";
  }

} // Normal completions are returned just like spec completions


exports.Completion = Completion;

class NormalCompletion extends Completion {
  constructor(value, precedingEffects, location, target) {
    super(value, precedingEffects, location, target);
    (0, _invariant.default)(this.constructor !== NormalCompletion, "NormalCompletion is an abstract base class");
  }

  shallowCloneWithoutEffects() {
    (0, _invariant.default)(false, "NormalCompletion.shallowCloneWithoutEffects is an abstract base method and should not be called");
  }

} // SimpleNormalCompletions are returned just like spec completions. This class exists as the parallel for
// PossiblyNormalCompletion to make comparisons easier.


exports.NormalCompletion = NormalCompletion;

class SimpleNormalCompletion extends NormalCompletion {
  shallowCloneWithoutEffects() {
    return new SimpleNormalCompletion(this.value, undefined, this.location, this.target);
  }

} // Abrupt completions are thrown as exeptions, to make it a easier
// to quickly get to the matching high level construct.


exports.SimpleNormalCompletion = SimpleNormalCompletion;

class AbruptCompletion extends Completion {
  constructor(value, precedingEffects, location, target) {
    super(value, precedingEffects, location, target);
    (0, _invariant.default)(this.constructor !== AbruptCompletion, "AbruptCompletion is an abstract base class");
  }

  shallowCloneWithoutEffects() {
    (0, _invariant.default)(false, "AbruptCompletion.shallowCloneWithoutEffects is an abstract base method and should not be called");
  }

}

exports.AbruptCompletion = AbruptCompletion;

class ThrowCompletion extends AbruptCompletion {
  constructor(value, precedingEffects, location, nativeStack) {
    super(value, precedingEffects, location);
    this.nativeStack = nativeStack || new Error().stack;
    let realm = value.$Realm;

    if (realm.isInPureScope()) {
      for (let callback of realm.reportSideEffectCallbacks) {
        callback("EXCEPTION_THROWN", undefined, location);
      }
    }
  }

  shallowCloneWithoutEffects() {
    return new ThrowCompletion(this.value, undefined, this.location, this.nativeStack);
  }

}

exports.ThrowCompletion = ThrowCompletion;

class ContinueCompletion extends AbruptCompletion {
  constructor(value, precedingEffects, location, target) {
    super(value, precedingEffects, location, target || null);
  }

  shallowCloneWithoutEffects() {
    return new ContinueCompletion(this.value, undefined, this.location, this.target);
  }

}

exports.ContinueCompletion = ContinueCompletion;

class BreakCompletion extends AbruptCompletion {
  constructor(value, precedingEffects, location, target) {
    super(value, precedingEffects, location, target || null);
  }

  shallowCloneWithoutEffects() {
    return new BreakCompletion(this.value, undefined, this.location, this.target);
  }

}

exports.BreakCompletion = BreakCompletion;

class ReturnCompletion extends AbruptCompletion {
  constructor(value, precedingEffects, location) {
    super(value, precedingEffects, location);

    if (value instanceof _index.EmptyValue) {
      this.value = value.$Realm.intrinsics.undefined;
    }
  }

  shallowCloneWithoutEffects() {
    return new ReturnCompletion(this.value, undefined, this.location);
  }

}

exports.ReturnCompletion = ReturnCompletion;

class ForkedAbruptCompletion extends AbruptCompletion {
  constructor(realm, joinCondition, consequent, alternate) {
    super(realm.intrinsics.empty, undefined, consequent.location);
    this.joinCondition = joinCondition;
    this.consequent = consequent;
    this.alternate = alternate;
  }

  shallowCloneWithoutEffects() {
    return new ForkedAbruptCompletion(this.value.$Realm, this.joinCondition, this.consequent, this.alternate);
  } // For convenience, this.consequent.effects should always be defined, but accessing it directly requires
  // verifying that with an invariant.


  get consequentEffects() {
    (0, _invariant.default)(this.consequent.effects);
    return this.consequent.effects;
  }

  get alternateEffects() {
    (0, _invariant.default)(this.alternate.effects);
    return this.alternate.effects;
  }

  updateConsequentKeepingCurrentEffects(newConsequent) {
    let e = this.consequent.effects;
    (0, _invariant.default)(e);
    newConsequent.effects = e.shallowCloneWithResult(newConsequent);
    this.consequent = newConsequent;
    return this;
  }

  updateAlternateKeepingCurrentEffects(newAlternate) {
    let e = this.alternate.effects;
    (0, _invariant.default)(e);
    newAlternate.effects = e.shallowCloneWithResult(newAlternate);
    this.alternate = newAlternate;
    return this;
  }

  toDisplayString() {
    let superString = super.toDisplayString().slice(0, -1);
    return superString + " c: [" + this.consequent.toDisplayString() + "] a: [" + this.alternate.toDisplayString() + "]]";
  }

  containsCompletion(CompletionType) {
    if (this.consequent instanceof CompletionType) return true;
    if (this.alternate instanceof CompletionType) return true;

    if (this.consequent instanceof ForkedAbruptCompletion) {
      if (this.consequent.containsCompletion(CompletionType)) return true;
    }

    if (this.alternate instanceof ForkedAbruptCompletion) {
      if (this.alternate.containsCompletion(CompletionType)) return true;
    }

    return false;
  }

  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 ForkedAbruptCompletion) {
      if (this.consequent.containsBreakOrContinue()) return true;
    }

    if (this.alternate instanceof ForkedAbruptCompletion) {
      if (this.alternate.containsBreakOrContinue()) return true;
    }

    return false;
  }

  transferChildrenToPossiblyNormalCompletion() {
    (0, _invariant.default)(this.consequent.value instanceof _index.EmptyValue || this.alternate.value instanceof _index.EmptyValue);
    return new PossiblyNormalCompletion(this.value.$Realm.intrinsics.empty, this.joinCondition, this.consequent, this.alternate, []);
  }

} // 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.


exports.ForkedAbruptCompletion = ForkedAbruptCompletion;

class PossiblyNormalCompletion extends NormalCompletion {
  constructor(value, joinCondition, consequent, alternate, savedPathConditions, savedEffects = undefined) {
    (0, _invariant.default)(consequent instanceof NormalCompletion || alternate instanceof NormalCompletion);
    super(value, undefined, consequent.location);
    this.joinCondition = joinCondition;
    this.consequent = consequent;
    this.alternate = alternate;
    this.savedEffects = savedEffects;
    this.savedPathConditions = savedPathConditions;
  }

  shallowCloneWithoutEffects() {
    let consequentEffects = this.consequentEffects;
    let alternateEffects = this.alternateEffects;
    (0, _invariant.default)(this.consequent === consequentEffects.result);
    (0, _invariant.default)(this.alternate === alternateEffects.result);
    return new PossiblyNormalCompletion(this.value, this.joinCondition, this.consequent, this.alternate, this.savedPathConditions, this.savedEffects);
  } // For convenience, this.consequent.effects should always be defined, but accessing it directly requires
  // verifying that with an invariant.


  get consequentEffects() {
    (0, _invariant.default)(this.consequent.effects);
    return this.consequent.effects;
  }

  get alternateEffects() {
    (0, _invariant.default)(this.alternate.effects);
    return this.alternate.effects;
  }

  updateConsequentKeepingCurrentEffects(newConsequent) {
    if (newConsequent instanceof NormalCompletion) this.value = newConsequent.value;
    let e = this.consequentEffects;
    let effects = e.shallowCloneWithResult(newConsequent);
    this.consequent = effects.result;
    return this;
  }

  updateAlternateKeepingCurrentEffects(newAlternate) {
    if (newAlternate instanceof NormalCompletion) this.value = newAlternate.value;
    let e = this.alternateEffects;
    let effects = e.shallowCloneWithResult(newAlternate);
    this.alternate = effects.result;
    return this;
  }

  toDisplayString() {
    let superString = super.toDisplayString().slice(0, -1);
    return superString + " c: [" + this.consequent.toDisplayString() + "] a: [" + this.alternate.toDisplayString() + "]]";
  }

  getNormalCompletion() {
    let result;

    if (this.alternate instanceof SimpleNormalCompletion) {
      result = this.alternate;
    } else if (this.consequent instanceof SimpleNormalCompletion) {
      result = this.consequent;
    } else {
      if (this.alternate instanceof PossiblyNormalCompletion) {
        result = this.alternate.getNormalCompletion();
      } else {
        (0, _invariant.default)(this.consequent instanceof PossiblyNormalCompletion);
        result = this.consequent.getNormalCompletion();
      }
    }

    (0, _invariant.default)(result.value === this.value);
    return result;
  }

  containsCompletion(CompletionType) {
    if (this.consequent instanceof CompletionType) return true;
    if (this.alternate instanceof CompletionType) return true;

    if (this.consequent instanceof ForkedAbruptCompletion || this.consequent instanceof PossiblyNormalCompletion) {
      if (this.consequent.containsCompletion(CompletionType)) return true;
    }

    if (this.alternate instanceof ForkedAbruptCompletion || this.alternate instanceof PossiblyNormalCompletion) {
      if (this.alternate.containsCompletion(CompletionType)) return true;
    }

    return false;
  }

  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 ForkedAbruptCompletion || this.consequent instanceof PossiblyNormalCompletion) {
      if (this.consequent.containsBreakOrContinue()) return true;
    }

    if (this.alternate instanceof ForkedAbruptCompletion || this.alternate instanceof PossiblyNormalCompletion) {
      if (this.alternate.containsBreakOrContinue()) return true;
    }

    return false;
  }

}

exports.PossiblyNormalCompletion = PossiblyNormalCompletion;
//# sourceMappingURL=completions.js.map