code: final void analyze(int maxSteps) {
      initialize();
      int step = 0;
      while (!orderedWorkSet.isEmpty()) {
        if (step > maxSteps) {
          throw new MaxIterationsExceededException(
              "Analysis did not terminate after " + maxSteps + " iterations");
        }
        DiGraphNode<N, Branch> curNode = orderedWorkSet.iterator().next();
        orderedWorkSet.remove(curNode);
        joinInputs(curNode);
        if (flow(curNode)) {
          // If there is a change in the current node, we want to grab the list
          // of nodes that this node affects.
          List<DiGraphNode<N, Branch>> nextNodes =
              isForward() ? cfg.getDirectedSuccNodes(curNode) : cfg.getDirectedPredNodes(curNode);
  
          for (DiGraphNode<N, Branch> nextNode : nextNodes) {
            if (nextNode != cfg.getImplicitReturn()) {
              orderedWorkSet.add(nextNode);
            }
          }
        }
        step++;
      }
      if (isForward()) {
        joinInputs(getCfg().getImplicitReturn());
      }
    }
docs: Finds a fixed-point solution. The function has the side effect of replacing
  the existing node annotations with the computed solutions using {@link
  com.google.javascript.jscomp.graph.GraphNode#setAnnotation(Annotation)}.
  
  <p>Initially, each node's input and output flow state contains the value
  given by {@link #createInitialEstimateLattice()} (with the exception of the
  entry node of the graph which takes on the {@link #createEntryLattice()}
  value. Each node will use the output state of its predecessor and compute a
  output state according to the instruction. At that time, any nodes that
  depends on the node's newly modified output value will need to recompute
  their output state again. Each step will perform a computation at one node
  until no extra computation will modify any existing output state anymore.
  
  @param maxSteps Max number of iterations before the method stops and throw
  a {@link MaxIterationsExceededException}. This will prevent the
  analysis from going into a infinite loop.