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

/**
 * Merge a block with its parent block.
 * @return Whether the block was removed.
 */
static boolean tryMergeBlock(Node block) {
  Preconditions.checkState(block.getType() == Token.BLOCK);
  Node parent = block.getParent();
  // Try to remove the block if its parent is a block/script or if its
  // parent is label and it has exactly one child.
  if (isStatementBlock(parent)) {
    Node previous = block;
    while (block.hasChildren()) {
      Node child = block.removeFirstChild();
      parent.addChildAfter(child, previous);
      previous = child;
    }
    parent.removeChild(block);
    return true;
  } else {
    return false;
  }
}
 

/**
 * Merge a block with its parent block.
 * @return Whether the block was removed.
 */
static boolean tryMergeBlock(Node block) {
  Preconditions.checkState(block.isBlock());
  Node parent = block.getParent();
  // Try to remove the block if its parent is a block/script or if its
  // parent is label and it has exactly one child.
  if (isStatementBlock(parent)) {
    Node previous = block;
    while (block.hasChildren()) {
      Node child = block.removeFirstChild();
      parent.addChildAfter(child, previous);
      previous = child;
    }
    parent.removeChild(block);
    return true;
  } else {
    return false;
  }
}
 

/**
 * Merge a block with its parent block.
 * @return Whether the block was removed.
 */
static boolean tryMergeBlock(Node block) {
  Preconditions.checkState(block.isBlock());
  Node parent = block.getParent();
  // Try to remove the block if its parent is a block/script or if its
  // parent is label and it has exactly one child.
  if (isStatementBlock(parent)) {
    Node previous = block;
    while (block.hasChildren()) {
      Node child = block.removeFirstChild();
      parent.addChildAfter(child, previous);
      previous = child;
    }
    parent.removeChild(block);
    return true;
  } else {
    return false;
  }
}
 

/**
 * Merge a block with its parent block.
 * @return Whether the block was removed.
 */
static boolean tryMergeBlock(Node block) {
  Preconditions.checkState(block.getType() == Token.BLOCK);
  Node parent = block.getParent();
  // Try to remove the block if its parent is a block/script or if its
  // parent is label and it has exactly one child.
  if (isStatementBlock(parent)) {
    Node previous = block;
    while (block.hasChildren()) {
      Node child = block.removeFirstChild();
      parent.addChildAfter(child, previous);
      previous = child;
    }
    parent.removeChild(block);
    return true;
  } else {
    return false;
  }
}
 

private void split(Node n) {
  Node c = n.getFirstChild();
  Node before = null;
  while (c != null) {
    Node next = c.getNext();
    if (shouldSplit.apply(c)) {
      Node placeHolder = placeHolderProvider.get();
      if (before == null) {
        forest.add(n.removeFirstChild());
        n.addChildToFront(placeHolder);
      } else {
        n.addChildAfter(placeHolder, c);
        n.removeChildAfter(before);
        forest.add(c);
      }
      recordSplitPoint(placeHolder, before, c);
      before = placeHolder;
    } else {
      split(c);
      before = c;
    }
    c = next;
  }
}
 

/**
 * Merge a block with its parent block.
 * @return Whether the block was removed.
 */
static boolean tryMergeBlock(Node block) {
  Preconditions.checkState(block.getType() == Token.BLOCK);
  Node parent = block.getParent();
  // Try to remove the block if its parent is a block/script or if its
  // parent is label and it has exactly one child.
  if (isStatementBlock(parent)) {
    Node previous = block;
    while (block.hasChildren()) {
      Node child = block.removeFirstChild();
      parent.addChildAfter(child, previous);
      previous = child;
    }
    parent.removeChild(block);
    return true;
  } else {
    return false;
  }
}
 

/**
 * Merge a block with its parent block.
 * @return Whether the block was removed.
 */
