| /******************************************************************************* |
| * 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 java.util.Objects; |
| |
| 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.AST; |
| import org.eclipse.jdt.core.dom.ASTMatcher; |
| import org.eclipse.jdt.core.dom.ASTNode; |
| import org.eclipse.jdt.core.dom.ASTVisitor; |
| import org.eclipse.jdt.core.dom.Block; |
| import org.eclipse.jdt.core.dom.BooleanLiteral; |
| 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.MethodInvocation; |
| import org.eclipse.jdt.core.dom.Name; |
| import org.eclipse.jdt.core.dom.NullLiteral; |
| import org.eclipse.jdt.core.dom.PrefixExpression; |
| 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.dom.rewrite.ImportRewrite; |
| import org.eclipse.jdt.core.refactoring.CompilationUnitChange; |
| |
| import org.eclipse.jdt.internal.corext.dom.ASTNodes; |
| import org.eclipse.jdt.internal.corext.dom.OrderedInfixExpression; |
| 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.internal.corext.util.JavaModelUtil; |
| |
| 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 reduces the code of the equals method implementation by using Objects.equals(). |
| */ |
| public class ObjectsEqualsCleanUp extends AbstractMultiFix implements ICleanUpFix { |
| private static final String EQUALS_METHOD= "equals"; //$NON-NLS-1$ |
| |
| public ObjectsEqualsCleanUp() { |
| this(Collections.emptyMap()); |
| } |
| |
| public ObjectsEqualsCleanUp(Map<String, String> options) { |
| super(options); |
| } |
| |
| @Override |
| public CleanUpRequirements getRequirements() { |
| boolean requireAST= isEnabled(CleanUpConstants.USE_OBJECTS_EQUALS); |
| return new CleanUpRequirements(requireAST, false, false, null); |
| } |
| |
| @Override |
| public String[] getStepDescriptions() { |
| if (isEnabled(CleanUpConstants.USE_OBJECTS_EQUALS)) { |
| return new String[] { MultiFixMessages.ObjectsEqualsCleanup_description }; |
| } |
| |
| return new String[0]; |
| } |
| |
| @Override |
| public String getPreview() { |
| if (isEnabled(CleanUpConstants.USE_OBJECTS_EQUALS)) { |
| return "" //$NON-NLS-1$ |
| + "if (!Objects.equals(aText, other.aText)) {\n" //$NON-NLS-1$ |
| + " return false;\n" //$NON-NLS-1$ |
| + "}\n\n\n\n\n"; //$NON-NLS-1$ |
| } else { |
| return "" //$NON-NLS-1$ |
| + "if (aText == null) {\n" //$NON-NLS-1$ |
| + " if (other.aText != null) {\n" //$NON-NLS-1$ |
| + " return false;\n" //$NON-NLS-1$ |
| + " }\n" //$NON-NLS-1$ |
| + "} else if (!aText.equals(other.aText)) {\n" //$NON-NLS-1$ |
| + " return false;\n" //$NON-NLS-1$ |
| + "}\n"; //$NON-NLS-1$ |
| } |
| } |
| |
| @Override |
| protected ICleanUpFix createFix(CompilationUnit unit) throws CoreException { |
| if (!isEnabled(CleanUpConstants.USE_OBJECTS_EQUALS) || !JavaModelUtil.is17OrHigher(unit.getJavaElement().getJavaProject())) { |
| return null; |
| } |
| |
| final List<CompilationUnitRewriteOperation> rewriteOperations= new ArrayList<>(); |
| |
| unit.accept(new ASTVisitor() { |
| |
| @Override |
| public boolean visit(final IfStatement node) { |
| if (node.getElseStatement() != null) { |
| InfixExpression condition= ASTNodes.as(node.getExpression(), InfixExpression.class); |
| List<Statement> thenStatements= ASTNodes.asList(node.getThenStatement()); |
| List<Statement> elseStatements= ASTNodes.asList(node.getElseStatement()); |
| |
| if (condition != null && !condition.hasExtendedOperands() |
| && ASTNodes.hasOperator(condition, InfixExpression.Operator.EQUALS, InfixExpression.Operator.NOT_EQUALS) |
| && thenStatements != null && thenStatements.size() == 1 && elseStatements != null && elseStatements.size() == 1) { |
| OrderedInfixExpression<Expression, NullLiteral> nullityTypedCondition= ASTNodes.orderedInfix(condition, Expression.class, NullLiteral.class); |
| |
| if (nullityTypedCondition != null && ASTNodes.isPassive(nullityTypedCondition.getFirstOperand())) { |
| return maybeReplaceCode(node, condition, thenStatements, elseStatements, nullityTypedCondition.getFirstOperand()); |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| private boolean maybeReplaceCode(final IfStatement node, final InfixExpression condition, |
| final List<Statement> thenStatements, final List<Statement> elseStatements, final Expression firstField) { |
| IfStatement checkNullityStatement; |
| IfStatement checkEqualsStatement; |
| |
| if (ASTNodes.hasOperator(condition, InfixExpression.Operator.EQUALS)) { |
| checkNullityStatement= ASTNodes.as(thenStatements.get(0), IfStatement.class); |
| checkEqualsStatement= ASTNodes.as(elseStatements.get(0), IfStatement.class); |
| } else { |
| checkEqualsStatement= ASTNodes.as(thenStatements.get(0), IfStatement.class); |
| checkNullityStatement= ASTNodes.as(elseStatements.get(0), IfStatement.class); |
| } |
| |
| if (checkNullityStatement != null && checkNullityStatement.getElseStatement() == null && checkEqualsStatement != null |
| && checkEqualsStatement.getElseStatement() == null) { |
| InfixExpression nullityCondition= ASTNodes.as(checkNullityStatement.getExpression(), InfixExpression.class); |
| List<Statement> nullityStatements= ASTNodes.asList(checkNullityStatement.getThenStatement()); |
| |
| PrefixExpression equalsCondition= ASTNodes.as(checkEqualsStatement.getExpression(), PrefixExpression.class); |
| List<Statement> equalsStatements= ASTNodes.asList(checkEqualsStatement.getThenStatement()); |
| |
| if (nullityCondition != null && !nullityCondition.hasExtendedOperands() |
| && ASTNodes.hasOperator(nullityCondition, InfixExpression.Operator.NOT_EQUALS) && nullityStatements != null |
| && nullityStatements.size() == 1 && equalsCondition != null |
| && ASTNodes.hasOperator(equalsCondition, PrefixExpression.Operator.NOT) && equalsStatements != null |
| && equalsStatements.size() == 1) { |
| return maybeReplaceEquals(node, firstField, nullityCondition, nullityStatements, equalsCondition, |
| equalsStatements); |
| } |
| } |
| |
| return true; |
| } |
| |
| private boolean maybeReplaceEquals(final IfStatement node, final Expression firstField, |
| final InfixExpression nullityCondition, final List<Statement> nullityStatements, |
| final PrefixExpression equalsCondition, final List<Statement> equalsStatements) { |
| OrderedInfixExpression<Expression, NullLiteral> nullityTypedCondition= ASTNodes.orderedInfix(nullityCondition, Expression.class, NullLiteral.class); |
| ReturnStatement returnStatement1= ASTNodes.as(nullityStatements.get(0), ReturnStatement.class); |
| ReturnStatement returnStatement2= ASTNodes.as(equalsStatements.get(0), ReturnStatement.class); |
| MethodInvocation equalsMethod= ASTNodes.as(equalsCondition.getOperand(), MethodInvocation.class); |
| |
| if (nullityTypedCondition != null && returnStatement1 != null && returnStatement2 != null && equalsMethod != null |
| && equalsMethod.getExpression() != null && EQUALS_METHOD.equals(equalsMethod.getName().getIdentifier()) |
| && equalsMethod.arguments() != null && equalsMethod.arguments().size() == 1) { |
| Expression secondField= nullityTypedCondition.getFirstOperand(); |
| |
| if (secondField != null |
| && (match(firstField, secondField, equalsMethod.getExpression(), |
| (ASTNode) equalsMethod.arguments().get(0)) |
| || match(secondField, firstField, equalsMethod.getExpression(), |
| (ASTNode) equalsMethod.arguments().get(0)))) { |
| BooleanLiteral returnFalse1= ASTNodes.as(returnStatement1.getExpression(), BooleanLiteral.class); |
| BooleanLiteral returnFalse2= ASTNodes.as(returnStatement2.getExpression(), BooleanLiteral.class); |
| |
| if (returnFalse1 != null && !returnFalse1.booleanValue() && returnFalse2 != null |
| && !returnFalse2.booleanValue()) { |
| rewriteOperations.add(new ObjectsEqualsOperation(node, firstField, secondField, returnStatement1)); |
| return false; |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| private boolean match(final Expression firstField, final Expression secondField, final Expression thisObject, |
| final ASTNode otherObject) { |
| ASTMatcher astMatcher= new ASTMatcher(); |
| return astMatcher.safeSubtreeMatch(thisObject, firstField) && astMatcher.safeSubtreeMatch(otherObject, secondField); |
| } |
| }); |
| |
| if (rewriteOperations.isEmpty()) { |
| return null; |
| } |
| |
| return new CompilationUnitRewriteOperationsFix(MultiFixMessages.ObjectsEqualsCleanup_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 ObjectsEqualsOperation extends CompilationUnitRewriteOperation { |
| private final IfStatement node; |
| private final Expression firstField; |
| private final Expression secondField; |
| private final ReturnStatement returnStatement; |
| |
| public ObjectsEqualsOperation(final IfStatement node, final Expression firstField, |
| final Expression secondField, |
| final ReturnStatement returnStatement) { |
| this.node= node; |
| this.firstField= firstField; |
| this.secondField= secondField; |
| this.returnStatement= returnStatement; |
| } |
| |
| @Override |
| public void rewriteAST(final CompilationUnitRewrite cuRewrite, final LinkedProposalModel linkedModel) throws CoreException { |
| ASTRewrite rewrite= cuRewrite.getASTRewrite(); |
| AST ast= cuRewrite.getRoot().getAST(); |
| TextEditGroup group= createTextEditGroup(MultiFixMessages.ObjectsEqualsCleanup_description, cuRewrite); |
| ImportRewrite importRewrite= cuRewrite.getImportRewrite(); |
| |
| String objectNameText= importRewrite.addImport(Objects.class.getCanonicalName()); |
| |
| MethodInvocation newEqualsMethod= ast.newMethodInvocation(); |
| newEqualsMethod.setExpression(newTypeName(ast, objectNameText)); |
| newEqualsMethod.setName(ast.newSimpleName(EQUALS_METHOD)); |
| newEqualsMethod.arguments().add(ASTNodes.createMoveTarget(rewrite, firstField)); |
| newEqualsMethod.arguments().add(ASTNodes.createMoveTarget(rewrite, secondField)); |
| |
| PrefixExpression notExpression= ast.newPrefixExpression(); |
| notExpression.setOperator(PrefixExpression.Operator.NOT); |
| notExpression.setOperand(newEqualsMethod); |
| |
| ReturnStatement copyOfReturnStatement= ASTNodes.createMoveTarget(rewrite, returnStatement); |
| |
| rewrite.replace(node.getExpression(), notExpression, group); |
| |
| if (node.getThenStatement() instanceof Block) { |
| rewrite.replace((ASTNode) ((Block) node.getThenStatement()).statements().get(0), copyOfReturnStatement, group); |
| } else { |
| rewrite.replace(node.getThenStatement(), copyOfReturnStatement, group); |
| } |
| |
| if (node.getElseStatement() != null) { |
| rewrite.remove(node.getElseStatement(), group); |
| } |
| } |
| |
| private Name newTypeName(final AST ast, final String objectNameText) { |
| Name qualifiedName= null; |
| |
| for (String packageName : objectNameText.split("\\.")) { //$NON-NLS-1$ |
| if (qualifiedName == null) { |
| qualifiedName= ast.newSimpleName(packageName); |
| } else { |
| qualifiedName= ast.newQualifiedName(qualifiedName, ast.newSimpleName(packageName)); |
| } |
| } |
| |
| return qualifiedName; |
| } |
| } |
| } |
