export function transformNode(t: typeof babelTypes, path: NodePath, options: TransformOptions = {}) {
    const parseResult = parse(t, path, options);
    if (parseResult == null)
        return;
    const transformResult = transform(t, transformCallExpression(parseResult));
    path.replaceWith(transformResult);
}

export function getBestComment(nodePath: NodePath): string|undefined {
  const maybeComment = getAttachedComment(nodePath.node);
  if (maybeComment !== undefined) {
    return maybeComment;
  }

  const parent = nodePath.parentPath;
  if (parent === undefined) {
    return undefined;
  }
  if (!isStatementWithUniqueStatementChild(parent.node) &&
      babel.isStatement(nodePath.node)) {
    // Don't walk up above the nearest statement.
    return undefined;
  }
  if (babel.isVariableDeclaration(parent.node) &&
      parent.node.declarations.length !== 1) {
    // The parent node is multiple declarations. We can't be sure its
    // comment applies to us.
    return undefined;
  }

  if (parent.isClassBody() || nodePath.isObjectMember()) {
    // don't go above an object or class member.
    return undefined;
  }

  return getBestComment(parent);
}

  const shouldHoistExpression = (expr: NodePath): boolean => {
    if (!expr.isCallExpression()) {
      return false;
    }

    const callee = expr.get('callee');
    // TODO: avoid type casts - the types can be arrays (is it possible to ignore that without casting?)
    const object = callee.get('object') as NodePath;
    const property = callee.get('property') as NodePath;
    return (
      property.isIdentifier() &&
      FUNCTIONS[property.node.name] &&
      (object.isIdentifier(JEST_GLOBAL) ||
        (callee.isMemberExpression() && shouldHoistExpression(object))) &&
      FUNCTIONS[property.node.name](expr.get('arguments'))
    );
  };

export function*
    getSimpleObjectPropPaths(nodePath: NodePath<babel.ObjectExpression>) {
  // tslint:disable-next-line: no-any typings are wrong here
  const props = nodePath.get('properties') as any as Array<NodePath>;
  for (const propPath of props) {
    if (propPath.isObjectProperty() || propPath.isObjectMethod()) {
      yield propPath;
    }
  }
}

/**
 * Calls into visitor methods for visited node types using `estraverse` API of
 * providing the node and the parent node, and translates the `VisitorOption`
 * return value into directives on the `path` object used by `babel-traverse` to
 * advise visitor control flow, i.e. `stop`, `skip`, and `remove`.
 */
function dispatchVisitMethods(
    methodNames: Array<keyof Visitor>,
    path: NodePath<babel.Node>,
    visitor: Visitor): void {
  for (const methodName of methodNames) {
    if (typeof visitor[methodName] === 'function') {
      // TODO(rictic): can maybe remove this cast in TS 2.8
      const result = (visitor[methodName] as VisitorCallback<babel.Node>)!
          (path.node, path.parent, path);
      switch (result) {
        case VisitorOption.Break:
          return path.stop();
        case VisitorOption.Skip:
          return path.skip();
        case VisitorOption.Remove:
          return path.remove();
      }
    }
  }
}

    function getNodeText(node: Node) {
        const outerNodeStart = path.node.start!;
        const innerNodeStart = node.start!;
        const offset = innerNodeStart - outerNodeStart;

        return path.getSource().substr(offset, node.end! - node.start!);
    }