Java Code Examples for com.google.javascript.rhino.Token#THROW

static boolean nodeTypeMayHaveSideEffects(Node n, AbstractCompiler compiler) {
  if (isAssignmentOp(n)) {
    return true;
  }

  switch(n.getType()) {
    case Token.DELPROP:
    case Token.DEC:
    case Token.INC:
    case Token.THROW:
      return true;
    case Token.CALL:
      return NodeUtil.functionCallHasSideEffects(n, compiler);
    case Token.NEW:
      return NodeUtil.constructorCallHasSideEffects(n, compiler);
    case Token.NAME:
      // A variable definition.
      return n.hasChildren();
    default:
      return false;
  }
}
 

static boolean nodeTypeMayHaveSideEffects(Node n, AbstractCompiler compiler) {
  if (isAssignmentOp(n)) {
    return true;
  }

  switch(n.getType()) {
    case Token.DELPROP:
    case Token.DEC:
    case Token.INC:
    case Token.THROW:
      return true;
    case Token.CALL:
      return NodeUtil.functionCallHasSideEffects(n, compiler);
    case Token.NEW:
      return NodeUtil.constructorCallHasSideEffects(n, compiler);
    case Token.NAME:
      // A variable definition.
      return n.hasChildren();
    default:
      return false;
  }
}
 

static boolean nodeTypeMayHaveSideEffects(Node n, AbstractCompiler compiler) {
  if (isAssignmentOp(n)) {
    return true;
  }

  switch(n.getType()) {
    case Token.DELPROP:
    case Token.DEC:
    case Token.INC:
    case Token.THROW:
      return true;
    case Token.CALL:
      return NodeUtil.functionCallHasSideEffects(n, compiler);
    case Token.NEW:
      return NodeUtil.constructorCallHasSideEffects(n, compiler);
    case Token.NAME:
      // A variable definition.
      return n.hasChildren();
    default:
      return false;
  }
}
 

static boolean nodeTypeMayHaveSideEffects(Node n, AbstractCompiler compiler) {
  if (isAssignmentOp(n)) {
    return true;
  }

  switch(n.getType()) {
    case Token.DELPROP:
    case Token.DEC:
    case Token.INC:
    case Token.THROW:
      return true;
    case Token.CALL:
      return NodeUtil.functionCallHasSideEffects(n, compiler);
    case Token.NEW:
      return NodeUtil.constructorCallHasSideEffects(n, compiler);
    case Token.NAME:
      // A variable definition.
      return n.hasChildren();
    default:
      return false;
  }
}
 

static boolean nodeTypeMayHaveSideEffects(Node n, AbstractCompiler compiler) {
  if (isAssignmentOp(n)) {
    return true;
  }

  switch(n.getType()) {
    case Token.DELPROP:
    case Token.DEC:
    case Token.INC:
    case Token.THROW:
      return true;
    case Token.CALL:
      return NodeUtil.functionCallHasSideEffects(n, compiler);
    case Token.NEW:
      return NodeUtil.constructorCallHasSideEffects(n, compiler);
    case Token.NAME:
      // A variable definition.
      return n.hasChildren();
    default:
      return false;
  }
}
 

static boolean nodeTypeMayHaveSideEffects(Node n, AbstractCompiler compiler) {
  if (isAssignmentOp(n)) {
    return true;
  }

  switch(n.getType()) {
    case Token.DELPROP:
    case Token.DEC:
    case Token.INC:
    case Token.THROW:
      return true;
    case Token.CALL:
      return NodeUtil.functionCallHasSideEffects(n, compiler);
    case Token.NEW:
      return NodeUtil.constructorCallHasSideEffects(n, compiler);
    case Token.NAME:
      // A variable definition.
      return n.hasChildren();
    default:
      return false;
  }
}
 

static boolean nodeTypeMayHaveSideEffects(Node n, AbstractCompiler compiler) {
  if (isAssignmentOp(n)) {
    return true;
  }

  switch(n.getType()) {
    case Token.DELPROP:
    case Token.DEC:
    case Token.INC:
    case Token.THROW:
      return true;
    case Token.CALL:
      return NodeUtil.functionCallHasSideEffects(n, compiler);
    case Token.NEW:
      return NodeUtil.constructorCallHasSideEffects(n, compiler);
    case Token.NAME:
      // A variable definition.
      return n.hasChildren();
    default:
      return false;
  }
}
 

