Java Token.ADD属性代码示例

/**
 * A "simple" operator is one whose children are expressions,
 * has no direct side-effects (unlike '+='), and has no
 * conditional aspects (unlike '||').
 */
static boolean isSimpleOperatorType(int type) {
  switch (type) {
    case Token.ADD:
    case Token.BITAND:
    case Token.BITNOT:
    case Token.BITOR:
    case Token.BITXOR:
    case Token.COMMA:
    case Token.DIV:
    case Token.EQ:
    case Token.GE:
    case Token.GETELEM:
    case Token.GETPROP:
    case Token.GT:
    case Token.INSTANCEOF:
    case Token.LE:
    case Token.LSH:
    case Token.LT:
    case Token.MOD:
    case Token.MUL:
    case Token.NE:
    case Token.NOT:
    case Token.RSH:
    case Token.SHEQ:
    case Token.SHNE:
    case Token.SUB:
    case Token.TYPEOF:
    case Token.VOID:
    case Token.POS:
    case Token.NEG:
    case Token.URSH:
      return true;

    default:
      return false;
  }
}
 

static int getOpFromAssignmentOp(Node n) {
  switch (n.getType()){
    case Token.ASSIGN_BITOR:
      return Token.BITOR;
    case Token.ASSIGN_BITXOR:
      return Token.BITXOR;
    case Token.ASSIGN_BITAND:
      return Token.BITAND;
    case Token.ASSIGN_LSH:
      return Token.LSH;
    case Token.ASSIGN_RSH:
      return Token.RSH;
    case Token.ASSIGN_URSH:
      return Token.URSH;
    case Token.ASSIGN_ADD:
      return Token.ADD;
    case Token.ASSIGN_SUB:
      return Token.SUB;
    case Token.ASSIGN_MUL:
      return Token.MUL;
    case Token.ASSIGN_DIV:
      return Token.DIV;
    case Token.ASSIGN_MOD:
      return Token.MOD;
  }
  throw new IllegalArgumentException("Not an assiment op");
}
 

/**
 * Expressions such as [foo() + 'a' + 'b'] generate parse trees
 * where no node has two const children ((foo() + 'a') + 'b'), so
 * tryFoldAdd() won't fold it -- tryFoldLeftChildAdd() will (for Strings).
 * Specifically it folds Add exprssions where:
 *  - The left child is also and add expression
 *  - The right child is a constant value
 *  - The left child's right child is a STRING constant.
 *
 * WARNING: If javascript ever adds operator overloading, this will
 * probably stop being correct.
 */
void tryFoldLeftChildAdd(NodeTraversal t, Node n, Node left, Node right,
                         Node parent) {

  if (NodeUtil.isLiteralValue(right) &&
      left.getType() == Token.ADD &&
      left.getChildCount() == 2) {

    Node ll = left.getFirstChild();
    Node lr = ll.getNext();

    // Left's right child MUST be a string. We would not want to fold
    // foo() + 2 + 'a' because we don't know what foo() will return, and
    // therefore we don't know if left is a string concat, or a numeric add.
    if (lr.getType() != Token.STRING)
      return;

    String leftString = NodeUtil.getStringValue(lr);
    String rightString = NodeUtil.getStringValue(right);
    if (leftString != null && rightString != null) {
      left.removeChild(ll);
      String result = leftString + rightString;
      n.replaceChild(left, ll);
      n.replaceChild(right, Node.newString(result));
      t.getCompiler().reportCodeChange();
    }
  }
}
 

/**
 * Try to fold arithmetic binary operators
 */
void tryFoldArithmetic(NodeTraversal t, Node n, Node left, Node right,
                       Node parent) {

  if (left.getType() == Token.NUMBER &&
      right.getType() == Token.NUMBER) {
    double result;
    double lval = left.getDouble();
    double rval = right.getDouble();

    switch (n.getType()) {
      case Token.ADD:
        result = lval + rval;
        break;
      case Token.SUB:
        result = lval - rval;
        break;
      case Token.MUL:
        result = lval * rval;
        break;
      case Token.DIV:
        if (rval == 0) {
          error(t, DIVIDE_BY_0_ERROR, right);
          return;
        }
        result = lval / rval;
        break;
      default:
        throw new Error("Unknown arithmetic operator");
    }

    // length of the left and right value plus 1 byte for the operator.
    if (String.valueOf(result).length() <=
        String.valueOf(lval).length() + String.valueOf(rval).length() + 1) {
      parent.replaceChild(n, Node.newNumber(result));
      t.getCompiler().reportCodeChange();
    }
 }
}
 

public void testUndefinedNode() throws Exception {
  Node p = new Node(Token.ADD);
  Node n = Node.newString(Token.NAME, "undefined");
  p.addChildToBack(n);
  p.addChildToBack(Node.newNumber(5));
  typeCheck(p);

  assertEquals(VOID_TYPE, n.getJSType());
}
 

