Java Code Examples for com.google.javascript.rhino.Node#isLabel()

/**
 * @return Whether the Node is a DO or FUNCTION (with or without
 * labels).
 */
private boolean isOneExactlyFunctionOrDo(Node n) {
  if (n.isLabel()) {
    Node labeledStatement = n.getLastChild();
    if (!labeledStatement.isBlock()) {
      return isOneExactlyFunctionOrDo(labeledStatement);
    } else {
      // For labels with block children, we need to ensure that a
      // labeled FUNCTION or DO isn't generated when extraneous BLOCKs
      // are skipped.
      if (getNonEmptyChildCount(n, 2) == 1) {
        return isOneExactlyFunctionOrDo(getFirstNonEmptyChild(n));
      } else {
        // Either a empty statement or an block with more than one child,
        // way it isn't a FUNCTION or DO.
        return false;
      }
    }
  } else {
    return (n.isFunction() || n.isDo());
  }
}
 

/**
 * Do normalizations that introduce new siblings or parents.
 */
private void doStatementNormalizations(
    NodeTraversal t, Node n, Node parent) {
  if (n.isLabel()) {
    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.isLabel()) {
    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.isFunction()) {
    moveNamedFunctions(n.getLastChild());
  }
}
 

/**
 * @return Whether the Node is a DO or FUNCTION (with or without
 * labels).
 */
private boolean isOneExactlyFunctionOrDo(Node n) {
  if (n.isLabel()) {
    Node labeledStatement = n.getLastChild();
    if (!labeledStatement.isBlock()) {
      return isOneExactlyFunctionOrDo(labeledStatement);
    } else {
      // For labels with block children, we need to ensure that a
      // labeled FUNCTION or DO isn't generated when extraneous BLOCKs
      // are skipped.
      if (getNonEmptyChildCount(n, 2) == 1) {
        return isOneExactlyFunctionOrDo(getFirstNonEmptyChild(n));
      } else {
        // Either a empty statement or an block with more than one child,
        // way it isn't a FUNCTION or DO.
        return false;
      }
    }
  } else {
    return (n.isFunction() || n.isDo());
  }
}
 

@Override public void visit(NodeTraversal t, Node n, Node parent) {
  if (n.isFunction()) {
    checkFunctionUse(t, n);
  } else if (n.isName()) {
    if (!isDeclaration(n)) {
      checkNameUse(t, n);
    }
  } else if (n.isAssign()) {
    checkAssignment(t, n);
  } else if (n.isDelProp()) {
    checkDelete(t, n);
  } else if (n.isObjectLit()) {
    checkObjectLiteral(t, n);
  } else if (n.isLabel()) {
    checkLabel(t, n);
  }
}
 

/**
 * shouldTraverse is call when descending into the Node tree, so it is used
 * here to build the context for label renames.
 *
 * {@inheritDoc}
 */
@Override
public boolean shouldTraverse(NodeTraversal nodeTraversal, Node node,
    Node parent) {
  if (node.isLabel()) {
    // 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(nameSupplier.get());
    }

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

  return true;
}
 

/**
 * Try folding EXPR_RESULT nodes by removing useless Ops and expressions.
 * @return the replacement node, if changed, or the original if not
 */
private Node tryFoldExpr(Node subtree) {
  Node result = trySimplifyUnusedResult(subtree.getFirstChild());
  if (result == null) {
    Node parent = subtree.getParent();
    // If the EXPR_RESULT no longer has any children, remove it as well.
    if (parent.isLabel()) {
      Node replacement = IR.block().srcref(subtree);
      parent.replaceChild(subtree, replacement);
      subtree = replacement;
    } else {
      subtree.detachFromParent();
      subtree = null;
    }
  }
  return subtree;
}
 

/**
 * Add blocks to IF, WHILE, DO, etc.
 */
private void normalizeBlocks(Node n) {
  if (NodeUtil.isControlStructure(n)
      && !n.isLabel()
      && !n.isSwitch()) {
    for (Node c = n.getFirstChild(); c != null; c = c.getNext()) {
      if (NodeUtil.isControlStructureCodeBlock(n,c) &&
          !c.isBlock()) {
        Node newBlock = IR.block().srcref(n);
        n.replaceChild(c, newBlock);
        if (!c.isEmpty()) {
          newBlock.addChildrenToFront(c);
        } else {
          newBlock.setWasEmptyNode(true);
        }
        c = newBlock;
        reportChange();
      }
    }
  }
}
 

/**
 * @return Whether the Node is a DO or FUNCTION (with or without
 * labels).
 */
private boolean isOneExactlyFunctionOrDo(Node n) {
  if (n.isLabel()) {
    Node labeledStatement = n.getLastChild();
    if (!labeledStatement.isBlock()) {
      return isOneExactlyFunctionOrDo(labeledStatement);
    } else {
      // For labels with block children, we need to ensure that a
      // labeled FUNCTION or DO isn't generated when extraneous BLOCKs
      // are skipped.
      if (getNonEmptyChildCount(n, 2) == 1) {
        return isOneExactlyFunctionOrDo(getFirstNonEmptyChild(n));
      } else {
        // Either a empty statement or an block with more than one child,
        // way it isn't a FUNCTION or DO.
        return false;
      }
    }
  } else {
    return (n.isFunction() || n.isDo());
  }
}
 

/**
 * Add blocks to IF, WHILE, DO, etc.
 */