private boolean statementMustExitParent(Node n) {
  switch (n.getType()) {
    case Token.THROW:
    case Token.RETURN:
      return true;
    case Token.BLOCK:
      if (n.hasChildren()) {
        Node child = n.getLastChild();
        return statementMustExitParent(child);
      }
      return false;
    // TODO(johnlenz): handle TRY/FINALLY
    case Token.FUNCTION:
    default:
      return false;
  }
}
 

/**
 * Determines if the subtree might throw an exception.
 */
public static boolean mayThrowException(Node n) {
  switch (n.getType()) {
    case Token.CALL:
    case Token.GETPROP:
    case Token.GETELEM:
    case Token.THROW:
    case Token.NEW:
    case Token.ASSIGN:
    case Token.INC:
    case Token.DEC:
    case Token.INSTANCEOF:
      return true;
    case Token.FUNCTION:
      return false;
  }
  for (Node c = n.getFirstChild(); c != null; c = c.getNext()) {
    if (!ControlFlowGraph.isEnteringNewCfgNode(c) && mayThrowException(c)) {
      return true;
    }
  }
  return false;
}
 

static boolean nodeTypeMayHaveSideEffects(Node n, AbstractCompiler compiler) {
  if (isAssignmentOp(n)) {
    return true;
  }

  switch(n.getType()) {
    case Token.DELPROP:
    case Token.DEC:
    case Token.INC:
    case Token.THROW:
      return true;
    case Token.CALL:
      return NodeUtil.functionCallHasSideEffects(n, compiler);
    case Token.NEW:
      return NodeUtil.constructorCallHasSideEffects(n, compiler);
    case Token.NAME:
      // A variable definition.
      return n.hasChildren();
    default:
      return false;
  }
}
 

private boolean statementMustExitParent(Node n) {
  switch (n.getType()) {
    case Token.THROW:
    case Token.RETURN:
      return true;
    case Token.BLOCK:
      if (n.hasChildren()) {
        Node child = n.getLastChild();
        return statementMustExitParent(child);
      }
      return false;
    // TODO(johnlenz): handle TRY/FINALLY
    case Token.FUNCTION:
    default:
      return false;
  }
}
 

private boolean canFuseIntoOneStatement(Node block) {
  // Fold only statement block. NOT scripts block.
  if (!block.isBlock()) {
    return false;
  }

  // Nothing to do here.
  if (!block.hasChildren() || block.hasOneChild()) {
    return false;
  }

  Node last = block.getLastChild();

  for (Node c = block.getFirstChild(); c != null; c = c.getNext()) {
    if (!c.isExprResult() && c != last) {
      return false;
    }
  }

  // TODO(user): Support more control statement for fusion.
  // FOR
  switch(last.getType()) {
    case Token.IF:
    case Token.THROW:
    case Token.SWITCH:
    case Token.EXPR_RESULT:
      return true;
    case Token.RETURN:
      // We don't want to add a new return value.
      return last.hasChildren();
    case Token.FOR:
      return NodeUtil.isForIn(last) &&
          // Avoid cases where we have for(var x = foo() in a) { ....
          !mayHaveSideEffects(last.getFirstChild());
  }

  return false;
}
 

private void fuseIntoOneStatement(Node block) {
  Node cur = block.removeFirstChild();

  // Starts building a tree.
  Node commaTree = cur.removeFirstChild();


  while (block.hasMoreThanOneChild()) {
    Node next = block.removeFirstChild().removeFirstChild();
    commaTree = fuseExpressionIntoExpression(commaTree, next);
  }

  Preconditions.checkState(block.hasOneChild());
  Node last = block.getLastChild();

  // Now we are just left with two statements. The comma tree of the first
  // n - 1 statements (which can be used in an expression) and the last
  // statement. We perform specific fusion based on the last statement's type.
  switch(last.getType()) {
    case Token.IF:
    case Token.RETURN:
    case Token.THROW:
    case Token.SWITCH:
    case Token.EXPR_RESULT:
      fuseExpresssonIntoFirstChild(commaTree, last);
      return;
    case Token.FOR:
      if (NodeUtil.isForIn(last)) {
        fuseExpresssonIntoSecondChild(commaTree, last);
      }
      return ;
    default:
      throw new IllegalStateException("Statement fusion missing.");
  }
}
 

