Code coverage report for 6to5/transformation/transformers/es6-generators/meta.js

Statements: 100% (41 / 41)      Branches: 92.86% (13 / 14)      Functions: 100% (5 / 5)      Lines: 100% (38 / 38)      Ignored: none     

All files » 6to5/transformation/transformers/es6-generators/ » meta.js
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99                    1 1 1 1   1 1   1 1 1911     1911   1 5771   5604 228 5376 1610 1610   5771     1911 5535     1911     1 2653   2653 2653       1953   1941   1633     2   2     1           1                     1                 1 5 5       1 1  
/**
 * Copyright (c) 2014, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
 * additional grant of patent rights can be found in the PATENTS file in
 * the same directory.
 */
 
var assert = require("assert");
var types  = require("ast-types");
var m      = require("private").makeAccessor();
var _      = require("lodash");
 
var isArray = types.builtInTypes.array;
var n       = types.namedTypes;
 
function makePredicate(propertyName, knownTypes) {
  function onlyChildren(node) {
    n.Node.check(node);
 
    // Assume no side effects until we find out otherwise.
    var result = false;
 
    function check(child) {
      if (result) {
        // Do nothing.
      } else if (isArray.check(child)) {
        child.some(check);
      } else if (n.Node.check(child)) {
        assert.strictEqual(result, false);
        result = predicate(child);
      }
      return result;
    }
 
    types.eachField(node, function (name, child) {
      check(child);
    });
 
    return result;
  }
 
  function predicate(node) {
    n.Node.check(node);
 
    var meta = m(node);
    if (_.has(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 (_.has(opaqueTypes, node.type)) return meta[propertyName] = false;
 
    if (_.has(knownTypes, node.type)) return meta[propertyName] = true;
 
    return meta[propertyName] = onlyChildren(node);
  }
 
  predicate.onlyChildren = onlyChildren;
 
  return predicate;
}
 
var opaqueTypes = {
  FunctionExpression: 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) {
  Eif (_.has(leapTypes, type)) {
    sideEffectTypes[type] = leapTypes[type];
  }
}
 
exports.hasSideEffects = makePredicate("hasSideEffects", sideEffectTypes);
exports.containsLeap = makePredicate("containsLeap", leapTypes);