Java Token.CATCH属性代码示例

private void removeDeadExprStatementSafely(Node n, Node parent) {
  if (n.getType() == Token.EMPTY ||
      (n.getType() == Token.BLOCK && !n.hasChildren())) {
    // Not always trivial to remove, let FoldContants work its magic later.
    return;
  }
  // Removing an unreachable DO node is messy because it means we still have
  // to execute one iteration. If the DO's body has breaks in the middle, it
  // can get even more trickier and code size might actually increase.
  switch (n.getType()) {
    case Token.DO:
    case Token.TRY:
    case Token.CATCH:
    case Token.FINALLY:
      return;
  }

  NodeUtil.redeclareVarsInsideBranch(n);
  compiler.reportCodeChange();
  if (logger.isLoggable(Level.FINE)) {
    logger.fine("Removing " + n.toString());
  }
  NodeUtil.removeChild(parent, n);
}
 

/**
 * Determines whether the given node is a FOR, DO, WHILE, WITH, or IF node.
 */
static boolean isControlStructure(Node n) {
  switch (n.getType()) {
    case Token.FOR:
    case Token.DO:
    case Token.WHILE:
    case Token.WITH:
    case Token.IF:
    case Token.LABEL:
    case Token.TRY:
    case Token.CATCH:
    case Token.SWITCH:
    case Token.CASE:
    case Token.DEFAULT:
      return true;
    default:
      return false;
  }
}
 

/**
 * Determines whether the given node is code node for FOR, DO,
 * WHILE, WITH, or IF node.
 */
static boolean isControlStructureCodeBlock(Node parent, Node n) {
  switch (parent.getType()) {
    case Token.FOR:
    case Token.WHILE:
    case Token.LABEL:
    case Token.WITH:
      return parent.getLastChild() == n;
    case Token.DO:
      return parent.getFirstChild() == n;
    case Token.IF:
      return parent.getFirstChild() != n;
    case Token.TRY:
      return parent.getFirstChild() == n || parent.getLastChild() == n;
    case Token.CATCH:
      return parent.getLastChild() == n;
    case Token.SWITCH:
    case Token.CASE:
      return parent.getFirstChild() != n;
    case Token.DEFAULT:
      return true;
    default:
      Preconditions.checkState(isControlStructure(parent));
      return false;
  }
}
 

/**
 * Visit a node in a local scope, and add any local variables or catch
 * parameters into the local symbol table.
 *
 * @param t The node traversal.
 * @param n The node being visited.
 * @param parent The parent of n
 */
@Override public void visit(NodeTraversal t, Node n, Node parent) {
  if (n == scope.getRootNode()) return;

  if (n.getType() == Token.LP && parent == scope.getRootNode()) {
    handleFunctionInputs(parent);
    return;
  }

  switch (n.getType()) {
    case Token.FUNCTION:
      // VARs and ASSIGNs are handled separately.
      if (parent.getType() == Token.NAME) {
        return;
      }
      define(n, parent);
      break;

    case Token.CATCH:
    case Token.VAR:
      define(n, parent);
      break;
  }
}
 

@Override
Node processCatchClause(CatchClause clauseNode) {
  AstNode catchVar = clauseNode.getVarName();
  Node node = new Node(Token.CATCH, transform(catchVar));
  if (clauseNode.getCatchCondition() != null) {
    node.addChildToBack(transform(clauseNode.getCatchCondition()));
  } else {
    Node catchCondition = new Node(Token.EMPTY);
    // Old Rhino used the position of the catchVar as the position
    // for the (nonexistent) error being caught.
    catchCondition.setLineno(catchVar.getLineno());
    int clauseAbsolutePosition =
        position2charno(catchVar.getAbsolutePosition());
    catchCondition.setCharno(clauseAbsolutePosition);
    node.addChildToBack(catchCondition);
  }
  node.addChildToBack(transform(clauseNode.getBody()));
  return node;
}
 

/**
 * Traverses a branch.
 */
@SuppressWarnings("fallthrough")
private void traverseBranch(Node n, Node parent) {
  int type = n.getType();
  if (type == Token.SCRIPT) {
    sourceName = getSourceName(n);
  }

  curNode = n;
  if (!callback.shouldTraverse(this, n, parent)) return;

  switch (type) {
    case Token.CATCH:
      Preconditions.checkState(n.getChildCount() == 3);
      Preconditions.checkState(n.getFirstChild().getType() == Token.NAME);
      // the first child is the catch var and the third child
      // is the code block
      traverseBranch(n.getFirstChild(), n);
      traverseBranch(n.getFirstChild().getNext().getNext(), n);
      break;

    case Token.FUNCTION:
      traverseFunction(n, parent);
      break;

    default:
      for (Node child = n.getFirstChild(); child != null; ) {
        // child could be replaced, in which case our child node
        // would no longer point to the true next
        Node next = child.getNext();
        traverseBranch(child, n);
        child = next;
      }
      break;
  }

  curNode = n;
  callback.visit(this, n, parent);
}
 

