com.google.javascript.jscomp.ControlFlowGraph.Branch Java Examples

/**
 * Given an entry node, find all the nodes reachable from that node
 * and prioritize them.
 */
private void prioritizeFromEntryNode(DiGraphNode<Node, Branch> entry) {
  PriorityQueue<DiGraphNode<Node, Branch>> worklist =
      new PriorityQueue<DiGraphNode<Node, Branch>>(10, priorityComparator);
  worklist.add(entry);

  while (!worklist.isEmpty()) {
    DiGraphNode<Node, Branch> current = worklist.remove();
    if (nodePriorities.containsKey(current)) {
      continue;
    }

    nodePriorities.put(current, ++priorityCounter);

    List<DiGraphNode<Node, Branch>> successors =
        cfg.getDirectedSuccNodes(current);
    for (DiGraphNode<Node, Branch> candidate : successors) {
      worklist.add(candidate);
    }
  }
}
 

@Override
public void visit(NodeTraversal t, Node n, Node parent) {
  if (parent == null || n.isFunction() || n.isScript()) {
    return;
  }
  DiGraphNode<Node, Branch> gNode = cfg.getDirectedGraphNode(n);
  if (gNode == null) { // Not in CFG.
    return;
  }
  if (gNode.getAnnotation() != GraphReachability.REACHABLE ||
      (removeNoOpStatements && !NodeUtil.mayHaveSideEffects(n, compiler))) {
    removeDeadExprStatementSafely(n);
    return;
  }
  tryRemoveUnconditionalBranching(n);
}
 

private void handleCase(Node node) {
  // Case is a bit tricky....First it goes into the body if condition is true.
  createEdge(node, Branch.ON_TRUE,
      node.getFirstChild().getNext());
  // Look for the next CASE, skipping over DEFAULT.
  Node next = getNextSiblingOfType(node.getNext(), Token.CASE);
  if (next != null) { // Found a CASE
    Preconditions.checkState(next.isCase());
    createEdge(node, Branch.ON_FALSE, next);
  } else { // No more CASE found, go back and search for a DEFAULT.
    Node parent = node.getParent();
    Node deflt = getNextSiblingOfType(
      parent.getFirstChild().getNext(), Token.DEFAULT_CASE);
    if (deflt != null) { // Has a DEFAULT
      createEdge(node, Branch.ON_FALSE, deflt);
    } else { // No DEFAULT found, go to the follow of the SWITCH.
      createEdge(node, Branch.ON_FALSE, computeFollowNode(node, this));
    }
  }
  connectToPossibleExceptionHandler(node, node.getFirstChild());
}
 

@Override
protected void joinInputs(DiGraphNode<N, Branch> node) {
  BranchedFlowState<L> state = node.getAnnotation();
  List<DiGraphNode<N, Branch>> predNodes =
      getCfg().getDirectedPredNodes(node);
  List<L> values = new ArrayList<L>(predNodes.size());

  for (DiGraphNode<N, Branch> predNode : predNodes) {
    BranchedFlowState<L> predNodeState = predNode.getAnnotation();

    L in = predNodeState.out.get(
        getCfg().getDirectedSuccNodes(predNode).indexOf(node));

    values.add(in);
  }
  if (getCfg().getEntry() == node) {
    state.setIn(createEntryLattice());
  } else if (!values.isEmpty()) {
    state.setIn(joinOp.apply(values));
  }
}
 

@Override
public void visit(NodeTraversal t, Node n, Node parent) {
  if (parent == null) {
    return;
  }
  if (n.getType() == Token.FUNCTION || n.getType() == Token.SCRIPT) {
    return;
  }

  DiGraphNode<Node, Branch> gNode = curCfg.getDirectedGraphNode(n);
  if (gNode == null) { // Not in CFG.
    return;
  }
  if (gNode.getAnnotation() != GraphReachability.REACHABLE ||
      (removeNoOpStatements && !NodeUtil.mayHaveSideEffects(n))) {
    removeDeadExprStatementSafely(n);
    return;
  }

  tryRemoveUnconditionalBranching(n);
}
 

@Override
public void visit(NodeTraversal t, Node n, Node parent) {
  if (parent == null) {
    return;
  }
  if (n.isFunction() || n.isScript()) {
    return;
  }

  DiGraphNode<Node, Branch> gNode = cfg.getDirectedGraphNode(n);
  if (gNode == null) { // Not in CFG.
    return;
  }
  if (gNode.getAnnotation() != GraphReachability.REACHABLE ||
      (removeNoOpStatements && !NodeUtil.mayHaveSideEffects(n, compiler))) {
    removeDeadExprStatementSafely(n);
    return;
  }

  tryRemoveUnconditionalBranching(n);
}
 

