“use strict”;

var _assert = _interopRequireDefault(require(“assert”));

var _util = require(“./util.js”);

var _private = require(“private”);

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

/**

* Copyright (c) 2014-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/

var m = (0, _private.makeAccessor)(); var hasOwn = Object.prototype.hasOwnProperty;

function makePredicate(propertyName, knownTypes) {

function onlyChildren(node) {
  var t = (0, _util.getTypes)();
  t.assertNode(node); // Assume no side effects until we find out otherwise.

  var result = false;

  function check(child) {
    if (result) {// Do nothing.
    } else if (Array.isArray(child)) {
      child.some(check);
    } else if (t.isNode(child)) {
      _assert["default"].strictEqual(result, false);

      result = predicate(child);
    }

    return result;
  }

  var keys = t.VISITOR_KEYS[node.type];

  if (keys) {
    for (var i = 0; i < keys.length; i++) {
      var key = keys[i];
      var child = node[key];
      check(child);
    }
  }

  return result;
}

function predicate(node) {
  (0, _util.getTypes)().assertNode(node);
  var meta = m(node);
  if (hasOwn.call(meta, propertyName)) return meta[propertyName]; // Certain types are "opaque," which means they have no side
  // effects or leaps and we don't care about their subexpressions.

  if (hasOwn.call(opaqueTypes, node.type)) return meta[propertyName] = false;
  if (hasOwn.call(knownTypes, node.type)) return meta[propertyName] = true;
  return meta[propertyName] = onlyChildren(node);
}

predicate.onlyChildren = onlyChildren;
return predicate;

}

var opaqueTypes = {

FunctionExpression: true,
ArrowFunctionExpression: true

}; // These types potentially have side effects regardless of what side // effects their subexpressions have.

var sideEffectTypes = {

CallExpression: true,
// Anything could happen!
ForInStatement: true,
// Modifies the key variable.
UnaryExpression: true,
// Think delete.
BinaryExpression: true,
// Might invoke .toString() or .valueOf().
AssignmentExpression: true,
// Side-effecting by definition.
UpdateExpression: true,
// Updates are essentially assignments.
NewExpression: true // Similar to CallExpression.

}; // These types are the direct cause of all leaps in control flow.

var leapTypes = {

YieldExpression: true,
BreakStatement: true,
ContinueStatement: true,
ReturnStatement: true,
ThrowStatement: true

}; // All leap types are also side effect types.

for (var type in leapTypes) {

if (hasOwn.call(leapTypes, type)) {
  sideEffectTypes[type] = leapTypes[type];
}

}

exports.hasSideEffects = makePredicate(“hasSideEffects”, sideEffectTypes); exports.containsLeap = makePredicate(“containsLeap”, leapTypes);