@Override
public void visit(NodeTraversal t, Node n, Node parent) {
  if (n.getType() == Token.CALL &&
      GET_CSS_NAME_FUNCTION.equals(n.getFirstChild().getQualifiedName())) {
    int count = n.getChildCount();
    Node first = n.getFirstChild().getNext();
    switch (count) {
      case 2:
        // Replace the function call with the processed argument.
        if (first.getType() == Token.STRING) {
          processStringNode(t, first);
          n.removeChild(first);
          parent.replaceChild(n, first);
          compiler.reportCodeChange();
        } else {
          compiler.report(JSError.make(t, n, STRING_LITERAL_EXPECTED_ERROR,
              Token.name(first.getType())));
        }
        break;

      case 3:
        // Replace function call with concatenation of two args.  It's
        // assumed the first arg has already been processed.

        Node second = first.getNext();

        if (first.getType() == Token.STRING) {
          compiler.report(JSError.make(
              t, n, UNEXPECTED_STRING_LITERAL_ERROR,
              first.getString(), second.getString()));

        } else if (second.getType() == Token.STRING) {
          processStringNode(t, second);
          n.removeChild(first);
          Node replacement = new Node(Token.ADD, first,
              Node.newString("-" + second.getString()));
          parent.replaceChild(n, replacement);
          compiler.reportCodeChange();

        } else {
          compiler.report(JSError.make(t, n, STRING_LITERAL_EXPECTED_ERROR,
              Token.name(second.getType())));
        }
        break;

      default:
        compiler.report(JSError.make(
            t, n, INVALID_NUM_ARGUMENTS_ERROR, String.valueOf(count)));
    }
  }
}
 

static int precedence(int type) {
  switch (type) {
    case Token.COMMA:  return 0;
    case Token.ASSIGN_BITOR:
    case Token.ASSIGN_BITXOR:
    case Token.ASSIGN_BITAND:
    case Token.ASSIGN_LSH:
    case Token.ASSIGN_RSH:
    case Token.ASSIGN_URSH:
    case Token.ASSIGN_ADD:
    case Token.ASSIGN_SUB:
    case Token.ASSIGN_MUL:
    case Token.ASSIGN_DIV:
    case Token.ASSIGN_MOD:
    case Token.ASSIGN: return 1;
    case Token.HOOK:   return 2;  // ?: operator
    case Token.OR:     return 3;
    case Token.AND:    return 4;
    case Token.BITOR:  return 5;
    case Token.BITXOR: return 6;
    case Token.BITAND: return 7;
    case Token.EQ:
    case Token.NE:
    case Token.SHEQ:
    case Token.SHNE:   return 8;
    case Token.LT:
    case Token.GT:
    case Token.LE:
    case Token.GE:
    case Token.INSTANCEOF:
    case Token.IN:     return 9;
    case Token.LSH:
    case Token.RSH:
    case Token.URSH:   return 10;
    case Token.SUB:
    case Token.ADD:    return 11;
    case Token.MUL:
    case Token.MOD:
    case Token.DIV:    return 12;
    case Token.INC:
    case Token.DEC:
    case Token.NEW:
    case Token.DELPROP:
    case Token.TYPEOF:
    case Token.VOID:
    case Token.NOT:
    case Token.BITNOT:
    case Token.POS:
    case Token.NEG:    return 13;

    case Token.ARRAYLIT:
    case Token.CALL:
    case Token.EMPTY:
    case Token.FALSE:
    case Token.FUNCTION:
    case Token.GETELEM:
    case Token.GETPROP:
    case Token.GET_REF:
    case Token.IF:
    case Token.LP:
    case Token.NAME:
    case Token.NULL:
    case Token.NUMBER:
    case Token.OBJECTLIT:
    case Token.REGEXP:
    case Token.RETURN:
    case Token.STRING:
    case Token.THIS:
    case Token.TRUE:
      return 15;

    default: throw new Error("Unknown precedence for " +
                             Node.tokenToName(type) +
                             " (type " + type + ")");
  }
}
 

/**
 * Converts an operator's token value (see {@link Token}) to a string
 * representation.
 *
 * @param operator the operator's token value to convert
 * @return the string representation or {@code null} if the token value is
 * not an operator
 */