/**
 * Given an entry node, find all the nodes reachable from that node
 * and prioritize them.
 */
private void prioritizeFromEntryNode(DiGraphNode<Node, Branch> entry) {
  PriorityQueue<DiGraphNode<Node, Branch>> worklist =
      new PriorityQueue<DiGraphNode<Node, Branch>>(10, priorityComparator);
  worklist.add(entry);

  while (!worklist.isEmpty()) {
    DiGraphNode<Node, Branch> current = worklist.remove();
    if (nodePriorities.containsKey(current)) {
      continue;
    }

    nodePriorities.put(current, ++priorityCounter);

    List<DiGraphNode<Node, Branch>> successors =
        cfg.getDirectedSuccNodes(current);
    for (DiGraphNode<Node, Branch> candidate : successors) {
      worklist.add(candidate);
    }
  }
}
 

@Override
public void visit(NodeTraversal t, Node n, Node parent) {
  if (parent == null || n.isFunction() || n.isScript()) {
    return;
  }
  DiGraphNode<Node, Branch> gNode = cfg.getDirectedGraphNode(n);
  if (gNode == null) { // Not in CFG.
    return;
  }
  if (gNode.getAnnotation() != GraphReachability.REACHABLE ||
      (removeNoOpStatements && !NodeUtil.mayHaveSideEffects(n, compiler))) {
    removeDeadExprStatementSafely(n);
    return;
  }
  tryRemoveUnconditionalBranching(n);
}
 

@Override
public boolean apply(EdgeTuple<Node, Branch> input) {
  Branch branch = input.edge;
  if (!branch.isConditional()) {
    return true;
  }
  Node predecessor = input.sourceNode;
  Node condition = NodeUtil.getConditionExpression(predecessor);

  // TODO(user): Handle more complicated expression like true == true,
  // etc....
  if (condition != null) {
    TernaryValue val = NodeUtil.getImpureBooleanValue(condition);
    if (val != TernaryValue.UNKNOWN) {
      return val.toBoolean(true) == (branch == Branch.ON_TRUE);
    }
  }
  return true;
}
 

private void handleCase(Node node) {
  // Case is a bit tricky....First it goes into the body if condition is true.
  createEdge(node, Branch.ON_TRUE,
      node.getFirstChild().getNext());
  // Look for the next CASE, skipping over DEFAULT.
  Node next = getNextSiblingOfType(node.getNext(), Token.CASE);
  if (next != null) { // Found a CASE
    Preconditions.checkState(next.getType() == Token.CASE);
    createEdge(node, Branch.ON_FALSE, next);
  } else { // No more CASE found, go back and search for a DEFAULT.
    Node parent = node.getParent();
    Node deflt = getNextSiblingOfType(
      parent.getFirstChild().getNext(), Token.DEFAULT);
    if (deflt != null) { // Has a DEFAULT
      createEdge(node, Branch.ON_FALSE, deflt);
    } else { // No DEFAULT found, go to the follow of the SWITCH.
      createEdge(node, Branch.ON_FALSE, computeFollowNode(node));
    }
  }
  connectToPossibleExceptionHandler(node, node.getFirstChild());
}
 

private void handleSwitch(Node node) {
  // Transfer to the first non-DEFAULT CASE. if there are none, transfer
  // to the DEFAULT or the EMPTY node.
  Node next = getNextSiblingOfType(
      node.getFirstChild().getNext(), Token.CASE, Token.EMPTY);
  if (next != null) { // Has at least one CASE or EMPTY
    createEdge(node, Branch.UNCOND, next);
  } else { // Has no CASE but possibly a DEFAULT
    if (node.getFirstChild().getNext() != null) {
      createEdge(node, Branch.UNCOND, node.getFirstChild().getNext());
    } else { // No CASE, no DEFAULT
      createEdge(node, Branch.UNCOND, computeFollowNode(node, this));
    }
  }
  connectToPossibleExceptionHandler(node, node.getFirstChild());
}
 

