Attachment #188426 for bug #335173

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

Lines 37-42 Link Here

(-)core extension/org/eclipse/jdt/internal/corext/codemanipulation/GetterSetterUtil.java (-1 / +2 lines)
37	import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;	37	import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
38		38
39	import org.eclipse.jdt.internal.corext.dom.ASTNodes;	39	import org.eclipse.jdt.internal.corext.dom.ASTNodes;
		40	import org.eclipse.jdt.internal.corext.fix.NecessaryParenthesesChecker;
40	import org.eclipse.jdt.internal.corext.util.JavaModelUtil;	41	import org.eclipse.jdt.internal.corext.util.JavaModelUtil;
41	import org.eclipse.jdt.internal.corext.util.JdtFlags;	42	import org.eclipse.jdt.internal.corext.util.JdtFlags;
42		43
Lines 336-342 Link Here
336	castTo= ast.newPrimitiveType(PrimitiveType.SHORT);	337	castTo= ast.newPrimitiveType(PrimitiveType.SHORT);
337	if (castTo != null) {	338	if (castTo != null) {
338	CastExpression cast= ast.newCastExpression();	339	CastExpression cast= ast.newCastExpression();
339	if (ASTNodes.needsParentheses(expression)) {	340	if (NecessaryParenthesesChecker.needsParentheses(expression)) {
340	ParenthesizedExpression parenthesized= ast.newParenthesizedExpression();	341	ParenthesizedExpression parenthesized= ast.newParenthesizedExpression();
341	parenthesized.setExpression(expression);	342	parenthesized.setExpression(expression);
342	cast.setExpression(parenthesized);	343	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(InfixExpression 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;
	}

	/*
	 * 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 || 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 (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 ?
	 * 
	 * <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 expression need parentheses ?
	 * 
	 * <p>
	 * <b>Note:</b> The expression must not be an unparented node.
	 * </p>
	 * 
	 * @param expression the expression
	 * @return <code>true</code> if the expression needs parentheses, <code>false</code> otherwise.
	 */
	public static boolean needsParentheses(Expression expression) {
		return needsParentheses(expression, expression.getParent(), expression.getLocationInParent());
	}

	/**
	 * Does the expression need parentheses ?
	 * 
	 * <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)) {
				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)) {
					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

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, reference.getParent(), reference.getLocationInParent())) { //TODO: this check is not really needed, and can be safely removed... i think
					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);
		boolean brackets= NecessaryParenthesesChecker.needsParentheses(copy, reference.getParent(), reference.getLocationInParent());
		if (brackets) {
			ParenthesizedExpression parentExpr= rewrite.getAST().newParenthesizedExpression();
			parentExpr.setExpression(copy);

		ITypeBinding explicitCast= ASTNodes.getExplicitCast(initializer, reference);
		if (explicitCast != null) {
			CastExpression cast= ast.newCastExpression();
			if (NecessaryParenthesesChecker.needsParentheses(copy, reference.getParent(), reference.getLocationInParent())) { //TODO: this definitley does not work, and is like the case in InlineConstantRefactoring
				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.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(newExpression, element.getParent(), element.getLocationInParent())) { //TODO: this definitley does not work, and is like the case in InlineConstantRefactoring
							newExpression= createParenthesizedExpression(newExpression, ast);
						}
						cast.setExpression(newExpression);
						ImportRewriteContext importRewriteContext= new ContextSensitiveImportRewriteContext(expression, importRewrite);
						cast.setType(importRewrite.addImport(explicitCast, ast, importRewriteContext));
						newExpression= createParenthesizedExpression(cast, ast);
					} else if (NecessaryParenthesesChecker.needsParentheses(expression, element.getParent(), element.getLocationInParent())) {
						newExpression= createParenthesizedExpression(newExpression, ast);
					}
					rewriter.replace(element, newExpression, null);

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 testRemoveQualifier01() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", 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);

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	}

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	}

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	}

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	}

Lines 4-10 Link Here

(-)resources/SefWorkSpace/SefTests/object_out/TestCompoundWrite2.java (-1 / +1 lines)
4	private String field;	4	private String field;
5		5
6	public void foo() {	6	public void foo() {
7	setField(getField() + ("d" + "e"));	7	setField(getField() + "d" + "e");
8	}	8	}
9		9
10	String getField() {	10	String getField() {

Lines 1-5 Link Here

(-)test cases/org/eclipse/jdt/ui/tests/refactoring/InlineConstantTests.java (-1 / +9 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 300-305 Link Here
300	helper1("p.A", 4, 24, 4, 25, true, true);	300	helper1("p.A", 4, 24, 4, 25, true, true);
301	}	301	}
302		302
		303	public void test35() throws Exception { // test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=335173
		304	helper1("p.A", 4, 22, 4, 23, true, true);
		305	}
		306
		307	public void test36() throws Exception { // test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=335173
		308	helper1("p.A", 4, 22, 4, 23, true, true);
		309	}
		310
303	// -- testing failing preconditions	311	// -- testing failing preconditions
304		312
305	public void testFail0() throws Exception {	313	public void testFail0() throws Exception {

Lines 1-5 Link Here

(-)test cases/org/eclipse/jdt/ui/tests/refactoring/InlineMethodTestSetup.java (-1 / +1 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 1-5 Link Here

(-)test cases/org/eclipse/jdt/ui/tests/refactoring/InlineMethodTests.java (-1 / +5 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 956-961 Link Here
956	performOperatorTest();	956	performOperatorTest();
957	}	957	}
958		958
		959	public void testDiffPlus() throws Exception {
		960	performOperatorTest();
		961	}
		962
959	public void testTimesPlus() throws Exception {	963	public void testTimesPlus() throws Exception {
960	performOperatorTest();	964	performOperatorTest();
961	}	965	}




/*******************************************************************************
 * 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(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 testFail0() throws Exception{

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)) {
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)) {
		482	toReplace= top.getParent();
		483	}
		484	rewrite.replace(toReplace, move, group);
480	}	485	}
481	}	486	}
482	}	487	}

Lines 1-5 Link Here

(-)core refactoring/org/eclipse/jdt/internal/corext/refactoring/code/CallInliner.java (-15 / +2 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 646-652 Link Here
646	node= castExpression;	646	node= castExpression;
647	}	647	}
648		648
649	if (needsParenthesis()) {	649	if (fSourceProvider.needsReturnedExpressionParenthesis(fTargetNode.getParent(), fTargetNode.getLocationInParent())) {
650	ParenthesizedExpression pExp= fTargetNode.getAST().newParenthesizedExpression();	650	ParenthesizedExpression pExp= fTargetNode.getAST().newParenthesizedExpression();
651	pExp.setExpression((Expression)node);	651	pExp.setExpression((Expression)node);
652	node= pExp;	652	node= pExp;
Lines 721-739 Link Here
721	return false;	721	return false;
722	}	722	}
723		723
724	private boolean needsParenthesis() {
725	if (!fSourceProvider.needsReturnedExpressionParenthesis())
726	return false;
727	ASTNode parent= fTargetNode.getParent();
728	int type= parent.getNodeType();
729	return
730	type == ASTNode.METHOD_INVOCATION \|\|
731	(parent instanceof Expression && type != ASTNode.ASSIGNMENT) \|\|
732	(fSourceProvider.returnsConditionalExpression() &&
733	type == ASTNode.VARIABLE_DECLARATION_FRAGMENT &&
734	((VariableDeclarationFragment)parent).getInitializer() == fTargetNode);
735	}
736
737	private VariableDeclarationStatement createLocalDeclaration(ITypeBinding type, String name, Expression initializer) {	724	private VariableDeclarationStatement createLocalDeclaration(ITypeBinding type, String name, Expression initializer) {
738	ImportRewriteContext context= new ContextSensitiveImportRewriteContext(fTargetNode, fImportRewrite);	725	ImportRewriteContext context= new ContextSensitiveImportRewriteContext(fTargetNode, fImportRewrite);
739	String typeName= fImportRewrite.addImport(type, context);	726	String typeName= fImportRewrite.addImport(type, context);

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 (+292 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(InfixExpression 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	/*
139	* Is the given expression associative?
140	*
141	* This is true if and only if:<br>
142	* <code>left operator (right) == (right) operator left == right operator left</code>
143	*/
144	private static boolean isAssociative(InfixExpression expression) {
145	Operator operator= expression.getOperator();
146
147	if (operator == InfixExpression.Operator.PLUS \|\| operator == InfixExpression.Operator.TIMES)
148	return isExpressionIntegerType(expression) && isAllOperandsHaveSameType(expression);
149
150	if (operator == InfixExpression.Operator.CONDITIONAL_AND
151	\|\| operator == InfixExpression.Operator.CONDITIONAL_OR
152	\|\| operator == InfixExpression.Operator.AND
153	\|\| operator == InfixExpression.Operator.OR
154	\|\| operator == InfixExpression.Operator.XOR)
155	return true;
156
157	return false;
158	}
159
160	private static boolean isIntegerNumber(String name) {
161	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$
162	}
163
164	private static boolean needsParenthesesInInfixExpression(Expression expression, InfixExpression parentInfix, StructuralPropertyDescriptor locationInParent) {
165	if (locationInParent == InfixExpression.LEFT_OPERAND_PROPERTY) {
166	//we have (expr op expr) op expr
167	//infix expressions are evaluated from left to right -> parentheses not needed
168	return false;
169	} else if (isAssociative(parentInfix)) {
170	//we have parent op (expr op expr) and op is associative
171	//left op (right) == (right) op left == right op left
172	if (expression instanceof InfixExpression) {
173	InfixExpression infixExpression= (InfixExpression)expression;
174	Operator operator= infixExpression.getOperator();
175	if (parentInfix.getOperator() != InfixExpression.Operator.TIMES)
176	return false;
177
178	if (operator == InfixExpression.Operator.TIMES)
179	// x * (y * z) == x * y * z
180	return false;
181
182	if (operator == InfixExpression.Operator.REMAINDER \|\| operator == InfixExpression.Operator.DIVIDE)
183	// x * (y % z) != x * y % z , x * (y / z) == x * y / z rounding involved
184	return true;
185
186	return false;
187	}
188	return false;
189	} else {
190	return true;
191	}
192	}
193
194	/**
195	* Can the parentheses be removed from the parenthesized expression ?
196	*
197	* <p>
198	* <b>Note:</b> The parenthesized expression must not be an unparented node.
199	* </p>
200	*
201	* @param expression the parenthesized expression
202	* @return <code>true</code> if parentheses can be removed, <code>false</code> otherwise.
203	*/
204	public static boolean canRemoveParentheses(Expression expression) {
205	return canRemoveParentheses(expression, expression.getParent(), expression.getLocationInParent());
206	}
207
208	/**
209	* Can the parentheses be removed from the parenthesized expression ?
210	*
211	* <p>
212	* <b>Note:</b> The parenthesized expression can be an unparented node.
213	* </p>
214	*
215	* @param expression the parenthesized expression
216	* @param parent the parent node
217	* @param locationInParent location of expression in the parent
218	* @return <code>true</code> if parentheses can be removed, <code>false</code> otherwise.
219	*/
220	public static boolean canRemoveParentheses(Expression expression, ASTNode parent, StructuralPropertyDescriptor locationInParent) {
221	if (!(expression instanceof ParenthesizedExpression)) {
222	return false;
223	}
224	return !needsParentheses(getExpression((ParenthesizedExpression)expression), parent, locationInParent);
225	}
226
227	/**
228	* Does the expression need parentheses ?
229	*
230	* <p>
231	* <b>Note:</b> The expression must not be an unparented node.
232	* </p>
233	*
234	* @param expression the expression
235	* @return <code>true</code> if the expression needs parentheses, <code>false</code> otherwise.
236	*/
237	public static boolean needsParentheses(Expression expression) {
238	return needsParentheses(expression, expression.getParent(), expression.getLocationInParent());
239	}
240
241	/**
242	* Does the expression need parentheses ?
243	*
244	* <p>
245	* <b>Note:</b> The expression can be an unparented node.
246	* </p>
247	*
248	* @param expression the expression
249	* @param parent the parent node
250	* @param locationInParent location of expression in the parent
251	* @return <code>true</code> if the expression needs parentheses, <code>false</code> otherwise.
252	*/
253	public static boolean needsParentheses(Expression expression, ASTNode parent, StructuralPropertyDescriptor locationInParent) {
254	if (!expressionTypeNeedsParentheses(expression))
255	return false;
256
257	if (!locationNeedsParentheses(locationInParent)) {
258	return false;
259	}
260
261	if (parent instanceof Expression) {
262	Expression parentExpression= (Expression)parent;
263	if (parentExpression instanceof ParenthesizedExpression)
264	return false;
265
266	int expressionPrecedence= OperatorPrecedence.getExpressionPrecedence(expression);
267	int parentPrecedence= OperatorPrecedence.getExpressionPrecedence(parentExpression);
268
269	if (expressionPrecedence > parentPrecedence)
270	//(opEx) opParent and opEx binds more -> parentheses not needed
271	return false;
272
273	if (expressionPrecedence < parentPrecedence)
274	//(opEx) opParent and opEx binds less -> parentheses needed
275	return true;
276
277	//(opEx) opParent binds equal
278
279	if (parentExpression instanceof InfixExpression) {
280	return needsParenthesesInInfixExpression(expression, (InfixExpression)parentExpression, locationInParent);
281	}
282
283	if (parentExpression instanceof ConditionalExpression && locationInParent == ConditionalExpression.EXPRESSION_PROPERTY) {
284	return true;
285	}
286
287	return false;
288	}
289
290	return true;
291	}
292	}

Lines 51-56 Link Here

(-)core refactoring/org/eclipse/jdt/internal/corext/refactoring/sef/AccessAnalyzer.java (-1 / +2 lines)
51	import org.eclipse.jdt.internal.corext.SourceRangeFactory;	51	import org.eclipse.jdt.internal.corext.SourceRangeFactory;
52	import org.eclipse.jdt.internal.corext.dom.ASTNodes;	52	import org.eclipse.jdt.internal.corext.dom.ASTNodes;
53	import org.eclipse.jdt.internal.corext.dom.Bindings;	53	import org.eclipse.jdt.internal.corext.dom.Bindings;
		54	import org.eclipse.jdt.internal.corext.fix.NecessaryParenthesesChecker;
54	import org.eclipse.jdt.internal.corext.refactoring.RefactoringCoreMessages;	55	import org.eclipse.jdt.internal.corext.refactoring.RefactoringCoreMessages;
55	import org.eclipse.jdt.internal.corext.refactoring.base.JavaStatusContext;	56	import org.eclipse.jdt.internal.corext.refactoring.base.JavaStatusContext;
56		57
Lines 138-144 Link Here
138	arguments.add(fRewriter.createCopyTarget(node.getRightHandSide()));	139	arguments.add(fRewriter.createCopyTarget(node.getRightHandSide()));
139	} else {	140	} else {
140	// This is the compound assignment case: field+= 10;	141	// This is the compound assignment case: field+= 10;
141	boolean needsParentheses= ASTNodes.needsParentheses(node.getRightHandSide());	142	boolean needsParentheses= NecessaryParenthesesChecker.needsParentheses((node.getRightHandSide()));
142	InfixExpression exp= ast.newInfixExpression();	143	InfixExpression exp= ast.newInfixExpression();
143	exp.setOperator(ASTNodes.convertToInfixOperator(node.getOperator()));	144	exp.setOperator(ASTNodes.convertToInfixOperator(node.getOperator()));
144	MethodInvocation getter= ast.newMethodInvocation();	145	MethodInvocation getter= ast.newMethodInvocation();

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/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	}