static boolean tryMergeBlock(Node block) {
  Preconditions.checkState(block.getType() == Token.BLOCK);
  Node parent = block.getParent();
  // Try to remove the block if its parent is a block/script or if its
  // parent is label and it has exactly one child.
  if (isStatementBlock(parent)) {
    Node previous = block;
    while (block.hasChildren()) {
      Node child = block.removeFirstChild();
      parent.addChildAfter(child, previous);
      previous = child;
    }
    parent.removeChild(block);
    return true;
  } else {
    return false;
  }
}
 

/**
 * Merge a block with its parent block.
 * @return Whether the block was removed.
 */
static boolean tryMergeBlock(Node block) {
  Preconditions.checkState(block.isBlock());
  Node parent = block.getParent();
  // Try to remove the block if its parent is a block/script or if its
  // parent is label and it has exactly one child.
  if (isStatementBlock(parent)) {
    Node previous = block;
    while (block.hasChildren()) {
      Node child = block.removeFirstChild();
      parent.addChildAfter(child, previous);
      previous = child;
    }
    parent.removeChild(block);
    return true;
  } else {
    return false;
  }
}
 

/**
 * Merge a block with its parent block.
 * @return Whether the block was removed.
 */
static boolean tryMergeBlock(Node block) {
  Preconditions.checkState(block.isBlock());
  Node parent = block.getParent();
  // Try to remove the block if its parent is a block/script or if its
  // parent is label and it has exactly one child.
  if (isStatementBlock(parent)) {
    Node previous = block;
    while (block.hasChildren()) {
      Node child = block.removeFirstChild();
      parent.addChildAfter(child, previous);
      previous = child;
    }
    parent.removeChild(block);
    return true;
  } else {
    return false;
  }
}
 

/**
 * Adds global variable "stubs" for any properties of a global name that are
 * only set in a local scope or read but never set.
 *
 * @param n An object representing a global name (e.g. "a", "a.b.c")
 * @param alias The flattened name of the object whose properties we are
 *     adding stubs for (e.g. "a$b$c")
 * @param parent The node to which new global variables should be added
 *     as children
 * @param addAfter The child of after which new
 *     variables should be added (may be null)
 * @return The number of variables added
 */
private int addStubsForUndeclaredProperties(
    Name n, String alias, Node parent, Node addAfter) {
  Preconditions.checkArgument(NodeUtil.isStatementBlock(parent));
  Preconditions.checkNotNull(addAfter);
  int numStubs = 0;
  if (n.props != null) {
    for (Name p : n.props) {
      if (p.needsToBeStubbed()) {
        String propAlias = appendPropForAlias(alias, p.name);
        Node nameNode = Node.newString(Token.NAME, propAlias);
        Node newVar = new Node(Token.VAR, nameNode)
            .copyInformationFromForTree(addAfter);
        parent.addChildAfter(newVar, addAfter);
        addAfter = newVar;
        numStubs++;
        compiler.reportCodeChange();

        // Determine if this is a constant var by checking the first
        // reference to it. Don't check the declaration, as it might be null.
        if (p.refs.get(0).node.getLastChild().getBooleanProp(
              Node.IS_CONSTANT_NAME)) {
          nameNode.putBooleanProp(Node.IS_CONSTANT_NAME, true);
        }
      }
    }
  }
  return numStubs;
}
 

@Override
public void visit(NodeTraversal t, Node n, Node parent) {
  switch (n.getType()) {
    case Token.WHILE:
      if (CONVERT_WHILE_TO_FOR) {
        Node expr = n.getFirstChild();
        n.setType(Token.FOR);
        Node empty = IR.empty();
        empty.copyInformationFrom(n);
        n.addChildBefore(empty, expr);
        n.addChildAfter(empty.cloneNode(), expr);
        reportCodeChange("WHILE node");
      }
      break;

    case Token.FUNCTION:
      normalizeFunctionDeclaration(n);
      break;

    case Token.NAME:
    case Token.STRING:
    case Token.STRING_KEY:
    case Token.GETTER_DEF:
    case Token.SETTER_DEF:
      if (!compiler.getLifeCycleStage().isNormalizedObfuscated()) {
        annotateConstantsByConvention(n, parent);
      }
      break;

    case Token.CAST:
      parent.replaceChild(n, n.removeFirstChild());
      break;
  }
}
 