private void handleCase(Node node) {
  // Case is a bit tricky....First it goes into the body if condition is true.
  createEdge(node, Branch.ON_TRUE,
      node.getFirstChild().getNext());
  // Look for the next CASE, skipping over DEFAULT.
  Node next = getNextSiblingOfType(node.getNext(), Token.CASE);
  if (next != null) { // Found a CASE
    Preconditions.checkState(next.isCase());
    createEdge(node, Branch.ON_FALSE, next);
  } else { // No more CASE found, go back and search for a DEFAULT.
    Node parent = node.getParent();
    Node deflt = getNextSiblingOfType(
      parent.getFirstChild().getNext(), Token.DEFAULT_CASE);
    if (deflt != null) { // Has a DEFAULT
      createEdge(node, Branch.ON_FALSE, deflt);
    } else { // No DEFAULT found, go to the follow of the SWITCH.
      createEdge(node, Branch.ON_FALSE, computeFollowNode(node, this));
    }
  }
  connectToPossibleExceptionHandler(node, node.getFirstChild());
}
 

private void handleStmtList(Node node) {
  Node parent = node.getParent();
  // Special case, don't add a block of empty CATCH block to the graph.
  if (node.isBlock() && parent != null &&
      parent.isTry() &&
      NodeUtil.getCatchBlock(parent) == node &&
      !NodeUtil.hasCatchHandler(node)) {
    return;
  }

  // A block transfer control to its first child if it is not empty.
  Node child = node.getFirstChild();

  // Function declarations are skipped since control doesn't go into that
  // function (unless it is called)
  while (child != null && child.isFunction()) {
    child = child.getNext();
  }

  if (child != null) {
    createEdge(node, Branch.UNCOND, computeFallThrough(child));
  } else {
    createEdge(node, Branch.UNCOND, computeFollowNode(node, this));
  }

  // Synthetic blocks
  if (parent != null) {
    switch (parent.getType()) {
      case Token.DEFAULT_CASE:
      case Token.CASE:
      case Token.TRY:
        break;
      default:
        if (node.isBlock() && node.isSyntheticBlock()) {
          createEdge(node, Branch.SYN_BLOCK, computeFollowNode(node, this));
        }
        break;
    }
  }
}
 

private void handleContinue(Node node) {
  String label = null;
  if (node.hasChildren()) {
    label = node.getFirstChild().getString();
  }
  Node cur;
  Node lastJump;
  // Similar to handBreak's logic with a few minor variation.
  Node parent = node.getParent();
  for (cur = node, lastJump = node;
      !isContinueTarget(cur, parent, label);
      cur = parent, parent = parent.getParent()) {
    if (cur.getType() == Token.TRY && NodeUtil.hasFinally(cur)) {
      if (lastJump == node) {
        createEdge(lastJump, Branch.UNCOND, cur.getLastChild());
      } else {
        finallyMap.put(lastJump, computeFallThrough(cur.getLastChild()));
      }
      lastJump = cur;
    }
    Preconditions.checkState(parent != null, "Cannot find continue target.");
  }
  Node iter = cur;
  if (cur.getChildCount() == 4) {
    iter = cur.getFirstChild().getNext().getNext();
  }

  if (lastJump == node) {
    createEdge(node, Branch.UNCOND, iter);
  } else {
    finallyMap.put(lastJump, iter);
  }
}
 

public void testReturnInTry() {
  String src = "function f(x){ try{x; return x()} finally {} var y;}";
  ControlFlowGraph<Node> cfg = createCfg(src);
  assertCrossEdge(cfg, Token.EXPR_RESULT, Token.RETURN, Branch.UNCOND);
  assertCrossEdge(cfg, Token.RETURN, Token.BLOCK, Branch.UNCOND);
  assertCrossEdge(cfg, Token.BLOCK, Token.VAR, Branch.UNCOND);
  assertReturnEdge(cfg, Token.VAR);
  assertReturnEdge(cfg, Token.BLOCK);
  assertNoReturnEdge(cfg, Token.RETURN);
}
 

private void handleWhile(Node node) {
  // Control goes to the first statement if the condition evaluates to true.
  createEdge(node, Branch.ON_TRUE,
      computeFallThrough(node.getFirstChild().getNext()));

  // Control goes to the follow() if the condition evaluates to false.
  createEdge(node, Branch.ON_FALSE,
      computeFollowNode(node, this));
  connectToPossibleExceptionHandler(
      node, NodeUtil.getConditionExpression(node));
}
 

