Attachment #189197 for bug #335173

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.Assignment;
import org.eclipse.jdt.core.dom.Assignment.Operator;
import org.eclipse.jdt.core.dom.CastExpression;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.ITypeBinding;

import org.eclipse.jdt.core.dom.PostfixExpression;
import org.eclipse.jdt.core.dom.PrefixExpression;
import org.eclipse.jdt.core.dom.PrimitiveType;
import org.eclipse.jdt.core.dom.Assignment.Operator;
import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;

import org.eclipse.jdt.internal.corext.dom.ASTNodes;
import org.eclipse.jdt.internal.corext.fix.NecessaryParenthesesChecker;
import org.eclipse.jdt.internal.corext.util.JavaModelUtil;
import org.eclipse.jdt.internal.corext.util.JdtFlags;


				InfixExpression infix= ast.newInfixExpression();
				infix.setLeftOperand(getterExpression);
				infix.setOperator(ASTNodes.convertToInfixOperator(assignment.getOperator()));
				infix.setRightOperand(copiedRightOp);
				ITypeBinding infixType= infix.resolveTypeBinding();
				if (NecessaryParenthesesChecker.needsParentheses(copiedRightOp, infix, InfixExpression.RIGHT_OPERAND_PROPERTY)) {
					//TODO: this introduces extra parentheses as bindings cannot be resolved
					ParenthesizedExpression p= ast.newParenthesizedExpression();
					p.setExpression(copiedRightOp);
					copiedRightOp= p;
				}
				infix.setRightOperand(copiedRightOp);
				return createNarrowCastIfNessecary(infix, infixType, ast, variableType, is50OrHigher);
			}
		} else if (node.getNodeType() == ASTNode.POSTFIX_EXPRESSION) {

			castTo= ast.newPrimitiveType(PrimitiveType.SHORT);
		if (castTo != null) {
			CastExpression cast= ast.newCastExpression();
			if (NecessaryParenthesesChecker.needsParentheses(expression, cast, CastExpression.EXPRESSION_PROPERTY)) {
				ParenthesizedExpression parenthesized= ast.newParenthesizedExpression();
				parenthesized.setExpression(expression);
				cast.setExpression(parenthesized);




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.AbstractTypeDeclaration;
import org.eclipse.jdt.core.dom.AnonymousClassDeclaration;
import org.eclipse.jdt.core.dom.ArrayAccess;
import org.eclipse.jdt.core.dom.ArrayType;
import org.eclipse.jdt.core.dom.Assignment;
import org.eclipse.jdt.core.dom.BodyDeclaration;

import org.eclipse.jdt.core.dom.PrimitiveType;
import org.eclipse.jdt.core.dom.QualifiedName;
import org.eclipse.jdt.core.dom.QualifiedType;
import org.eclipse.jdt.core.dom.ReturnStatement;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.SimpleType;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.eclipse.jdt.core.dom.StructuralPropertyDescriptor;
import org.eclipse.jdt.core.dom.SwitchCase;
import org.eclipse.jdt.core.dom.SwitchStatement;
import org.eclipse.jdt.core.dom.Type;
import org.eclipse.jdt.core.dom.VariableDeclaration;
import org.eclipse.jdt.core.dom.VariableDeclarationExpression;

import org.eclipse.jdt.core.dom.WhileStatement;

import org.eclipse.jdt.internal.corext.codemanipulation.StubUtility;
import org.eclipse.jdt.internal.corext.refactoring.code.OperatorPrecedence;
import org.eclipse.jdt.internal.corext.util.CodeFormatterUtil;
import org.eclipse.jdt.internal.corext.util.Strings;


			|| locationInParent == DoStatement.BODY_PROPERTY;
	}

	public static boolean needsParentheses(Expression expression) {
		int type= expression.getNodeType();
		return type == ASTNode.INFIX_EXPRESSION || type == ASTNode.CONDITIONAL_EXPRESSION ||
			type == ASTNode.PREFIX_EXPRESSION || type == ASTNode.POSTFIX_EXPRESSION ||
			type == ASTNode.CAST_EXPRESSION || type == ASTNode.INSTANCEOF_EXPRESSION;
	}

	/**
	 * Checks whether <code>substitute</code> must be parenthesized when used to replace
	 * <code>location</code>.
	 * 
	 * @param substitute substitute expression
	 * @param location expression to be replaced
	 * @return <code>true</code> iff <code>substitute</code> must be parenthesized when used to
	 *         replace <code>location</code>
	 */
	public static boolean substituteMustBeParenthesized(Expression substitute, Expression location) {
		if (substitute instanceof Assignment) //for esthetic reasons
			return true;

    	if (!needsParentheses(substitute))
    		return false;

    	ASTNode parent= location.getParent();
    	StructuralPropertyDescriptor locationInParent= location.getLocationInParent();
		if (locationInParent instanceof ChildListPropertyDescriptor && locationInParent != InfixExpression.EXTENDED_OPERANDS_PROPERTY) {
			// e.g. argument lists of MethodInvocation, ClassInstanceCreation, ...
   			return false;
    	} else if (locationInParent == VariableDeclarationFragment.INITIALIZER_PROPERTY) {
   			return false;
    	} else if (locationInParent == SingleVariableDeclaration.INITIALIZER_PROPERTY) {
    		return false;
    	} else if (locationInParent == ReturnStatement.EXPRESSION_PROPERTY) {
    		return false;
    	} else if (locationInParent == EnhancedForStatement.EXPRESSION_PROPERTY) {
    		return false;
    	} else if (locationInParent == SwitchStatement.EXPRESSION_PROPERTY) {
    		return false;
    	} else if (locationInParent == SwitchCase.EXPRESSION_PROPERTY) {
    		return false;
    	} else if (locationInParent == ArrayAccess.INDEX_PROPERTY) {
    		return false;
    	} else if (parent instanceof Expression) {
			int substitutePrecedence= OperatorPrecedence.getExpressionPrecedence(substitute);
			int locationPrecedence= OperatorPrecedence.getExpressionPrecedence((Expression)parent);
			if (substitutePrecedence > locationPrecedence)
				return false;
		}

        return true;
	}

	/**
	 * Returns the type to which an inlined variable initializer should be cast, or
	 * <code>null</code> if no cast is necessary.





import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;

import org.eclipse.core.runtime.CoreException;


import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.ConditionalExpression;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.InfixExpression;
import org.eclipse.jdt.core.dom.InfixExpression.Operator;
import org.eclipse.jdt.core.dom.InstanceofExpression;
import org.eclipse.jdt.core.dom.ParenthesizedExpression;
import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;

import org.eclipse.jdt.internal.corext.refactoring.code.OperatorPrecedence;
import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;
import org.eclipse.jdt.internal.corext.refactoring.util.NoCommentSourceRangeComputer;


		}

		public boolean visit(ParenthesizedExpression node) {
			if (NecessaryParenthesesChecker.canRemoveParentheses(node)) {
				fNodes.add(node);
			}

			return true;
		}

		/*
		 * Can the parenthesis around node be removed?
		 */
		private boolean canRemoveParenthesis(ParenthesizedExpression node) {
			ASTNode parent= node.getParent();
			if (!(parent instanceof Expression))
				return true;

			Expression parentExpression= (Expression) parent;
			if (parentExpression instanceof ParenthesizedExpression)
				return true;

			Expression expression= getExpression(node);

			int expressionPrecedence= OperatorPrecedence.getExpressionPrecedence(expression);
			int parentPrecedence= OperatorPrecedence.getExpressionPrecedence(parentExpression);

			if (expressionPrecedence > parentPrecedence)
				//(opEx) opParent and opEx binds more -> can safely remove
				return true;

			if (expressionPrecedence < parentPrecedence)
				//(opEx) opParent and opEx binds less -> do not remove
				return false;

			//(opEx) opParent binds equal

			if (parentExpression instanceof InfixExpression) {
				InfixExpression parentInfix= (InfixExpression) parentExpression;
				if (parentInfix.getLeftOperand() == node) {
					//we have (expr op expr) op expr
					//infix expressions are evaluated from left to right -> can safely remove
					return true;
				} else if (isAssociative(parentInfix)) {
					//we have parent op (expr op expr) and op is associative
					//left op (right) == (right) op left == right op left
					if (expression instanceof InfixExpression) {
						InfixExpression infixExpression= (InfixExpression) expression;
						Operator operator= infixExpression.getOperator();
						if (parentInfix.getOperator() != InfixExpression.Operator.TIMES)
							return true;

						if (operator == InfixExpression.Operator.TIMES)
							// x * (y * z) == x * y * z
							return true;

						if (operator == InfixExpression.Operator.REMAINDER)
							// x * (y % z) != x * y % z
							return false;

						//x * (y / z) == z * y / z  iff no rounding
						ITypeBinding binding= infixExpression.resolveTypeBinding();
						if (binding == null)
							return false;

						if (!binding.isPrimitive())
							return false;

						String name= binding.getName();
						if (isIntegerNumber(name))
							//rounding involved
							return false;

						return true;
					}
					return true;
				} else {
					return false;
				}
			} else if (parentExpression instanceof ConditionalExpression) {
				ConditionalExpression conditionalExpression= (ConditionalExpression) parentExpression;
				if (conditionalExpression.getElseExpression() != node)
					return false;
			}

			return true;
		}

		private boolean isIntegerNumber(String name) {
			return "int".equals(name) || "long".equals(name) || "byte".equals(name) || "char".equals(name) || "short".equals(name); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
		}

		/*
		 * Get the expression wrapped by the parentheses
		 * i.e. ((((expression)))) -> expression
		 */
		private Expression getExpression(ParenthesizedExpression node) {
			Expression expression= node.getExpression();
			while (expression instanceof ParenthesizedExpression) {
				expression= ((ParenthesizedExpression) expression).getExpression();
			}
			return expression;
		}

		/**
		 * Is the given expression associative?
		 * <p>
		 * This is true if and only if:<br>
		 * <code>left operator (right) == (right) operator left == right operator left</code>
		 * </p>
		 *
		 * @param expression the expression to inspect
		 * @return true if expression is associative
		 */
		public static boolean isAssociative(InfixExpression expression) {
			Operator operator= expression.getOperator();
			if (operator == InfixExpression.Operator.PLUS) {
				return isAllOperandsHaveSameType(expression);
			}

			if (operator == Operator.LESS || operator == Operator.LESS_EQUALS || operator == Operator.GREATER || operator == Operator.GREATER_EQUALS) {
				return isAllOperandsHaveSameType(expression);
			}

			if (operator == InfixExpression.Operator.CONDITIONAL_AND)
				return true;

			if (operator == InfixExpression.Operator.CONDITIONAL_OR)
				return true;

			if (operator == InfixExpression.Operator.AND)
				return true;

			if (operator == InfixExpression.Operator.OR)
				return true;

			if (operator == InfixExpression.Operator.XOR)
				return true;

			if (operator == InfixExpression.Operator.TIMES)
				return true;

			return false;
		}

		/*
		 * Do all operands in expression have same type
		 */
		private static boolean isAllOperandsHaveSameType(InfixExpression expression) {
			ITypeBinding binding= expression.getLeftOperand().resolveTypeBinding();
			if (binding == null)
				return false;

			ITypeBinding current= expression.getRightOperand().resolveTypeBinding();
			if (binding != current)
				return false;

			for (Iterator iterator= expression.extendedOperands().iterator(); iterator.hasNext();) {
				Expression operand= (Expression) iterator.next();
				current= operand.resolveTypeBinding();
				if (binding != current)
					return false;
			}

			return true;
		}
	}

	private static class AddParenthesisOperation extends CompilationUnitRewriteOperation {

	protected ExpressionsFix(String name, CompilationUnit compilationUnit, CompilationUnitRewriteOperation[] fixRewriteOperations) {
		super(name, compilationUnit, fixRewriteOperations);
	}

}




/*******************************************************************************
 * Copyright (c) 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.jdt.internal.corext.fix;

import java.util.Iterator;

import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ArrayAccess;
import org.eclipse.jdt.core.dom.AssertStatement;
import org.eclipse.jdt.core.dom.ChildListPropertyDescriptor;
import org.eclipse.jdt.core.dom.ConditionalExpression;
import org.eclipse.jdt.core.dom.DoStatement;
import org.eclipse.jdt.core.dom.EnhancedForStatement;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.ForStatement;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.IfStatement;
import org.eclipse.jdt.core.dom.InfixExpression;
import org.eclipse.jdt.core.dom.InfixExpression.Operator;
import org.eclipse.jdt.core.dom.ParenthesizedExpression;
import org.eclipse.jdt.core.dom.ReturnStatement;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.eclipse.jdt.core.dom.StructuralPropertyDescriptor;
import org.eclipse.jdt.core.dom.SwitchCase;
import org.eclipse.jdt.core.dom.SwitchStatement;
import org.eclipse.jdt.core.dom.SynchronizedStatement;
import org.eclipse.jdt.core.dom.ThrowStatement;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
import org.eclipse.jdt.core.dom.WhileStatement;

import org.eclipse.jdt.internal.corext.refactoring.code.OperatorPrecedence;

/**
 * Helper class to check if an expression requires parentheses.
 * 
 * @since 3.7
 */
public class NecessaryParenthesesChecker {

	/*
	 * Get the expression wrapped by the parentheses
	 * i.e. ((((expression)))) -> expression
	 */
	private static Expression getExpression(ParenthesizedExpression node) {
		Expression expression= node.getExpression();
		while (expression instanceof ParenthesizedExpression) {
			expression= ((ParenthesizedExpression)expression).getExpression();
		}
		return expression;
	}

	private static boolean expressionTypeNeedsParentheses(Expression expression) {
		int type= expression.getNodeType();
		return type == ASTNode.INFIX_EXPRESSION
				|| type == ASTNode.CONDITIONAL_EXPRESSION
				|| type == ASTNode.PREFIX_EXPRESSION
				|| type == ASTNode.POSTFIX_EXPRESSION
				|| type == ASTNode.CAST_EXPRESSION
				|| type == ASTNode.INSTANCEOF_EXPRESSION
				|| type == ASTNode.ARRAY_CREATION
				|| type == ASTNode.ASSIGNMENT;
	}

	private static boolean locationNeedsParentheses(StructuralPropertyDescriptor locationInParent) {
		if (locationInParent instanceof ChildListPropertyDescriptor && locationInParent != InfixExpression.EXTENDED_OPERANDS_PROPERTY) {
			// e.g. argument lists of MethodInvocation, ClassInstanceCreation, dimensions of ArrayCreation ...
			return false;
		}
		if (locationInParent == VariableDeclarationFragment.INITIALIZER_PROPERTY
				|| locationInParent == SingleVariableDeclaration.INITIALIZER_PROPERTY
				|| locationInParent == ReturnStatement.EXPRESSION_PROPERTY
				|| locationInParent == EnhancedForStatement.EXPRESSION_PROPERTY
				|| locationInParent == ForStatement.EXPRESSION_PROPERTY
				|| locationInParent == WhileStatement.EXPRESSION_PROPERTY
				|| locationInParent == DoStatement.EXPRESSION_PROPERTY
				|| locationInParent == AssertStatement.EXPRESSION_PROPERTY
				|| locationInParent == AssertStatement.MESSAGE_PROPERTY
				|| locationInParent == IfStatement.EXPRESSION_PROPERTY
				|| locationInParent == SwitchStatement.EXPRESSION_PROPERTY
				|| locationInParent == SwitchCase.EXPRESSION_PROPERTY
				|| locationInParent == ArrayAccess.INDEX_PROPERTY
				|| locationInParent == ThrowStatement.EXPRESSION_PROPERTY
				|| locationInParent == SynchronizedStatement.EXPRESSION_PROPERTY) {
			return false;
		}
		return true;
	}

	/*
	 * Do all operands in expression have same type
	 */
	private static boolean isAllOperandsHaveSameType(InfixExpression expression) {
		ITypeBinding binding= expression.getLeftOperand().resolveTypeBinding();
		if (binding == null)
			return false;
	
		ITypeBinding current= expression.getRightOperand().resolveTypeBinding();
		if (binding != current)
			return false;
	
		for (Iterator iterator= expression.extendedOperands().iterator(); iterator.hasNext();) {
			Expression operand= (Expression) iterator.next();
			current= operand.resolveTypeBinding();
			if (binding != current)
				return false;
		}
	
		return true;
	}

	/*
	 * Is the expression of integer type
	 */
	private static boolean isExpressionIntegerType(Expression expression) {
		ITypeBinding binding= expression.resolveTypeBinding();
		if (binding == null)
			return false;

		if (!binding.isPrimitive())
			return false;

		String name= binding.getName();
		if (isIntegerNumber(name))
			return true;

		return false;
	}

	private static boolean isExpressionStringType(Expression expression) {
		ITypeBinding binding= expression.resolveTypeBinding();
		if (binding == null)
			return false;

		return "java.lang.String".equals(binding.getQualifiedName()); //$NON-NLS-1$
	}

	/*
	 * Is the given expression associative?
	 * 
	 * This is true if and only if:<br>
	 * <code>left operator (right) == (right) operator left == right operator left</code>
	 */
	private static boolean isAssociative(InfixExpression expression) {
		Operator operator= expression.getOperator();

		if (operator == InfixExpression.Operator.PLUS)
			return isExpressionStringType(expression) || isExpressionIntegerType(expression) && isAllOperandsHaveSameType(expression);

		if (operator == InfixExpression.Operator.TIMES)
			return isExpressionIntegerType(expression) && isAllOperandsHaveSameType(expression);

		if (operator == InfixExpression.Operator.CONDITIONAL_AND
				|| operator == InfixExpression.Operator.CONDITIONAL_OR
				|| operator == InfixExpression.Operator.AND
				|| operator == InfixExpression.Operator.OR
				|| operator == InfixExpression.Operator.XOR)
			return true;
	
		return false;
	}

	private static boolean isIntegerNumber(String name) {
		return "int".equals(name) || "long".equals(name) || "byte".equals(name) || "char".equals(name) || "short".equals(name); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
	}

	private static boolean needsParenthesesInInfixExpression(Expression expression, InfixExpression parentInfix, StructuralPropertyDescriptor locationInParent) {
		if (locationInParent == InfixExpression.LEFT_OPERAND_PROPERTY) {
			//we have (expr op expr) op expr
			//infix expressions are evaluated from left to right -> parentheses not needed
			return false;
		} else if (isAssociative(parentInfix)) {
			//we have parent op (expr op expr) and op is associative
			//left op (right) == (right) op left == right op left
			if (expression instanceof InfixExpression) {
				InfixExpression infixExpression= (InfixExpression)expression;
				Operator operator= infixExpression.getOperator();

				if (isExpressionStringType(parentInfix)) {
					if (parentInfix.getOperator() == InfixExpression.Operator.PLUS && operator == InfixExpression.Operator.PLUS && isExpressionStringType(infixExpression)) {
						// 1 + ("" + 2) == 1 + "" + 2
						// 1 + (2 + "") != 1 + 2 + ""
						// "" + (2 + "") == "" + 2 + ""
						return !isExpressionStringType(infixExpression.getLeftOperand()) && !isExpressionStringType(parentInfix.getLeftOperand());
					}
					//"" + (1 + 2), "" + (1 - 2) etc
					return true;
				}

				if (parentInfix.getOperator() != InfixExpression.Operator.TIMES)
					return false;
	
				if (operator == InfixExpression.Operator.TIMES)
					// x * (y * z) == x * y * z
					return false;
	
				if (operator == InfixExpression.Operator.REMAINDER || operator == InfixExpression.Operator.DIVIDE)
					// x * (y % z) != x * y % z , x * (y / z) == x * y / z rounding involved
					return true;
	
				return false;
			}
			return false;
		} else {
			return true;
		}
	}

	/**
	 * Can the parentheses be removed from the parenthesized expression ?
	 * 
	 * <p>
	 * <b>Note:</b> The parenthesized expression must not be an unparented node.
	 * </p>
	 * 
	 * @param expression the parenthesized expression
	 * @return <code>true</code> if parentheses can be removed, <code>false</code> otherwise.
	 */
	public static boolean canRemoveParentheses(Expression expression) {
		return canRemoveParentheses(expression, expression.getParent(), expression.getLocationInParent());
	}

	/**
	 * Can the parentheses be removed from the parenthesized expression when inserted into
	 * <code>parent</code> at <code>locationInParent</code> ?
	 * 
	 * <p>
	 * <b>Note:</b> The parenthesized expression can be an unparented node.
	 * </p>
	 * 
	 * @param expression the parenthesized expression
	 * @param parent the parent node
	 * @param locationInParent location of expression in the parent
	 * @return <code>true</code> if parentheses can be removed, <code>false</code> otherwise.
	 */
	public static boolean canRemoveParentheses(Expression expression, ASTNode parent, StructuralPropertyDescriptor locationInParent) {
		if (!(expression instanceof ParenthesizedExpression)) {
			return false;
		}
		return !needsParentheses(getExpression((ParenthesizedExpression)expression), parent, locationInParent);
	}

	/**
	 * Does the <code>expression</code> need parentheses when inserted into <code>parent</code> at
	 * <code>locationInParent</code> ?
	 * 
	 * <p>
	 * <b>Note:</b> The expression can be an unparented node.
	 * </p>
	 * 
	 * @param expression the expression
	 * @param parent the parent node
	 * @param locationInParent location of expression in the parent
	 * @return <code>true</code> if the expression needs parentheses, <code>false</code> otherwise.
	 */
	public static boolean needsParentheses(Expression expression, ASTNode parent, StructuralPropertyDescriptor locationInParent) {
		if (!expressionTypeNeedsParentheses(expression))
			return false;

		if (!locationNeedsParentheses(locationInParent)) {
			return false;
		}

		if (parent instanceof Expression) {
			Expression parentExpression= (Expression)parent;
			if (parentExpression instanceof ParenthesizedExpression)
				return false;

			int expressionPrecedence= OperatorPrecedence.getExpressionPrecedence(expression);
			int parentPrecedence= OperatorPrecedence.getExpressionPrecedence(parentExpression);

			if (expressionPrecedence > parentPrecedence)
				//(opEx) opParent and opEx binds more -> parentheses not needed
				return false;

			if (expressionPrecedence < parentPrecedence)
				//(opEx) opParent and opEx binds less -> parentheses needed
				return true;

			//(opEx) opParent binds equal

			if (parentExpression instanceof InfixExpression) {
				return needsParenthesesInInfixExpression(expression, (InfixExpression)parentExpression, locationInParent);
			}

			if (parentExpression instanceof ConditionalExpression && locationInParent == ConditionalExpression.EXPRESSION_PROPERTY) {
				return true;
			}

			return false;
		}

		return true;
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

			Expression expression= cast.getExpression();
			ASTNode placeholder= rewrite.createCopyTarget(expression);

			if (NecessaryParenthesesChecker.needsParentheses(expression, cast.getParent(), cast.getLocationInParent())) {
				rewrite.replace(fCast, placeholder, group);
			} else {
				rewrite.replace(fCast.getParent() instanceof ParenthesizedExpression ? fCast.getParent() : fSelectedNode, placeholder, group);
			}
		}
	}

					fUnnecessaryCasts.remove(down);
				}

				Expression expression= down.getExpression();
				ASTNode move= rewrite.createMoveTarget(expression);

				CastExpression top= castExpression;
				while (fUnnecessaryCasts.contains(top.getParent())) {

					fUnnecessaryCasts.remove(top);
				}

				ASTNode toReplace= top;
				if (top.getParent() instanceof ParenthesizedExpression && !NecessaryParenthesesChecker.needsParentheses(expression, top.getParent(), top.getLocationInParent())) {
					toReplace= top.getParent();
				}
				rewrite.replace(toReplace, move, group);
			}
		}
	}




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

					node= castExpression;
				}

				if (fSourceProvider.needsReturnedExpressionParenthesis(fTargetNode.getParent(), fTargetNode.getLocationInParent())) {
					ParenthesizedExpression pExp= fTargetNode.getAST().newParenthesizedExpression();
					pExp.setExpression((Expression)node);
					node= pExp;

		return false;
	}

	private boolean needsParenthesis() {
		if (!fSourceProvider.needsReturnedExpressionParenthesis())
			return false;
		ASTNode parent= fTargetNode.getParent();
		int type= parent.getNodeType();
		return
			type == ASTNode.METHOD_INVOCATION ||
			(parent instanceof Expression && type != ASTNode.ASSIGNMENT) ||
			(fSourceProvider.returnsConditionalExpression() &&
				type == ASTNode.VARIABLE_DECLARATION_FRAGMENT &&
				((VariableDeclarationFragment)parent).getInitializer() == fTargetNode);
	}

	private VariableDeclarationStatement createLocalDeclaration(ITypeBinding type, String name, Expression initializer) {
		ImportRewriteContext context= new ContextSensitiveImportRewriteContext(fTargetNode, fImportRewrite);
		String typeName= fImportRewrite.addImport(type, context);




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

		Type type= getConstantType();

		IExpressionFragment fragment= getSelectedExpression();
		Expression initializer= getSelectedExpression().createCopyTarget(fCuRewrite.getASTRewrite(), true);

		AST ast= fCuRewrite.getAST();
		VariableDeclarationFragment variableDeclarationFragment= ast.newVariableDeclarationFragment();
		variableDeclarationFragment.setName(ast.newSimpleName(fConstantName));
		variableDeclarationFragment.setInitializer(initializer);

		FieldDeclaration fieldDeclaration= ast.newFieldDeclaration(variableDeclarationFragment);
		fieldDeclaration.setType(type);

Lines 1-5 Link Here

(-)core refactoring/org/eclipse/jdt/internal/corext/refactoring/code/ExtractMethodRefactoring.java (-4 / +14 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2010 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 75-80 Link Here
75	import org.eclipse.jdt.core.dom.MethodDeclaration;	75	import org.eclipse.jdt.core.dom.MethodDeclaration;
76	import org.eclipse.jdt.core.dom.MethodInvocation;	76	import org.eclipse.jdt.core.dom.MethodInvocation;
77	import org.eclipse.jdt.core.dom.Modifier;	77	import org.eclipse.jdt.core.dom.Modifier;
		78	import org.eclipse.jdt.core.dom.ParenthesizedExpression;
78	import org.eclipse.jdt.core.dom.QualifiedName;	79	import org.eclipse.jdt.core.dom.QualifiedName;
79	import org.eclipse.jdt.core.dom.ReturnStatement;	80	import org.eclipse.jdt.core.dom.ReturnStatement;
80	import org.eclipse.jdt.core.dom.SimpleName;	81	import org.eclipse.jdt.core.dom.SimpleName;
Lines 909-915 Link Here
909	if (!duplicate.isMethodBody()) {	910	if (!duplicate.isMethodBody()) {
910	if (isDestinationReachable(duplicate.getEnclosingMethod())) {	911	if (isDestinationReachable(duplicate.getEnclosingMethod())) {
911	ASTNode[] callNodes= createCallNodes(duplicate, modifiers);	912	ASTNode[] callNodes= createCallNodes(duplicate, modifiers);
912	new StatementRewrite(fRewriter, duplicate.getNodes()).replace(callNodes, description);	913	ASTNode[] duplicateNodes= duplicate.getNodes();
		914	for (int i= 0; i < duplicateNodes.length; i++) {
		915	ASTNode parent= duplicateNodes[i].getParent();
		916	if (parent instanceof ParenthesizedExpression) {
		917	duplicateNodes[i]= parent;
		918	}
		919	}
		920	new StatementRewrite(fRewriter, duplicateNodes).replace(callNodes, description);
913	}	921	}
914	}	922	}
915	}	923	}
Lines 1059-1071 Link Here
1059	ITypeBinding binding= fAnalyzer.getExpressionBinding();	1067	ITypeBinding binding= fAnalyzer.getExpressionBinding();
1060	if (binding != null && (!binding.isPrimitive() \|\| !"void".equals(binding.getName()))) { //$NON-NLS-1$	1068	if (binding != null && (!binding.isPrimitive() \|\| !"void".equals(binding.getName()))) { //$NON-NLS-1$
1061	ReturnStatement rs= fAST.newReturnStatement();	1069	ReturnStatement rs= fAST.newReturnStatement();
1062	rs.setExpression((Expression)fRewriter.createMoveTarget(selectedNodes[0]));	1070	rs.setExpression((Expression)fRewriter.createMoveTarget(selectedNodes[0] instanceof ParenthesizedExpression
		1071	? ((ParenthesizedExpression)selectedNodes[0]).getExpression()
		1072	: selectedNodes[0]));
1063	statements.insertLast(rs, null);	1073	statements.insertLast(rs, null);
1064	} else {	1074	} else {
1065	ExpressionStatement st= fAST.newExpressionStatement((Expression)fRewriter.createMoveTarget(selectedNodes[0]));	1075	ExpressionStatement st= fAST.newExpressionStatement((Expression)fRewriter.createMoveTarget(selectedNodes[0]));
1066	statements.insertLast(st, null);	1076	statements.insertLast(st, null);
1067	}	1077	}
1068	fRewriter.replace(selectedNodes[0], replacementNode, substitute);	1078	fRewriter.replace(selectedNodes[0].getParent() instanceof ParenthesizedExpression ? selectedNodes[0].getParent() : selectedNodes[0], replacementNode, substitute);
1069	} else {	1079	} else {
1070	if (selectedNodes.length == 1) {	1080	if (selectedNodes.length == 1) {
1071	statements.insertLast(fRewriter.createMoveTarget(selectedNodes[0]), substitute);	1081	statements.insertLast(fRewriter.createMoveTarget(selectedNodes[0]), substitute);




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.jdt.core.dom.VariableDeclaration;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
import org.eclipse.jdt.core.dom.rewrite.ListRewrite;
import org.eclipse.jdt.core.dom.rewrite.ImportRewrite.ImportRewriteContext;
import org.eclipse.jdt.core.dom.rewrite.ListRewrite;
import org.eclipse.jdt.core.refactoring.CompilationUnitChange;
import org.eclipse.jdt.core.refactoring.IJavaRefactorings;
import org.eclipse.jdt.core.refactoring.descriptors.InlineConstantDescriptor;

import org.eclipse.jdt.internal.corext.dom.HierarchicalASTVisitor;
import org.eclipse.jdt.internal.corext.dom.fragments.ASTFragmentFactory;
import org.eclipse.jdt.internal.corext.dom.fragments.IExpressionFragment;
import org.eclipse.jdt.internal.corext.fix.NecessaryParenthesesChecker;
import org.eclipse.jdt.internal.corext.refactoring.Checks;
import org.eclipse.jdt.internal.corext.refactoring.IRefactoringSearchRequestor;
import org.eclipse.jdt.internal.corext.refactoring.JDTRefactoringDescriptorComment;

			if (explicitCast != null) {
				CastExpression cast= ast.newCastExpression();
				Expression modifiedInitializerExpr= (Expression) fCuRewrite.getASTRewrite().createStringPlaceholder(modifiedInitializer, reference.getNodeType());
				if (NecessaryParenthesesChecker.needsParentheses(fInitializer, cast, CastExpression.EXPRESSION_PROPERTY)) {
					ParenthesizedExpression parenthesized= ast.newParenthesizedExpression();
					parenthesized.setExpression(modifiedInitializerExpr);
					modifiedInitializerExpr= parenthesized;

				isStringPlaceholder= true;
			}

			if (NecessaryParenthesesChecker.needsParentheses((isStringPlaceholder ? fInitializer : newReference), reference.getParent(), reference.getLocationInParent())) {
				ParenthesizedExpression parenthesized= ast.newParenthesizedExpression();
				parenthesized.setExpression(newReference);
				newReference= parenthesized;




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.jdt.internal.core.refactoring.descriptors.RefactoringSignatureDescriptorFactory;
import org.eclipse.jdt.internal.corext.dom.ASTNodeFactory;
import org.eclipse.jdt.internal.corext.dom.ASTNodes;
import org.eclipse.jdt.internal.corext.fix.NecessaryParenthesesChecker;
import org.eclipse.jdt.internal.corext.refactoring.Checks;
import org.eclipse.jdt.internal.corext.refactoring.JDTRefactoringDescriptorComment;
import org.eclipse.jdt.internal.corext.refactoring.JavaRefactoringArguments;


	private Expression getInitializerSource(CompilationUnitRewrite rewrite, SimpleName reference) throws JavaModelException {
		Expression copy= getModifiedInitializerSource(rewrite, reference);
		if (NecessaryParenthesesChecker.needsParentheses(copy, reference.getParent(), reference.getLocationInParent())) {
		if (brackets) {
			ParenthesizedExpression parentExpr= rewrite.getAST().newParenthesizedExpression();
			parentExpr.setExpression(copy);
			return parentExpr;

		ITypeBinding explicitCast= ASTNodes.getExplicitCast(initializer, reference);
		if (explicitCast != null) {
			CastExpression cast= ast.newCastExpression();
			if (NecessaryParenthesesChecker.needsParentheses(initializer, cast, CastExpression.EXPRESSION_PROPERTY)) {
				ParenthesizedExpression parenthesized= ast.newParenthesizedExpression();
				parenthesized.setExpression(copy);
				copy= parenthesized;




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.jdt.core.dom.Name;
import org.eclipse.jdt.core.dom.NodeFinder;
import org.eclipse.jdt.core.dom.NullLiteral;
import org.eclipse.jdt.core.dom.ParenthesizedExpression;
import org.eclipse.jdt.core.dom.QualifiedName;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.refactoring.IJavaRefactorings;

		ITypeBinding typeBinding= Bindings.normalizeForDeclarationUse(fSelectedExpression.resolveTypeBinding(), fSelectedExpression.getAST());
		String typeName= cuRewrite.getImportRewrite().addImport(typeBinding);
		String name= fParameterName != null ? fParameterName : guessedParameterName();
		Expression expression= fSelectedExpression instanceof ParenthesizedExpression ? ((ParenthesizedExpression)fSelectedExpression).getExpression() : fSelectedExpression;
		String defaultValue= fSourceCU.getBuffer().getText(expression.getStartPosition(), expression.getLength());
		fParameter= ParameterInfo.createInfoForAddedParameter(typeBinding, typeName, name, defaultValue);
		if (fArguments == null) {
			List parameterInfos= fChangeSignatureProcessor.getParameterInfos();


		ASTNode newExpression= cuRewrite.getRoot().getAST().newSimpleName(fParameter.getNewName());
		String description= RefactoringCoreMessages.IntroduceParameterRefactoring_replace;
		cuRewrite.getASTRewrite().replace(expression.getParent() instanceof ParenthesizedExpression
				? expression.getParent() : expression, newExpression, cuRewrite.createGroupDescription(description));
	}

	private void initializeSelectedExpression(CompilationUnitRewrite cuRewrite) throws JavaModelException {




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.ArrayCreation;
import org.eclipse.jdt.core.dom.Block;
import org.eclipse.jdt.core.dom.CastExpression;
import org.eclipse.jdt.core.dom.ChildPropertyDescriptor;

import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.eclipse.jdt.core.dom.Statement;
import org.eclipse.jdt.core.dom.StructuralPropertyDescriptor;
import org.eclipse.jdt.core.dom.ThisExpression;
import org.eclipse.jdt.core.dom.WhileStatement;
import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;

import org.eclipse.jdt.internal.corext.dom.ASTNodes;
import org.eclipse.jdt.internal.corext.dom.Bindings;
import org.eclipse.jdt.internal.corext.dom.CodeScopeBuilder;
import org.eclipse.jdt.internal.corext.fix.NecessaryParenthesesChecker;
import org.eclipse.jdt.internal.corext.refactoring.code.SourceAnalyzer.NameData;
import org.eclipse.jdt.internal.corext.refactoring.util.RefactoringFileBuffers;
import org.eclipse.jdt.internal.corext.util.CodeFormatterUtil;

		return fTypeRoot;
	}

	public boolean needsReturnedExpressionParenthesis(ASTNode parent, StructuralPropertyDescriptor locationInParent) {
		ASTNode last= getLastStatement();
		if (last instanceof ReturnStatement) {
			return NecessaryParenthesesChecker.needsParentheses(((ReturnStatement)last).getExpression(), parent, locationInParent);
		}
		return false;
	}

		return new String[] {};
	}

	private boolean argumentNeedsParenthesis(Expression expression, ParameterData param) {
		if (expression instanceof CastExpression || expression instanceof ArrayCreation)
			return true;
		int argPrecedence= OperatorPrecedence.getExpressionPrecedence(expression);
		int paramPrecedence= param.getOperatorPrecedence();
		if (argPrecedence != Integer.MAX_VALUE && paramPrecedence != Integer.MAX_VALUE)
			return argPrecedence <= paramPrecedence;
		return false;
	}

	private Expression createParenthesizedExpression(Expression newExpression, AST ast) {
		ParenthesizedExpression parenthesized= ast.newParenthesizedExpression();
		parenthesized.setExpression(newExpression);

					ITypeBinding explicitCast= ASTNodes.getExplicitCast(expression, (Expression)element);
					if (explicitCast != null) {
						CastExpression cast= ast.newCastExpression();
						if (NecessaryParenthesesChecker.needsParentheses(expression, cast, CastExpression.EXPRESSION_PROPERTY)) {
							newExpression= createParenthesizedExpression(newExpression, ast);
						}
						cast.setExpression(newExpression);
						ImportRewriteContext importRewriteContext= new ContextSensitiveImportRewriteContext(expression, importRewrite);
						cast.setType(importRewrite.addImport(explicitCast, ast, importRewriteContext));
						expression= newExpression= cast;
					}
					if (NecessaryParenthesesChecker.needsParentheses(expression, element.getParent(), element.getLocationInParent())) {
						newExpression= createParenthesizedExpression(newExpression, ast);
					}
					rewriter.replace(element, newExpression, null);




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.jdt.internal.corext.SourceRangeFactory;
import org.eclipse.jdt.internal.corext.dom.ASTNodes;
import org.eclipse.jdt.internal.corext.dom.Bindings;
import org.eclipse.jdt.internal.corext.fix.NecessaryParenthesesChecker;
import org.eclipse.jdt.internal.corext.refactoring.RefactoringCoreMessages;
import org.eclipse.jdt.internal.corext.refactoring.base.JavaStatusContext;


				arguments.add(fRewriter.createCopyTarget(node.getRightHandSide()));
			} else {
				// This is the compound assignment case: field+= 10;
				boolean needsParentheses= ASTNodes.needsParentheses(node.getRightHandSide());
				InfixExpression exp= ast.newInfixExpression();
				exp.setOperator(ASTNodes.convertToInfixOperator(node.getOperator()));
				MethodInvocation getter= ast.newMethodInvocation();

					getter.setExpression((Expression)fRewriter.createCopyTarget(receiver));
				exp.setLeftOperand(getter);
				Expression rhs= (Expression)fRewriter.createCopyTarget(node.getRightHandSide());
				if (NecessaryParenthesesChecker.needsParentheses(node.getRightHandSide(), exp, InfixExpression.RIGHT_OPERAND_PROPERTY)) {
					//TODO: this introduces extra parentheses as bindings cannot be resolved
					ParenthesizedExpression p= ast.newParenthesizedExpression();
					p.setExpression(rhs);
					rhs= p;

Lines 87-92 Link Here

(-)ui/org/eclipse/jdt/internal/ui/text/correction/AdvancedQuickAssistProcessor.java (-44 / +32 lines)
87	import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;	87	import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;
88	import org.eclipse.jdt.internal.corext.fix.ExpressionsFix;	88	import org.eclipse.jdt.internal.corext.fix.ExpressionsFix;
89	import org.eclipse.jdt.internal.corext.fix.IProposableFix;	89	import org.eclipse.jdt.internal.corext.fix.IProposableFix;
		90	import org.eclipse.jdt.internal.corext.fix.NecessaryParenthesesChecker;
90	import org.eclipse.jdt.internal.corext.refactoring.code.OperatorPrecedence;	91	import org.eclipse.jdt.internal.corext.refactoring.code.OperatorPrecedence;
91	import org.eclipse.jdt.internal.corext.refactoring.util.TightSourceRangeComputer;	92	import org.eclipse.jdt.internal.corext.refactoring.util.TightSourceRangeComputer;
92	import org.eclipse.jdt.internal.corext.util.JavaModelUtil;	93	import org.eclipse.jdt.internal.corext.util.JavaModelUtil;
Lines 523-529 Link Here
523	if (expression instanceof PrefixExpression) {	524	if (expression instanceof PrefixExpression) {
524	PrefixExpression prefixExpression= (PrefixExpression) expression;	525	PrefixExpression prefixExpression= (PrefixExpression) expression;
525	if (prefixExpression.getOperator() == PrefixExpression.Operator.NOT) {	526	if (prefixExpression.getOperator() == PrefixExpression.Operator.NOT) {
526	return getRenamedNameCopy(provider, rewrite, prefixExpression.getOperand());	527	Expression operand= prefixExpression.getOperand();
		528	if ((operand instanceof ParenthesizedExpression)
		529	&& NecessaryParenthesesChecker.canRemoveParentheses(operand, expression.getParent(), expression.getLocationInParent())) {
		530	operand= ((ParenthesizedExpression)operand).getExpression();
		531	}
		532	return getRenamedNameCopy(provider, rewrite, operand);
527	}	533	}
528	}	534	}
529	if (expression instanceof InstanceofExpression) {	535	if (expression instanceof InstanceofExpression) {
Lines 745-756 Link Here
745	//	751	//
746	AST ast= node.getAST();	752	AST ast= node.getAST();
747	ASTRewrite rewrite= ASTRewrite.create(ast);	753	ASTRewrite rewrite= ASTRewrite.create(ast);
748	// prepare condition parts, add parentheses if needed
749	Expression outerCondition= getParenthesizedForAndIfNeeded(ast, rewrite, outerIf.getExpression());
750	Expression innerCondition= getParenthesizedForAndIfNeeded(ast, rewrite, ifStatement.getExpression());
751	// create compound condition	754	// create compound condition
752	InfixExpression condition= ast.newInfixExpression();	755	InfixExpression condition= ast.newInfixExpression();
753	condition.setOperator(InfixExpression.Operator.CONDITIONAL_AND);	756	condition.setOperator(InfixExpression.Operator.CONDITIONAL_AND);
		757	// prepare condition parts, add parentheses if needed
		758	Expression outerCondition= getParenthesizedExpressionIfNeeded(ast, rewrite, outerIf.getExpression(), condition, InfixExpression.LEFT_OPERAND_PROPERTY);
		759	Expression innerCondition= getParenthesizedExpressionIfNeeded(ast, rewrite, ifStatement.getExpression(), condition, InfixExpression.RIGHT_OPERAND_PROPERTY);
754	condition.setLeftOperand(outerCondition);	760	condition.setLeftOperand(outerCondition);
755	condition.setRightOperand(innerCondition);	761	condition.setRightOperand(innerCondition);
756	// create new IfStatement	762	// create new IfStatement
Lines 784-795 Link Here
784	//	790	//
785	AST ast= node.getAST();	791	AST ast= node.getAST();
786	ASTRewrite rewrite= ASTRewrite.create(ast);	792	ASTRewrite rewrite= ASTRewrite.create(ast);
787	// prepare condition parts, add parentheses if needed
788	Expression outerCondition= getParenthesizedForAndIfNeeded(ast, rewrite, ifStatement.getExpression());
789	Expression innerCondition= getParenthesizedForAndIfNeeded(ast, rewrite, innerIf.getExpression());
790	// create compound condition	793	// create compound condition
791	InfixExpression condition= ast.newInfixExpression();	794	InfixExpression condition= ast.newInfixExpression();
792	condition.setOperator(InfixExpression.Operator.CONDITIONAL_AND);	795	condition.setOperator(InfixExpression.Operator.CONDITIONAL_AND);
		796	// prepare condition parts, add parentheses if needed
		797	Expression outerCondition= getParenthesizedExpressionIfNeeded(ast, rewrite, ifStatement.getExpression(), condition, InfixExpression.LEFT_OPERAND_PROPERTY);
		798	Expression innerCondition= getParenthesizedExpressionIfNeeded(ast, rewrite, innerIf.getExpression(), condition, InfixExpression.RIGHT_OPERAND_PROPERTY);
793	condition.setLeftOperand(outerCondition);	799	condition.setLeftOperand(outerCondition);
794	condition.setRightOperand(innerCondition);	800	condition.setRightOperand(innerCondition);
795	// create new IfStatement	801	// create new IfStatement
Lines 808-823 Link Here
808	return true;	814	return true;
809	}	815	}
810		816
811	private static Expression getParenthesizedForAndIfNeeded(AST ast, ASTRewrite rewrite, Expression expression) {	817	private static Expression getParenthesizedExpressionIfNeeded(AST ast, ASTRewrite rewrite, Expression expression, ASTNode parent, StructuralPropertyDescriptor locationInParent) {
812	boolean addParentheses= false;	818	boolean addParentheses= NecessaryParenthesesChecker.needsParentheses(expression, parent, locationInParent);
813	int nodeType= expression.getNodeType();	819	expression= (Expression)rewrite.createCopyTarget(expression);
814	if (nodeType == ASTNode.INFIX_EXPRESSION) {
815	InfixExpression infixExpression= (InfixExpression) expression;
816	addParentheses= infixExpression.getOperator() == InfixExpression.Operator.CONDITIONAL_OR;
817	} else {
818	addParentheses= nodeType == ASTNode.CONDITIONAL_EXPRESSION \|\| nodeType == ASTNode.ASSIGNMENT \|\| nodeType == ASTNode.INSTANCEOF_EXPRESSION;
819	}
820	expression= (Expression) rewrite.createCopyTarget(expression);
821	if (addParentheses) {	820	if (addParentheses) {
822	return getParenthesizedExpression(ast, expression);	821	return getParenthesizedExpression(ast, expression);
823	}	822	}
Lines 976-994 Link Here
976	IfStatement ifStatement= (IfStatement) iter.next();	975	IfStatement ifStatement= (IfStatement) iter.next();
977	if (thenStatement == null)	976	if (thenStatement == null)
978	thenStatement= (Statement) rewrite.createCopyTarget(ifStatement.getThenStatement());	977	thenStatement= (Statement) rewrite.createCopyTarget(ifStatement.getThenStatement());
979	Expression ifCondition= getParenthesizedForOrIfNeeded(ast, rewrite, ifStatement.getExpression());
980	if (condition == null) {	978	if (condition == null) {
981	condition= ast.newInfixExpression();	979	condition= ast.newInfixExpression();
982	condition.setOperator(orOperator);	980	condition.setOperator(orOperator);
983	condition.setLeftOperand(ifCondition);	981	condition.setLeftOperand(getParenthesizedExpressionIfNeeded(ast, rewrite, ifStatement.getExpression(), condition, InfixExpression.LEFT_OPERAND_PROPERTY));
984	} else if (!hasRightOperand) {	982	} else if (!hasRightOperand) {
985	condition.setRightOperand(ifCondition);	983	condition.setRightOperand(getParenthesizedExpressionIfNeeded(ast, rewrite, ifStatement.getExpression(), condition, InfixExpression.RIGHT_OPERAND_PROPERTY));
986	hasRightOperand= true;	984	hasRightOperand= true;
987	} else {	985	} else {
988	InfixExpression newCondition= ast.newInfixExpression();	986	InfixExpression newCondition= ast.newInfixExpression();
989	newCondition.setOperator(orOperator);	987	newCondition.setOperator(orOperator);
990	newCondition.setLeftOperand(condition);	988	newCondition.setLeftOperand(condition);
991	newCondition.setRightOperand(ifCondition);	989	newCondition.setRightOperand(getParenthesizedExpressionIfNeeded(ast, rewrite, ifStatement.getExpression(), condition, InfixExpression.RIGHT_OPERAND_PROPERTY));
992	condition= newCondition;	990	condition= newCondition;
993	}	991	}
994	}	992	}
Lines 1020-1036 Link Here
1020	return true;	1018	return true;
1021	}	1019	}
1022		1020
1023	private static Expression getParenthesizedForOrIfNeeded(AST ast, ASTRewrite rewrite, Expression expression) {
1024	boolean addParentheses= false;
1025	int nodeType= expression.getNodeType();
1026	addParentheses= nodeType == ASTNode.CONDITIONAL_EXPRESSION \|\| nodeType == ASTNode.ASSIGNMENT \|\| nodeType == ASTNode.INSTANCEOF_EXPRESSION;
1027	expression= (Expression) rewrite.createCopyTarget(expression);
1028	if (addParentheses) {
1029	return getParenthesizedExpression(ast, expression);
1030	}
1031	return expression;
1032	}
1033
1034	public static boolean getSplitOrConditionProposals(IInvocationContext context, ASTNode node, Collection resultingCollections) {	1021	public static boolean getSplitOrConditionProposals(IInvocationContext context, ASTNode node, Collection resultingCollections) {
1035	Operator orOperator= InfixExpression.Operator.CONDITIONAL_OR;	1022	Operator orOperator= InfixExpression.Operator.CONDITIONAL_OR;
1036	// check that user invokes quick assist on infix expression	1023	// check that user invokes quick assist on infix expression
Lines 1254-1267 Link Here
1254	}	1241	}
1255	}	1242	}
1256		1243
1257	// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=332019	1244	if (NecessaryParenthesesChecker.needsParentheses(leftExpression, infixExpression, InfixExpression.RIGHT_OPERAND_PROPERTY)) {
1258	if (operator == InfixExpression.Operator.EQUALS \|\| operator == InfixExpression.Operator.NOT_EQUALS) {	1245	leftExpression= getParenthesizedExpression(ast, leftExpression);
1259	if (leftExpression instanceof InfixExpression && !(leftExpression instanceof ParenthesizedExpression)) {	1246	}
1260	leftExpression= getParenthesizedExpression(ast, leftExpression);	1247	if (NecessaryParenthesesChecker.needsParentheses(rightExpression, infixExpression, InfixExpression.LEFT_OPERAND_PROPERTY)) {
1261	}	1248	rightExpression= getParenthesizedExpression(ast, rightExpression);
1262	if (rightExpression instanceof InfixExpression && !(rightExpression instanceof ParenthesizedExpression)) {
1263	rightExpression= getParenthesizedExpression(ast, rightExpression);
1264	}
1265	}	1249	}
1266		1250
1267	if (operator == InfixExpression.Operator.LESS) {	1251	if (operator == InfixExpression.Operator.LESS) {
Lines 1319-1331 Link Here
1319	}	1303	}
1320	}	1304	}
1321		1305
1322	private static Expression combineOperands(ASTRewrite rewrite, Expression existing, Expression nodeToAdd, boolean removeParentheses, Operator operator) {	1306	private static Expression combineOperands(ASTRewrite rewrite, Expression existing, Expression originalNode, boolean removeParentheses, Operator operator) {
1323	if (existing == null && removeParentheses) {	1307	if (existing == null && removeParentheses) {
1324	while (nodeToAdd instanceof ParenthesizedExpression) {	1308	while (originalNode instanceof ParenthesizedExpression) {
1325	nodeToAdd= ((ParenthesizedExpression) nodeToAdd).getExpression();	1309	originalNode= ((ParenthesizedExpression)originalNode).getExpression();
1326	}	1310	}
1327	}	1311	}
1328	Expression newRight= (Expression) rewrite.createMoveTarget(nodeToAdd);	1312	Expression newRight= (Expression)rewrite.createMoveTarget(originalNode);
		1313	if (originalNode instanceof InfixExpression) {
		1314	((InfixExpression)newRight).setOperator(((InfixExpression)originalNode).getOperator());
		1315	}
		1316
1329	if (existing == null) {	1317	if (existing == null) {
1330	return newRight;	1318	return newRight;
1331	}	1319	}





	}

	public void testJoinAndIfStatementsBug335173() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(Object a, int x) {\n");
		buf.append("        if (a instanceof String) {\n");
		buf.append("            if (x > 2) {\n");
		buf.append("            }\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		int offset= buf.toString().indexOf("if (a");
		AssistContext context= getCorrectionContext(cu, offset, 0);
		List proposals= collectAssists(context, false);

		assertCorrectLabels(proposals);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(Object a, int x) {\n");
		buf.append("        if (a instanceof String && x > 2) {\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertExpectedExistInProposals(proposals, new String[] { expected1 });

	}

	public void testJoinOrIfStatements1() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();


	}

	public void testJoinOrIfStatementsBug335173() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(Object a, int x) {\n");
		buf.append("        if (a instanceof String)\n");
		buf.append("            return;\n");
		buf.append("        if (x > 2)\n");
		buf.append("            return;\n");
		buf.append("        x= 9;\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		int offset1= buf.toString().indexOf("if (a");
		int offset2= buf.toString().lastIndexOf("x= 9;");
		AssistContext context= getCorrectionContext(cu, offset1, offset2 - offset1);
		List proposals= collectAssists(context, false);

		for (Iterator I= proposals.iterator(); I.hasNext();) {
			Object o= I.next();
			if (!(o instanceof CUCorrectionProposal))
				I.remove();
		}

		assertCorrectLabels(proposals);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(Object a, int x) {\n");
		buf.append("        if (a instanceof String || x > 2)\n");
		buf.append("            return;\n");
		buf.append("        x= 9;\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertExpectedExistInProposals(proposals, new String[] { expected1 });

	}

	public void testSplitOrCondition1() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();

		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public boolean foo(int a, int b) {\n");
		buf.append("        return (a == b) != b > 0;\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();


	}

	public void testExchangeOperandsBug332019_4() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public boolean foo(int a, int b) {\n");
		buf.append("        return b + 1 != a - 1;\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		int offset= buf.toString().indexOf("!=");
		AssistContext context= getCorrectionContext(cu, offset, 0);
		assertNoErrors(context);
		List proposals= collectAssists(context, false);

		assertCorrectLabels(proposals);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public boolean foo(int a, int b) {\n");
		buf.append("        return a - 1 != b + 1;\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertExpectedExistInProposals(proposals, new String[] { expected1 });

	}

	public void testAssignAndCast1() throws Exception {
		//https://bugs.eclipse.org/bugs/show_bug.cgi?id=75066
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);


	}

	public void testInverseCondition2() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(Object a) {\n");
		buf.append("        if (!(a instanceof String)) {\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		int offset= buf.toString().indexOf("!");
		int length= "!(a instanceof String)".length();
		AssistContext context= getCorrectionContext(cu, offset, length);
		List proposals= collectAssists(context, false);

		assertCorrectLabels(proposals);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(Object a) {\n");
		buf.append("        if (a instanceof String) {\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertExpectedExistInProposals(proposals, new String[] { expected1 });

	}

	public void testInverseCondition3() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(Object a) {\n");
		buf.append("        while (!(a instanceof String)) {\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		int offset= buf.toString().indexOf("!");
		int length= "!(a instanceof String)".length();
		AssistContext context= getCorrectionContext(cu, offset, length);
		List proposals= collectAssists(context, false);

		assertCorrectLabels(proposals);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(Object a) {\n");
		buf.append("        while (a instanceof String) {\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertExpectedExistInProposals(proposals, new String[] { expected1 });

	}

	public void testInverseCondition4() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(Object a) {\n");
		buf.append("        for (int i = 0; !(a instanceof String); i++) {\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		int offset= buf.toString().indexOf("!");
		int length= "!(a instanceof String)".length();
		AssistContext context= getCorrectionContext(cu, offset, length);
		List proposals= collectAssists(context, false);

		assertCorrectLabels(proposals);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(Object a) {\n");
		buf.append("        for (int i = 0; a instanceof String; i++) {\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertExpectedExistInProposals(proposals, new String[] { expected1 });

	}

	public void testInverseCondition5() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(Object a) {\n");
		buf.append("        do {\n");
		buf.append("        } while (!(a instanceof String));\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		int offset= buf.toString().indexOf("!");
		int length= "!(a instanceof String)".length();
		AssistContext context= getCorrectionContext(cu, offset, length);
		List proposals= collectAssists(context, false);

		assertCorrectLabels(proposals);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(Object a) {\n");
		buf.append("        do {\n");
		buf.append("        } while (a instanceof String);\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertExpectedExistInProposals(proposals, new String[] { expected1 });

	}

	public void testInverseCondition6() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(Object a) {\n");
		buf.append("        assert !(a instanceof String);\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		int offset= buf.toString().indexOf("!");
		int length= "!(a instanceof String)".length();
		AssistContext context= getCorrectionContext(cu, offset, length);
		List proposals= collectAssists(context, false);

		assertCorrectLabels(proposals);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(Object a) {\n");
		buf.append("        assert a instanceof String;\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertExpectedExistInProposals(proposals, new String[] { expected1 });

	}

	public void testPushNegationDown1() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();




		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testUnusedCodeBug335173_1() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();

		buf.append("package test1;\n");
		buf.append("import java.util.Comparator;\n");
		buf.append("\n");
		buf.append("class IntComp implements Comparator<Integer> {\n");
		buf.append("    public int compare(Integer o1, Integer o2) {\n");
		buf.append("        return ((Integer) o1).intValue() - ((Integer) o2).intValue();\n");
		buf.append("    }\n");
		buf.append("}\n");

		ICompilationUnit cu1= pack1.createCompilationUnit("IntComp.java", buf.toString(), false, null);

		enable(CleanUpConstants.REMOVE_UNNECESSARY_CASTS);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import java.util.Comparator;\n");
		buf.append("\n");
		buf.append("class IntComp implements Comparator<Integer> {\n");
		buf.append("    public int compare(Integer o1, Integer o2) {\n");
		buf.append("        return o1.intValue() - o2.intValue();\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testUnusedCodeBug335173_2() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("\n");
		buf.append("public class E1 {\n");
		buf.append("    public void foo(Integer n) {\n");
		buf.append("        int i = (((Integer) n)).intValue();\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);

		enable(CleanUpConstants.REMOVE_UNNECESSARY_CASTS);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("\n");
		buf.append("public class E1 {\n");
		buf.append("    public void foo(Integer n) {\n");
		buf.append("        int i = (n).intValue();\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testUnusedCodeBug335173_3() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("\n");
		buf.append("public class E1 {\n");
		buf.append("    public void foo(Integer n) {\n");
		buf.append("        int i = ((Integer) (n)).intValue();\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);

		enable(CleanUpConstants.REMOVE_UNNECESSARY_CASTS);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("\n");
		buf.append("public class E1 {\n");
		buf.append("    public void foo(Integer n) {\n");
		buf.append("        int i = (n).intValue();\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testJava5001() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();

		buf.append("package test1;\n");
		buf.append("public class E1 {\n");
		buf.append("    public void foo() {\n");
		buf.append("        double d = 2.0 * (0.5 / 4.0);\n");
		buf.append("        int spaceCount = 3;\n");
		buf.append("        spaceCount = 2 * (spaceCount / 2);\n");
		buf.append("    }\n");

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { buf.toString() });
	}

	public void testRemoveParenthesesBug335173_1() throws Exception {
		//while loop's expression
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(boolean a) {\n");
		buf.append("        while (((a))) {\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("    public void bar(int x) {\n");
		buf.append("        while ((x > 2)) {\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER);

		buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(boolean a) {\n");
		buf.append("        while (a) {\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("    public void bar(int x) {\n");
		buf.append("        while (x > 2) {\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testRemoveParenthesesBug335173_2() throws Exception {
		//do while loop's expression
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        do {\n");
		buf.append("        } while ((x > 2));\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER);

		buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        do {\n");
		buf.append("        } while (x > 2);\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testRemoveParenthesesBug335173_3() throws Exception {
		//for loop's expression
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        for (int x = 0; (x > 2); x++) {\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER);

		buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        for (int x = 0; x > 2; x++) {\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testRemoveParenthesesBug335173_4() throws Exception {
		//switch statement expression
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        switch ((x - 2)) {\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER);

		buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        switch (x - 2) {\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testRemoveParenthesesBug335173_5() throws Exception {
		//switch case expression
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        switch (x) {\n");
		buf.append("        case (1 + 2):\n");
		buf.append("            break;\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER);

		buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        switch (x) {\n");
		buf.append("        case 1 + 2:\n");
		buf.append("            break;\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testRemoveParenthesesBug335173_6() throws Exception {
		//throw statement expression
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int type) throws Exception {\n");
		buf.append("        throw (type == 1 ? new IllegalArgumentException() : new Exception());\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER);

		buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int type) throws Exception {\n");
		buf.append("        throw type == 1 ? new IllegalArgumentException() : new Exception();\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testRemoveParenthesesBug335173_7() throws Exception {
		//synchronized statement expression
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    private static final Object OBJECT = new Object();\n");
		buf.append("    private static final String STRING = new String();\n");
		buf.append("    \n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        synchronized ((x == 1 ? STRING : OBJECT)) {\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER);

		buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    private static final Object OBJECT = new Object();\n");
		buf.append("    private static final String STRING = new String();\n");
		buf.append("    \n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        synchronized (x == 1 ? STRING : OBJECT) {\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testRemoveParenthesesBug335173_8() throws Exception {
		//assert statement expression
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        assert (x > 2);\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER);

		buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        assert x > 2;\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testRemoveParenthesesBug335173_9() throws Exception {
		//assert statement message expression
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        assert x > 2 : (x - 2);\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER);

		buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        assert x > 2 : x - 2;\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testRemoveParenthesesBug335173_10() throws Exception {
		//array access index expression
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int a[], int x) {\n");
		buf.append("        int i = a[(x + 2)];\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER);

		buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int a[], int x) {\n");
		buf.append("        int i = a[x + 2];\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testRemoveParenthesesBug335173_11() throws Exception {
		//conditional expression's then expression
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        int i = x > 10 ? (x > 5 ? x - 1 : x - 2): x;\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER);

		buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        int i = x > 10 ? x > 5 ? x - 1 : x - 2: x;\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testRemoveParenthesesBug335173_12() throws Exception {
		//conditional expression's else expression
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        int i = x > 10 ? x: (x > 5 ? x - 1 : x - 2);\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER);

		buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        int i = x > 10 ? x: x > 5 ? x - 1 : x - 2;\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testRemoveParenthesesBug335173_13() throws Exception {
		//conditional expression's then expression
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        int i = x > 10 ? (x = x - 2): x;\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER);

		buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        int i = x > 10 ? (x = x - 2): x;\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testRemoveParenthesesBug335173_14() throws Exception {
		//conditional expression's else expression
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        int i = x > 10 ? x: (x = x - 2);\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER);

		buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        int i = x > 10 ? x: (x = x - 2);\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testRemoveParenthesesBug335173_15() throws Exception {
		//shift operators
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        int m= (x >> 2) >> 1;\n");
		buf.append("        m= x >> (2 >> 1);\n");
		buf.append("        int n= (x << 2) << 1;\n");
		buf.append("        n= x << (2 << 1);\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER);

		buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x) {\n");
		buf.append("        int m= x >> 2 >> 1;\n");
		buf.append("        m= x >> (2 >> 1);\n");
		buf.append("        int n= x << 2 << 1;\n");
		buf.append("        n= x << (2 << 1);\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testRemoveParenthesesBug335173_16() throws Exception {
		//integer multiplication
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x, long y) {\n");
		buf.append("        int m= (4 * x) * 2;\n");
		buf.append("        int n= 4 * (x * 2);\n");
		buf.append("        int p= 4 * (x % 3);\n");
		buf.append("        int q= 4 * (x / 3);\n");
		buf.append("        int r= 4 * (x * y);\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER);

		buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x, long y) {\n");
		buf.append("        int m= 4 * x * 2;\n");
		buf.append("        int n= 4 * x * 2;\n");
		buf.append("        int p= 4 * (x % 3);\n");
		buf.append("        int q= 4 * (x / 3);\n");
		buf.append("        int r= 4 * (x * y);\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testRemoveParenthesesBug335173_17() throws Exception {
		//floating point multiplication
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(double x) {\n");
		buf.append("        int m= (4.0 * x) * 0.5;\n");
		buf.append("        int n= 4.0 * (x * 0.5);\n");
		buf.append("        int p= 4.0 * (x / 100);\n");
		buf.append("        int q= 4.0 * (x % 3);\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER);

		buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(double x) {\n");
		buf.append("        int m= 4.0 * x * 0.5;\n");
		buf.append("        int n= 4.0 * (x * 0.5);\n");
		buf.append("        int p= 4.0 * (x / 100);\n");
		buf.append("        int q= 4.0 * (x % 3);\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testRemoveParenthesesBug335173_18() throws Exception {
		//integer addition
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x, long y) {\n");
		buf.append("        int m= (4 + x) + 2;\n");
		buf.append("        int n= 4 + (x + 2);\n");
		buf.append("        int p= 4 + (x + y);\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER);

		buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(int x, long y) {\n");
		buf.append("        int m= 4 + x + 2;\n");
		buf.append("        int n= 4 + x + 2;\n");
		buf.append("        int p= 4 + (x + y);\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testRemoveParenthesesBug335173_19() throws Exception {
		//floating point addition
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(double x) {\n");
		buf.append("        int m= (4.0 + x) + 100.0;\n");
		buf.append("        int n= 4.0 + (x + 100.0);\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER);

		buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(double x) {\n");
		buf.append("        int m= 4.0 + x + 100.0;\n");
		buf.append("        int n= 4.0 + (x + 100.0);\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testRemoveParenthesesBug335173_20() throws Exception {
		//string concatenation
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(String s, String t, String u) {\n");
		buf.append("        String a= (s + t) + u;\n");
		buf.append("        String b= s + (t + u);\n");
		buf.append("        String c= (1 + 2) + s;\n");
		buf.append("        String d= 1 + (2 + s);\n");
		buf.append("        String e= s + (1 + 2);\n");
		buf.append("        String f= (s + 1) + 2;\n");
		buf.append("        String g= (1 + s) + 2;\n");
		buf.append("        String h= 1 + (s + 2);\n");
		buf.append("        String i= s + (1 + t);\n");
		buf.append("        String j= s + (t + 1);\n");
		buf.append("        String k= s + (1 - 2);\n");
		buf.append("        String l= s + (1 * 2);\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu1= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
		enable(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER);

		buf= new StringBuffer();
		buf.append("package test;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(String s, String t, String u) {\n");
		buf.append("        String a= s + t + u;\n");
		buf.append("        String b= s + t + u;\n");
		buf.append("        String c= 1 + 2 + s;\n");
		buf.append("        String d= 1 + (2 + s);\n");
		buf.append("        String e= s + (1 + 2);\n");
		buf.append("        String f= s + 1 + 2;\n");
		buf.append("        String g= 1 + s + 2;\n");
		buf.append("        String h= 1 + s + 2;\n");
		buf.append("        String i= s + 1 + t;\n");
		buf.append("        String j= s + t + 1;\n");
		buf.append("        String k= s + (1 - 2);\n");
		buf.append("        String l= s + 1 * 2;\n");
		buf.append("    }\n");
		buf.append("}\n");
		String expected1= buf.toString();

		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
	}

	public void testRemoveQualifier01() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();




/*******************************************************************************
 * Copyright (c) 2007, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

		assertExpectedExistInProposals(proposals, expected);
	}

	public void testInvisibleFieldToGetterSetterBug335173_1() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("p", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package p;\n");
		buf.append("\n");
		buf.append("public class C {\n");
		buf.append("    private int test;\n");
		buf.append("\n");
		buf.append("    public int getTest() {\n");
		buf.append("        return this.test;\n");
		buf.append("    }\n");
		buf.append("\n");
		buf.append("    public void setTest(int test) {\n");
		buf.append("        this.test = test;\n");
		buf.append("    }\n");
		buf.append("}\n");
		buf.append("\n");
		buf.append("class D {\n");
		buf.append("    public void foo(int x){\n");
		buf.append("        C c=new C();\n");
		buf.append("        c.test+= x;\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("C.java", buf.toString(), false, null);

		CompilationUnit astRoot= getASTRoot(cu);
		ArrayList proposals= collectCorrections(cu, astRoot);

		assertCorrectLabels(proposals);
		assertNumberOfProposals(proposals, 2);

		String[] expected= new String[1];
		buf= new StringBuffer();
		buf.append("package p;\n");
		buf.append("\n");
		buf.append("public class C {\n");
		buf.append("    private int test;\n");
		buf.append("\n");
		buf.append("    public int getTest() {\n");
		buf.append("        return this.test;\n");
		buf.append("    }\n");
		buf.append("\n");
		buf.append("    public void setTest(int test) {\n");
		buf.append("        this.test = test;\n");
		buf.append("    }\n");
		buf.append("}\n");
		buf.append("\n");
		buf.append("class D {\n");
		buf.append("    public void foo(int x){\n");
		buf.append("        C c=new C();\n");
		buf.append("        c.setTest(c.getTest() + x);\n");
		buf.append("    }\n");
		buf.append("}\n");
		expected[0]= buf.toString();

		assertExpectedExistInProposals(proposals, expected);
	}

	public void testInvisibleFieldToGetterSetterBug335173_2() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("p", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package p;\n");
		buf.append("\n");
		buf.append("public class C {\n");
		buf.append("    private int test;\n");
		buf.append("\n");
		buf.append("    public int getTest() {\n");
		buf.append("        return this.test;\n");
		buf.append("    }\n");
		buf.append("\n");
		buf.append("    public void setTest(int test) {\n");
		buf.append("        this.test = test;\n");
		buf.append("    }\n");
		buf.append("}\n");
		buf.append("\n");
		buf.append("class D {\n");
		buf.append("    public void foo(){\n");
		buf.append("        C c=new C();\n");
		buf.append("        c.test+= 1 + 2;\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("C.java", buf.toString(), false, null);

		CompilationUnit astRoot= getASTRoot(cu);
		ArrayList proposals= collectCorrections(cu, astRoot);

		assertCorrectLabels(proposals);
		assertNumberOfProposals(proposals, 2);

		String[] expected= new String[1];
		buf= new StringBuffer();
		buf.append("package p;\n");
		buf.append("\n");
		buf.append("public class C {\n");
		buf.append("    private int test;\n");
		buf.append("\n");
		buf.append("    public int getTest() {\n");
		buf.append("        return this.test;\n");
		buf.append("    }\n");
		buf.append("\n");
		buf.append("    public void setTest(int test) {\n");
		buf.append("        this.test = test;\n");
		buf.append("    }\n");
		buf.append("}\n");
		buf.append("\n");
		buf.append("class D {\n");
		buf.append("    public void foo(){\n");
		buf.append("        C c=new C();\n");
		buf.append("        c.setTest(c.getTest() + (1 + 2));\n");
		buf.append("    }\n");
		buf.append("}\n");
		expected[0]= buf.toString();

		assertExpectedExistInProposals(proposals, expected);
	}

	public void testInvisibleFieldToGetterSetterBug335173_3() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("p", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package p;\n");
		buf.append("\n");
		buf.append("public class C {\n");
		buf.append("    private int test;\n");
		buf.append("\n");
		buf.append("    public int getTest() {\n");
		buf.append("        return this.test;\n");
		buf.append("    }\n");
		buf.append("\n");
		buf.append("    public void setTest(int test) {\n");
		buf.append("        this.test = test;\n");
		buf.append("    }\n");
		buf.append("}\n");
		buf.append("\n");
		buf.append("class D {\n");
		buf.append("    public void foo(){\n");
		buf.append("        C c=new C();\n");
		buf.append("        c.test-= 1 + 2;\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("C.java", buf.toString(), false, null);

		CompilationUnit astRoot= getASTRoot(cu);
		ArrayList proposals= collectCorrections(cu, astRoot);

		assertCorrectLabels(proposals);
		assertNumberOfProposals(proposals, 2);

		String[] expected= new String[1];
		buf= new StringBuffer();
		buf.append("package p;\n");
		buf.append("\n");
		buf.append("public class C {\n");
		buf.append("    private int test;\n");
		buf.append("\n");
		buf.append("    public int getTest() {\n");
		buf.append("        return this.test;\n");
		buf.append("    }\n");
		buf.append("\n");
		buf.append("    public void setTest(int test) {\n");
		buf.append("        this.test = test;\n");
		buf.append("    }\n");
		buf.append("}\n");
		buf.append("\n");
		buf.append("class D {\n");
		buf.append("    public void foo(){\n");
		buf.append("        C c=new C();\n");
		buf.append("        c.setTest(c.getTest() - (1 + 2));\n");
		buf.append("    }\n");
		buf.append("}\n");
		expected[0]= buf.toString();

		assertExpectedExistInProposals(proposals, expected);
	}

	public void testInvisibleFieldToGetterSetterBug335173_4() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("p", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package p;\n");
		buf.append("\n");
		buf.append("public class C {\n");
		buf.append("    private int test;\n");
		buf.append("\n");
		buf.append("    public int getTest() {\n");
		buf.append("        return this.test;\n");
		buf.append("    }\n");
		buf.append("\n");
		buf.append("    public void setTest(int test) {\n");
		buf.append("        this.test = test;\n");
		buf.append("    }\n");
		buf.append("}\n");
		buf.append("\n");
		buf.append("class D {\n");
		buf.append("    public void foo(){\n");
		buf.append("        C c=new C();\n");
		buf.append("        c.test*= 1 + 2;\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("C.java", buf.toString(), false, null);

		CompilationUnit astRoot= getASTRoot(cu);
		ArrayList proposals= collectCorrections(cu, astRoot);

		assertCorrectLabels(proposals);
		assertNumberOfProposals(proposals, 2);

		String[] expected= new String[1];
		buf= new StringBuffer();
		buf.append("package p;\n");
		buf.append("\n");
		buf.append("public class C {\n");
		buf.append("    private int test;\n");
		buf.append("\n");
		buf.append("    public int getTest() {\n");
		buf.append("        return this.test;\n");
		buf.append("    }\n");
		buf.append("\n");
		buf.append("    public void setTest(int test) {\n");
		buf.append("        this.test = test;\n");
		buf.append("    }\n");
		buf.append("}\n");
		buf.append("\n");
		buf.append("class D {\n");
		buf.append("    public void foo(){\n");
		buf.append("        C c=new C();\n");
		buf.append("        c.setTest(c.getTest() * (1 + 2));\n");
		buf.append("    }\n");
		buf.append("}\n");
		expected[0]= buf.toString();

		assertExpectedExistInProposals(proposals, expected);
	}

	public void testCreateFieldUsingSef() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("", false, null);
		StringBuffer buf= new StringBuffer();




		assertEqualString(preview, buf.toString());
	}

	public void testUnnecessaryCastBug335173_1() throws Exception {
		Hashtable hashtable= JavaCore.getOptions();
		hashtable.put(JavaCore.COMPILER_PB_UNNECESSARY_TYPE_CHECK, JavaCore.ERROR);
		JavaCore.setOptions(hashtable);

		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(Integer n) {\n");
		buf.append("        int i = (((Integer) n)).intValue();\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		CompilationUnit astRoot= getASTRoot(cu);
		ArrayList proposals= collectCorrections(cu, astRoot);
		assertNumberOfProposals(proposals, 1);
		assertCorrectLabels(proposals);

		CUCorrectionProposal proposal= (CUCorrectionProposal)proposals.get(0);
		String preview= getPreviewContent(proposal);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(Integer n) {\n");
		buf.append("        int i = (n).intValue();\n");
		buf.append("    }\n");
		buf.append("}\n");
		assertEqualString(preview, buf.toString());
	}

	public void testUnnecessaryCastBug335173_2() throws Exception {
		Hashtable hashtable= JavaCore.getOptions();
		hashtable.put(JavaCore.COMPILER_PB_UNNECESSARY_TYPE_CHECK, JavaCore.ERROR);
		JavaCore.setOptions(hashtable);

		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(Integer n) {\n");
		buf.append("        int i = ((Integer) (n)).intValue();\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		CompilationUnit astRoot= getASTRoot(cu);
		ArrayList proposals= collectCorrections(cu, astRoot);
		assertNumberOfProposals(proposals, 1);
		assertCorrectLabels(proposals);

		CUCorrectionProposal proposal= (CUCorrectionProposal)proposals.get(0);
		String preview= getPreviewContent(proposal);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("public class E {\n");
		buf.append("    public void foo(Integer n) {\n");
		buf.append("        int i = (n).intValue();\n");
		buf.append("    }\n");
		buf.append("}\n");
		assertEqualString(preview, buf.toString());
	}

	public void testSuperfluousSemicolon() throws Exception {
		Hashtable hashtable= JavaCore.getOptions();
		hashtable.put(JavaCore.COMPILER_PB_EMPTY_STATEMENT, JavaCore.ERROR);

Added Link Here

(-)resources/ExtractConstant/canExtract/A_test39_in.java (+7 lines)
1	//5, 21 -> 5, 26 AllowLoadtime == false
2	package p;
3	class A {
4	void f() {
5	int i= 1 - (2 + 3);
6	}
7	}

Added Link Here

(-)resources/ExtractConstant/canExtract/A_test39_out.java (+9 lines)
1	//5, 21 -> 5, 26 AllowLoadtime == false
2	package p;
3	class A {
4	private static final int CONSTANT= 2 + 3;
5
6	void f() {
7	int i= 1 - CONSTANT;
8	}
9	}

Added Link Here

(-)resources/ExtractConstant/canExtract/A_test40_in.java (+7 lines)
1	//5, 20 -> 5, 27 AllowLoadtime == false
2	package p;
3	class A {
4	void f() {
5	int i= 1 - (2 + 3);
6	}
7	}

Added Link Here

(-)resources/ExtractConstant/canExtract/A_test40_out.java (+9 lines)
1	//5, 20 -> 5, 27 AllowLoadtime == false
2	package p;
3	class A {
4	private static final int CONSTANT= 2 + 3;
5
6	void f() {
7	int i= 1 - CONSTANT;
8	}
9	}

Added Link Here

(-)resources/ExtractConstant/canExtract/A_test41_in.java (+7 lines)
1	//5, 22 -> 5, 27 AllowLoadtime == false
2	package p;
3	class A {
4	void f() {
5	int i= 1 - ((2 + 3));
6	}
7	}

Added Link Here

(-)resources/ExtractConstant/canExtract/A_test41_out.java (+9 lines)
1	//5, 22 -> 5, 27 AllowLoadtime == false
2	package p;
3	class A {
4	private static final int CONSTANT= 2 + 3;
5
6	void f() {
7	int i= 1 - (CONSTANT);
8	}
9	}

Added Link Here

(-)resources/ExtractConstant/canExtract/A_test42_in.java (+7 lines)
1	//5, 21 -> 5, 28 AllowLoadtime == false
2	package p;
3	class A {
4	void f() {
5	int i= 1 - ((2 + 3));
6	}
7	}

Added Link Here

(-)resources/ExtractConstant/canExtract/A_test42_out.java (+9 lines)
1	//5, 21 -> 5, 28 AllowLoadtime == false
2	package p;
3	class A {
4	private static final int CONSTANT= 2 + 3;
5
6	void f() {
7	int i= 1 - CONSTANT;
8	}
9	}

Added Link Here

(-)resources/ExtractConstant/canExtract/A_test43_in.java (+7 lines)
1	//5, 20 -> 5, 29 AllowLoadtime == false
2	package p;
3	class A {
4	void f() {
5	int i= 1 - ((2 + 3));
6	}
7	}

Added Link Here

(-)resources/ExtractConstant/canExtract/A_test43_out.java (+9 lines)
1	//5, 20 -> 5, 29 AllowLoadtime == false
2	package p;
3	class A {
4	private static final int CONSTANT= (2 + 3);
5
6	void f() {
7	int i= 1 - CONSTANT;
8	}
9	}

Added Link Here

(-)resources/ExtractMethodWorkSpace/ExtractMethodTests/expression_in/A_test625.java (+9 lines)
1	package expression_in;
2
3	public class A_test625 {
4
5	public void foo() {
6	int i= 1 - (/[/2 + 3/]/);
7	int j= 1 - (2 + 3);
8	}
9	}

Added Link Here

(-)resources/ExtractMethodWorkSpace/ExtractMethodTests/expression_in/A_test626.java (+9 lines)
1	package expression_in;
2
3	public class A_test626 {
4
5	public void foo() {
6	int i= 1 - /[/(2 + 3)/]/;
7	int j= 1 - (2 + 3);
8	}
9	}

Added Link Here

(-)resources/ExtractMethodWorkSpace/ExtractMethodTests/expression_in/A_test627.java (+9 lines)
1	package expression_in;
2
3	public class A_test627 {
4
5	public void foo() {
6	int i= 1 - ((/[/2 + 3/]/));
7	int j= 1 - ((2 + 3));
8	}
9	}

Added Link Here

(-)resources/ExtractMethodWorkSpace/ExtractMethodTests/expression_in/A_test628.java (+9 lines)
1	package expression_in;
2
3	public class A_test627 {
4
5	public void foo() {
6	int i= 1 - (/[/(2 + 3)/]/);
7	int j= 1 - ((2 + 3));
8	}
9	}

Added Link Here

(-)resources/ExtractMethodWorkSpace/ExtractMethodTests/expression_in/A_test629.java (+9 lines)
1	package expression_in;
2
3	public class A_test627 {
4
5	public void foo() {
6	int i= 1 - /[/((2 + 3))/]/;
7	int j= 1 - ((2 + 3));
8	}
9	}




package expression_out;

public class A_test625 {

	public void foo() {
		int i= 1 - extracted();
		int j= 1 - extracted();
	}

	protected int extracted() {
		return /*[*/2 + 3/*]*/;
	}	
}




package expression_out;

public class A_test626 {

	public void foo() {
		int i= 1 - extracted();
		int j= 1 - extracted();
	}

	protected int extracted() {
		return 2 + 3;
	}	
}




package expression_out;

public class A_test627 {

	public void foo() {
		int i= 1 - (extracted());
		int j= 1 - (extracted());
	}

	protected int extracted() {
		return /*[*/2 + 3/*]*/;
	}	
}




package expression_out;

public class A_test627 {

	public void foo() {
		int i= 1 - extracted();
		int j= 1 - extracted();
	}

	protected int extracted() {
		return 2 + 3;
	}	
}




package expression_out;

public class A_test627 {

	public void foo() {
		int i= 1 - extracted();
		int j= 1 - extracted();
	}

	protected int extracted() {
		return (2 + 3);
	}	
}

Added Link Here

(-)resources/ExtractTemp/canExtract/A_test105_in.java (+7 lines)
1	package p; //5, 21, 5, 26
2
3	class A {
4	public void m() {
5	int a= 1 - (2 + 3);
6	}
7	}

Added Link Here

(-)resources/ExtractTemp/canExtract/A_test105_out.java (+8 lines)
1	package p; //5, 21, 5, 26
2
3	class A {
4	public void m() {
5	int temp= 2 + 3;
6	int a= 1 - temp;
7	}
8	}

Added Link Here

(-)resources/ExtractTemp/canExtract/A_test106_in.java (+7 lines)
1	package p; //5, 20, 5, 27
2
3	class A {
4	public void m() {
5	int a= 1 - (2 + 3);
6	}
7	}

Added Link Here

(-)resources/ExtractTemp/canExtract/A_test106_out.java (+8 lines)
1	package p; //5, 20, 5, 27
2
3	class A {
4	public void m() {
5	int temp= 2 + 3;
6	int a= 1 - temp;
7	}
8	}

Added Link Here

(-)resources/ExtractTemp/canExtract/A_test107_in.java (+7 lines)
1	package p; //5, 22, 5, 27
2
3	class A {
4	public void m() {
5	int a= 1 - ((2 + 3));
6	}
7	}

Added Link Here

(-)resources/ExtractTemp/canExtract/A_test107_out.java (+8 lines)
1	package p; //5, 22, 5, 27
2
3	class A {
4	public void m() {
5	int temp= 2 + 3;
6	int a= 1 - (temp);
7	}
8	}

Added Link Here

(-)resources/ExtractTemp/canExtract/A_test108_in.java (+7 lines)
1	package p; //5, 21, 5, 28
2
3	class A {
4	public void m() {
5	int a= 1 - ((2 + 3));
6	}
7	}

Added Link Here

(-)resources/ExtractTemp/canExtract/A_test108_out.java (+8 lines)
1	package p; //5, 21, 5, 28
2
3	class A {
4	public void m() {
5	int temp= 2 + 3;
6	int a= 1 - temp;
7	}
8	}

Added Link Here

(-)resources/ExtractTemp/canExtract/A_test109_in.java (+7 lines)
1	package p; //5, 20, 5, 29
2
3	class A {
4	public void m() {
5	int a= 1 - ((2 + 3));
6	}
7	}

Added Link Here

(-)resources/ExtractTemp/canExtract/A_test109_out.java (+8 lines)
1	package p; //5, 20, 5, 29
2
3	class A {
4	public void m() {
5	int temp= (2 + 3);
6	int a= 1 - temp;
7	}
8	}

Lines 14-20 Link Here

(-)resources/InlineConstant/canInline/test24/out/A.java (-2 / +2 lines)
14	+ p.A.getCount() + A.getCount() + getCount2();	14	+ p.A.getCount() + A.getCount() + getCount2();
15	int ii= Consts.I + Consts.I + q.Consts.I	15	int ii= Consts.I + Consts.I + q.Consts.I
16	+ p.A.getCount() + A.getCount() + getCount2();	16	+ p.A.getCount() + A.getCount() + getCount2();
17	return (I + Consts.I + q.Consts.I	17	return I + Consts.I + q.Consts.I
18	+ p.A.getCount() + A.getCount() + getCount2()) + i + ii;	18	+ p.A.getCount() + A.getCount() + getCount2() + i + ii;
19	}	19	}
20	}	20	}

Lines 8-17 Link Here

(-)resources/InlineConstant/canInline/test33/out/A.java (-3 / +3 lines)
8	int f1= K - 1 - (B - 1);	8	int f1= K - 1 - (B - 1);
9	int f2= K - (B - 1) - (B - 1) - (B - 1);	9	int f2= K - (B - 1) - (B - 1) - (B - 1);
10		10
11	int x1= K + (B - 1);	11	int x1= K + B - 1;
12	int x2= K - (B - 1);	12	int x2= K - (B - 1);
13	int x3= K + 1 - (B - 1);	13	int x3= K + 1 - (B - 1);
14	int x4= K - 1 + (B - 1);	14	int x4= K - 1 + B - 1;
15	int x5= K + 1 + (B - 1) - (B - 1) - (B - 1);	15	int x5= K + 1 + B - 1 - (B - 1) - (B - 1);
16	}	16	}
17	}	17	}

Added Link Here

(-)resources/InlineConstant/canInline/test35/in/A.java (+8 lines)
1	package p;
2
3	class A {
4	static final int a = 10 + 20;
5	void foo() {
6	int b = 1 + a;
7	}
8	}

Added Link Here

(-)resources/InlineConstant/canInline/test35/out/A.java (+7 lines)
1	package p;
2
3	class A {
4	void foo() {
5	int b = 1 + 10 + 20;
6	}
7	}

Added Link Here

(-)resources/InlineConstant/canInline/test36/in/A.java (+8 lines)
1	package p;
2
3	class A {
4	static final int a = 10 + 20;
5	void foo() {
6	int b = 1 - a;
7	}
8	}

Added Link Here

(-)resources/InlineConstant/canInline/test36/out/A.java (+7 lines)
1	package p;
2
3	class A {
4	void foo() {
5	int b = 1 - (10 + 20);
6	}
7	}

Added Link Here

(-)resources/InlineConstant/canInline/test37/in/A.java (+7 lines)
1	package p;
2
3	class A {
4	static final long CONST = 2 * Integer.MAX_VALUE;
5
6	long much = CONST * Integer.MAX_VALUE;
7	}

Added Link Here

(-)resources/InlineConstant/canInline/test37/out/A.java (+5 lines)
1	package p;
2
3	class A {
4	long much = (long) (2 * Integer.MAX_VALUE) * Integer.MAX_VALUE;
5	}

Lines 7-12 Link Here

(-)resources/InlineMethodWorkspace/TestCases/argument_out/TestArray.java (-1 / +1 lines)
7	}	7	}
8		8
9	public void main() {	9	public void main() {
10	int i= (new int[] {1})[0];	10	int i= new int[] {1}[0];
11	}	11	}
12	}	12	}

Added Link Here

(-)resources/InlineMethodWorkspace/TestCases/cast_in/TestInfixExpression1.java (+11 lines)
1	package cast_in;
2
3	public class TestInfixExpression1 {
4	long x(long two) {
5	return two * Integer.MAX_VALUE;
6	}
7
8	void foo() {
9	long much = /]/x(1 + 1)/[/;
10	}
11	}

Added Link Here

(-)resources/InlineMethodWorkspace/TestCases/cast_in/TestInfixExpression2.java (+11 lines)
1	package cast_in;
2
3	public class TestInfixExpression2 {
4	long x(long two) {
5	return two * Integer.MAX_VALUE;
6	}
7
8	void foo() {
9	long much = /]/x(2 * Integer.MAX_VALUE)/[/;
10	}
11	}

Added Link Here

(-)resources/InlineMethodWorkspace/TestCases/cast_out/TestInfixExpression1.java (+11 lines)
1	package cast_out;
2
3	public class TestInfixExpression1 {
4	long x(long two) {
5	return two * Integer.MAX_VALUE;
6	}
7
8	void foo() {
9	long much = (long) (1 + 1) * Integer.MAX_VALUE;
10	}
11	}

Added Link Here

(-)resources/InlineMethodWorkspace/TestCases/cast_out/TestInfixExpression2.java (+11 lines)
1	package cast_out;
2
3	public class TestInfixExpression2 {
4	long x(long two) {
5	return two * Integer.MAX_VALUE;
6	}
7
8	void foo() {
9	long much = (long) (2 * Integer.MAX_VALUE) * Integer.MAX_VALUE;
10	}
11	}

Lines 5-10 Link Here

(-)resources/InlineMethodWorkspace/TestCases/expression_out/TestConditionalExpression.java (-1 / +1 lines)
5	return k == 3 ? s.hashCode() : 3;	5	return k == 3 ? s.hashCode() : 3;
6	}	6	}
7	void f(int p) {	7	void f(int p) {
8	int u = (p == 3 ? this.hashCode() : 3);	8	int u = p == 3 ? this.hashCode() : 3;
9	}	9	}
10	}	10	}




package operator_in;

public class TestPlusPlus {
	int result;
	
	public void foo() {
		result= /*]*/inline(20 - 10)/*[*/;
	}
	
	public int inline(int x) {
		return 1 + x;
	}
}




package operator_out;

public class TestPlusPlus {
	int result;
	
	public void foo() {
		result= /*]*/1 + 20 - 10/*[*/;
	}
	
	public int inline(int x) {
		return 1 + x;
	}
}

Lines 4-10 Link Here

(-)resources/InlineMethodWorkspace/TestCases/operator_out/TestPlusPlus.java (-1 / +1 lines)
4	int result;	4	int result;
5		5
6	public void foo() {	6	public void foo() {
7	result= /]/1 + (10 + 10)/[/;	7	result= /]/1 + 10 + 10/[/;
8	}	8	}
9		9
10	public int inline(int x) {	10	public int inline(int x) {

Lines 4-10 Link Here

(-)resources/InlineMethodWorkspace/TestCases/operator_out/TestTimesTimes.java (-1 / +1 lines)
4	int result;	4	int result;
5		5
6	public void foo() {	6	public void foo() {
7	result= /]/1 * (10 * 10)/[/;	7	result= /]/1 * 10 * 10/[/;
8	}	8	}
9		9
10	public int inline(int x) {	10	public int inline(int x) {

Lines 2-7 Link Here

(-)resources/InlineMethodWorkspace/TestCases/simple_out/TestComment2.java (-1 / +1 lines)
2		2
3	public class TestComment2 {	3	public class TestComment2 {
4	public void ref() {	4	public void ref() {
5	int toInline = 42 * (5 /op1/ * /op2/ 2);	5	int toInline = 42 * 5 /op1/ * /op2/ 2;
6	}	6	}
7	}	7	}

Lines 1-7 Link Here

(-)resources/InlineTemp/canInline/A_test36_in.java (-2 lines)
1	package p;	1	package p;
2		2
3	import java.util.List;
4
5	class A {	3	class A {
6	void x() {	4	void x() {
7	long two = 1 + 1;	5	long two = 1 + 1;

Lines 1-7 Link Here

(-)resources/InlineTemp/canInline/A_test36_out.java (-2 lines)
1	package p;	1	package p;
2		2
3	import java.util.List;
4
5	class A {	3	class A {
6	void x() {	4	void x() {
7	long much = (long) (1 + 1) * Integer.MAX_VALUE;	5	long much = (long) (1 + 1) * Integer.MAX_VALUE;

Added Link Here

(-)resources/InlineTemp/canInline/A_test41_in.java (+8 lines)
1	package p;
2
3	class A {
4	void foo() {
5	int a = 10 + 20;
6	int b = 1 + a;
7	}
8	}

Added Link Here

(-)resources/InlineTemp/canInline/A_test41_out.java (+7 lines)
1	package p;
2
3	class A {
4	void foo() {
5	int b = 1 + 10 + 20;
6	}
7	}

Added Link Here

(-)resources/InlineTemp/canInline/A_test42_in.java (+8 lines)
1	package p;
2
3	class A {
4	void foo() {
5	int a = 10 + 20;
6	int b = 1 - a;
7	}
8	}

Added Link Here

(-)resources/InlineTemp/canInline/A_test42_out.java (+7 lines)
1	package p;
2
3	class A {
4	void foo() {
5	int b = 1 - (10 + 20);
6	}
7	}

Added Link Here

(-)resources/InlineTemp/canInline/A_test43_in.java (+8 lines)
1	package p;
2
3	class A {
4	void x() {
5	long two = 2 * Integer.MAX_VALUE;
6	long much = two * Integer.MAX_VALUE;
7	}
8	}

Added Link Here

(-)resources/InlineTemp/canInline/A_test43_out.java (+7 lines)
1	package p;
2
3	class A {
4	void x() {
5	long much = (long) (2 * Integer.MAX_VALUE) * Integer.MAX_VALUE;
6	}
7	}




//selection: 7, 21, 7, 26
//name: i -> first
package simple;

public class Expression1 {
	public void m() {
		int a= 1 - (2 + 3);
	}
	public void use() {
		m();
	}
}




//selection: 7, 20, 7, 27
//name: i -> first
package simple;

public class Expression2 {
	public void m() {
		int a= 1 - (2 + 3);
	}
	public void use() {
		m();
	}
}




//selection: 7, 22, 7, 27
//name: i -> first
package simple;

public class Expression3 {
	public void m() {
		int a= 1 - ((2 + 3));
	}
	public void use() {
		m();
	}
}




//selection: 7, 21, 7, 28
//name: i -> first
package simple;

public class Expression4 {
	public void m() {
		int a= 1 - ((2 + 3));
	}
	public void use() {
		m();
	}
}




//selection: 7, 20, 7, 29
//name: i -> first
package simple;

public class Expression5 {
	public void m() {
		int a= 1 - ((2 + 3));
	}
	public void use() {
		m();
	}
}




//selection: 7, 21, 7, 26
//name: i -> first
package simple.out;

public class Expression1 {
	public void m(int first) {
		int a= 1 - first;
	}
	public void use() {
		m(2 + 3);
	}
}




//selection: 7, 20, 7, 27
//name: i -> first
package simple.out;

public class Expression2 {
	public void m(int first) {
		int a= 1 - first;
	}
	public void use() {
		m(2 + 3);
	}
}




//selection: 7, 22, 7, 27
//name: i -> first
package simple.out;

public class Expression3 {
	public void m(int first) {
		int a= 1 - (first);
	}
	public void use() {
		m(2 + 3);
	}
}




//selection: 7, 21, 7, 28
//name: i -> first
package simple.out;

public class Expression4 {
	public void m(int first) {
		int a= 1 - first;
	}
	public void use() {
		m(2 + 3);
	}
}




//selection: 7, 20, 7, 29
//name: i -> first
package simple.out;

public class Expression5 {
	public void m(int first) {
		int a= 1 - first;
	}
	public void use() {
		m((2 + 3));
	}
}

Added Link Here

(-)resources/SefWorkSpace/SefTests/object_in/TestCompoundWrite4.java (+9 lines)
1	package object_in;
2
3	public class TestCompoundWrite4 {
4	int field;
5
6	public void foo() {
7	field+= 1 + 2;
8	}
9	}




package object_out;

public class TestCompoundWrite4 {
	private int field;
	
	public void foo() {
		setField(getField() + (1 + 2));
	}

	int getField() {
		return field;
	}

	void setField(int field) {
		this.field = field;
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

		helper1(3, 19, 3, 24, true, false, "S_ALL", "ALL");
	}

	public void test39() throws Exception { // bug 335173
		helper1(5, 21, 5, 26, false, false, "CONSTANT", "INT");
	}

	public void test40() throws Exception { // bug 335173
		helper1(5, 20, 5, 27, false, false, "CONSTANT", "INT");
	}

	public void test41() throws Exception { // bug 335173
		helper1(5, 22, 5, 27, false, false, "CONSTANT", "INT");
	}

	public void test42() throws Exception { // bug 335173
		helper1(5, 21, 5, 28, false, false, "CONSTANT", "INT");
	}

	public void test43() throws Exception { // bug 335173
		helper1(5, 20, 5, 29, false, false, "CONSTANT", "INT");
	}

	public void testZeroLengthSelection0() throws Exception {
		helper1(5, 18, 5, 18, false, false, "CONSTANT", "_100");
	}




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

		expressionTest();
	}

	public void test625() throws Exception {
		expressionTest();
	}

	public void test626() throws Exception {
		expressionTest();
	}

	public void test627() throws Exception {
		expressionTest();
	}

	public void test628() throws Exception {
		expressionTest();
	}

	public void test629() throws Exception {
		expressionTest();
	}

	//---- Test nested methods and constructor

	public void test650() throws Exception {




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

		helper1(6, 17, 6, 24, true, false, "temp", "i");
	}

	public void test105() throws Exception {
		//test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=335173
		helper1(5, 21, 5, 26, true, false, "temp", "i");
	}

	public void test106() throws Exception {
		//test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=335173
		helper1(5, 20, 5, 27, true, false, "temp", "i");
	}

	public void test107() throws Exception {
		//test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=335173
		helper1(5, 22, 5, 27, true, false, "temp", "i");
	}

	public void test108() throws Exception {
		//test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=335173
		helper1(5, 21, 5, 28, true, false, "temp", "i");
	}

	public void test109() throws Exception {
		//test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=335173
		helper1(5, 20, 5, 29, true, false, "temp", "i");
	}

	public void testZeroLengthSelection0() throws Exception {
//		printTestDisabledMessage("test for bug 30146");
		helper1(4, 18, 4, 18, true, false, "temp", "j");




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

		helper1("p.A", 4, 24, 4, 25, true, true);
	}
	
	public void test35() throws Exception { // test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=335173
		helper1("p.A", 4, 22, 4, 23, true, true);
	}

	public void test36() throws Exception { // test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=335173
		helper1("p.A", 4, 22, 4, 23, true, true);
	}

	public void test37() throws Exception { // test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=335173
		helper1("p.A", 4, 23, 4, 28, true, true);
	}

	// -- testing failing preconditions

	public void testFail0() throws Exception {

Lines 1-5 Link Here

(-)test cases/org/eclipse/jdt/ui/tests/refactoring/InlineMethodTests.java (-1 / +13 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2010 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 836-841 Link Here
836	performCastTest();	836	performCastTest();
837	}	837	}
838		838
		839	public void testInfixExpression1() throws Exception {
		840	performCastTest();
		841	}
		842
		843	public void testInfixExpression2() throws Exception {
		844	performCastTest();
		845	}
		846
839	/* ********************* Enum Tests ***************************** */	847	/* ********************* Enum Tests ***************************** */
840		848
841	private void performEnumTest() throws Exception {	849	private void performEnumTest() throws Exception {
Lines 956-961 Link Here
956	performOperatorTest();	964	performOperatorTest();
957	}	965	}
958		966
		967	public void testDiffPlus() throws Exception {
		968	performOperatorTest();
		969	}
		970
959	public void testTimesPlus() throws Exception {	971	public void testTimesPlus() throws Exception {
960	performOperatorTest();	972	performOperatorTest();
961	}	973	}




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

	
	public void test36() throws Exception{
		// parenthesize complex cast expression
		helper1(6, 21, 6, 24);
	}
	
	public void test37() throws Exception{

		helper1(5, 43, 5, 46);
	}
	
	public void test41() throws Exception {
		// https://bugs.eclipse.org/bugs/show_bug.cgi?id=335173
		helper1(5, 13, 5, 14);
	}

	public void test42() throws Exception {
		// https://bugs.eclipse.org/bugs/show_bug.cgi?id=335173
		helper1(5, 13, 5, 14);
	}

	public void test43() throws Exception {
		// parenthesize complex cast expression https://bugs.eclipse.org/bugs/show_bug.cgi?id=335173
		helper1(6, 21, 6, 24);
	}

	//------

	public void testFail0() throws Exception{




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

		performOK();
	}

	public void testSimple_Expression1() throws Exception {
		performOK();
	}

	public void testSimple_Expression2() throws Exception {
		performOK();
	}

	public void testSimple_Expression3() throws Exception {
		performOK();
	}

	public void testSimple_Expression4() throws Exception {
		performOK();
	}

	public void testSimple_Expression5() throws Exception {
		performOK();
	}

	public void testSimple_NewInstance1() throws Exception {
		performOK();
	}

Lines 1-5 Link Here

(-)test cases/org/eclipse/jdt/ui/tests/refactoring/SefTests.java (-1 / +5 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 238-243 Link Here
238	objectTest("field");	238	objectTest("field");
239	}	239	}
240		240
		241	public void testCompoundWrite4() throws Exception {
		242	objectTest("field");
		243	}
		244
241	public void testFinalField() throws Exception {	245	public void testFinalField() throws Exception {
242	objectTest("field");	246	objectTest("field");
243	}	247	}

Return to bug 335173

Lines 1-5 Link Here

(-)core extension/org/eclipse/jdt/internal/corext/fix/UnusedCodeFix.java (-5 / +10 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2010 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 435-444 Link Here
435	Expression expression= cast.getExpression();	435	Expression expression= cast.getExpression();
436	ASTNode placeholder= rewrite.createCopyTarget(expression);	436	ASTNode placeholder= rewrite.createCopyTarget(expression);
437		437
438	if (ASTNodes.needsParentheses(expression)) {	438	if (NecessaryParenthesesChecker.needsParentheses(expression, cast.getParent(), cast.getLocationInParent())) {
439	rewrite.replace(fCast, placeholder, group);	439	rewrite.replace(fCast, placeholder, group);
440	} else {	440	} else {
441	rewrite.replace(fSelectedNode, placeholder, group);	441	rewrite.replace(fCast.getParent() instanceof ParenthesizedExpression ? fCast.getParent() : fSelectedNode, placeholder, group);
442	}	442	}
443	}	443	}
444	}	444	}
Lines 468-474 Link Here
468	fUnnecessaryCasts.remove(down);	468	fUnnecessaryCasts.remove(down);
469	}	469	}
470		470
471	ASTNode move= rewrite.createMoveTarget(down.getExpression());	471	Expression expression= down.getExpression();
		472	ASTNode move= rewrite.createMoveTarget(expression);
472		473
473	CastExpression top= castExpression;	474	CastExpression top= castExpression;
474	while (fUnnecessaryCasts.contains(top.getParent())) {	475	while (fUnnecessaryCasts.contains(top.getParent())) {
Lines 476-482 Link Here
476	fUnnecessaryCasts.remove(top);	477	fUnnecessaryCasts.remove(top);
477	}	478	}
478		479
479	rewrite.replace(top, move, group);	480	ASTNode toReplace= top;
		481	if (top.getParent() instanceof ParenthesizedExpression && !NecessaryParenthesesChecker.needsParentheses(expression, top.getParent(), top.getLocationInParent())) {
		482	toReplace= top.getParent();
		483	}
		484	rewrite.replace(toReplace, move, group);
480	}	485	}
481	}	486	}
482	}	487	}

Lines 4411-4416 Link Here

(-)ui/org/eclipse/jdt/ui/tests/quickfix/LocalCorrectionsQuickFixTest.java (+66 lines)
4411	assertEqualString(preview, buf.toString());	4411	assertEqualString(preview, buf.toString());
4412	}	4412	}
4413		4413
		4414	public void testUnnecessaryCastBug335173_1() throws Exception {
		4415	Hashtable hashtable= JavaCore.getOptions();
		4416	hashtable.put(JavaCore.COMPILER_PB_UNNECESSARY_TYPE_CHECK, JavaCore.ERROR);
		4417	JavaCore.setOptions(hashtable);
		4418
		4419	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		4420	StringBuffer buf= new StringBuffer();
		4421	buf.append("package test1;\n");
		4422	buf.append("public class E {\n");
		4423	buf.append(" public void foo(Integer n) {\n");
		4424	buf.append(" int i = (((Integer) n)).intValue();\n");
		4425	buf.append(" }\n");
		4426	buf.append("}\n");
		4427	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
		4428
		4429	CompilationUnit astRoot= getASTRoot(cu);
		4430	ArrayList proposals= collectCorrections(cu, astRoot);
		4431	assertNumberOfProposals(proposals, 1);
		4432	assertCorrectLabels(proposals);
		4433
		4434	CUCorrectionProposal proposal= (CUCorrectionProposal)proposals.get(0);
		4435	String preview= getPreviewContent(proposal);
		4436
		4437	buf= new StringBuffer();
		4438	buf.append("package test1;\n");
		4439	buf.append("public class E {\n");
		4440	buf.append(" public void foo(Integer n) {\n");
		4441	buf.append(" int i = (n).intValue();\n");
		4442	buf.append(" }\n");
		4443	buf.append("}\n");
		4444	assertEqualString(preview, buf.toString());
		4445	}
		4446
		4447	public void testUnnecessaryCastBug335173_2() throws Exception {
		4448	Hashtable hashtable= JavaCore.getOptions();
		4449	hashtable.put(JavaCore.COMPILER_PB_UNNECESSARY_TYPE_CHECK, JavaCore.ERROR);
		4450	JavaCore.setOptions(hashtable);
		4451
		4452	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		4453	StringBuffer buf= new StringBuffer();
		4454	buf.append("package test1;\n");
		4455	buf.append("public class E {\n");
		4456	buf.append(" public void foo(Integer n) {\n");
		4457	buf.append(" int i = ((Integer) (n)).intValue();\n");
		4458	buf.append(" }\n");
		4459	buf.append("}\n");
		4460	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
		4461
		4462	CompilationUnit astRoot= getASTRoot(cu);
		4463	ArrayList proposals= collectCorrections(cu, astRoot);
		4464	assertNumberOfProposals(proposals, 1);
		4465	assertCorrectLabels(proposals);
		4466
		4467	CUCorrectionProposal proposal= (CUCorrectionProposal)proposals.get(0);
		4468	String preview= getPreviewContent(proposal);
		4469
		4470	buf= new StringBuffer();
		4471	buf.append("package test1;\n");
		4472	buf.append("public class E {\n");
		4473	buf.append(" public void foo(Integer n) {\n");
		4474	buf.append(" int i = (n).intValue();\n");
		4475	buf.append(" }\n");
		4476	buf.append("}\n");
		4477	assertEqualString(preview, buf.toString());
4478	}
4479
4414	public void testSuperfluousSemicolon() throws Exception {	4480	public void testSuperfluousSemicolon() throws Exception {
4415	Hashtable hashtable= JavaCore.getOptions();	4481	Hashtable hashtable= JavaCore.getOptions();
4416	hashtable.put(JavaCore.COMPILER_PB_EMPTY_STATEMENT, JavaCore.ERROR);	4482	hashtable.put(JavaCore.COMPILER_PB_EMPTY_STATEMENT, JavaCore.ERROR);

Lines 12-18 Link Here

(-)core extension/org/eclipse/jdt/internal/corext/fix/ExpressionsFix.java (-164 / +1 lines)
12		12
13	import java.util.ArrayList;	13	import java.util.ArrayList;
14	import java.util.HashSet;	14	import java.util.HashSet;
15	import java.util.Iterator;
16		15
17	import org.eclipse.core.runtime.CoreException;	16	import org.eclipse.core.runtime.CoreException;
18		17
Lines 22-37 Link Here
22	import org.eclipse.jdt.core.dom.ASTNode;	21	import org.eclipse.jdt.core.dom.ASTNode;
23	import org.eclipse.jdt.core.dom.ASTVisitor;	22	import org.eclipse.jdt.core.dom.ASTVisitor;
24	import org.eclipse.jdt.core.dom.CompilationUnit;	23	import org.eclipse.jdt.core.dom.CompilationUnit;
25	import org.eclipse.jdt.core.dom.ConditionalExpression;
26	import org.eclipse.jdt.core.dom.Expression;	24	import org.eclipse.jdt.core.dom.Expression;
27	import org.eclipse.jdt.core.dom.ITypeBinding;
28	import org.eclipse.jdt.core.dom.InfixExpression;	25	import org.eclipse.jdt.core.dom.InfixExpression;
29	import org.eclipse.jdt.core.dom.InfixExpression.Operator;
30	import org.eclipse.jdt.core.dom.InstanceofExpression;	26	import org.eclipse.jdt.core.dom.InstanceofExpression;
31	import org.eclipse.jdt.core.dom.ParenthesizedExpression;	27	import org.eclipse.jdt.core.dom.ParenthesizedExpression;
32	import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;	28	import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
33		29
34	import org.eclipse.jdt.internal.corext.refactoring.code.OperatorPrecedence;
35	import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;	30	import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;
36	import org.eclipse.jdt.internal.corext.refactoring.util.NoCommentSourceRangeComputer;	31	import org.eclipse.jdt.internal.corext.refactoring.util.NoCommentSourceRangeComputer;
37		32
Lines 86-254 Link Here
86	}	81	}
87		82
88	public boolean visit(ParenthesizedExpression node) {	83	public boolean visit(ParenthesizedExpression node) {
89	if (canRemoveParenthesis(node)) {	84	if (NecessaryParenthesesChecker.canRemoveParentheses(node)) {
90	fNodes.add(node);	85	fNodes.add(node);
91	}	86	}
92		87
93	return true;	88	return true;
94	}	89	}
95
96	/*
97	* Can the parenthesis around node be removed?
98	*/
99	private boolean canRemoveParenthesis(ParenthesizedExpression node) {
100	ASTNode parent= node.getParent();
101	if (!(parent instanceof Expression))
102	return true;
103
104	Expression parentExpression= (Expression) parent;
105	if (parentExpression instanceof ParenthesizedExpression)
106	return true;
107
108	Expression expression= getExpression(node);
109
110	int expressionPrecedence= OperatorPrecedence.getExpressionPrecedence(expression);
111	int parentPrecedence= OperatorPrecedence.getExpressionPrecedence(parentExpression);
112
113	if (expressionPrecedence > parentPrecedence)
114	//(opEx) opParent and opEx binds more -> can safely remove
115	return true;
116
117	if (expressionPrecedence < parentPrecedence)
118	//(opEx) opParent and opEx binds less -> do not remove
119	return false;
120
121	//(opEx) opParent binds equal
122
123	if (parentExpression instanceof InfixExpression) {
124	InfixExpression parentInfix= (InfixExpression) parentExpression;
125	if (parentInfix.getLeftOperand() == node) {
126	//we have (expr op expr) op expr
127	//infix expressions are evaluated from left to right -> can safely remove
128	return true;
129	} else if (isAssociative(parentInfix)) {
130	//we have parent op (expr op expr) and op is associative
131	//left op (right) == (right) op left == right op left
132	if (expression instanceof InfixExpression) {
133	InfixExpression infixExpression= (InfixExpression) expression;
134	Operator operator= infixExpression.getOperator();
135	if (parentInfix.getOperator() != InfixExpression.Operator.TIMES)
136	return true;
137
138	if (operator == InfixExpression.Operator.TIMES)
139	// x * (y * z) == x * y * z
140	return true;
141
142	if (operator == InfixExpression.Operator.REMAINDER)
143	// x * (y % z) != x * y % z
144	return false;
145
146	//x * (y / z) == z * y / z iff no rounding
147	ITypeBinding binding= infixExpression.resolveTypeBinding();
148	if (binding == null)
149	return false;
150
151	if (!binding.isPrimitive())
152	return false;
153
154	String name= binding.getName();
155	if (isIntegerNumber(name))
156	//rounding involved
157	return false;
158
159	return true;
160	}
161	return true;
162	} else {
163	return false;
164	}
165	} else if (parentExpression instanceof ConditionalExpression) {
166	ConditionalExpression conditionalExpression= (ConditionalExpression) parentExpression;
167	if (conditionalExpression.getElseExpression() != node)
168	return false;
169	}
170
171	return true;
172	}
173
174	private boolean isIntegerNumber(String name) {
175	return "int".equals(name) \|\| "long".equals(name) \|\| "byte".equals(name) \|\| "char".equals(name) \|\| "short".equals(name); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
176	}
177
178	/*
179	* Get the expression wrapped by the parentheses
180	* i.e. ((((expression)))) -> expression
181	*/
182	private Expression getExpression(ParenthesizedExpression node) {
183	Expression expression= node.getExpression();
184	while (expression instanceof ParenthesizedExpression) {
185	expression= ((ParenthesizedExpression) expression).getExpression();
186	}
187	return expression;
188	}
189
190	/**
191	* Is the given expression associative?
192	* <p>
193	* This is true if and only if:<br>
194	* <code>left operator (right) == (right) operator left == right operator left</code>
195	* </p>
196	*
197	* @param expression the expression to inspect
198	* @return true if expression is associative
199	*/
200	public static boolean isAssociative(InfixExpression expression) {
201	Operator operator= expression.getOperator();
202	if (operator == InfixExpression.Operator.PLUS) {
203	return isAllOperandsHaveSameType(expression);
204	}
205
206	if (operator == Operator.LESS \|\| operator == Operator.LESS_EQUALS \|\| operator == Operator.GREATER \|\| operator == Operator.GREATER_EQUALS) {
207	return isAllOperandsHaveSameType(expression);
208	}
209
210	if (operator == InfixExpression.Operator.CONDITIONAL_AND)
211	return true;
212
213	if (operator == InfixExpression.Operator.CONDITIONAL_OR)
214	return true;
215
216	if (operator == InfixExpression.Operator.AND)
217	return true;
218
219	if (operator == InfixExpression.Operator.OR)
220	return true;
221
222	if (operator == InfixExpression.Operator.XOR)
223	return true;
224
225	if (operator == InfixExpression.Operator.TIMES)
226	return true;
227
228	return false;
229	}
230
231	/*
232	* Do all operands in expression have same type
233	*/
234	private static boolean isAllOperandsHaveSameType(InfixExpression expression) {
235	ITypeBinding binding= expression.getLeftOperand().resolveTypeBinding();
236	if (binding == null)
237	return false;
238
239	ITypeBinding current= expression.getRightOperand().resolveTypeBinding();
240	if (binding != current)
241	return false;
242
243	for (Iterator iterator= expression.extendedOperands().iterator(); iterator.hasNext();) {
244	Expression operand= (Expression) iterator.next();
245	current= operand.resolveTypeBinding();
246	if (binding != current)
247	return false;
248	}
249
250	return true;
251	}
252	}	90	}
253		91
254	private static class AddParenthesisOperation extends CompilationUnitRewriteOperation {	92	private static class AddParenthesisOperation extends CompilationUnitRewriteOperation {
Lines 385-389 Link Here
385	protected ExpressionsFix(String name, CompilationUnit compilationUnit, CompilationUnitRewriteOperation[] fixRewriteOperations) {	223	protected ExpressionsFix(String name, CompilationUnit compilationUnit, CompilationUnitRewriteOperation[] fixRewriteOperations) {
386	super(name, compilationUnit, fixRewriteOperations);	224	super(name, compilationUnit, fixRewriteOperations);
387	}	225	}
388
389	}	226	}

Added Link Here

(-)core (+303 lines)
1	/*******************************************************************************
2	* Copyright (c) 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.jdt.internal.corext.fix;
13
14	import java.util.Iterator;
15
16	import org.eclipse.jdt.core.dom.ASTNode;
17	import org.eclipse.jdt.core.dom.ArrayAccess;
18	import org.eclipse.jdt.core.dom.AssertStatement;
19	import org.eclipse.jdt.core.dom.ChildListPropertyDescriptor;
20	import org.eclipse.jdt.core.dom.ConditionalExpression;
21	import org.eclipse.jdt.core.dom.DoStatement;
22	import org.eclipse.jdt.core.dom.EnhancedForStatement;
23	import org.eclipse.jdt.core.dom.Expression;
24	import org.eclipse.jdt.core.dom.ForStatement;
25	import org.eclipse.jdt.core.dom.ITypeBinding;
26	import org.eclipse.jdt.core.dom.IfStatement;
27	import org.eclipse.jdt.core.dom.InfixExpression;
28	import org.eclipse.jdt.core.dom.InfixExpression.Operator;
29	import org.eclipse.jdt.core.dom.ParenthesizedExpression;
30	import org.eclipse.jdt.core.dom.ReturnStatement;
31	import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
32	import org.eclipse.jdt.core.dom.StructuralPropertyDescriptor;
33	import org.eclipse.jdt.core.dom.SwitchCase;
34	import org.eclipse.jdt.core.dom.SwitchStatement;
35	import org.eclipse.jdt.core.dom.SynchronizedStatement;
36	import org.eclipse.jdt.core.dom.ThrowStatement;
37	import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
38	import org.eclipse.jdt.core.dom.WhileStatement;
39
40	import org.eclipse.jdt.internal.corext.refactoring.code.OperatorPrecedence;
41
42	/**
43	* Helper class to check if an expression requires parentheses.
44	*
45	* @since 3.7
46	*/
47	public class NecessaryParenthesesChecker {
48
49	/*
50	* Get the expression wrapped by the parentheses
51	* i.e. ((((expression)))) -> expression
52	*/
53	private static Expression getExpression(ParenthesizedExpression node) {
54	Expression expression= node.getExpression();
55	while (expression instanceof ParenthesizedExpression) {
56	expression= ((ParenthesizedExpression)expression).getExpression();
57	}
58	return expression;
59	}
60
61	private static boolean expressionTypeNeedsParentheses(Expression expression) {
62	int type= expression.getNodeType();
63	return type == ASTNode.INFIX_EXPRESSION
64	\|\| type == ASTNode.CONDITIONAL_EXPRESSION
65	\|\| type == ASTNode.PREFIX_EXPRESSION
66	\|\| type == ASTNode.POSTFIX_EXPRESSION
67	\|\| type == ASTNode.CAST_EXPRESSION
68	\|\| type == ASTNode.INSTANCEOF_EXPRESSION
69	\|\| type == ASTNode.ARRAY_CREATION
70	\|\| type == ASTNode.ASSIGNMENT;
71	}
72
73	private static boolean locationNeedsParentheses(StructuralPropertyDescriptor locationInParent) {
74	if (locationInParent instanceof ChildListPropertyDescriptor && locationInParent != InfixExpression.EXTENDED_OPERANDS_PROPERTY) {
75	// e.g. argument lists of MethodInvocation, ClassInstanceCreation, dimensions of ArrayCreation ...
76	return false;
77	}
78	if (locationInParent == VariableDeclarationFragment.INITIALIZER_PROPERTY
79	\|\| locationInParent == SingleVariableDeclaration.INITIALIZER_PROPERTY
80	\|\| locationInParent == ReturnStatement.EXPRESSION_PROPERTY
81	\|\| locationInParent == EnhancedForStatement.EXPRESSION_PROPERTY
82	\|\| locationInParent == ForStatement.EXPRESSION_PROPERTY
83	\|\| locationInParent == WhileStatement.EXPRESSION_PROPERTY
84	\|\| locationInParent == DoStatement.EXPRESSION_PROPERTY
85	\|\| locationInParent == AssertStatement.EXPRESSION_PROPERTY
86	\|\| locationInParent == AssertStatement.MESSAGE_PROPERTY
87	\|\| locationInParent == IfStatement.EXPRESSION_PROPERTY
88	\|\| locationInParent == SwitchStatement.EXPRESSION_PROPERTY
89	\|\| locationInParent == SwitchCase.EXPRESSION_PROPERTY
90	\|\| locationInParent == ArrayAccess.INDEX_PROPERTY
91	\|\| locationInParent == ThrowStatement.EXPRESSION_PROPERTY
92	\|\| locationInParent == SynchronizedStatement.EXPRESSION_PROPERTY) {
93	return false;
94	}
95	return true;
96	}
97
98	/*
99	* Do all operands in expression have same type
100	*/
101	private static boolean isAllOperandsHaveSameType(InfixExpression expression) {
102	ITypeBinding binding= expression.getLeftOperand().resolveTypeBinding();
103	if (binding == null)
104	return false;
105
106	ITypeBinding current= expression.getRightOperand().resolveTypeBinding();
107	if (binding != current)
108	return false;
109
110	for (Iterator iterator= expression.extendedOperands().iterator(); iterator.hasNext();) {
111	Expression operand= (Expression) iterator.next();
112	current= operand.resolveTypeBinding();
113	if (binding != current)
114	return false;
115	}
116
117	return true;
118	}
119
120	/*
121	* Is the expression of integer type
122	*/
123	private static boolean isExpressionIntegerType(Expression expression) {
124	ITypeBinding binding= expression.resolveTypeBinding();
125	if (binding == null)
126	return false;
127
128	if (!binding.isPrimitive())
129	return false;
130
131	String name= binding.getName();
132	if (isIntegerNumber(name))
133	return true;
134
135	return false;
136	}
137
138	private static boolean isExpressionStringType(Expression expression) {
139	ITypeBinding binding= expression.resolveTypeBinding();
140	if (binding == null)
141	return false;
142
143	return "java.lang.String".equals(binding.getQualifiedName()); //$NON-NLS-1$
144	}
145
146	/*
147	* Is the given expression associative?
148	*
149	* This is true if and only if:<br>
150	* <code>left operator (right) == (right) operator left == right operator left</code>
151	*/
152	private static boolean isAssociative(InfixExpression expression) {
153	Operator operator= expression.getOperator();
154
155	if (operator == InfixExpression.Operator.PLUS)
156	return isExpressionStringType(expression) \|\| isExpressionIntegerType(expression) && isAllOperandsHaveSameType(expression);
157
158	if (operator == InfixExpression.Operator.TIMES)
159	return isExpressionIntegerType(expression) && isAllOperandsHaveSameType(expression);
160
161	if (operator == InfixExpression.Operator.CONDITIONAL_AND
162	\|\| operator == InfixExpression.Operator.CONDITIONAL_OR
163	\|\| operator == InfixExpression.Operator.AND
164	\|\| operator == InfixExpression.Operator.OR
165	\|\| operator == InfixExpression.Operator.XOR)
166	return true;
167
168	return false;
169	}
170
171	private static boolean isIntegerNumber(String name) {
172	return "int".equals(name) \|\| "long".equals(name) \|\| "byte".equals(name) \|\| "char".equals(name) \|\| "short".equals(name); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
173	}
174
175	private static boolean needsParenthesesInInfixExpression(Expression expression, InfixExpression parentInfix, StructuralPropertyDescriptor locationInParent) {
176	if (locationInParent == InfixExpression.LEFT_OPERAND_PROPERTY) {
177	//we have (expr op expr) op expr
178	//infix expressions are evaluated from left to right -> parentheses not needed
179	return false;
180	} else if (isAssociative(parentInfix)) {
181	//we have parent op (expr op expr) and op is associative
182	//left op (right) == (right) op left == right op left
183	if (expression instanceof InfixExpression) {
184	InfixExpression infixExpression= (InfixExpression)expression;
185	Operator operator= infixExpression.getOperator();
186
187	if (isExpressionStringType(parentInfix)) {
188	if (parentInfix.getOperator() == InfixExpression.Operator.PLUS && operator == InfixExpression.Operator.PLUS && isExpressionStringType(infixExpression)) {
189	// 1 + ("" + 2) == 1 + "" + 2
190	// 1 + (2 + "") != 1 + 2 + ""
191	// "" + (2 + "") == "" + 2 + ""
192	return !isExpressionStringType(infixExpression.getLeftOperand()) && !isExpressionStringType(parentInfix.getLeftOperand());
193	}
194	//"" + (1 + 2), "" + (1 - 2) etc
195	return true;
196	}
197
198	if (parentInfix.getOperator() != InfixExpression.Operator.TIMES)
199	return false;
200
201	if (operator == InfixExpression.Operator.TIMES)
202	// x * (y * z) == x * y * z
203	return false;
204
205	if (operator == InfixExpression.Operator.REMAINDER \|\| operator == InfixExpression.Operator.DIVIDE)
206	// x * (y % z) != x * y % z , x * (y / z) == x * y / z rounding involved
207	return true;
208
209	return false;
210	}
211	return false;
212	} else {
213	return true;
214	}
215	}
216
217	/**
218	* Can the parentheses be removed from the parenthesized expression ?
219	*
220	* <p>
221	* <b>Note:</b> The parenthesized expression must not be an unparented node.
222	* </p>
223	*
224	* @param expression the parenthesized expression
225	* @return <code>true</code> if parentheses can be removed, <code>false</code> otherwise.
226	*/
227	public static boolean canRemoveParentheses(Expression expression) {
228	return canRemoveParentheses(expression, expression.getParent(), expression.getLocationInParent());
229	}
230
231	/**
232	* Can the parentheses be removed from the parenthesized expression when inserted into
233	* <code>parent</code> at <code>locationInParent</code> ?
234	*
235	* <p>
236	* <b>Note:</b> The parenthesized expression can be an unparented node.
237	* </p>
238	*
239	* @param expression the parenthesized expression
240	* @param parent the parent node
241	* @param locationInParent location of expression in the parent
242	* @return <code>true</code> if parentheses can be removed, <code>false</code> otherwise.
243	*/
244	public static boolean canRemoveParentheses(Expression expression, ASTNode parent, StructuralPropertyDescriptor locationInParent) {
245	if (!(expression instanceof ParenthesizedExpression)) {
246	return false;
247	}
248	return !needsParentheses(getExpression((ParenthesizedExpression)expression), parent, locationInParent);
249	}
250
251	/**
252	* Does the <code>expression</code> need parentheses when inserted into <code>parent</code> at
253	* <code>locationInParent</code> ?
254	*
255	* <p>
256	* <b>Note:</b> The expression can be an unparented node.
257	* </p>
258	*
259	* @param expression the expression
260	* @param parent the parent node
261	* @param locationInParent location of expression in the parent
262	* @return <code>true</code> if the expression needs parentheses, <code>false</code> otherwise.
263	*/
264	public static boolean needsParentheses(Expression expression, ASTNode parent, StructuralPropertyDescriptor locationInParent) {
265	if (!expressionTypeNeedsParentheses(expression))
266	return false;
267
268	if (!locationNeedsParentheses(locationInParent)) {
269	return false;
270	}
271
272	if (parent instanceof Expression) {
273	Expression parentExpression= (Expression)parent;
274	if (parentExpression instanceof ParenthesizedExpression)
275	return false;
276
277	int expressionPrecedence= OperatorPrecedence.getExpressionPrecedence(expression);
278	int parentPrecedence= OperatorPrecedence.getExpressionPrecedence(parentExpression);
279
280	if (expressionPrecedence > parentPrecedence)
281	//(opEx) opParent and opEx binds more -> parentheses not needed
282	return false;
283
284	if (expressionPrecedence < parentPrecedence)
285	//(opEx) opParent and opEx binds less -> parentheses needed
286	return true;
287
288	//(opEx) opParent binds equal
289
290	if (parentExpression instanceof InfixExpression) {
291	return needsParenthesesInInfixExpression(expression, (InfixExpression)parentExpression, locationInParent);
292	}
293
294	if (parentExpression instanceof ConditionalExpression && locationInParent == ConditionalExpression.EXPRESSION_PROPERTY) {
295	return true;
296	}
297
298	return false;
299	}
300
301	return true;
302	}
303	}

Lines 382-387 Link Here

(-)ui/org/eclipse/jdt/ui/tests/quickfix/AdvancedQuickAssistTest.java (-1 / +272 lines)
382		382
383	}	383	}
384		384
		385	public void testJoinAndIfStatementsBug335173() throws Exception {
		386	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		387	StringBuffer buf= new StringBuffer();
		388	buf.append("package test1;\n");
		389	buf.append("public class E {\n");
		390	buf.append(" public void foo(Object a, int x) {\n");
		391	buf.append(" if (a instanceof String) {\n");
		392	buf.append(" if (x > 2) {\n");
		393	buf.append(" }\n");
		394	buf.append(" }\n");
		395	buf.append(" }\n");
		396	buf.append("}\n");
		397	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
		398
		399	int offset= buf.toString().indexOf("if (a");
		400	AssistContext context= getCorrectionContext(cu, offset, 0);
		401	List proposals= collectAssists(context, false);
		402
		403	assertCorrectLabels(proposals);
		404
		405	buf= new StringBuffer();
		406	buf.append("package test1;\n");
		407	buf.append("public class E {\n");
		408	buf.append(" public void foo(Object a, int x) {\n");
		409	buf.append(" if (a instanceof String && x > 2) {\n");
		410	buf.append(" }\n");
		411	buf.append(" }\n");
		412	buf.append("}\n");
		413	String expected1= buf.toString();
		414
		415	assertExpectedExistInProposals(proposals, new String[] { expected1 });
		416
		417	}
		418
385	public void testJoinOrIfStatements1() throws Exception {	419	public void testJoinOrIfStatements1() throws Exception {
386	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);	420	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
387	StringBuffer buf= new StringBuffer();	421	StringBuffer buf= new StringBuffer();
Lines 425-430 Link Here
425		459
426	}	460	}
427		461
		462	public void testJoinOrIfStatementsBug335173() throws Exception {
		463	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		464	StringBuffer buf= new StringBuffer();
		465	buf.append("package test1;\n");
		466	buf.append("public class E {\n");
		467	buf.append(" public void foo(Object a, int x) {\n");
		468	buf.append(" if (a instanceof String)\n");
		469	buf.append(" return;\n");
		470	buf.append(" if (x > 2)\n");
		471	buf.append(" return;\n");
		472	buf.append(" x= 9;\n");
		473	buf.append(" }\n");
		474	buf.append("}\n");
		475	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
		476
		477	int offset1= buf.toString().indexOf("if (a");
		478	int offset2= buf.toString().lastIndexOf("x= 9;");
		479	AssistContext context= getCorrectionContext(cu, offset1, offset2 - offset1);
		480	List proposals= collectAssists(context, false);
		481
		482	for (Iterator I= proposals.iterator(); I.hasNext();) {
		483	Object o= I.next();
		484	if (!(o instanceof CUCorrectionProposal))
		485	I.remove();
		486	}
		487
		488	assertCorrectLabels(proposals);
		489
		490	buf= new StringBuffer();
		491	buf.append("package test1;\n");
		492	buf.append("public class E {\n");
		493	buf.append(" public void foo(Object a, int x) {\n");
		494	buf.append(" if (a instanceof String \|\| x > 2)\n");
		495	buf.append(" return;\n");
		496	buf.append(" x= 9;\n");
		497	buf.append(" }\n");
		498	buf.append("}\n");
		499	String expected1= buf.toString();
		500
		501	assertExpectedExistInProposals(proposals, new String[] { expected1 });
		502
		503	}
		504
428	public void testSplitOrCondition1() throws Exception {	505	public void testSplitOrCondition1() throws Exception {
429	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);	506	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
430	StringBuffer buf= new StringBuffer();	507	StringBuffer buf= new StringBuffer();
Lines 1639-1645 Link Here
1639	buf.append("package test1;\n");	1716	buf.append("package test1;\n");
1640	buf.append("public class E {\n");	1717	buf.append("public class E {\n");
1641	buf.append(" public boolean foo(int a, int b) {\n");	1718	buf.append(" public boolean foo(int a, int b) {\n");
1642	buf.append(" return (a == b) != (b > 0);\n");	1719	buf.append(" return (a == b) != b > 0;\n");
1643	buf.append(" }\n");	1720	buf.append(" }\n");
1644	buf.append("}\n");	1721	buf.append("}\n");
1645	String expected1= buf.toString();	1722	String expected1= buf.toString();
Lines 1679-1684 Link Here
1679		1756
1680	}	1757	}
1681		1758
		1759	public void testExchangeOperandsBug332019_4() throws Exception {
		1760	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		1761	StringBuffer buf= new StringBuffer();
		1762	buf.append("package test1;\n");
		1763	buf.append("public class E {\n");
		1764	buf.append(" public boolean foo(int a, int b) {\n");
		1765	buf.append(" return b + 1 != a - 1;\n");
		1766	buf.append(" }\n");
		1767	buf.append("}\n");
		1768	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
		1769
		1770	int offset= buf.toString().indexOf("!=");
		1771	AssistContext context= getCorrectionContext(cu, offset, 0);
		1772	assertNoErrors(context);
		1773	List proposals= collectAssists(context, false);
		1774
		1775	assertCorrectLabels(proposals);
		1776
		1777	buf= new StringBuffer();
		1778	buf.append("package test1;\n");
		1779	buf.append("public class E {\n");
		1780	buf.append(" public boolean foo(int a, int b) {\n");
		1781	buf.append(" return a - 1 != b + 1;\n");
		1782	buf.append(" }\n");
		1783	buf.append("}\n");
		1784	String expected1= buf.toString();
		1785
		1786	assertExpectedExistInProposals(proposals, new String[] { expected1 });
		1787
		1788	}
		1789
1682	public void testAssignAndCast1() throws Exception {	1790	public void testAssignAndCast1() throws Exception {
1683	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=75066	1791	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=75066
1684	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);	1792	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
Lines 2895-2900 Link Here
2895		3003
2896	}	3004	}
2897		3005
		3006	public void testInverseCondition2() throws Exception {
		3007	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		3008	StringBuffer buf= new StringBuffer();
		3009	buf.append("package test1;\n");
		3010	buf.append("public class E {\n");
		3011	buf.append(" public void foo(Object a) {\n");
		3012	buf.append(" if (!(a instanceof String)) {\n");
		3013	buf.append(" }\n");
		3014	buf.append(" }\n");
		3015	buf.append("}\n");
		3016	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
		3017
		3018	int offset= buf.toString().indexOf("!");
		3019	int length= "!(a instanceof String)".length();
		3020	AssistContext context= getCorrectionContext(cu, offset, length);
		3021	List proposals= collectAssists(context, false);
		3022
		3023	assertCorrectLabels(proposals);
		3024
		3025	buf= new StringBuffer();
		3026	buf.append("package test1;\n");
		3027	buf.append("public class E {\n");
		3028	buf.append(" public void foo(Object a) {\n");
		3029	buf.append(" if (a instanceof String) {\n");
		3030	buf.append(" }\n");
		3031	buf.append(" }\n");
		3032	buf.append("}\n");
		3033	String expected1= buf.toString();
		3034
		3035	assertExpectedExistInProposals(proposals, new String[] { expected1 });
		3036
		3037	}
		3038
		3039	public void testInverseCondition3() throws Exception {
		3040	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		3041	StringBuffer buf= new StringBuffer();
		3042	buf.append("package test1;\n");
		3043	buf.append("public class E {\n");
		3044	buf.append(" public void foo(Object a) {\n");
		3045	buf.append(" while (!(a instanceof String)) {\n");
		3046	buf.append(" }\n");
		3047	buf.append(" }\n");
		3048	buf.append("}\n");
		3049	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
		3050
		3051	int offset= buf.toString().indexOf("!");
		3052	int length= "!(a instanceof String)".length();
		3053	AssistContext context= getCorrectionContext(cu, offset, length);
		3054	List proposals= collectAssists(context, false);
		3055
		3056	assertCorrectLabels(proposals);
		3057
		3058	buf= new StringBuffer();
		3059	buf.append("package test1;\n");
		3060	buf.append("public class E {\n");
		3061	buf.append(" public void foo(Object a) {\n");
		3062	buf.append(" while (a instanceof String) {\n");
		3063	buf.append(" }\n");
		3064	buf.append(" }\n");
		3065	buf.append("}\n");
		3066	String expected1= buf.toString();
		3067
		3068	assertExpectedExistInProposals(proposals, new String[] { expected1 });
		3069
3070	}
3071
3072	public void testInverseCondition4() throws Exception {
3073	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
3074	StringBuffer buf= new StringBuffer();
3075	buf.append("package test1;\n");
3076	buf.append("public class E {\n");
3077	buf.append(" public void foo(Object a) {\n");
3078	buf.append(" for (int i = 0; !(a instanceof String); i++) {\n");
3079	buf.append(" }\n");
3080	buf.append(" }\n");
3081	buf.append("}\n");
3082	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
3083
3084	int offset= buf.toString().indexOf("!");
3085	int length= "!(a instanceof String)".length();
3086	AssistContext context= getCorrectionContext(cu, offset, length);
3087	List proposals= collectAssists(context, false);
3088
3089	assertCorrectLabels(proposals);
3090
3091	buf= new StringBuffer();
3092	buf.append("package test1;\n");
3093	buf.append("public class E {\n");
3094	buf.append(" public void foo(Object a) {\n");
3095	buf.append(" for (int i = 0; a instanceof String; i++) {\n");
3096	buf.append(" }\n");
3097	buf.append(" }\n");
3098	buf.append("}\n");
3099	String expected1= buf.toString();
3100
3101	assertExpectedExistInProposals(proposals, new String[] { expected1 });
3102
3103	}
3104
3105	public void testInverseCondition5() throws Exception {
3106	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
3107	StringBuffer buf= new StringBuffer();
3108	buf.append("package test1;\n");
3109	buf.append("public class E {\n");
3110	buf.append(" public void foo(Object a) {\n");
3111	buf.append(" do {\n");
3112	buf.append(" } while (!(a instanceof String));\n");
3113	buf.append(" }\n");
3114	buf.append("}\n");
3115	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
3116
3117	int offset= buf.toString().indexOf("!");
3118	int length= "!(a instanceof String)".length();
3119	AssistContext context= getCorrectionContext(cu, offset, length);
3120	List proposals= collectAssists(context, false);
3121
3122	assertCorrectLabels(proposals);
3123
3124	buf= new StringBuffer();
3125	buf.append("package test1;\n");
3126	buf.append("public class E {\n");
3127	buf.append(" public void foo(Object a) {\n");
3128	buf.append(" do {\n");
3129	buf.append(" } while (a instanceof String);\n");
3130	buf.append(" }\n");
3131	buf.append("}\n");
3132	String expected1= buf.toString();
3133
3134	assertExpectedExistInProposals(proposals, new String[] { expected1 });
3135
3136	}
3137
3138	public void testInverseCondition6() throws Exception {
3139	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
3140	StringBuffer buf= new StringBuffer();
3141	buf.append("package test1;\n");
3142	buf.append("public class E {\n");
3143	buf.append(" public void foo(Object a) {\n");
3144	buf.append(" assert !(a instanceof String);\n");
3145	buf.append(" }\n");
3146	buf.append("}\n");
3147	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
3148
3149	int offset= buf.toString().indexOf("!");
3150	int length= "!(a instanceof String)".length();
3151	AssistContext context= getCorrectionContext(cu, offset, length);
3152	List proposals= collectAssists(context, false);
3153
3154	assertCorrectLabels(proposals);
3155
3156	buf= new StringBuffer();
3157	buf.append("package test1;\n");
3158	buf.append("public class E {\n");
3159	buf.append(" public void foo(Object a) {\n");
3160	buf.append(" assert a instanceof String;\n");
3161	buf.append(" }\n");
3162	buf.append("}\n");
3163	String expected1= buf.toString();
3164
3165	assertExpectedExistInProposals(proposals, new String[] { expected1 });
3166
3167	}
3168
2898	public void testPushNegationDown1() throws Exception {	3169	public void testPushNegationDown1() throws Exception {
2899	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);	3170	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
2900	StringBuffer buf= new StringBuffer();	3171	StringBuffer buf= new StringBuffer();

Added Link Here

(-)resources/ExtractMethodWorkSpace/ExtractMethodTests/expression_out/A_test625.java (+13 lines)
1	package expression_out;
2
3	public class A_test625 {
4
5	public void foo() {
6	int i= 1 - extracted();
7	int j= 1 - extracted();
8	}
9
10	protected int extracted() {
11	return /[/2 + 3/]/;
12	}
13	}

Added Link Here

(-)resources/InlineMethodWorkspace/TestCases/operator_in/TestDiffPlus.java (+13 lines)
1	package operator_in;
2
3	public class TestPlusPlus {
4	int result;
5
6	public void foo() {
7	result= /]/inline(20 - 10)/[/;
8	}
9
10	public int inline(int x) {
11	return 1 + x;
12	}
13	}

Added Link Here

(-)resources/InlineMethodWorkspace/TestCases/operator_out/TestDiffPlus.java (+13 lines)
1	package operator_out;
2
3	public class TestPlusPlus {
4	int result;
5
6	public void foo() {
7	result= /]/1 + 20 - 10/[/;
8	}
9
10	public int inline(int x) {
11	return 1 + x;
12	}
13	}

Added Link Here

(-)resources/IntroduceParameter/simple/Expression1.java (+12 lines)
1	//selection: 7, 21, 7, 26
2	//name: i -> first
3	package simple;
4
5	public class Expression1 {
6	public void m() {
7	int a= 1 - (2 + 3);
8	}
9	public void use() {
10	m();
11	}
12	}

Added Link Here

(-)resources/IntroduceParameter/simple/Expression2.java (+12 lines)
1	//selection: 7, 20, 7, 27
2	//name: i -> first
3	package simple;
4
5	public class Expression2 {
6	public void m() {
7	int a= 1 - (2 + 3);
8	}
9	public void use() {
10	m();
11	}
12	}

Added Link Here

(-)resources/IntroduceParameter/simple/Expression3.java (+12 lines)
1	//selection: 7, 22, 7, 27
2	//name: i -> first
3	package simple;
4
5	public class Expression3 {
6	public void m() {
7	int a= 1 - ((2 + 3));
8	}
9	public void use() {
10	m();
11	}
12	}

Added Link Here

(-)resources/IntroduceParameter/simple/Expression4.java (+12 lines)
1	//selection: 7, 21, 7, 28
2	//name: i -> first
3	package simple;
4
5	public class Expression4 {
6	public void m() {
7	int a= 1 - ((2 + 3));
8	}
9	public void use() {
10	m();
11	}
12	}

Added Link Here

(-)resources/IntroduceParameter/simple/Expression5.java (+12 lines)
1	//selection: 7, 20, 7, 29
2	//name: i -> first
3	package simple;
4
5	public class Expression5 {
6	public void m() {
7	int a= 1 - ((2 + 3));
8	}
9	public void use() {
10	m();
11	}
12	}

Added Link Here

(-)resources/IntroduceParameter/simple/out/Expression1.java (+12 lines)
1	//selection: 7, 21, 7, 26
2	//name: i -> first
3	package simple.out;
4
5	public class Expression1 {
6	public void m(int first) {
7	int a= 1 - first;
8	}
9	public void use() {
10	m(2 + 3);
11	}
12	}

Added Link Here

(-)resources/SefWorkSpace/SefTests/object_out/TestCompoundWrite4.java (+17 lines)
1	package object_out;
2
3	public class TestCompoundWrite4 {
4	private int field;
5
6	public void foo() {
7	setField(getField() + (1 + 2));
8	}
9
10	int getField() {
11	return field;
12	}
13
14	void setField(int field) {
15	this.field = field;
16	}
17	}