/**
 * @param after The child node to insert the newChild after, or null if
 *     newChild should be added to the front of parent's child list.
 * @return The inserted child node.
 */
private Node addToFront(Node parent, Node newChild, Node after) {
  if (after == null) {
    parent.addChildToFront(newChild);
  } else {
    parent.addChildAfter(newChild, after);
  }
  return newChild;
}
 

@Override
public void visit(NodeTraversal t, Node n, Node parent) {
  switch (n.getType()) {
    case Token.WHILE:
      if (CONVERT_WHILE_TO_FOR) {
        Node expr = n.getFirstChild();
        n.setType(Token.FOR);
        n.addChildBefore(new Node(Token.EMPTY), expr);
        n.addChildAfter(new Node(Token.EMPTY), expr);
        reportCodeChange("WHILE node");
      }
      break;
  }
}
 

/**
 * Try to remove duplicate statements from IF blocks. For example:
 *
 * if (a) {
 *   x = 1;
 *   return true;
 * } else {
 *   x = 2;
 *   return true;
 * }
 *
 * becomes:
 *
 * if (a) {
 *   x = 1;
 * } else {
 *   x = 2;
 * }
 * return true;
 *
 * @param n The IF node to examine.
 */
private void tryRemoveRepeatedStatements(Node n) {
  Preconditions.checkState(n.isIf());

  Node parent = n.getParent();
  if (!NodeUtil.isStatementBlock(parent)) {
    // If the immediate parent is something like a label, we
    // can't move the statement, so bail.
    return;
  }

  Node cond = n.getFirstChild();
  Node trueBranch = cond.getNext();
  Node falseBranch = trueBranch.getNext();
  Preconditions.checkNotNull(trueBranch);
  Preconditions.checkNotNull(falseBranch);

  while (true) {
    Node lastTrue = trueBranch.getLastChild();
    Node lastFalse = falseBranch.getLastChild();
    if (lastTrue == null || lastFalse == null
        || !areNodesEqualForInlining(lastTrue, lastFalse)) {
      break;
    }
    lastTrue.detachFromParent();
    lastFalse.detachFromParent();
    parent.addChildAfter(lastTrue, n);
    reportCodeChange();
  }
}
 

/**
 * @param after The child node to insert the newChild after, or null if
 *     newChild should be added to the front of parent's child list.
 * @return The inserted child node.
 */
private Node addToFront(Node parent, Node newChild, Node after) {
  if (after == null) {
    parent.addChildToFront(newChild);
  } else {
    parent.addChildAfter(newChild, after);
  }
  return newChild;
}
 

private void replaceOriginalJqueryEachCall(Node n, Node expandedBlock) {
  // Check to see if the return value of the original jQuery.expandedEach
  // call is used. If so, we need to wrap each loop expansion in an anonymous
  // function and return the original objectToLoopOver.
  if (n.getParent().isExprResult()) {
    Node parent = n.getParent();
    Node grandparent = parent.getParent();
    Node insertAfter = parent;
    while (expandedBlock.hasChildren()) {
      Node child = expandedBlock.getFirstChild().detachFromParent();
      grandparent.addChildAfter(child, insertAfter);
      insertAfter = child;
    }
    grandparent.removeChild(parent);
  } else {
    // Return the original object
    Node callTarget = n.getFirstChild();
    Node objectToLoopOver = callTarget.getNext();

    objectToLoopOver.detachFromParent();
    Node ret = IR.returnNode(objectToLoopOver).srcref(callTarget);
    expandedBlock.addChildToBack(ret);

    // Wrap all of the expanded loop calls in a new anonymous function
    Node fnc = IR.function(IR.name("").srcref(callTarget),
        IR.paramList().srcref(callTarget),
        expandedBlock);
    n.replaceChild(callTarget, fnc);
    n.putBooleanProp(Node.FREE_CALL, true);

    // remove any other pre-existing call arguments
    while(fnc.getNext() != null) {
      n.removeChildAfter(fnc);
    }
  }
  compiler.reportCodeChange();
}
 