@Override
public void visit(NodeTraversal t, Node n, Node parent) {
  switch (n.getType()) {
    case Token.IF:
      handleIf(n);
      return;
    case Token.WHILE:
      handleWhile(n);
      return;
    case Token.DO:
      handleDo(n);
      return;
    case Token.FOR:
      handleFor(n);
      return;
    case Token.SWITCH:
      handleSwitch(n);
      return;
    case Token.CASE:
      handleCase(n);
      return;
    case Token.DEFAULT_CASE:
      handleDefault(n);
      return;
    case Token.BLOCK:
    case Token.SCRIPT:
      handleStmtList(n);
      return;
    case Token.FUNCTION:
      handleFunction(n);
      return;
    case Token.EXPR_RESULT:
      handleExpr(n);
      return;
    case Token.THROW:
      handleThrow(n);
      return;
    case Token.TRY:
      handleTry(n);
      return;
    case Token.CATCH:
      handleCatch(n);
      return;
    case Token.BREAK:
      handleBreak(n);
      return;
    case Token.CONTINUE:
      handleContinue(n);
      return;
    case Token.RETURN:
      handleReturn(n);
      return;
    case Token.WITH:
      handleWith(n);
      return;
    case Token.LABEL:
      return;
    default:
      handleStmt(n);
      return;
  }
}
 

@Override
public void visit(NodeTraversal traversal, Node node, Node parent) {

  if (inExterns) {
    return;
  }

  if (!NodeUtil.nodeTypeMayHaveSideEffects(node)
      && !node.isReturn()) {
    return;
  }

  if (node.isCall() || node.isNew()) {
    allFunctionCalls.add(node);
  }

  Node enclosingFunction = traversal.getEnclosingFunction();
  if (enclosingFunction != null) {
    FunctionInformation sideEffectInfo =
        functionSideEffectMap.get(enclosingFunction);
    Preconditions.checkNotNull(sideEffectInfo);

    if (NodeUtil.isAssignmentOp(node)) {
      visitAssignmentOrUnaryOperator(
          sideEffectInfo, traversal.getScope(),
          node, node.getFirstChild(), node.getLastChild());
    } else {
      switch(node.getType()) {
        case Token.CALL:
        case Token.NEW:
          visitCall(sideEffectInfo, node);
          break;
        case Token.DELPROP:
        case Token.DEC:
        case Token.INC:
          visitAssignmentOrUnaryOperator(
              sideEffectInfo, traversal.getScope(),
              node, node.getFirstChild(), null);
          break;
        case Token.NAME:
          // Variable definition are not side effects.
          // Just check that the name appears in the context of a
          // variable declaration.
          Preconditions.checkArgument(
              NodeUtil.isVarDeclaration(node));
          Node value = node.getFirstChild();
          // Assignment to local, if the value isn't a safe local value,
          // new object creation or literal or known primitive result
          // value, add it to the local blacklist.
          if (value != null && !NodeUtil.evaluatesToLocalValue(value)) {
            Scope scope = traversal.getScope();
            Var var = scope.getVar(node.getString());
            sideEffectInfo.blacklistLocal(var);
          }
          break;
        case Token.THROW:
          visitThrow(sideEffectInfo);
          break;
        case Token.RETURN:
          if (node.hasChildren()
              && !NodeUtil.evaluatesToLocalValue(node.getFirstChild())) {
            sideEffectInfo.setTaintsReturn();
          }
          break;
        default:
          throw new IllegalArgumentException(
              "Unhandled side effect node type " +
              Token.name(node.getType()));
      }
    }
  }
}
 

