@babel/traverse 7.0.0-beta.31

package/lib/path/evaluation.js

@@ -0,0 +1,450 @@
+"use strict";
+
+exports.__esModule = true;
+exports.evaluateTruthy = evaluateTruthy;
+exports.evaluate = evaluate;
+var VALID_CALLEES = ["String", "Number", "Math"];
+var INVALID_METHODS = ["random"];
+
+function evaluateTruthy() {
+  var res = this.evaluate();
+  if (res.confident) return !!res.value;
+}
+
+function deopt(path, state) {
+  if (!state.confident) return;
+  state.deoptPath = path;
+  state.confident = false;
+}
+
+function evaluateCached(path, state) {
+  var node = path.node;
+  var seen = state.seen;
+
+  if (seen.has(node)) {
+    var existing = seen.get(node);
+
+    if (existing.resolved) {
+      return existing.value;
+    } else {
+      deopt(path, state);
+      return;
+    }
+  } else {
+    var item = {
+      resolved: false
+    };
+    seen.set(node, item);
+
+    var val = _evaluate(path, state);
+
+    if (state.confident) {
+      item.resolved = true;
+      item.value = val;
+    }
+
+    return val;
+  }
+}
+
+function _evaluate(path, state) {
+  if (!state.confident) return;
+  var node = path.node;
+
+  if (path.isSequenceExpression()) {
+    var exprs = path.get("expressions");
+    return evaluateCached(exprs[exprs.length - 1], state);
+  }
+
+  if (path.isStringLiteral() || path.isNumericLiteral() || path.isBooleanLiteral()) {
+    return node.value;
+  }
+
+  if (path.isNullLiteral()) {
+    return null;
+  }
+
+  if (path.isTemplateLiteral()) {
+    return evaluateQuasis(path, node.quasis, state);
+  }
+
+  if (path.isTaggedTemplateExpression() && path.get("tag").isMemberExpression()) {
+    var object = path.get("tag.object");
+    var name = object.node.name;
+    var property = path.get("tag.property");
+
+    if (object.isIdentifier() && name === "String" && !path.scope.getBinding(name, true) && property.isIdentifier && property.node.name === "raw") {
+      return evaluateQuasis(path, node.quasi.quasis, state, true);
+    }
+  }
+
+  if (path.isConditionalExpression()) {
+    var testResult = evaluateCached(path.get("test"), state);
+    if (!state.confident) return;
+
+    if (testResult) {
+      return evaluateCached(path.get("consequent"), state);
+    } else {
+      return evaluateCached(path.get("alternate"), state);
+    }
+  }
+
+  if (path.isExpressionWrapper()) {
+    return evaluateCached(path.get("expression"), state);
+  }
+
+  if (path.isMemberExpression() && !path.parentPath.isCallExpression({
+    callee: node
+  })) {
+    var _property = path.get("property");
+
+    var _object = path.get("object");
+
+    if (_object.isLiteral() && _property.isIdentifier()) {
+      var value = _object.node.value;
+      var type = typeof value;
+
+      if (type === "number" || type === "string") {
+        return value[_property.node.name];
+      }
+    }
+  }
+
+  if (path.isReferencedIdentifier()) {
+    var binding = path.scope.getBinding(node.name);
+
+    if (binding && binding.constantViolations.length > 0) {
+      return deopt(binding.path, state);
+    }
+
+    if (binding && path.node.start < binding.path.node.end) {
+      return deopt(binding.path, state);
+    }
+
+    if (binding && binding.hasValue) {
+      return binding.value;
+    } else {
+      if (node.name === "undefined") {
+        return binding ? deopt(binding.path, state) : undefined;
+      } else if (node.name === "Infinity") {
+        return binding ? deopt(binding.path, state) : Infinity;
+      } else if (node.name === "NaN") {
+        return binding ? deopt(binding.path, state) : NaN;
+      }
+
+      var resolved = path.resolve();
+
+      if (resolved === path) {
+        return deopt(path, state);
+      } else {
+        return evaluateCached(resolved, state);
+      }
+    }
+  }
+
+  if (path.isUnaryExpression({
+    prefix: true
+  })) {
+    if (node.operator === "void") {
+      return undefined;
+    }
+
+    var argument = path.get("argument");
+
+    if (node.operator === "typeof" && (argument.isFunction() || argument.isClass())) {
+      return "function";
+    }
+
+    var arg = evaluateCached(argument, state);
+    if (!state.confident) return;
+
+    switch (node.operator) {
+      case "!":
+        return !arg;
+
+      case "+":
+        return +arg;
+
+      case "-":
+        return -arg;
+
+      case "~":
+        return ~arg;
+
+      case "typeof":
+        return typeof arg;
+    }
+  }
+
+  if (path.isArrayExpression()) {
+    var arr = [];
+    var elems = path.get("elements");
+
+    for (var _iterator = elems, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref = _i.value;
+      }
+
+      var _elem = _ref;
+      _elem = _elem.evaluate();
+
+      if (_elem.confident) {
+        arr.push(_elem.value);
+      } else {
+        return deopt(_elem, state);
+      }
+    }
+
+    return arr;
+  }
+
+  if (path.isObjectExpression()) {
+    var obj = {};
+    var props = path.get("properties");
+
+    for (var _iterator2 = props, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+      var _ref2;
+
+      if (_isArray2) {
+        if (_i2 >= _iterator2.length) break;
+        _ref2 = _iterator2[_i2++];
+      } else {
+        _i2 = _iterator2.next();
+        if (_i2.done) break;
+        _ref2 = _i2.value;
+      }
+
+      var _prop = _ref2;
+
+      if (_prop.isObjectMethod() || _prop.isSpreadElement()) {
+        return deopt(_prop, state);
+      }
+
+      var keyPath = _prop.get("key");
+
+      var key = keyPath;
+
+      if (_prop.node.computed) {
+        key = key.evaluate();
+
+        if (!key.confident) {
+          return deopt(keyPath, state);
+        }
+
+        key = key.value;
+      } else if (key.isIdentifier()) {
+        key = key.node.name;
+      } else {
+        key = key.node.value;
+      }
+
+      var valuePath = _prop.get("value");
+
+      var _value2 = valuePath.evaluate();
+
+      if (!_value2.confident) {
+        return deopt(valuePath, state);
+      }
+
+      _value2 = _value2.value;
+      obj[key] = _value2;
+    }
+
+    return obj;
+  }
+
+  if (path.isLogicalExpression()) {
+    var wasConfident = state.confident;
+    var left = evaluateCached(path.get("left"), state);
+    var leftConfident = state.confident;
+    state.confident = wasConfident;
+    var right = evaluateCached(path.get("right"), state);
+    var rightConfident = state.confident;
+    state.confident = leftConfident && rightConfident;
+
+    switch (node.operator) {
+      case "||":
+        if (left && leftConfident) {
+          state.confident = true;
+          return left;
+        }
+
+        if (!state.confident) return;
+        return left || right;
+
+      case "&&":
+        if (!left && leftConfident || !right && rightConfident) {
+          state.confident = true;
+        }
+
+        if (!state.confident) return;
+        return left && right;
+    }
+  }
+
+  if (path.isBinaryExpression()) {
+    var _left = evaluateCached(path.get("left"), state);
+
+    if (!state.confident) return;
+
+    var _right = evaluateCached(path.get("right"), state);
+
+    if (!state.confident) return;
+
+    switch (node.operator) {
+      case "-":
+        return _left - _right;
+
+      case "+":
+        return _left + _right;
+
+      case "/":
+        return _left / _right;
+
+      case "*":
+        return _left * _right;
+
+      case "%":
+        return _left % _right;
+
+      case "**":
+        return Math.pow(_left, _right);
+
+      case "<":
+        return _left < _right;
+
+      case ">":
+        return _left > _right;
+
+      case "<=":
+        return _left <= _right;
+
+      case ">=":
+        return _left >= _right;
+
+      case "==":
+        return _left == _right;
+
+      case "!=":
+        return _left != _right;
+
+      case "===":
+        return _left === _right;
+
+      case "!==":
+        return _left !== _right;
+
+      case "|":
+        return _left | _right;
+
+      case "&":
+        return _left & _right;
+
+      case "^":
+        return _left ^ _right;
+
+      case "<<":
+        return _left << _right;
+
+      case ">>":
+        return _left >> _right;
+
+      case ">>>":
+        return _left >>> _right;
+    }
+  }
+
+  if (path.isCallExpression()) {
+    var callee = path.get("callee");
+    var context;
+    var func;
+
+    if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name, true) && VALID_CALLEES.indexOf(callee.node.name) >= 0) {
+      func = global[node.callee.name];
+    }
+
+    if (callee.isMemberExpression()) {
+      var _object2 = callee.get("object");
+
+      var _property2 = callee.get("property");
+
+      if (_object2.isIdentifier() && _property2.isIdentifier() && VALID_CALLEES.indexOf(_object2.node.name) >= 0 && INVALID_METHODS.indexOf(_property2.node.name) < 0) {
+        context = global[_object2.node.name];
+        func = context[_property2.node.name];
+      }
+
+      if (_object2.isLiteral() && _property2.isIdentifier()) {
+        var _type = typeof _object2.node.value;
+
+        if (_type === "string" || _type === "number") {
+          context = _object2.node.value;
+          func = context[_property2.node.name];
+        }
+      }
+    }
+
+    if (func) {
+      var args = path.get("arguments").map(function (arg) {
+        return evaluateCached(arg, state);
+      });
+      if (!state.confident) return;
+      return func.apply(context, args);
+    }
+  }
+
+  deopt(path, state);
+}
+
+function evaluateQuasis(path, quasis, state, raw) {
+  if (raw === void 0) {
+    raw = false;
+  }
+
+  var str = "";
+  var i = 0;
+  var exprs = path.get("expressions");
+
+  for (var _iterator3 = quasis, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
+    var _ref3;
+
+    if (_isArray3) {
+      if (_i3 >= _iterator3.length) break;
+      _ref3 = _iterator3[_i3++];
+    } else {
+      _i3 = _iterator3.next();
+      if (_i3.done) break;
+      _ref3 = _i3.value;
+    }
+
+    var _elem2 = _ref3;
+    if (!state.confident) break;
+    str += raw ? _elem2.value.raw : _elem2.value.cooked;
+    var expr = exprs[i++];
+    if (expr) str += String(evaluateCached(expr, state));
+  }
+
+  if (!state.confident) return;
+  return str;
+}
+
+function evaluate() {
+  var state = {
+    confident: true,
+    deoptPath: null,
+    seen: new Map()
+  };
+  var value = evaluateCached(this, state);
+  if (!state.confident) value = undefined;
+  return {
+    confident: state.confident,
+    deopt: state.deoptPath,
+    value: value
+  };
+}

