Java Token.LABEL属性代码示例

/**
 * 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;
  }
}
 

/**
 * @return Whether the node is used as a statement.
 */
static boolean isStatement(Node n) {
  Node parent = n.getParent();
  // It is not possible to determine definitely if a node is a statement
  // or not if it is not part of the AST.  A FUNCTION node, for instance,
  // is either part of an expression (as a anonymous function) or as
  // a statement.
  Preconditions.checkState(parent != null);
  switch (parent.getType()) {
    case Token.SCRIPT:
    case Token.BLOCK:
    case Token.LABEL:
      return true;
    default:
      return false;
  }
}
 

/**
 * @return For the subExpression, find the nearest statement Node before which
 * it can be inlined.  Null if no such location can be found.
 */
static Node findInjectionPoint(Node subExpression) {
  Node expressionRoot = findExpressionRoot(subExpression);
  Preconditions.checkNotNull(expressionRoot);

  Node injectionPoint = expressionRoot;

  Node parent = injectionPoint.getParent();
  while (parent.getType() == Token.LABEL) {
    injectionPoint = parent;
    parent = injectionPoint.getParent();
  }

  Preconditions.checkState(
      NodeUtil.isStatementBlock(injectionPoint.getParent()));
  return injectionPoint;
}
 

/**
 * Limit the number of special cases where LABELs need to be handled. Only
 * BLOCK and loops are allowed to be labeled.  Loop labels must remain in
 * place as the named continues are not allowed for labeled blocks.
 */
private void normalizeLabels(Node n) {
  Preconditions.checkArgument(n.getType() == Token.LABEL);

  Node last = n.getLastChild();
  switch (last.getType()) {
    case Token.LABEL:
    case Token.BLOCK:
    case Token.FOR:
    case Token.WHILE:
    case Token.DO:
      return;
    default:
      Node block = new Node(Token.BLOCK);
      n.replaceChild(last, block);
      block.addChildToFront(last);
      reportCodeChange("LABEL normalization");
      return;
  }
}
 

/**
 * shouldTraverse is call when descending into the Node tree, so it is used
 * here to build the context for label renames.
 *
 * {@inheritDoc}
 */
public boolean shouldTraverse(NodeTraversal nodeTraversal, Node node,
    Node parent) {
  if (node.getType() == Token.LABEL) {
    // Determine the new name for this label.
    LabelNamespace current = namespaceStack.peek();
    int currentDepth = current.renameMap.size() + 1;
    String name = node.getFirstChild().getString();

    // Store the context for this label name.
    LabelInfo li = new LabelInfo(currentDepth);
    Preconditions.checkState(!current.renameMap.containsKey(name));
    current.renameMap.put(name, li);

    // Create a new name, if needed, for this depth.
    if (names.size() < currentDepth) {
      names.add(nameGenerator.generateNextName());
    }

    String newName = getNameForId(currentDepth);
    compiler.addToDebugLog("label renamed: " + name + " => " + newName);
  }

  return true;
}
 

private FlowState<LiveVariablesAnalysis.LiveVariableLattice> getFlowStateAtX(
    Node node, ControlFlowGraph<Node> cfg) {
  if (node.getType() == Token.LABEL) {
    if (node.getFirstChild().getString().equals("X")) {
      return cfg.getNode(node.getLastChild()).getAnnotation();
    }
  }
  for (Node c = node.getFirstChild(); c != null; c = c.getNext()) {
    FlowState<LiveVariablesAnalysis.LiveVariableLattice> state =
        getFlowStateAtX(c, cfg);
    if (state != null) {
      return state;
    }
  }
  return null;
}
 

@Override public void visit(NodeTraversal t, Node n, Node parent) {
  if (n.getType() == Token.WITH) {
    t.report(n, WITH_DISALLOWED);
  } else if (n.getType() == Token.NAME) {
    if (!NodeUtil.isLabelName(n) && !isDeclaration(n)) {
      checkNameUse(t, n);
    }
  } else if (n.getType() == Token.ASSIGN) {
    checkAssignment(t, n);
  } else if (n.getType() == Token.DELPROP) {
    checkDelete(t, n);
  } else if (n.getType() == Token.OBJECTLIT) {
    checkObjectLiteral(t, n);
  } else if (n.getType() == Token.LABEL) {
    checkLabel(t, n);
  }
}
 

/**
 * Computes the destination node of n when we want to fallthough into the
 * subtree of n. We don't always create a CFG edge into n itself because of
 * DOs and FORs.
 */
private static Node computeFallThrough(Node n) {
  switch (n.getType()) {
    case Token.DO:
      return computeFallThrough(n.getFirstChild());
    case Token.FOR:
      if (NodeUtil.isForIn(n)) {
        return n;
      }
      return computeFallThrough(n.getFirstChild());
    case Token.LABEL:
      return computeFallThrough(n.getLastChild());
    default:
      return n;
  }
}
 

/**
 * Do normalizations that introduce new siblings or parents.
 */
private void doStatementNormalizations(
    NodeTraversal t, Node n, Node parent) {
  if (n.getType() == Token.LABEL) {
    normalizeLabels(n);
  }

  // Only inspect the children of SCRIPTs, BLOCKs and LABELs, as all these
  // are the only legal place for VARs and FOR statements.
  if (NodeUtil.isStatementBlock(n) || n.getType() == Token.LABEL) {
    extractForInitializer(n, null, null);
  }

  // Only inspect the children of SCRIPTs, BLOCKs, as all these
  // are the only legal place for VARs.
  if (NodeUtil.isStatementBlock(n)) {
    splitVarDeclarations(n);
  }

  if (n.getType() == Token.FUNCTION) {
    moveNamedFunctions(n.getLastChild());
  }
}
 