@Override
public boolean shouldTraverse(
    NodeTraversal nodeTraversal, Node n, Node parent) {
  astPosition.put(n, astPositionCounter++);

  switch (n.getType()) {
    case Token.FUNCTION:
      if (shouldTraverseFunctions || n == cfg.getEntry().getValue()) {
        exceptionHandler.push(n);
        return true;
      }
      return false;
    case Token.TRY:
      exceptionHandler.push(n);
      return true;
  }

  /*
   * We are going to stop the traversal depending on what the node's parent
   * is.
   *
   * We are only interested in adding edges between nodes that change control
   * flow. The most obvious ones are loops and IF-ELSE's. A statement
   * transfers control to its next sibling.
   *
   * In case of an expression tree, there is no control flow within the tree
   * even when there are short circuited operators and conditionals. When we
   * are doing data flow analysis, we will simply synthesize lattices up the
   * expression tree by finding the meet at each expression node.
   *
   * For example: within a Token.SWITCH, the expression in question does not
   * change the control flow and need not to be considered.
   */
  if (parent != null) {
    switch (parent.getType()) {
      case Token.FOR:
        // Only traverse the body of the for loop.
        return n == parent.getLastChild();

      // Skip the conditions.
      case Token.IF:
      case Token.WHILE:
      case Token.WITH:
        return n != parent.getFirstChild();
      case Token.DO:
        return n != parent.getFirstChild().getNext();
      // Only traverse the body of the cases
      case Token.SWITCH:
      case Token.CASE:
      case Token.CATCH:
      case Token.LABEL:
        return n != parent.getFirstChild();
      case Token.FUNCTION:
        return n == parent.getFirstChild().getNext().getNext();
      case Token.CONTINUE:
      case Token.BREAK:
      case Token.EXPR_RESULT:
      case Token.VAR:
      case Token.RETURN:
      case Token.THROW:
        return false;
      case Token.TRY:
        /* Just before we are about to visit the second child of the TRY node,
         * we know that we will be visiting either the CATCH or the FINALLY.
         * In other words, we know that the post order traversal of the TRY
         * block has been finished, no more exceptions can be caught by the
         * handler at this TRY block and should be taken out of the stack.
         */
        if (n == parent.getFirstChild().getNext()) {
          Preconditions.checkState(exceptionHandler.peek() == parent);
          exceptionHandler.pop();
        }
    }
  }
  return true;
}
 

@Override
public boolean shouldTraverse(
    NodeTraversal nodeTraversal, Node n, Node parent) {
  astPosition.put(n, astPositionCounter++);

  switch (n.getType()) {
    case Token.FUNCTION:
      if (shouldTraverseFunctions || n == cfg.getEntry().getValue()) {
        exceptionHandler.push(n);
        return true;
      }
      return false;
    case Token.TRY:
      exceptionHandler.push(n);
      return true;
  }

  /*
   * We are going to stop the traversal depending on what the node's parent
   * is.
   *
   * We are only interested in adding edges between nodes that change control
   * flow. The most obvious ones are loops and IF-ELSE's. A statement
   * transfers control to its next sibling.
   *
   * In case of an expression tree, there is no control flow within the tree
   * even when there are short circuited operators and conditionals. When we
   * are doing data flow analysis, we will simply synthesize lattices up the
   * expression tree by finding the meet at each expression node.
   *
   * For example: within a Token.SWITCH, the expression in question does not
   * change the control flow and need not to be considered.
   */
  if (parent != null) {
    switch (parent.getType()) {
      case Token.FOR:
        // Only traverse the body of the for loop.
        return n == parent.getLastChild();

      // Skip the conditions.
      case Token.IF:
      case Token.WHILE:
      case Token.WITH:
        return n != parent.getFirstChild();
      case Token.DO:
        return n != parent.getFirstChild().getNext();
      // Only traverse the body of the cases
      case Token.SWITCH:
      case Token.CASE:
      case Token.CATCH:
      case Token.LABEL:
        return n != parent.getFirstChild();
      case Token.FUNCTION:
        return n == parent.getFirstChild().getNext().getNext();
      case Token.CONTINUE:
      case Token.BREAK:
      case Token.EXPR_RESULT:
      case Token.VAR:
      case Token.RETURN:
      case Token.THROW:
        return false;
      case Token.TRY:
        /* Just before we are about to visit the second child of the TRY node,
         * we know that we will be visiting either the CATCH or the FINALLY.
         * In other words, we know that the post order traversal of the TRY
         * block has been finished, no more exceptions can be caught by the
         * handler at this TRY block and should be taken out of the stack.
         */
        if (n == parent.getFirstChild().getNext()) {
          Preconditions.checkState(exceptionHandler.peek() == parent);
          exceptionHandler.pop();
        }
    }
  }
  return true;
}
 