/**
 * Is the {@link Node} currently within a 'throw' expression?
 */
private static boolean isInThrowExpression(Node n) {
  // Look up the traversal stack to find a THROW node
  for (Node ancestor : n.getAncestors()) {
    switch (ancestor.getType()) {
      case Token.THROW:
        return true;
      case Token.IF:
      case Token.WHILE:
      case Token.DO:
      case Token.FOR:
      case Token.SWITCH:
      case Token.CASE:
      case Token.DEFAULT:
      case Token.BLOCK:
      case Token.SCRIPT:
      case Token.FUNCTION:
      case Token.TRY:
      case Token.CATCH:
      case Token.RETURN:
      case Token.EXPR_RESULT:
        // early exit - these nodes types can't be within a THROW
        return false;
    }
  }
  return false;
}
 

public void onRedeclaration(
    Scope s, String name,
    Node n, Node parent, Node gramps, Node nodeWithLineNumber) {
  // Don't allow multiple variables to be declared at the top level scope
  if (scope.isGlobal()) {
    Scope.Var origVar = scope.getVar(name);
    Node origParent = origVar.getParentNode();
    if (origParent.getType() == Token.CATCH &&
        parent.getType() == Token.CATCH) {
      // Okay, both are 'catch(x)' variables.
      return;
    }

    boolean allowDupe = false;
    JSDocInfo info = n.getJSDocInfo();
    if (info == null) {
      info = parent.getJSDocInfo();
    }
    allowDupe =
        info != null && info.getSuppressions().contains("duplicate");

    if (!allowDupe) {
      compiler.report(
          JSError.make(sourceName, nodeWithLineNumber,
                       VAR_MULTIPLY_DECLARED_ERROR,
                       name,
                       (origVar.input != null
                        ? origVar.input.getName()
                        : "??")));
    }
  }
}
 

/**
 * Visits a NAME node.
 *
 * @param t The node traversal object that supplies context, such as the
 * scope chain to use in name lookups as well as error reporting.
 * @param n The node being visited.
 * @param parent The parent of the node n.
 * @return whether the node is typeable or not
 */
boolean visitName(NodeTraversal t, Node n, Node parent) {
  // At this stage, we need to determine whether this is a leaf
  // node in an expression (which therefore needs to have a type
  // assigned for it) versus some other decorative node that we
  // can safely ignore.  Function names, arguments (children of LP nodes) and
  // variable declarations are ignored.
  // TODO(user): remove this short-circuiting in favor of a
  // pre order traversal of the FUNCTION, CATCH, LP and VAR nodes.
  int parentNodeType = parent.getType();
  if (parentNodeType == Token.FUNCTION ||
      parentNodeType == Token.CATCH ||
      parentNodeType == Token.LP ||
      parentNodeType == Token.VAR) {
    return false;
  }

  JSType type = n.getJSType();
  if (type == null) {
    type = getNativeType(UNKNOWN_TYPE);
    Var var = t.getScope().getVar(n.getString());
    if (var != null) {
      JSType varType = var.getType();
      if (varType != null) {
        type = varType;
      }
    }
  }
  ensureTyped(t, n, type);
  return true;
}
 

/**
 * Gather any names declared in the local scope.
 */
private static void gatherLocalNames(Node n, Set<String> names) {
  Preconditions.checkState(n.getType() != Token.FUNCTION);
  if (n.getType() == Token.NAME) {
    switch (n.getParent().getType()) {
      case Token.VAR:
      case Token.CATCH:
        names.add(n.getString());
    }
  }

  for (Node c = n.getFirstChild(); c != null; c = c.getNext()) {
    gatherLocalNames(c, names);
  }
}
 

/**
 * Determines if the given name is a declaration, which can be a declaration
 * of a variable, function, or argument.
 */
private static boolean isDeclaration(Node n) {
  switch (n.getParent().getType()) {
    case Token.VAR:
    case Token.FUNCTION:
    case Token.CATCH:
      return true;

    case Token.LP:
      return n.getParent().getParent().getType() == Token.FUNCTION;

    default:
      return false;
  }
}
 