/**
 * Try to remove duplicate statements from IF blocks. For example:
 *
 * if (a) {
 *   x = 1;
 *   return true;
 * } else {
 *   x = 2;
 *   return true;
 * }
 *
 * becomes:
 *
 * if (a) {
 *   x = 1;
 * } else {
 *   x = 2;
 * }
 * return true;
 *
 * @param n The IF node to examine.
 */
private void tryRemoveRepeatedStatements(Node n) {
  Preconditions.checkState(n.isIf());

  Node parent = n.getParent();
  if (!NodeUtil.isStatementBlock(parent)) {
    // If the immediate parent is something like a label, we
    // can't move the statement, so bail.
    return;
  }

  Node cond = n.getFirstChild();
  Node trueBranch = cond.getNext();
  Node falseBranch = trueBranch.getNext();
  Preconditions.checkNotNull(trueBranch);
  Preconditions.checkNotNull(falseBranch);

  while (true) {
    Node lastTrue = trueBranch.getLastChild();
    Node lastFalse = falseBranch.getLastChild();
    if (lastTrue == null || lastFalse == null
        || !areNodesEqualForInlining(lastTrue, lastFalse)) {
      break;
    }
    lastTrue.detachFromParent();
    lastFalse.detachFromParent();
    parent.addChildAfter(lastTrue, n);
    reportCodeChange();
  }
}
 

/**
 * Try to remove duplicate statements from IF blocks. For example:
 *
 * if (a) {
 *   x = 1;
 *   return true;
 * } else {
 *   x = 2;
 *   return true;
 * }
 *
 * becomes:
 *
 * if (a) {
 *   x = 1;
 * } else {
 *   x = 2;
 * }
 * return true;
 *
 * @param n The IF node to examine.
 */
private void tryRemoveRepeatedStatements(Node n) {
  Preconditions.checkState(n.getType() == Token.IF);

  Node parent = n.getParent();
  if (!NodeUtil.isStatementBlock(parent)) {
    // If the immediate parent is something like a label, we
    // can't move the statement, so bail.
    return;
  }

  Node cond = n.getFirstChild();
  Node trueBranch = cond.getNext();
  Node falseBranch = trueBranch.getNext();
  Preconditions.checkNotNull(trueBranch);
  Preconditions.checkNotNull(falseBranch);

  while (true) {
    Node lastTrue = trueBranch.getLastChild();
    Node lastFalse = falseBranch.getLastChild();
    if (lastTrue == null || lastFalse == null
        || !areNodesEqualForInlining(lastTrue, lastFalse)) {
      break;
    }
    lastTrue.detachFromParent();
    lastFalse.detachFromParent();
    parent.addChildAfter(lastTrue, n);
    reportCodeChange();
  }
}
 

/**
 * Try to remove duplicate statements from IF blocks. For example:
 *
 * if (a) {
 *   x = 1;
 *   return true;
 * } else {
 *   x = 2;
 *   return true;
 * }
 *
 * becomes:
 *
 * if (a) {
 *   x = 1;
 * } else {
 *   x = 2;
 * }
 * return true;
 *
 * @param n The IF node to examine.
 */
private void tryRemoveRepeatedStatements(Node n) {
  Preconditions.checkState(n.isIf());

  Node parent = n.getParent();
  if (!NodeUtil.isStatementBlock(parent)) {
    // If the immediate parent is something like a label, we
    // can't move the statement, so bail.
    return;
  }

  Node cond = n.getFirstChild();
  Node trueBranch = cond.getNext();
  Node falseBranch = trueBranch.getNext();
  Preconditions.checkNotNull(trueBranch);
  Preconditions.checkNotNull(falseBranch);

  while (true) {
    Node lastTrue = trueBranch.getLastChild();
    Node lastFalse = falseBranch.getLastChild();
    if (lastTrue == null || lastFalse == null
        || !areNodesEqualForInlining(lastTrue, lastFalse)) {
      break;
    }
    lastTrue.detachFromParent();
    lastFalse.detachFromParent();
    parent.addChildAfter(lastTrue, n);
    reportCodeChange();
  }
}
 