private void handleReturn(Node node) {
  Node lastJump = null;
  for (Iterator<Node> iter = exceptionHandler.iterator(); iter.hasNext();) {
    Node curHandler = iter.next();
    if (curHandler.isFunction()) {
      break;
    }
    if (NodeUtil.hasFinally(curHandler)) {
      if (lastJump == null) {
        createEdge(node, Branch.UNCOND, curHandler.getLastChild());
      } else {
        finallyMap.put(lastJump,
            computeFallThrough(curHandler.getLastChild()));
      }
      lastJump = curHandler;
    }
  }

  if (node.hasChildren()) {
    connectToPossibleExceptionHandler(node, node.getFirstChild());
  }

  if (lastJump == null) {
    createEdge(node, Branch.UNCOND, null);
  } else {
    finallyMap.put(lastJump, null);
  }
}
 

/**
 * Gets the must reaching definition of a given node. The node must be one of
 * the control flow graph nodes.
 *
 * @param name name of the variable. It can only be names of local variable
 *     that are not function parameters, escaped variables or variables
 *     declared in catch.
 * @param useNode the location of the use where the definition reaches.
 */
Node getDef(String name, Node useNode) {
  Preconditions.checkArgument(getCfg().hasNode(useNode));
  GraphNode<Node, Branch> n = getCfg().getNode(useNode);
  FlowState<MustDef> state = n.getAnnotation();
  Definition def = state.getIn().reachingDef.get(jsScope.getVar(name));
  if (def == null) {
    return null;
  } else {
    return def.node;
  }
}
 

private void handleIf(Node node) {
  Node thenBlock = node.getFirstChild().getNext();
  Node elseBlock = thenBlock.getNext();
  createEdge(node, Branch.ON_TRUE, computeFallThrough(thenBlock));

  if (elseBlock == null) {
    createEdge(node, Branch.ON_FALSE,
        computeFollowNode(node)); // not taken branch
  } else {
    createEdge(node, Branch.ON_FALSE, computeFallThrough(elseBlock));
  }
  connectToPossibleExceptionHandler(
      node, NodeUtil.getConditionExpression(node));
}
 

/**
 * Assert that there exists no control flow edge of the given type
 * from some node with the first token to the return node.
 */
private static void assertNoReturnEdge(ControlFlowGraph<Node> cfg,
    int startToken) {
  List<DiGraphEdge<Node, Branch>> edges = getAllEdges(cfg);
  for (DiGraphEdge<Node, Branch> edge : edges) {
    Node source = edge.getSource().getValue();
    DiGraphNode<Node, Branch> dest = edge.getDestination();
    if (source.getType() == startToken) {
      assertTrue("Token " + startToken + " should not have an out going" +
          " edge to the implicit return", !cfg.isImplicitReturn(dest));
      return;
    }
  }
}
 

private void handleFunction(Node node) {
  // A block transfer control to its first child if it is not empty.
  Preconditions.checkState(node.getChildCount() >= 3);
  createEdge(node, Branch.UNCOND,
      computeFallThrough(node.getFirstChild().getNext().getNext()));
  Preconditions.checkState(exceptionHandler.peek() == node);
  exceptionHandler.pop();
}
 

private void handleFunction(Node node) {
  // A block transfer control to its first child if it is not empty.
  Preconditions.checkState(node.getChildCount() >= 3);
  createEdge(node, Branch.UNCOND,
      computeFallThrough(node.getFirstChild().getNext().getNext()));
  Preconditions.checkState(exceptionHandler.peek() == node);
  exceptionHandler.pop();
}
 

/**
 * Try to remove useless assignments from a control flow graph that has been
 * annotated with liveness information.
 *
 * @param t The node traversal.
 * @param cfg The control flow graph of the program annotated with liveness
 *        information.
 */
private void tryRemoveDeadAssignments(NodeTraversal t,
    ControlFlowGraph<Node> cfg) {
  Iterable<DiGraphNode<Node, Branch>> nodes = cfg.getDirectedGraphNodes();

  for (DiGraphNode<Node, Branch> cfgNode : nodes) {
    FlowState<LiveVariableLattice> state =
        cfgNode.getAnnotation();
    Node n = cfgNode.getValue();
    if (n == null) {
      continue;
    }
    switch (n.getType()) {
      case Token.IF:
      case Token.WHILE:
      case Token.DO:
        tryRemoveAssignment(t, NodeUtil.getConditionExpression(n), state);
        continue;
      case Token.FOR:
        if (!NodeUtil.isForIn(n)) {
          tryRemoveAssignment(
              t, NodeUtil.getConditionExpression(n), state);
        }
        continue;
      case Token.SWITCH:
      case Token.CASE:
      case Token.RETURN:
        if (n.hasChildren()) {
          tryRemoveAssignment(t, n.getFirstChild(), state);
        }
        continue;
      // TODO(user): case Token.VAR: Remove var a=1;a=2;.....
    }

    tryRemoveAssignment(t, n, state);
  }
}
 