@Override
public void visit(NodeTraversal t, Node n, Node parent) {
  switch (n.getType()) {
    case Token.NAME:
      String newName = getReplacementName(n.getString());
      if (newName != null) {
        Renamer renamer = nameStack.peek();
        if (renamer.stripConstIfReplaced()) {
          // TODO(johnlenz): Do we need to do anything about the javadoc?
          n.removeProp(Node.IS_CONSTANT_NAME);
        }
        n.setString(newName);
        t.getCompiler().reportCodeChange();
      }
      break;

    case Token.FUNCTION:
      // Remove function recursive name (if any).
      nameStack.pop();
      break;

    case Token.CATCH:
      // Remove catch except name from the stack of names.
      nameStack.pop();
      break;
  }
}
 

/**
 * @return Whether BLOCK (from a TRY node) contains a CATCH.
 * @see NodeUtil#getCatchBlock
 */
static boolean hasCatchHandler(Node n) {
  Preconditions.checkArgument(n.getType() == Token.BLOCK);
  return n.hasChildren() && n.getFirstChild().getType() == Token.CATCH;
}
 

private void advanceLookAhead(boolean atStart) {
  if (!atStart) {
    if (lookAhead == null) {
      return;
    }

    // Don't advance past a refrence to the variable that we're trying
    // to inline.
    Node curNode = iterator.current();
    if (curNode.getType() == Token.NAME &&
        varName.equals(curNode.getString())) {
      lookAhead = null;
      return;
    }
  }

  if (!iterator.hasNext()) {
    lookAhead = null;
    return;
  }

  Node nextNode = iterator.next();
  Node nextParent = iterator.currentParent();
  int type = nextNode.getType();

  if (valueHasSideEffects) {
    // Reject anything that might read state, i.e. any NAME that is not
    // newly redeclared or an assignment to a simple name.

    if (type == Token.NAME && !varName.equals(nextNode.getString())) {
      boolean blocked = false;
      if (nextParent == null) {
        blocked = true;
      } else {
        boolean assignsName = (nextParent.getType() == Token.ASSIGN
                && nextNode == nextParent.getFirstChild());
        boolean isVarDeclaration = (nextParent.getType() == Token.VAR);

        if (!assignsName && !isVarDeclaration) {
          blocked = true;
        }
      }

      if (blocked) {
        lookAhead = null;
        return;
      }
    }
  }

  // Reject anything that might modify relevant state. We assume that
  // nobody relies on variables being undeclared, which will break
  // constructions like:
  //   var a = b;
  //   var b = 3;
  //   alert(a);
  if (NodeUtil.nodeTypeMayHaveSideEffects(nextNode) && type != Token.NAME
      || type == Token.NAME && nextParent.getType() == Token.CATCH) {
    lookAhead = null;
    return;
  }

  lookAhead = nextNode;
}
 

/**
 * @return True if n should be represented by a new CFG node in the control
 * flow graph.
 */
public static boolean isEnteringNewCfgNode(Node n) {
  Node parent = n.getParent();
  switch (parent.getType()) {
    case Token.BLOCK:
    case Token.SCRIPT:
    case Token.TRY:
    case Token.FINALLY:
      return true;
    case Token.FUNCTION:
      // A function node represents the start of a function where the name
      // is bleed into the local scope and parameters has been assigned
      // to the formal argument names. The node includes the name of the
      // function and the LP list since we assume the whole set up process
      // is atomic without change in control flow. The next change of
      // control is going into the function's body represent by the second
      // child.
      return n != parent.getFirstChild().getNext();
    case Token.WHILE:
    case Token.DO:
    case Token.IF:
      // Theses control structure is represented by its node that holds the
      // condition. Each of them is a branch node based on its condition.
      return NodeUtil.getConditionExpression(parent) != n;
      
    case Token.FOR:
      // The FOR(;;) node differs from other control structure in that
      // it has a initialization and a increment statement. Those
      // two statements have its corresponding CFG nodes to represent them.
      // The FOR node represents the condition check for each iteration.
      // That way the following:
      // for(var x = 0; x < 10; x++) { } has a graph that is isomorphic to
      // var x = 0; while(x<10) {  x++; }
      if (NodeUtil.isForIn(parent)) {
        return n == parent.getLastChild(); 
      } else {
        return NodeUtil.getConditionExpression(parent) != n;
      }
    case Token.SWITCH:
    case Token.CASE:
    case Token.CATCH:
    case Token.WITH:
      return n != parent.getFirstChild();
    default:
      return false;
  }
}