public void validateStatement(Node n) {
  switch (n.getType()) {
    case Token.LABEL:
      validateLabel(n);
      return;
    case Token.BLOCK:
      validateBlock(n);
      return;
    case Token.FUNCTION:
      validateFunctionStatement(n);
      return;
    case Token.WITH:
      validateWith(n);
      return;
    case Token.FOR:
      validateFor(n);
      return;
    case Token.WHILE:
      validateWhile(n);
      return;
    case Token.DO:
      validateDo(n);
      return;
    case Token.SWITCH:
      validateSwitch(n);
      return;
    case Token.IF:
      validateIf(n);
      return;
    case Token.VAR:
      validateVar(n);
      return;
    case Token.EXPR_RESULT:
      validateExprStmt(n);
      return;
    case Token.RETURN:
      validateReturn(n);
      return;
    case Token.THROW:
      validateThrow(n);
      return;
    case Token.TRY:
      validateTry(n);
      return;
    case Token.BREAK:
      validateBreak(n);
      return;
    case Token.CONTINUE:
      validateContinue(n);
      return;
    case Token.EMPTY:
      validateChildless(n);
      return;
    case Token.DEBUGGER:
      validateChildless(n);
      return;
    default:
      violation("Expected statement but was "
          + Token.name(n.getType()) + ".", n);
  }
}
 

@Override
public boolean shouldTraverse(
    NodeTraversal nodeTraversal, Node n, Node parent) {
  astPosition.put(n, astPositionCounter++);

  switch (n.getType()) {
    case Token.FUNCTION:
      if (shouldTraverseFunctions || n == cfg.getEntry().getValue()) {
        exceptionHandler.push(n);
        return true;
      }
      return false;
    case Token.TRY:
      exceptionHandler.push(n);
      return true;
  }

  /*
   * We are going to stop the traversal depending on what the node's parent
   * is.
   *
   * We are only interested in adding edges between nodes that change control
   * flow. The most obvious ones are loops and IF-ELSE's. A statement
   * transfers control to its next sibling.
   *
   * In case of an expression tree, there is no control flow within the tree
   * even when there are short circuited operators and conditionals. When we
   * are doing data flow analysis, we will simply synthesize lattices up the
   * expression tree by finding the meet at each expression node.
   *
   * For example: within a Token.SWITCH, the expression in question does not
   * change the control flow and need not to be considered.
   */
  if (parent != null) {
    switch (parent.getType()) {
      case Token.FOR:
        // Only traverse the body of the for loop.
        return n == parent.getLastChild();

      // Skip the conditions.
      case Token.IF:
      case Token.WHILE:
      case Token.WITH:
        return n != parent.getFirstChild();
      case Token.DO:
        return n != parent.getFirstChild().getNext();
      // Only traverse the body of the cases
      case Token.SWITCH:
      case Token.CASE:
      case Token.CATCH:
      case Token.LABEL:
        return n != parent.getFirstChild();
      case Token.FUNCTION:
        return n == parent.getFirstChild().getNext().getNext();
      case Token.CONTINUE:
      case Token.BREAK:
      case Token.EXPR_RESULT:
      case Token.VAR:
      case Token.RETURN:
      case Token.THROW:
        return false;
      case Token.TRY:
        /* Just before we are about to visit the second child of the TRY node,
         * we know that we will be visiting either the CATCH or the FINALLY.
         * In other words, we know that the post order traversal of the TRY
         * block has been finished, no more exceptions can be caught by the
         * handler at this TRY block and should be taken out of the stack.
         */
        if (n == parent.getFirstChild().getNext()) {
          Preconditions.checkState(exceptionHandler.peek() == parent);
          exceptionHandler.pop();
        }
    }
  }
  return true;
}
 

@Override
public void visit(NodeTraversal t, Node n, Node parent) {
  switch (n.getType()) {
    case Token.IF:
      handleIf(n);
      return;
    case Token.WHILE:
      handleWhile(n);
      return;
    case Token.DO:
      handleDo(n);
      return;
    case Token.FOR:
      handleFor(n);
      return;
    case Token.SWITCH:
      handleSwitch(n);
      return;
    case Token.CASE:
      handleCase(n);
      return;
    case Token.DEFAULT_CASE:
      handleDefault(n);
      return;
    case Token.BLOCK:
    case Token.SCRIPT:
      handleStmtList(n);
      return;
    case Token.FUNCTION:
      handleFunction(n);
      return;
    case Token.EXPR_RESULT:
      handleExpr(n);
      return;
    case Token.THROW:
      handleThrow(n);
      return;
    case Token.TRY:
      handleTry(n);
      return;
    case Token.CATCH:
      handleCatch(n);
      return;
    case Token.BREAK:
      handleBreak(n);
      return;
    case Token.CONTINUE:
      handleContinue(n);
      return;
    case Token.RETURN:
      handleReturn(n);
      return;
    case Token.WITH:
      handleWith(n);
      return;
    case Token.LABEL:
      return;
    default:
      handleStmt(n);
      return;
  }
}