How to use the decaffeinate-parser.traverse function in decaffeinate-parser

export default function countVariableUsages(node: Node, name: string): number {
  let numUsages = 0;

  traverse(node, child => {
    // Make sure it's the name we're looking for.
    if (!(child instanceof Identifier) || child.data !== name) {
      return;
    }

    // Skip `b` in `a.b`.
    if (child.parentNode instanceof MemberAccessOp && child.parentNode.member === child) {
      return;
    }

    // Skip `a` in `{ a: b }`, but not in `{ a }` or `{ [a]: b }`.
    if (
      child.parentNode instanceof ObjectInitialiserMember &&
      child.parentNode.key === child &&
      // `{ a }`
      child.parentNode.expression !== null &&

// it might be modified.
    if (this.isThisAssignIndexBinding()) {
      return true;
    }
    const userIndex = this.getIndexBinding();

    // We need to extract this to a variable if there's an assignment within the
    // loop, but assignments outside the loop are fine, so we make a fake scope
    // that only looks at assignments within the loop body. But assignments
    // within closures could also happen temporally in the loop, so bail out if
    // we see one of those.
    if (this.getScope().hasInnerClosureModification(userIndex)) {
      return true;
    }
    const fakeScope = new Scope(this.node, null);
    traverse(this.node, child => {
      fakeScope.processNode(child);
    });
    return fakeScope.hasModificationAfterDeclaration(userIndex);
  }

initialize(): void {
    for (const iifePatcher of this._iifePatcherDescendants) {
      if (!iifePatcher.willPatchAsIIFE()) {
        continue;
      }
      // Use the scope code to find all assignments, including loop assignees,
      // destructuring, etc.
      const fakeScope = new Scope(iifePatcher.node);
      traverse(iifePatcher.node, child => {
        fakeScope.processNode(child);
      });
      for (const name of fakeScope.getOwnNames()) {
        if (
          countVariableUsages(this.node, name) > countVariableUsages(iifePatcher.node, name) &&
          this._explicitDeclarationsToAdd.indexOf(name) === -1
        ) {
          this._explicitDeclarationsToAdd.push(name);
        }
      }
    }
  }

function computeParentMap(program: Program): Map {
  const resultMap: Map = new Map();
  traverse(program, (node, parent) => {
    resultMap.set(node, parent);
  });
  return resultMap;
}

function computeScopeMap(program: Program): Map {
  const scopeMap: Map = new Map();
  traverse(program, (node, parent) => {
    let scope;
    switch (node.type) {
      case 'Program':
        scope = new Scope(node);
        break;

      case 'Function':
      case 'BoundFunction':
      case 'GeneratorFunction':
      case 'BoundGeneratorFunction':
      case 'AsyncFunction':
      case 'Class': {
        const parentScope = parent && scopeMap.get(parent);
        if (!parentScope) {
          throw new Error('Expected to find parent scope.');
        }

export default function containsDescendant(
  node: Node,
  predicate: (node: Node) => boolean,
  { shouldStopTraversal = () => false }: { shouldStopTraversal?: (node: Node) => boolean } = {}
): boolean {
  let found = false;
  traverse(node, childNode => {
    if (found) {
      return false;
    }
    if (predicate(childNode)) {
      found = true;
      return false;
    }
    if (shouldStopTraversal(childNode)) {
      return false;
    }
    return true;
  });
  return found;
}