org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/RedundantComparisonStatementCleanUp.java - jdt/eclipse.jdt.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2020 Fabrice TIERCELIN and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Fabrice TIERCELIN - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jdt.internal.ui.fix;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;

 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IProgressMonitor;

 import org.eclipse.text.edits.TextEditGroup;

 import org.eclipse.jdt.core.ICompilationUnit;
 import org.eclipse.jdt.core.dom.ASTVisitor;
 import org.eclipse.jdt.core.dom.Assignment;
 import org.eclipse.jdt.core.dom.Block;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jdt.core.dom.Expression;
 import org.eclipse.jdt.core.dom.IfStatement;
 import org.eclipse.jdt.core.dom.InfixExpression;
 import org.eclipse.jdt.core.dom.ReturnStatement;
 import org.eclipse.jdt.core.dom.Statement;
 import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
 import org.eclipse.jdt.core.refactoring.CompilationUnitChange;

 import org.eclipse.jdt.internal.corext.dom.ASTNodes;
 import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;
 import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFix;
 import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFix.CompilationUnitRewriteOperation;
 import org.eclipse.jdt.internal.corext.fix.LinkedProposalModel;
 import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;

 import org.eclipse.jdt.ui.cleanup.CleanUpRequirements;
 import org.eclipse.jdt.ui.cleanup.ICleanUpFix;
 import org.eclipse.jdt.ui.text.java.IProblemLocation;

 /**
  * A fix that removes useless bad value checks before assignments or return statements.
  * Such useless bad value checks are comparing an expression against bad value,
  * then either assigning bad value or the expression depending on the result of the bad value check.
  * It is simpler to directly assign the expression:
  * <ul>
  * <li>The expression should be passive.</li>
  * <li>The excluded value should be hard coded.</li>
  * </ul>
  */
 public class RedundantComparisonStatementCleanUp extends AbstractMultiFix implements ICleanUpFix {
 	public RedundantComparisonStatementCleanUp() {
 		this(Collections.emptyMap());
 	}

 	public RedundantComparisonStatementCleanUp(Map<String, String> options) {
 		super(options);
 	}

 	@Override
 	public CleanUpRequirements getRequirements() {
 		boolean requireAST= isEnabled(CleanUpConstants.REMOVE_REDUNDANT_COMPARISON_STATEMENT);
 		return new CleanUpRequirements(requireAST, false, false, null);
 	}

 	@Override
 	public String[] getStepDescriptions() {
 		if (isEnabled(CleanUpConstants.REMOVE_REDUNDANT_COMPARISON_STATEMENT)) {
 			return new String[] { MultiFixMessages.RedundantComparisonStatementCleanup_description };
 		}

 		return new String[0];
 	}

 	@Override
 	public String getPreview() {
 		if (isEnabled(CleanUpConstants.REMOVE_REDUNDANT_COMPARISON_STATEMENT)) {
 			return "return i;\n\n\n\n\n"; //$NON-NLS-1$
 		}

 		return "" //$NON-NLS-1$
 				+ "if (i != 123) {\n" //$NON-NLS-1$
 				+ " return i;\n" //$NON-NLS-1$
 				+ "} else {\n" //$NON-NLS-1$
 				+ " return 123;\n" //$NON-NLS-1$
 				+ "}\n"; //$NON-NLS-1$
 	}

 	@Override
 	protected ICleanUpFix createFix(CompilationUnit unit) throws CoreException {
 		if (!isEnabled(CleanUpConstants.REMOVE_REDUNDANT_COMPARISON_STATEMENT)) {
 			return null;
 		}

 		final List<CompilationUnitRewriteOperation> rewriteOperations= new ArrayList<>();

 		unit.accept(new ASTVisitor() {
 			@Override
 			public boolean visit(final Block node) {
 				IfAndReturnVisitor ifAndReturnVisitor= new IfAndReturnVisitor(node);
 				node.accept(ifAndReturnVisitor);
 				return ifAndReturnVisitor.result;
 			}

 			final class IfAndReturnVisitor extends ASTVisitor {
 				private final Block startNode;
 				private boolean result= true;

 				public IfAndReturnVisitor(final Block startNode) {
 					this.startNode= startNode;
 				}

 				@Override
 				public boolean visit(final Block node) {
 					return startNode == node;
 				}

 				@Override
 				public boolean visit(final IfStatement node) {
 					InfixExpression condition= ASTNodes.as(node.getExpression(), InfixExpression.class);
 					Statement thenStatement= getThenStatement(node);
 					Statement elseStatement= getElseStatement(node, thenStatement);

 					if (result
 							&& thenStatement != null
 							&& elseStatement != null
 							&& condition != null
 							&& !condition.hasExtendedOperands()
 							&& ASTNodes.hasOperator(condition, InfixExpression.Operator.EQUALS, InfixExpression.Operator.NOT_EQUALS)) {
 						boolean isEqual= ASTNodes.hasOperator(condition, InfixExpression.Operator.EQUALS);
 						Assignment thenAssignment= ASTNodes.asExpression(thenStatement, Assignment.class);
 						Assignment elseAssignment= ASTNodes.asExpression(elseStatement, Assignment.class);

 						if (ASTNodes.hasOperator(thenAssignment, Assignment.Operator.ASSIGN)
 								&& ASTNodes.hasOperator(elseAssignment, Assignment.Operator.ASSIGN)
 								&& ASTNodes.match(thenAssignment.getLeftHandSide(), elseAssignment.getLeftHandSide())) {
 							if (isEqual) {
 								return maybeReplace(node, condition, thenAssignment.getRightHandSide(), elseAssignment.getRightHandSide(), elseStatement, null)
 										&& maybeReplace(node, condition, elseAssignment.getRightHandSide(), thenAssignment.getRightHandSide(), elseStatement, null);
 							}

 							return maybeReplace(node, condition, elseAssignment.getRightHandSide(), thenAssignment.getRightHandSide(), thenStatement, null)
 									&& maybeReplace(node, condition, thenAssignment.getRightHandSide(), elseAssignment.getRightHandSide(), thenStatement, null);
 						}

 						ReturnStatement thenReturnStatement= ASTNodes.as(thenStatement, ReturnStatement.class);
 						ReturnStatement elseReturnStatement= ASTNodes.as(elseStatement, ReturnStatement.class);

 						if (thenReturnStatement != null && elseReturnStatement != null) {
 							if (isEqual) {
 								return maybeReplace(node, condition, thenReturnStatement.getExpression(), elseReturnStatement.getExpression(), elseReturnStatement, thenReturnStatement)
 										&& maybeReplace(node, condition, elseReturnStatement.getExpression(), thenReturnStatement.getExpression(), elseReturnStatement, thenReturnStatement);
 							}

 							return maybeReplace(node, condition, elseReturnStatement.getExpression(), thenReturnStatement.getExpression(), thenReturnStatement, elseReturnStatement)
 									&& maybeReplace(node, condition, thenReturnStatement.getExpression(), elseReturnStatement.getExpression(), thenReturnStatement, elseReturnStatement);
 						}
 					}

 					return true;
 				}

 				private Statement getThenStatement(final IfStatement node) {
 					List<Statement> thenStatements= ASTNodes.asList(node.getThenStatement());

 					if (thenStatements.size() == 1) {
 						return thenStatements.get(0);
 					}

 					return null;
 				}

 				private Statement getElseStatement(final IfStatement node, final Statement thenStatement) {
 					List<Statement> elseStatements= ASTNodes.asList(node.getElseStatement());

 					if (elseStatements.size() == 1) {
 						return elseStatements.get(0);
 					}

 					if (ASTNodes.is(thenStatement, ReturnStatement.class)) {
 						return ASTNodes.getNextSibling(node);
 					}

 					return null;
 				}

 				private boolean maybeReplace(final IfStatement node, final InfixExpression condition, final Expression hardCodedExpression, final Expression valuedExpression,
 						final Statement statementToMove, final ReturnStatement returnToRemove) {
 					if (ASTNodes.isHardCoded(hardCodedExpression)
 							&& ASTNodes.isPassiveWithoutFallingThrough(hardCodedExpression)
 							&& ASTNodes.isPassive(valuedExpression)
 							&& ((ASTNodes.match(condition.getRightOperand(), hardCodedExpression) && ASTNodes.match(condition.getLeftOperand(), valuedExpression))
 									|| (ASTNodes.match(condition.getRightOperand(), valuedExpression) && ASTNodes.match(condition.getLeftOperand(), hardCodedExpression)))) {
 						rewriteOperations.add(new RedundantComparisonStatementOperation(node, statementToMove, returnToRemove));
 						result= false;
 						return false;
 					}

 					return true;
 				}
 			}
 		});

 		if (rewriteOperations.isEmpty()) {
 			return null;
 		}

 		return new CompilationUnitRewriteOperationsFix(MultiFixMessages.RedundantComparisonStatementCleanup_description, unit,
 				rewriteOperations.toArray(new CompilationUnitRewriteOperation[0]));
 	}

 	@Override
 	public CompilationUnitChange createChange(IProgressMonitor progressMonitor) throws CoreException {
 		return null;
 	}

 	@Override
 	public boolean canFix(final ICompilationUnit compilationUnit, final IProblemLocation problem) {
 		return false;
 	}

 	@Override
 	protected ICleanUpFix createFix(final CompilationUnit unit, final IProblemLocation[] problems) throws CoreException {
 		return null;
 	}

 	private static class RedundantComparisonStatementOperation extends CompilationUnitRewriteOperation {
 		private final IfStatement node;
 		private final Statement toMove;
 		private final ReturnStatement toRemove;

 		public RedundantComparisonStatementOperation(final IfStatement node, final Statement toMove, final ReturnStatement toRemove) {
 			this.node= node;
 			this.toMove= toMove;
 			this.toRemove= toRemove;
 		}

 		@Override
 		public void rewriteAST(final CompilationUnitRewrite cuRewrite, final LinkedProposalModel linkedModel) throws CoreException {
 			ASTRewrite rewrite= cuRewrite.getASTRewrite();
 			TextEditGroup group= createTextEditGroup(MultiFixMessages.RedundantComparisonStatementCleanup_description, cuRewrite);

 			ASTNodes.replaceButKeepComment(rewrite, node, ASTNodes.createMoveTarget(rewrite, toMove), group);

 			if (toRemove != null) {
 				rewrite.remove(toRemove, group);
 			}
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2020 Fabrice TIERCELIN and others.
	*
	* This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License 2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* Fabrice TIERCELIN - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jdt.internal.ui.fix;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.List;
	import java.util.Map;

	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IProgressMonitor;

	import org.eclipse.text.edits.TextEditGroup;

	import org.eclipse.jdt.core.ICompilationUnit;
	import org.eclipse.jdt.core.dom.ASTVisitor;
	import org.eclipse.jdt.core.dom.Assignment;
	import org.eclipse.jdt.core.dom.Block;
	import org.eclipse.jdt.core.dom.CompilationUnit;
	import org.eclipse.jdt.core.dom.Expression;
	import org.eclipse.jdt.core.dom.IfStatement;
	import org.eclipse.jdt.core.dom.InfixExpression;
	import org.eclipse.jdt.core.dom.ReturnStatement;
	import org.eclipse.jdt.core.dom.Statement;
	import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
	import org.eclipse.jdt.core.refactoring.CompilationUnitChange;

	import org.eclipse.jdt.internal.corext.dom.ASTNodes;
	import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;
	import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFix;
	import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFix.CompilationUnitRewriteOperation;
	import org.eclipse.jdt.internal.corext.fix.LinkedProposalModel;
	import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;

	import org.eclipse.jdt.ui.cleanup.CleanUpRequirements;
	import org.eclipse.jdt.ui.cleanup.ICleanUpFix;
	import org.eclipse.jdt.ui.text.java.IProblemLocation;

	/**
	* A fix that removes useless bad value checks before assignments or return statements.
	* Such useless bad value checks are comparing an expression against bad value,
	* then either assigning bad value or the expression depending on the result of the bad value check.
	* It is simpler to directly assign the expression:
	* <ul>
	* <li>The expression should be passive.</li>
	* <li>The excluded value should be hard coded.</li>
	* </ul>
	*/
	public class RedundantComparisonStatementCleanUp extends AbstractMultiFix implements ICleanUpFix {
	public RedundantComparisonStatementCleanUp() {
	this(Collections.emptyMap());
	}

	public RedundantComparisonStatementCleanUp(Map<String, String> options) {
	super(options);
	}

	@Override
	public CleanUpRequirements getRequirements() {
	boolean requireAST= isEnabled(CleanUpConstants.REMOVE_REDUNDANT_COMPARISON_STATEMENT);
	return new CleanUpRequirements(requireAST, false, false, null);
	}

	@Override
	public String[] getStepDescriptions() {
	if (isEnabled(CleanUpConstants.REMOVE_REDUNDANT_COMPARISON_STATEMENT)) {
	return new String[] { MultiFixMessages.RedundantComparisonStatementCleanup_description };
	}

	return new String[0];
	}

	@Override
	public String getPreview() {
	if (isEnabled(CleanUpConstants.REMOVE_REDUNDANT_COMPARISON_STATEMENT)) {
	return "return i;\n\n\n\n\n"; //$NON-NLS-1$
	}

	return "" //$NON-NLS-1$
	+ "if (i != 123) {\n" //$NON-NLS-1$
	+ " return i;\n" //$NON-NLS-1$
	+ "} else {\n" //$NON-NLS-1$
	+ " return 123;\n" //$NON-NLS-1$
	+ "}\n"; //$NON-NLS-1$
	}

	@Override
	protected ICleanUpFix createFix(CompilationUnit unit) throws CoreException {
	if (!isEnabled(CleanUpConstants.REMOVE_REDUNDANT_COMPARISON_STATEMENT)) {
	return null;
	}

	final List<CompilationUnitRewriteOperation> rewriteOperations= new ArrayList<>();

	unit.accept(new ASTVisitor() {
	@Override
	public boolean visit(final Block node) {
	IfAndReturnVisitor ifAndReturnVisitor= new IfAndReturnVisitor(node);
	node.accept(ifAndReturnVisitor);
	return ifAndReturnVisitor.result;
	}

	final class IfAndReturnVisitor extends ASTVisitor {
	private final Block startNode;
	private boolean result= true;

	public IfAndReturnVisitor(final Block startNode) {
	this.startNode= startNode;
	}

	@Override
	public boolean visit(final Block node) {
	return startNode == node;
	}

	@Override
	public boolean visit(final IfStatement node) {
	InfixExpression condition= ASTNodes.as(node.getExpression(), InfixExpression.class);
	Statement thenStatement= getThenStatement(node);
	Statement elseStatement= getElseStatement(node, thenStatement);

	if (result
	&& thenStatement != null
	&& elseStatement != null
	&& condition != null
	&& !condition.hasExtendedOperands()
	&& ASTNodes.hasOperator(condition, InfixExpression.Operator.EQUALS, InfixExpression.Operator.NOT_EQUALS)) {
	boolean isEqual= ASTNodes.hasOperator(condition, InfixExpression.Operator.EQUALS);
	Assignment thenAssignment= ASTNodes.asExpression(thenStatement, Assignment.class);
	Assignment elseAssignment= ASTNodes.asExpression(elseStatement, Assignment.class);

	if (ASTNodes.hasOperator(thenAssignment, Assignment.Operator.ASSIGN)
	&& ASTNodes.hasOperator(elseAssignment, Assignment.Operator.ASSIGN)
	&& ASTNodes.match(thenAssignment.getLeftHandSide(), elseAssignment.getLeftHandSide())) {
	if (isEqual) {
	return maybeReplace(node, condition, thenAssignment.getRightHandSide(), elseAssignment.getRightHandSide(), elseStatement, null)
	&& maybeReplace(node, condition, elseAssignment.getRightHandSide(), thenAssignment.getRightHandSide(), elseStatement, null);
	}

	return maybeReplace(node, condition, elseAssignment.getRightHandSide(), thenAssignment.getRightHandSide(), thenStatement, null)
	&& maybeReplace(node, condition, thenAssignment.getRightHandSide(), elseAssignment.getRightHandSide(), thenStatement, null);
	}

	ReturnStatement thenReturnStatement= ASTNodes.as(thenStatement, ReturnStatement.class);
	ReturnStatement elseReturnStatement= ASTNodes.as(elseStatement, ReturnStatement.class);

	if (thenReturnStatement != null && elseReturnStatement != null) {
	if (isEqual) {
	return maybeReplace(node, condition, thenReturnStatement.getExpression(), elseReturnStatement.getExpression(), elseReturnStatement, thenReturnStatement)
	&& maybeReplace(node, condition, elseReturnStatement.getExpression(), thenReturnStatement.getExpression(), elseReturnStatement, thenReturnStatement);
	}

	return maybeReplace(node, condition, elseReturnStatement.getExpression(), thenReturnStatement.getExpression(), thenReturnStatement, elseReturnStatement)
	&& maybeReplace(node, condition, thenReturnStatement.getExpression(), elseReturnStatement.getExpression(), thenReturnStatement, elseReturnStatement);
	}
	}

	return true;
	}

	private Statement getThenStatement(final IfStatement node) {
	List<Statement> thenStatements= ASTNodes.asList(node.getThenStatement());

	if (thenStatements.size() == 1) {
	return thenStatements.get(0);
	}

	return null;
	}

	private Statement getElseStatement(final IfStatement node, final Statement thenStatement) {
	List<Statement> elseStatements= ASTNodes.asList(node.getElseStatement());

	if (elseStatements.size() == 1) {
	return elseStatements.get(0);
	}

	if (ASTNodes.is(thenStatement, ReturnStatement.class)) {
	return ASTNodes.getNextSibling(node);
	}

	return null;
	}

	private boolean maybeReplace(final IfStatement node, final InfixExpression condition, final Expression hardCodedExpression, final Expression valuedExpression,
	final Statement statementToMove, final ReturnStatement returnToRemove) {
	if (ASTNodes.isHardCoded(hardCodedExpression)
	&& ASTNodes.isPassiveWithoutFallingThrough(hardCodedExpression)
	&& ASTNodes.isPassive(valuedExpression)
	&& ((ASTNodes.match(condition.getRightOperand(), hardCodedExpression) && ASTNodes.match(condition.getLeftOperand(), valuedExpression))
	\|\| (ASTNodes.match(condition.getRightOperand(), valuedExpression) && ASTNodes.match(condition.getLeftOperand(), hardCodedExpression)))) {
	rewriteOperations.add(new RedundantComparisonStatementOperation(node, statementToMove, returnToRemove));
	result= false;
	return false;
	}

	return true;
	}
	}
	});

	if (rewriteOperations.isEmpty()) {
	return null;
	}

	return new CompilationUnitRewriteOperationsFix(MultiFixMessages.RedundantComparisonStatementCleanup_description, unit,
	rewriteOperations.toArray(new CompilationUnitRewriteOperation[0]));
	}

	@Override
	public CompilationUnitChange createChange(IProgressMonitor progressMonitor) throws CoreException {
	return null;
	}

	@Override
	public boolean canFix(final ICompilationUnit compilationUnit, final IProblemLocation problem) {
	return false;
	}

	@Override
	protected ICleanUpFix createFix(final CompilationUnit unit, final IProblemLocation[] problems) throws CoreException {
	return null;
	}

	private static class RedundantComparisonStatementOperation extends CompilationUnitRewriteOperation {
	private final IfStatement node;
	private final Statement toMove;
	private final ReturnStatement toRemove;

	public RedundantComparisonStatementOperation(final IfStatement node, final Statement toMove, final ReturnStatement toRemove) {
	this.node= node;
	this.toMove= toMove;
	this.toRemove= toRemove;
	}

	@Override
	public void rewriteAST(final CompilationUnitRewrite cuRewrite, final LinkedProposalModel linkedModel) throws CoreException {
	ASTRewrite rewrite= cuRewrite.getASTRewrite();
	TextEditGroup group= createTextEditGroup(MultiFixMessages.RedundantComparisonStatementCleanup_description, cuRewrite);

	ASTNodes.replaceButKeepComment(rewrite, node, ASTNodes.createMoveTarget(rewrite, toMove), group);

	if (toRemove != null) {
	rewrite.remove(toRemove, group);
	}
	}
	}
	}