package/lib/path/family.js

@@ -0,0 +1,244 @@
+"use strict";
+
+exports.__esModule = true;
+exports.getOpposite = getOpposite;
+exports.getCompletionRecords = getCompletionRecords;
+exports.getSibling = getSibling;
+exports.getPrevSibling = getPrevSibling;
+exports.getNextSibling = getNextSibling;
+exports.getAllNextSiblings = getAllNextSiblings;
+exports.getAllPrevSiblings = getAllPrevSiblings;
+exports.get = get;
+exports._getKey = _getKey;
+exports._getPattern = _getPattern;
+exports.getBindingIdentifiers = getBindingIdentifiers;
+exports.getOuterBindingIdentifiers = getOuterBindingIdentifiers;
+exports.getBindingIdentifierPaths = getBindingIdentifierPaths;
+exports.getOuterBindingIdentifierPaths = getOuterBindingIdentifierPaths;
+
+var _index = _interopRequireDefault(require("./index"));
+
+var t = _interopRequireWildcard(require("@babel/types"));
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getOpposite() {
+  if (this.key === "left") {
+    return this.getSibling("right");
+  } else if (this.key === "right") {
+    return this.getSibling("left");
+  }
+}
+
+function addCompletionRecords(path, paths) {
+  if (path) return paths.concat(path.getCompletionRecords());
+  return paths;
+}
+
+function getCompletionRecords() {
+  var paths = [];
+
+  if (this.isIfStatement()) {
+    paths = addCompletionRecords(this.get("consequent"), paths);
+    paths = addCompletionRecords(this.get("alternate"), paths);
+  } else if (this.isDoExpression() || this.isFor() || this.isWhile()) {
+    paths = addCompletionRecords(this.get("body"), paths);
+  } else if (this.isProgram() || this.isBlockStatement()) {
+    paths = addCompletionRecords(this.get("body").pop(), paths);
+  } else if (this.isFunction()) {
+    return this.get("body").getCompletionRecords();
+  } else if (this.isTryStatement()) {
+    paths = addCompletionRecords(this.get("block"), paths);
+    paths = addCompletionRecords(this.get("handler"), paths);
+    paths = addCompletionRecords(this.get("finalizer"), paths);
+  } else if (this.isCatchClause()) {
+    paths = addCompletionRecords(this.get("body"), paths);
+  } else {
+    paths.push(this);
+  }
+
+  return paths;
+}
+
+function getSibling(key) {
+  return _index.default.get({
+    parentPath: this.parentPath,
+    parent: this.parent,
+    container: this.container,
+    listKey: this.listKey,
+    key: key
+  });
+}
+
+function getPrevSibling() {
+  return this.getSibling(this.key - 1);
+}
+
+function getNextSibling() {
+  return this.getSibling(this.key + 1);
+}
+
+function getAllNextSiblings() {
+  var _key = this.key;
+  var sibling = this.getSibling(++_key);
+  var siblings = [];
+
+  while (sibling.node) {
+    siblings.push(sibling);
+    sibling = this.getSibling(++_key);
+  }
+
+  return siblings;
+}
+
+function getAllPrevSiblings() {
+  var _key = this.key;
+  var sibling = this.getSibling(--_key);
+  var siblings = [];
+
+  while (sibling.node) {
+    siblings.push(sibling);
+    sibling = this.getSibling(--_key);
+  }
+
+  return siblings;
+}
+
+function get(key, context) {
+  if (context === true) context = this.context;
+  var parts = key.split(".");
+
+  if (parts.length === 1) {
+    return this._getKey(key, context);
+  } else {
+    return this._getPattern(parts, context);
+  }
+}
+
+function _getKey(key, context) {
+  var _this = this;
+
+  var node = this.node;
+  var container = node[key];
+
+  if (Array.isArray(container)) {
+    return container.map(function (_, i) {
+      return _index.default.get({
+        listKey: key,
+        parentPath: _this,
+        parent: node,
+        container: container,
+        key: i
+      }).setContext(context);
+    });
+  } else {
+    return _index.default.get({
+      parentPath: this,
+      parent: node,
+      container: node,
+      key: key
+    }).setContext(context);
+  }
+}
+
+function _getPattern(parts, context) {
+  var path = this;
+  var _arr = parts;
+
+  for (var _i = 0; _i < _arr.length; _i++) {
+    var part = _arr[_i];
+
+    if (part === ".") {
+      path = path.parentPath;
+    } else {
+      if (Array.isArray(path)) {
+        path = path[part];
+      } else {
+        path = path.get(part, context);
+      }
+    }
+  }
+
+  return path;
+}
+
+function getBindingIdentifiers(duplicates) {
+  return t.getBindingIdentifiers(this.node, duplicates);
+}
+
+function getOuterBindingIdentifiers(duplicates) {
+  return t.getOuterBindingIdentifiers(this.node, duplicates);
+}
+
+function getBindingIdentifierPaths(duplicates, outerOnly) {
+  if (duplicates === void 0) {
+    duplicates = false;
+  }
+
+  if (outerOnly === void 0) {
+    outerOnly = false;
+  }
+
+  var path = this;
+  var search = [].concat(path);
+  var ids = Object.create(null);
+
+  while (search.length) {
+    var id = search.shift();
+    if (!id) continue;
+    if (!id.node) continue;
+    var keys = t.getBindingIdentifiers.keys[id.node.type];
+
+    if (id.isIdentifier()) {
+      if (duplicates) {
+        var _ids = ids[id.node.name] = ids[id.node.name] || [];
+
+        _ids.push(id);
+      } else {
+        ids[id.node.name] = id;
+      }
+
+      continue;
+    }
+
+    if (id.isExportDeclaration()) {
+      var declaration = id.get("declaration");
+
+      if (declaration.isDeclaration()) {
+        search.push(declaration);
+      }
+
+      continue;
+    }
+
+    if (outerOnly) {
+      if (id.isFunctionDeclaration()) {
+        search.push(id.get("id"));
+        continue;
+      }
+
+      if (id.isFunctionExpression()) {
+        continue;
+      }
+    }
+
+    if (keys) {
+      for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        var child = id.get(key);
+
+        if (Array.isArray(child) || child.node) {
+          search = search.concat(child);
+        }
+      }
+    }
+  }
+
+  return ids;
+}
+
+function getOuterBindingIdentifierPaths(duplicates) {
+  return this.getBindingIdentifierPaths(duplicates, true);
+}