private void handleIf(Node node) {
  Node thenBlock = node.getFirstChild().getNext();
  Node elseBlock = thenBlock.getNext();
  createEdge(node, Branch.ON_TRUE, computeFallThrough(thenBlock));

  if (elseBlock == null) {
    createEdge(node, Branch.ON_FALSE,
        computeFollowNode(node, this)); // not taken branch
  } else {
    createEdge(node, Branch.ON_FALSE, computeFallThrough(elseBlock));
  }
  connectToPossibleExceptionHandler(
      node, NodeUtil.getConditionExpression(node));
}
 

private boolean hasExceptionHandler(Node cfgNode) {
  List<DiGraphEdge<Node, Branch>> branchEdges = getCfg().getOutEdges(cfgNode);
  for (DiGraphEdge<Node, Branch> edge : branchEdges) {
    if (edge.getValue() == Branch.ON_EX) {
      return true;
    }
  }
  return false;
}
 

private void handleFunction(Node node) {
  // A block transfer control to its first child if it is not empty.
  Preconditions.checkState(node.getChildCount() >= 3);
  createEdge(node, Branch.UNCOND,
      computeFallThrough(node.getFirstChild().getNext().getNext()));
  Preconditions.checkState(exceptionHandler.peek() == node);
  exceptionHandler.pop();
}
 

/**
 * Connects cfgNode to the proper CATCH block if target subtree might throw
 * an exception. If there are FINALLY blocks reached before a CATCH, it will
 * make the corresponding entry in finallyMap.
 */
private void connectToPossibleExceptionHandler(Node cfgNode, Node target) {
  if (mayThrowException(target) && !exceptionHandler.isEmpty()) {
    Node lastJump = cfgNode;
    for (Node handler : exceptionHandler) {
      if (handler.isFunction()) {
        return;
      }
      Preconditions.checkState(handler.isTry());
      Node catchBlock = NodeUtil.getCatchBlock(handler);

      if (!NodeUtil.hasCatchHandler(catchBlock)) { // No catch but a FINALLY.
        if (lastJump == cfgNode) {
          createEdge(cfgNode, Branch.ON_EX, handler.getLastChild());
        } else {
          finallyMap.put(lastJump, handler.getLastChild());
        }
      } else { // Has a catch.
        if (lastJump == cfgNode) {
          createEdge(cfgNode, Branch.ON_EX, catchBlock);
          return;
        } else {
          finallyMap.put(lastJump, catchBlock);
        }
      }
      lastJump = handler;
    }
  }
}
 

private void handleIf(Node node) {
  Node thenBlock = node.getFirstChild().getNext();
  Node elseBlock = thenBlock.getNext();
  createEdge(node, Branch.ON_TRUE, computeFallThrough(thenBlock));

  if (elseBlock == null) {
    createEdge(node, Branch.ON_FALSE,
        computeFollowNode(node)); // not taken branch
  } else {
    createEdge(node, Branch.ON_FALSE, computeFallThrough(elseBlock));
  }
  connectToPossibleExceptionHandler(
      node, NodeUtil.getConditionExpression(node));
}
 

private void handleReturn(Node node) {
  Node lastJump = null;
  for (Iterator<Node> iter = exceptionHandler.iterator(); iter.hasNext();) {
    Node curHandler = iter.next();
    if (curHandler.isFunction()) {
      break;
    }
    if (NodeUtil.hasFinally(curHandler)) {
      if (lastJump == null) {
        createEdge(node, Branch.UNCOND, curHandler.getLastChild());
      } else {
        finallyMap.put(lastJump,
            computeFallThrough(curHandler.getLastChild()));
      }
      lastJump = curHandler;
    }
  }

  if (node.hasChildren()) {
    connectToPossibleExceptionHandler(node, node.getFirstChild());
  }

  if (lastJump == null) {
    createEdge(node, Branch.UNCOND, null);
  } else {
    finallyMap.put(lastJump, null);
  }
}
 

public void testReturnInFinally2() {
  String src = "function f(x){" +
    " try{ try{}finally{var dummy; return x;} } finally {} }";
  ControlFlowGraph<Node> cfg = createCfg(src);
  assertCrossEdge(cfg, Token.VAR, Token.RETURN, Branch.UNCOND);
  assertCrossEdge(cfg, Token.RETURN, Token.BLOCK, Branch.UNCOND);
  assertReturnEdge(cfg, Token.BLOCK);
  assertNoReturnEdge(cfg, Token.RETURN);
}