private void normalizeBlocks(Node n) {
  if (NodeUtil.isControlStructure(n)
      && !n.isLabel()
      && !n.isSwitch()) {
    for (Node c = n.getFirstChild(); c != null; c = c.getNext()) {
      if (NodeUtil.isControlStructureCodeBlock(n,c) &&
          !c.isBlock()) {
        Node newBlock = IR.block().srcref(n);
        n.replaceChild(c, newBlock);
        if (!c.isEmpty()) {
          newBlock.addChildrenToFront(c);
        } else {
          newBlock.setWasEmptyNode(true);
        }
        c = newBlock;
        reportChange();
      }
    }
  }
}
 

/**
 * @return Whether the Node is a DO or FUNCTION (with or without
 * labels).
 */
private boolean isOneExactlyFunctionOrDo(Node n) {
  if (n.isLabel()) {
    Node labeledStatement = n.getLastChild();
    if (!labeledStatement.isBlock()) {
      return isOneExactlyFunctionOrDo(labeledStatement);
    } else {
      // For labels with block children, we need to ensure that a
      // labeled FUNCTION or DO isn't generated when extraneous BLOCKs
      // are skipped.
      if (getNonEmptyChildCount(n, 2) == 1) {
        return isOneExactlyFunctionOrDo(getFirstNonEmptyChild(n));
      } else {
        // Either a empty statement or an block with more than one child,
        // way it isn't a FUNCTION or DO.
        return false;
      }
    }
  } else {
    return (n.isFunction() || n.isDo());
  }
}
 

/**
 * @return Whether the Node is a DO or FUNCTION (with or without
 * labels).
 */
private boolean isOneExactlyFunctionOrDo(Node n) {
  if (n.isLabel()) {
    Node labeledStatement = n.getLastChild();
    if (!labeledStatement.isBlock()) {
      return isOneExactlyFunctionOrDo(labeledStatement);
    } else {
      // For labels with block children, we need to ensure that a
      // labeled FUNCTION or DO isn't generated when extraneous BLOCKs
      // are skipped.
      if (getNonEmptyChildCount(n, 2) == 1) {
        return isOneExactlyFunctionOrDo(getFirstNonEmptyChild(n));
      } else {
        // Either a empty statement or an block with more than one child,
        // way it isn't a FUNCTION or DO.
        return false;
      }
    }
  } else {
    return (n.isFunction() || n.isDo());
  }
}
 

/**
 * @return Whether the Node is a DO or FUNCTION (with or without
 * labels).
 */
private boolean isOneExactlyFunctionOrDo(Node n) {
  if (n.isLabel()) {
    Node labeledStatement = n.getLastChild();
    if (!labeledStatement.isBlock()) {
      return isOneExactlyFunctionOrDo(labeledStatement);
    } else {
      // For labels with block children, we need to ensure that a
      // labeled FUNCTION or DO isn't generated when extraneous BLOCKs
      // are skipped.
      if (getNonEmptyChildCount(n, 2) == 1) {
        return isOneExactlyFunctionOrDo(getFirstNonEmptyChild(n));
      } else {
        // Either a empty statement or an block with more than one child,
        // way it isn't a FUNCTION or DO.
        return false;
      }
    }
  } else {
    return (n.isFunction() || n.isDo());
  }
}
 

/**
 * @return Whether the Node is a DO or FUNCTION (with or without
 * labels).
 */
private boolean isOneExactlyFunctionOrDo(Node n) {
  if (n.isLabel()) {
    Node labeledStatement = n.getLastChild();
    if (!labeledStatement.isBlock()) {
      return isOneExactlyFunctionOrDo(labeledStatement);
    } else {
      // For labels with block children, we need to ensure that a
      // labeled FUNCTION or DO isn't generated when extraneous BLOCKs
      // are skipped.
      if (getNonEmptyChildCount(n, 2) == 1) {
        return isOneExactlyFunctionOrDo(getFirstNonEmptyChild(n));
      } else {
        // Either a empty statement or an block with more than one child,
        // way it isn't a FUNCTION or DO.
        return false;
      }
    }
  } else {
    return (n.isFunction() || n.isDo());
  }
}
 

@Override
public void visit(NodeTraversal t, Node n, Node parent) {
  if (n.isLabel() &&
      target.equals(n.getFirstChild().getString())) {

    found = n.getLastChild();
  }
}
 

/**
 * Check if label is actually referencing the target control structure. If
 * label is null, it always returns true.
 */
private static boolean matchLabel(Node target, String label) {
  if (label == null) {
    return true;
  }
  while (target.isLabel()) {
    if (target.getFirstChild().getString().equals(label)) {
      return true;
    }
    target = target.getParent();
  }
  return false;
}
 

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

/**
 * Check if label is actually referencing the target control structure. If
 * label is null, it always returns true.
 */
private static boolean matchLabel(Node target, String label) {
  if (label == null) {
    return true;
  }
  while (target.isLabel()) {
    if (target.getFirstChild().getString().equals(label)) {
      return true;
    }
    target = target.getParent();
  }
  return false;
}
 

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

/**
 * Check if label is actually referencing the target control structure. If
 * label is null, it always returns true.
 */
private static boolean matchLabel(Node target, String label) {
  if (label == null) {
    return true;
  }
  while (target.isLabel()) {
    if (target.getFirstChild().getString().equals(label)) {
      return true;
    }
    target = target.getParent();
  }
  return false;
}
 

/**
 * Check if label is actually referencing the target control structure. If
 * label is null, it always returns true.
 */
private static boolean matchLabel(Node target, String label) {
  if (label == null) {
    return true;
  }
  while (target.isLabel()) {
    if (target.getFirstChild().getString().equals(label)) {
      return true;
    }
    target = target.getParent();
  }
  return false;
}