Java Node.addChildrenToBack方法代码示例

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
/**
 * Create a VAR node containing the given name and initial value expression.
 */
static Node newVarNode(String name, Node value) {
  Node nodeName = Node.newString(Token.NAME, name);
  if (value != null) {
    nodeName.addChildrenToBack(value);
  }
  Node var = new Node(Token.VAR, nodeName);

  return var;
}
 

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
/**
 * @param expr The expression to extract.
 * @param injectionPoint The node before which to added the extracted
 *     expression.
 * @return The extract statement node.
 */
private Node extractExpression(Node expr, Node injectionPoint) {
  Node parent = expr.getParent();
  // The temp value is known to be constant.
  String tempName = getTempConstantValueName();

  // Replace the expression with the temporary name.
  Node replacementValueNode = Node.newString(Token.NAME, tempName);
  parent.replaceChild(expr, replacementValueNode);

  // Re-add the expression in the declaration of the temporary name.
  Node tempNameNode = Node.newString(Token.NAME, tempName);
  tempNameNode.addChildrenToBack(expr);
  Node tempVarNode = new Node(Token.VAR, tempNameNode);

  Node injectionPointParent = injectionPoint.getParent();
  injectionPointParent.addChildBefore(tempVarNode, injectionPoint);

  // If it is ASSIGN_XXX we need to assign it back to the original value.
  // Note that calling the temp constant is a lie in this case, but we do know
  // that it is not modified until after the exposed expression.
  if (NodeUtil.isAssignmentOp(parent) && !NodeUtil.isAssign(parent)) {
    Node gParent = parent.getParent();
    Node assignBack = new Node(Token.ASSIGN,
        expr.cloneTree(),
        tempNameNode.cloneNode());
    if (NodeUtil.isExpressionNode(gParent)) {
      gParent.getParent().addChildAfter(
          NodeUtil.newExpr(assignBack), gParent);
    } else {
      // TODO(user): Use comma here sucks. We might close some accuracy
      // in flow sensitive passes but as far as I know it is unavoidable.
      Node comma = new Node(Token.COMMA);
      gParent.replaceChild(parent, comma);
      comma.addChildrenToFront(assignBack);
      comma.addChildrenToFront(parent);
    }
  }
  return tempVarNode;
}
 

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
/**
 * Example:
 *   a = (void) 0;
 */
private static void addDummyAssignment(Node node, String resultName) {
  Preconditions.checkArgument(node.getType() == Token.BLOCK);

  // A result is needed create a dummy value.
  Node retVal = NodeUtil.newUndefinedNode();
  Node resultNode = createAssignStatementNode(resultName, retVal);

  node.addChildrenToBack(resultNode);
}
 

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
private void applyCollapses() {
  for (Collapse collapse : collapses) {
    Node first = collapse.firstVarNode;
    while (first.getNext() != null &&
        first.getNext().getType() == Token.VAR) {
      Node next = collapse.parent.removeChildAfter(first);

      // Move all children of the next var node into the first one.
      first.addChildrenToBack(next.removeChildren());
    }
  }
}
 

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
/** 
 * Returns a Node tree with the post-order traversal a b c d e f g h i j k l m
 * and the in-order traversal m d a b c h e f g l i j k:
 * 
 *                                   m
 *                         ,---------|---------.
 *                         d         h         l
 *                      ,--|--.   ,--|--.   ,--|--.
 *                      a  b  c   e  f  g   i  j  k
 * 
 */
private static Node createPostOrderAlphabet() {
  Node a = Node.newString("a");
  Node b = Node.newString("b");
  Node c = Node.newString("c");
  Node d = Node.newString("d");
  Node e = Node.newString("e");
  Node f = Node.newString("f");
  Node g = Node.newString("g");
  Node h = Node.newString("h");
  Node i = Node.newString("i");
  Node j = Node.newString("j");
  Node k = Node.newString("k");
  Node l = Node.newString("l");
  Node m = Node.newString("m");
  
  d.addChildToBack(a);
  d.addChildToBack(b);
  d.addChildToBack(c);
  
  h.addChildrenToBack(e);
  h.addChildrenToBack(f);
  h.addChildrenToBack(g);
  
  l.addChildToBack(i);
  l.addChildToBack(j);
  l.addChildToBack(k);
  
  m.addChildToBack(d);
  m.addChildToBack(h);
  m.addChildToBack(l);
  
  return m;
}
 

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
/**
 * Rewrite the call so "this" is preserved.
 *   a.b(c);
 * becomes:
 *   var temp1 = a;
 *   var temp0 = temp1.b;
 *   temp0.call(temp1,c);
 *
 * @return The replacement node.
 */
