/* (omit javadoc for this method)
  * Method declared on ASTNode.
  */
 ASTNode clone0(AST target) {
   InfixExpression result = new InfixExpression(target);
   result.setSourceRange(this.getStartPosition(), this.getLength());
   result.setOperator(getOperator());
   result.setLeftOperand((Expression) getLeftOperand().clone(target));
   result.setRightOperand((Expression) getRightOperand().clone(target));
   if (this.extendedOperands != null) {
     // be careful not to trigger lazy creation of list
     result.extendedOperands().addAll(ASTNode.copySubtrees(target, this.extendedOperands()));
   }
   return result;
 }
 public void postVisit(ASTNode node) {
   if (!(node instanceof ParenthesizedExpression)) {
     return;
   }
   ParenthesizedExpression parenthesizedExpression = (ParenthesizedExpression) node;
   Expression expression = parenthesizedExpression.getExpression();
   while (expression instanceof ParenthesizedExpression) {
     expression = ((ParenthesizedExpression) expression).getExpression();
   }
   // if this is part of another expression, check for this and parent precedences
   if (parenthesizedExpression.getParent() instanceof Expression) {
     Expression parentExpression = (Expression) parenthesizedExpression.getParent();
     int expressionPrecedence = getExpressionPrecedence(expression);
     int parentPrecedence = getExpressionPrecedence(parentExpression);
     if ((expressionPrecedence > parentPrecedence)
         && !(parenthesizedExpression.getParent() instanceof ParenthesizedExpression)) {
       return;
     }
     // check for case when precedences for expression and parent are same
     if ((expressionPrecedence == parentPrecedence)
         && (parentExpression instanceof InfixExpression)) {
       // we have expr infix (expr infix expr) removing the parenthesis is equal to (expr infix
       // expr) infix expr
       InfixExpression parentInfix = (InfixExpression) parentExpression;
       Operator parentOperator = parentInfix.getOperator();
       if (parentInfix.getLeftOperand() == parenthesizedExpression) {
         fNodes.add(node);
       } else if (isAssoziative(parentOperator)) {
         if (parentOperator == InfixExpression.Operator.PLUS) {
           if (isStringExpression(parentInfix.getLeftOperand())
               || isStringExpression(parentInfix.getRightOperand())) {
             return;
           }
           for (Iterator J = parentInfix.extendedOperands().iterator(); J.hasNext(); ) {
             Expression operand = (Expression) J.next();
             if (isStringExpression(operand)) {
               return;
             }
           }
         }
         fNodes.add(node);
       }
       return;
     } else if (expressionPrecedence == parentPrecedence
         && parentExpression instanceof ConditionalExpression) {
       if (((ConditionalExpression) parentExpression).getElseExpression()
           != parenthesizedExpression) return;
     }
   }
   fNodes.add(node);
 }
 /*
  * @see ASTVisitor#visit(InfixExpression)
  */
 public boolean visit(InfixExpression node) {
   node.getLeftOperand().accept(this);
   this.fBuffer.append(' '); // for cases like x= i - -1; or x= i++ + ++i;
   this.fBuffer.append(node.getOperator().toString());
   this.fBuffer.append(' ');
   node.getRightOperand().accept(this);
   final List extendedOperands = node.extendedOperands();
   if (extendedOperands.size() != 0) {
     this.fBuffer.append(' ');
     for (Iterator it = extendedOperands.iterator(); it.hasNext(); ) {
       this.fBuffer.append(node.getOperator().toString()).append(' ');
       Expression e = (Expression) it.next();
       e.accept(this);
     }
   }
   return false;
 }
  /** @deprecated using deprecated code */
  public void testInfixExpression() throws Exception {
    IPackageFragment pack1 = this.sourceFolder.createPackageFragment("test1", false, null);
    StringBuffer buf = new StringBuffer();
    buf.append("    function foo() {\n");
    buf.append("        i= 1 + 2;\n");
    buf.append("        j= 1 + 2 + 3 + 4 + 5;\n");
    buf.append("        k= 1 + 2 + 3 + 4 + 5;\n");
    buf.append("    }\n");
    IJavaScriptUnit cu = pack1.createCompilationUnit("E.js", buf.toString(), false, null);

    JavaScriptUnit astRoot = createAST(cu);
    ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());

    AST ast = astRoot.getAST();

    assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
    //		TypeDeclaration type= findTypeDeclaration(astRoot, "E");
    FunctionDeclaration methodDecl = findMethodDeclaration(astRoot, "foo");
    Block block = methodDecl.getBody();
    List statements = block.statements();
    assertTrue("Number of statements not 3", statements.size() == 3);
    { // change left side & right side & operand
      ExpressionStatement stmt = (ExpressionStatement) statements.get(0);
      Assignment assignment = (Assignment) stmt.getExpression();
      InfixExpression expr = (InfixExpression) assignment.getRightHandSide();

      SimpleName leftOp = ast.newSimpleName("k");
      rewrite.replace(expr.getLeftOperand(), leftOp, null);

      SimpleName rightOp = ast.newSimpleName("j");
      rewrite.replace(expr.getRightOperand(), rightOp, null);

      // change operand
      rewrite.set(expr, InfixExpression.OPERATOR_PROPERTY, InfixExpression.Operator.MINUS, null);
    }

    { // remove an ext. operand, add one and replace one
      ExpressionStatement stmt = (ExpressionStatement) statements.get(1);
      Assignment assignment = (Assignment) stmt.getExpression();
      InfixExpression expr = (InfixExpression) assignment.getRightHandSide();

      List extendedOperands = expr.extendedOperands();
      assertTrue("Number of extendedOperands not 3", extendedOperands.size() == 3);

      rewrite.remove((ASTNode) extendedOperands.get(0), null);

      SimpleName newOp1 = ast.newSimpleName("k");
      rewrite.replace((ASTNode) extendedOperands.get(1), newOp1, null);

      SimpleName newOp2 = ast.newSimpleName("n");
      rewrite
          .getListRewrite(expr, InfixExpression.EXTENDED_OPERANDS_PROPERTY)
          .insertLast(newOp2, null);
    }

    { // change operand
      ExpressionStatement stmt = (ExpressionStatement) statements.get(2);
      Assignment assignment = (Assignment) stmt.getExpression();
      InfixExpression expr = (InfixExpression) assignment.getRightHandSide();

      rewrite.set(expr, InfixExpression.OPERATOR_PROPERTY, InfixExpression.Operator.TIMES, null);
    }

    String preview = evaluateRewrite(cu, rewrite);

    buf = new StringBuffer();
    buf.append("    function foo() {\n");
    buf.append("        i= k - j;\n");
    buf.append("        j= 1 + 2 + k + 5 + n;\n");
    buf.append("        k= 1 * 2 * 3 * 4 * 5;\n");
    buf.append("    }\n");
    assertEqualString(preview, buf.toString());
  }