/**
 * Declares global variables to serve as aliases for the values in an object
 * literal, optionally removing all of the object literal's keys and values.
 *
 * @param alias The object literal's flattened name (e.g. "a$b$c")
 * @param objlit The OBJLIT node
 * @param varNode The VAR node to which new global variables should be added
 *     as children
 * @param nameToAddAfter The child of {@code varNode} after which new
 *     variables should be added (may be null)
 * @param varParent {@code varNode}'s parent
 * @return The number of variables added
 */
private int declareVarsForObjLitValues(
    Name objlitName, String alias, Node objlit, Node varNode,
    Node nameToAddAfter, Node varParent) {
  int numVars = 0;
  int arbitraryNameCounter = 0;
  boolean discardKeys = !objlitName.shouldKeepKeys();

  for (Node key = objlit.getFirstChild(), nextKey; key != null;
       key = nextKey) {
    Node value = key.getFirstChild();
    nextKey = key.getNext();

    // A get or a set can not be rewritten as a VAR.
    if (key.isGetterDef() || key.isSetterDef()) {
      continue;
    }

    // We generate arbitrary names for keys that aren't valid JavaScript
    // identifiers, since those keys are never referenced. (If they were,
    // this object literal's child names wouldn't be collapsible.) The only
    // reason that we don't eliminate them entirely is the off chance that
    // their values are expressions that have side effects.
    boolean isJsIdentifier = !key.isNumber() &&
                             TokenStream.isJSIdentifier(key.getString());
    String propName = isJsIdentifier ?
        key.getString() : String.valueOf(++arbitraryNameCounter);

    // If the name cannot be collapsed, skip it.
    String qName = objlitName.getFullName() + '.' + propName;
    Name p = nameMap.get(qName);
    if (p != null && !p.canCollapse()) {
      continue;
    }

    String propAlias = appendPropForAlias(alias, propName);
    Node refNode = null;
    if (discardKeys) {
      objlit.removeChild(key);
      value.detachFromParent();
    } else {
      // Substitute a reference for the value.
      refNode = IR.name(propAlias);
      if (key.getBooleanProp(Node.IS_CONSTANT_NAME)) {
        refNode.putBooleanProp(Node.IS_CONSTANT_NAME, true);
      }

      key.replaceChild(value, refNode);
    }

    // Declare the collapsed name as a variable with the original value.
    Node nameNode = IR.name(propAlias);
    nameNode.addChildToFront(value);
    if (key.getBooleanProp(Node.IS_CONSTANT_NAME)) {
      nameNode.putBooleanProp(Node.IS_CONSTANT_NAME, true);
    }
    Node newVar = IR.var(nameNode)
        .copyInformationFromForTree(key);
    if (nameToAddAfter != null) {
      varParent.addChildAfter(newVar, nameToAddAfter);
    } else {
      varParent.addChildBefore(newVar, varNode);
    }
    compiler.reportCodeChange();
    nameToAddAfter = newVar;

    // Update the global name's node ancestry if it hasn't already been
    // done. (Duplicate keys in an object literal can bring us here twice
    // for the same global name.)
    if (isJsIdentifier && p != null) {
      if (!discardKeys) {
        Ref newAlias =
            p.getDeclaration().cloneAndReclassify(Ref.Type.ALIASING_GET);
        newAlias.node = refNode;
        p.addRef(newAlias);
      }

      p.getDeclaration().node = nameNode;

      if (value.isFunction()) {
        checkForHosedThisReferences(value, value.getJSDocInfo(), p);
      }
    }

    numVars++;
  }
  return numVars;
}