private Node rewriteCallExpression(Node call, DecompositionState state) {
  Preconditions.checkArgument(call.getType() == Token.CALL);
  Node first = call.getFirstChild();
  Preconditions.checkArgument(NodeUtil.isGet(first));

  // Extracts the expression representing the function to call. For example:
  //   "a['b'].c" from "a['b'].c()"
  Node getVarNode = extractExpression(
      first, state.extractBeforeStatement);
  state.extractBeforeStatement = getVarNode;

  // Extracts the object reference to be used as "this". For example:
  //   "a['b']" from "a['b'].c"
  Node getExprNode = getVarNode.getFirstChild().getFirstChild();
  Preconditions.checkArgument(NodeUtil.isGet(getExprNode));
  Node thisVarNode = extractExpression(
      getExprNode.getFirstChild(), state.extractBeforeStatement);
  state.extractBeforeStatement = thisVarNode;

  // Rewrite the CALL expression.
  Node thisNameNode = thisVarNode.getFirstChild();
  Node functionNameNode = getVarNode.getFirstChild();

  // CALL
  //   GETPROP
  //     functionName
  //     "call"
  //   thisName
  //   original-parameter1
  //   original-parameter2
  //   ...
  Node newCall = new Node(Token.CALL,
      new Node(Token.GETPROP,
          functionNameNode.cloneNode(),
          Node.newString("call")),
      thisNameNode.cloneNode(), call.getLineno(), call.getCharno());

  // Throw away the call name
  call.removeFirstChild();
  if (call.hasChildren()) {
    // Add the call parameters to the new call.
    newCall.addChildrenToBack(call.removeChildren());
  }

  // Replace the call.
  Node callParent = call.getParent();
  callParent.replaceChild(call, newCall);

  return newCall;
}
 

import com.google.javascript.rhino.Node; //导入方法依赖的package包/类
/**
 *  Convert returns to assignments and breaks, as needed.
 *  For example, with a lableName of 'foo':
 *    {
 *      return a;
 *    }
 *  becomes:
 *    foo: {
 *      a;
 *      break foo;
 *    }
 *  or
 *    foo: {
 *      resultName = a;
 *      break foo;
 *    }
 *
 * @param resultMustBeSet Whether the result must always be set to a value.
 * @return The node containing the transformed block, this may be different
 *     than the passed in node 'block'.
 */
private static Node replaceReturns(
    Node block, String resultName, String labelName,
    boolean resultMustBeSet) {
  Preconditions.checkNotNull(block);
  Preconditions.checkNotNull(labelName);

  Node root = block;

  boolean hasReturnAtExit = false;
  int returnCount = NodeUtil.getNodeTypeReferenceCount(block, Token.RETURN);
  if (returnCount > 0) {
    hasReturnAtExit = hasReturnAtExit(block);
    // TODO(johnlenz): Simpler not to special case this,
    // and let it be optimized later.
    if (hasReturnAtExit) {
      convertLastReturnToStatement(block, resultName);
      returnCount--;
    }

    if (returnCount > 0) {
      // A label and breaks are needed.

      // Add the breaks
      replaceReturnWithBreak(block, null, resultName, labelName);

      // Add label
      Node label = new Node(Token.LABEL);
      Node name = Node.newString(Token.NAME, labelName);
      label.addChildToFront(name);
      label.addChildToBack(block);

      Node newRoot = new Node(Token.BLOCK);
      newRoot.addChildrenToBack(label);

      // The label is now the root.
      root = newRoot;
    }
  }

  // If there wasn't an return at the end of the function block, and we need
  // a result, add one to the block.
  if (resultMustBeSet && !hasReturnAtExit && resultName != null) {
    addDummyAssignment(block, resultName);
  }

  return root;
}