static String opToStr(int operator) {
  switch (operator) {
    case Token.BITOR: return "|";
    case Token.OR: return "||";
    case Token.BITXOR: return "^";
    case Token.AND: return "&&";
    case Token.BITAND: return "&";
    case Token.SHEQ: return "===";
    case Token.EQ: return "==";
    case Token.NOT: return "!";
    case Token.NE: return "!=";
    case Token.SHNE: return "!==";
    case Token.LSH: return "<<";
    case Token.IN: return "in";
    case Token.LE: return "<=";
    case Token.LT: return "<";
    case Token.URSH: return ">>>";
    case Token.RSH: return ">>";
    case Token.GE: return ">=";
    case Token.GT: return ">";
    case Token.MUL: return "*";
    case Token.DIV: return "/";
    case Token.MOD: return "%";
    case Token.BITNOT: return "~";
    case Token.ADD: return "+";
    case Token.SUB: return "-";
    case Token.POS: return "+";
    case Token.NEG: return "-";
    case Token.ASSIGN: return "=";
    case Token.ASSIGN_BITOR: return "|=";
    case Token.ASSIGN_BITXOR: return "^=";
    case Token.ASSIGN_BITAND: return "&=";
    case Token.ASSIGN_LSH: return "<<=";
    case Token.ASSIGN_RSH: return ">>=";
    case Token.ASSIGN_URSH: return ">>>=";
    case Token.ASSIGN_ADD: return "+=";
    case Token.ASSIGN_SUB: return "-=";
    case Token.ASSIGN_MUL: return "*=";
    case Token.ASSIGN_DIV: return "/=";
    case Token.ASSIGN_MOD: return "%=";
    case Token.VOID: return "void";
    case Token.TYPEOF: return "typeof";
    case Token.INSTANCEOF: return "instanceof";
    default: return null;
  }
}
 

private void tryFoldAssign(NodeTraversal t, Node n, Node left, Node right) {
  Preconditions.checkArgument(n.getType() == Token.ASSIGN);

  // Tries to convert x = x + y -> x += y;
  if (!right.hasChildren() ||
      right.getFirstChild().getNext() != right.getLastChild()) {
    // RHS must have two children.
    return;
  }

  if (NodeUtil.mayHaveSideEffects(left)) {
    return;
  }

  Node leftChild = right.getFirstChild();
  if (!compiler.areNodesEqualForInlining(left, leftChild)) {
    return;
  }

  int newType = -1;
  switch (right.getType()) {
    case Token.ADD:
      newType = Token.ASSIGN_ADD;
      break;
    case Token.BITAND:
      newType = Token.ASSIGN_BITAND;
      break;
    case Token.BITOR:
      newType = Token.ASSIGN_BITOR;
      break;
    case Token.BITXOR:
      newType = Token.ASSIGN_BITXOR;
      break;
    case Token.DIV:
      newType = Token.ASSIGN_DIV;
      break;
    case Token.LSH:
      newType = Token.ASSIGN_LSH;
      break;
    case Token.MOD:
      newType = Token.ASSIGN_MOD;
      break;
    case Token.MUL:
      newType = Token.ASSIGN_MUL;
      break;
    case Token.RSH:
      newType = Token.ASSIGN_RSH;
      break;
    case Token.SUB:
      newType = Token.ASSIGN_SUB;
      break;
    case Token.URSH:
      newType = Token.ASSIGN_URSH;
      break;
    default:
      return;
  }

  n.getParent().replaceChild(n, new Node(newType,
      left.detachFromParent(), right.getLastChild().detachFromParent()));
  t.getCompiler().reportCodeChange();
}
 

/**
 * This function unifies the type checking involved in the core binary
 * operators and the corresponding assignment operators.  The representation
 * used internally is such that common code can handle both kinds of
 * operators easily.
 *
 * @param op The operator.
 * @param t The traversal object, needed to report errors.
 * @param n The node being checked.
 */
private void visitBinaryOperator(int op, NodeTraversal t, Node n) {
  Node left = n.getFirstChild();
  JSType leftType = getJSType(left);
  Node right = n.getLastChild();
  JSType rightType = getJSType(right);
  switch (op) {
    case Token.ASSIGN_LSH:
    case Token.ASSIGN_RSH:
    case Token.LSH:
    case Token.RSH:
    case Token.ASSIGN_URSH:
    case Token.URSH:
      if (!leftType.matchesInt32Context()) {
        t.report(left, BIT_OPERATION,
                 NodeUtil.opToStr(n.getType()), leftType.toString());
      }
      if (!rightType.matchesUint32Context()) {
        t.report(right, BIT_OPERATION,
                 NodeUtil.opToStr(n.getType()), rightType.toString());
      }
      break;

    case Token.ASSIGN_DIV:
    case Token.ASSIGN_MOD:
    case Token.ASSIGN_MUL:
    case Token.ASSIGN_SUB:
    case Token.DIV:
    case Token.MOD:
    case Token.MUL:
    case Token.SUB:
      validator.expectNumber(t, left, leftType, "left operand");
      validator.expectNumber(t, right, rightType, "right operand");
      break;

    case Token.ASSIGN_BITAND:
    case Token.ASSIGN_BITXOR:
    case Token.ASSIGN_BITOR:
    case Token.BITAND:
    case Token.BITXOR:
    case Token.BITOR:
      validator.expectBitwiseable(t, left, leftType,
          "bad left operand to bitwise operator");
      validator.expectBitwiseable(t, right, rightType,
          "bad right operand to bitwise operator");
      break;

    case Token.ASSIGN_ADD:
    case Token.ADD:
      break;

    default:
      t.report(n, UNEXPECTED_TOKEN, Node.tokenToName(op));
  }
  ensureTyped(t, n);
}