@Override
public void visit(NodeTraversal t, Node n, Node parent) {
  if (n.getType() == Token.LABEL) {
    if (n.getFirstChild().getString().equals("D")) {
      def = n.getLastChild();
    } else if (n.getFirstChild().getString().equals("U")) {
      use = n.getLastChild();
    }
  }
}
 

/** @return Whether the node is a label name. */
static boolean isLabelName(Node n) {
  if (n != null && n.getType() == Token.NAME) {
    Node parent = n.getParent();
    switch (parent.getType()) {
      case Token.LABEL:
      case Token.BREAK:
      case Token.CONTINUE:
        if (n == parent.getFirstChild()) {
          return true;
        }
    }
  }
  return false;
}
 

/** Safely remove children while maintaining a valid node structure. */
static void removeChild(Node parent, Node node) {
  // Node parent = node.getParent();
  if (isStatementBlock(parent)
      || isSwitchCase(node)
      || isTryFinallyNode(parent, node)) {
    // A statement in a block can simply be removed.
    parent.removeChild(node);
  } else if (parent.getType() == Token.VAR) {
    if (parent.hasMoreThanOneChild()) {
      parent.removeChild(node);
    } else {
      // Remove the node from the parent, so it can be reused.
      parent.removeChild(node);
      // This would leave an empty VAR, remove the VAR itself.
      removeChild(parent.getParent(), parent);
    }
  } else if (node.getType() == Token.BLOCK) {
    // Simply empty the block.  This maintains source location and
    // "synthetic"-ness.
    node.detachChildren();
  } else if (parent.getType() == Token.LABEL
      && node == parent.getLastChild()) {
    // Remove the node from the parent, so it can be reused.
    parent.removeChild(node);
    // A LABEL without children can not be referred to, remove it.
    removeChild(parent.getParent(), parent);
  } else if (parent.getType() == Token.FOR
      && parent.getChildCount() == 4) {
    // Only Token.FOR can have an Token.EMPTY other control structure
    // need something for the condition. Others need to be replaced
    // or the structure removed.
    parent.replaceChild(node, new Node(Token.EMPTY));
  } else {
    throw new IllegalStateException("Invalid attempt to remove node: " +
        node.toString() + " of "+ parent.toString());
  }
}
 

@Override
public void visit(NodeTraversal t, Node n, Node parent) {
  if (n.getType() == Token.LABEL) {
    if (n.getFirstChild().getString().equals("D")) {
      def = n.getLastChild();
    } else if (n.getFirstChild().getString().startsWith("U")) {
      uses.add(n.getLastChild());
    }
  }
}
 

/**
 * Bring the initializers out of FOR loops.  These need to be placed
 * before any associated LABEL nodes. This needs to be done from the top
 * level label first so this is called as a pre-order callback (from
 * shouldTraverse).
 *
 * @param n The node to inspect.
 * @param before The node to insert the initializer before.
 * @param beforeParent The parent of the node before which the initializer
 *     will be inserted.
 */
private void extractForInitializer(
    Node n, Node before, Node beforeParent) {

  for (Node next, c = n.getFirstChild(); c != null; c = next) {
    next = c.getNext();
    Node insertBefore = (before == null) ? c : before;
    Node insertBeforeParent = (before == null) ? n : beforeParent;
    switch (c.getType()) {
      case Token.LABEL:
        extractForInitializer(c, insertBefore, insertBeforeParent);
        break;
      case Token.FOR:
        if (!NodeUtil.isForIn(c)
            && c.getFirstChild().getType() != Token.EMPTY) {
          Node init = c.getFirstChild();
          c.replaceChild(init, new Node(Token.EMPTY));

          Node newStatement;
          // Only VAR statements, and expressions are allowed,
          // but are handled differently.
          if (init.getType() == Token.VAR) {
            newStatement = init;
          } else {
            newStatement = NodeUtil.newExpr(init);
          }

          insertBeforeParent.addChildBefore(newStatement, insertBefore);
          reportCodeChange("FOR initializer");
        }
        break;
    }
  }
}
 

@Override
public void visit(NodeTraversal t, Node n, Node parent) {
  switch (n.getType()) {
    case Token.LABEL:
      tryMinimizeExits(
          n.getLastChild(), Token.BREAK, n.getFirstChild().getString());
      break;

    case Token.FOR:
    case Token.WHILE:
      tryMinimizeExits(
          NodeUtil.getLoopCodeBlock(n), Token.CONTINUE, null);
      break;

    case Token.DO:
      tryMinimizeExits(
          NodeUtil.getLoopCodeBlock(n), Token.CONTINUE, null);

      Node cond = NodeUtil.getConditionExpression(n);
      if (NodeUtil.isLiteralValue(cond) && !NodeUtil.getBooleanValue(cond)) {
        // Normally, we wouldn't be able to optimize BREAKs inside a loop
        // but as we know the condition will always false, we can treat them
        // as we would a CONTINUE.
        tryMinimizeExits(
            n.getFirstChild(), Token.BREAK, null);
      }
      break;

    case Token.FUNCTION:
      tryMinimizeExits(
          n.getLastChild(), Token.RETURN, null);
      break;
  }
}