From 209a7dae444b004b2061ff680f8dba8b8b837642 Mon Sep 17 00:00:00 2001 From: Bas Leijdekkers Date: Mon, 3 Apr 2017 14:12:55 +0200 Subject: [PATCH] IG: improve EquivalenceChecker naming --- .../java18api/Java8MapApiInspection.java | 5 +- ...essionWithIdenticalBranchesInspection.java | 28 +- .../RedundantMethodOverrideInspection.java | 10 +- ...alsReplaceableByObjectsCallInspection.java | 42 +- .../siyeh/ig/psiutils/EquivalenceChecker.java | 572 +++++++++--------- 5 files changed, 324 insertions(+), 333 deletions(-) diff --git a/java/java-impl/src/com/intellij/codeInspection/java18api/Java8MapApiInspection.java b/java/java-impl/src/com/intellij/codeInspection/java18api/Java8MapApiInspection.java index 1c6512393eb2..9aff50e52f4c 100644 --- a/java/java-impl/src/com/intellij/codeInspection/java18api/Java8MapApiInspection.java +++ b/java/java-impl/src/com/intellij/codeInspection/java18api/Java8MapApiInspection.java @@ -94,10 +94,9 @@ public class Java8MapApiInspection extends BaseJavaBatchLocalInspectionTool { processMerge(condition, existsBranch, noneBranch); } if(condition.hasVariable()) return; - EquivalenceChecker.Decision decision = - EquivalenceChecker.getCanonicalPsiEquivalence().statementsAreEquivalentDecision(noneBranch, existsBranch); + EquivalenceChecker.Match match = EquivalenceChecker.getCanonicalPsiEquivalence().statementsMatch(noneBranch, existsBranch); - processGetPut(condition, existsBranch, decision.getRightDiff(), decision.getLeftDiff()); + processGetPut(condition, existsBranch, match.getRightDiff(), match.getLeftDiff()); } } diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/controlflow/ConditionalExpressionWithIdenticalBranchesInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/controlflow/ConditionalExpressionWithIdenticalBranchesInspection.java index 491cfbef7c2d..fa06c963926a 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/controlflow/ConditionalExpressionWithIdenticalBranchesInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/controlflow/ConditionalExpressionWithIdenticalBranchesInspection.java @@ -1,5 +1,5 @@ /* - * Copyright 2003-2016 Dave Griffith, Bas Leijdekkers + * Copyright 2003-2017 Dave Griffith, Bas Leijdekkers * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -50,10 +50,10 @@ public class ConditionalExpressionWithIdenticalBranchesInspection extends BaseIn @Override @NotNull protected String buildErrorString(Object... infos) { - final EquivalenceChecker.Decision decision = (EquivalenceChecker.Decision)infos[1]; - return InspectionGadgetsBundle.message(decision.isExact() - ? "conditional.expression.with.identical.branches.problem.descriptor" - : "conditional.expression.with.similar.branches.problem.descriptor"); + final EquivalenceChecker.Match decision = (EquivalenceChecker.Match)infos[1]; + return InspectionGadgetsBundle.message(decision.isPartialMatch() + ? "conditional.expression.with.similar.branches.problem.descriptor" + : "conditional.expression.with.identical.branches.problem.descriptor"); } @Override @@ -71,7 +71,7 @@ public class ConditionalExpressionWithIdenticalBranchesInspection extends BaseIn @Override @NotNull public String getName() { - return InspectionGadgetsBundle.message(getEquivalenceDecision().getExactlyMatches() + return InspectionGadgetsBundle.message(getEquivalenceDecision().isExactMatch() ? "conditional.expression.with.identical.branches.collapse.quickfix" : "conditional.expression.with.identical.branches.push.inside.quickfix"); } @@ -86,22 +86,22 @@ public class ConditionalExpressionWithIdenticalBranchesInspection extends BaseIn return myConditionalExpression.getElement(); } - private EquivalenceChecker.Decision getEquivalenceDecision() { + private EquivalenceChecker.Match getEquivalenceDecision() { return EquivalenceChecker.getCanonicalPsiEquivalence() - .expressionsAreEquivalentDecision(getConditionalExpression().getThenExpression(), getConditionalExpression().getElseExpression()); + .expressionsMatch(getConditionalExpression().getThenExpression(), getConditionalExpression().getElseExpression()); } @Override public void doFix(Project project, ProblemDescriptor descriptor) { - final EquivalenceChecker.Decision decision = getEquivalenceDecision(); + final EquivalenceChecker.Match decision = getEquivalenceDecision(); final PsiConditionalExpression conditionalExpression = getConditionalExpression(); final PsiExpression thenExpression = conditionalExpression.getThenExpression(); assert thenExpression != null; - if (decision.getExactlyMatches()) { + if (decision.isExactMatch()) { final PsiConditionalExpression expression = (PsiConditionalExpression)descriptor.getPsiElement(); final String bodyText = thenExpression.getText(); PsiReplacementUtil.replaceExpression(expression, bodyText); - } else if (!decision.isExactUnMatches()) { + } else if (!decision.isExactMismatch()) { final PsiElement leftDiff = decision.getLeftDiff(); final PsiElement rightDiff = decision.getRightDiff(); @@ -128,9 +128,9 @@ public class ConditionalExpressionWithIdenticalBranchesInspection extends BaseIn super.visitConditionalExpression(expression); final PsiExpression thenExpression = expression.getThenExpression(); final PsiExpression elseExpression = expression.getElseExpression(); - final EquivalenceChecker.Decision decision = EquivalenceChecker.getCanonicalPsiEquivalence() - .expressionsAreEquivalentDecision(thenExpression, elseExpression); - if (thenExpression != null && (myReportOnlyExactlyIdentical ? decision.getExactlyMatches() : !decision.isExactUnMatches())) { + final EquivalenceChecker.Match decision = EquivalenceChecker.getCanonicalPsiEquivalence() + .expressionsMatch(thenExpression, elseExpression); + if (thenExpression != null && (myReportOnlyExactlyIdentical ? decision.isExactMatch() : !decision.isExactMismatch())) { registerError(expression, expression, decision); } } diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/inheritance/RedundantMethodOverrideInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/inheritance/RedundantMethodOverrideInspection.java index ffa2f680feee..c473b7078f97 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/inheritance/RedundantMethodOverrideInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/inheritance/RedundantMethodOverrideInspection.java @@ -1,5 +1,5 @@ /* - * Copyright 2005-2016 Bas Leijdekkers + * Copyright 2005-2017 Bas Leijdekkers * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -125,12 +125,12 @@ public class RedundantMethodOverrideInspection extends BaseInspection { } @Override - protected Decision referenceExpressionsAreEquivalentDecision(PsiReferenceExpression referenceExpression1, - PsiReferenceExpression referenceExpression2) { + protected Match referenceExpressionsMatch(PsiReferenceExpression referenceExpression1, + PsiReferenceExpression referenceExpression2) { if (areSameParameters(referenceExpression1, referenceExpression2)) { - return EXACTLY_MATCHES; + return EXACT_MATCH; } - return super.referenceExpressionsAreEquivalentDecision(referenceExpression1, referenceExpression2); + return super.referenceExpressionsMatch(referenceExpression1, referenceExpression2); } private boolean areSameParameters(PsiReferenceExpression referenceExpression1, PsiReferenceExpression referenceExpression2) { diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/migration/EqualsReplaceableByObjectsCallInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/migration/EqualsReplaceableByObjectsCallInspection.java index d75843edb77c..e6e4e704ec2d 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/migration/EqualsReplaceableByObjectsCallInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/migration/EqualsReplaceableByObjectsCallInspection.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2015 JetBrains s.r.o. + * Copyright 2000-2017 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -361,45 +361,45 @@ public class EqualsReplaceableByObjectsCallInspection extends BaseInspection { private static class NoSideEffectExpressionEquivalenceChecker extends EquivalenceChecker { @Override - protected Decision newExpressionsAreEquivalentDecision(@NotNull PsiNewExpression newExpression1, - @NotNull PsiNewExpression newExpression2) { - return EXACTLY_UN_MATCHES; + protected Match newExpressionsMatch(@NotNull PsiNewExpression newExpression1, + @NotNull PsiNewExpression newExpression2) { + return EXACT_MISMATCH; } @Override - protected Decision methodCallExpressionsAreEquivalentDecision(@NotNull PsiMethodCallExpression methodCallExpression1, - @NotNull PsiMethodCallExpression methodCallExpression2) { - return EXACTLY_UN_MATCHES; + protected Match methodCallExpressionsMatch(@NotNull PsiMethodCallExpression methodCallExpression1, + @NotNull PsiMethodCallExpression methodCallExpression2) { + return EXACT_MISMATCH; } @Override - protected Decision assignmentExpressionsAreEquivalentDecision(@NotNull PsiAssignmentExpression assignmentExpression1, - @NotNull PsiAssignmentExpression assignmentExpression2) { - return EXACTLY_UN_MATCHES; + protected Match assignmentExpressionsMatch(@NotNull PsiAssignmentExpression assignmentExpression1, + @NotNull PsiAssignmentExpression assignmentExpression2) { + return EXACT_MISMATCH; } @Override - protected Decision arrayInitializerExpressionsAreEquivalentDecision(@NotNull PsiArrayInitializerExpression arrayInitializerExpression1, - @NotNull PsiArrayInitializerExpression arrayInitializerExpression2) { - return EXACTLY_UN_MATCHES; + protected Match arrayInitializerExpressionsMatch(@NotNull PsiArrayInitializerExpression arrayInitializerExpression1, + @NotNull PsiArrayInitializerExpression arrayInitializerExpression2) { + return EXACT_MISMATCH; } @Override - protected Decision prefixExpressionsAreEquivalentDecision(@NotNull PsiPrefixExpression prefixExpression1, - @NotNull PsiPrefixExpression prefixExpression2) { + protected Match prefixExpressionsMatch(@NotNull PsiPrefixExpression prefixExpression1, + @NotNull PsiPrefixExpression prefixExpression2) { if (isSideEffectUnaryOperator(prefixExpression1.getOperationTokenType())) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } - return super.prefixExpressionsAreEquivalentDecision(prefixExpression1, prefixExpression2); + return super.prefixExpressionsMatch(prefixExpression1, prefixExpression2); } @Override - protected Decision postfixExpressionsAreEquivalentDecision(@NotNull PsiPostfixExpression postfixExpression1, - @NotNull PsiPostfixExpression postfixExpression2) { + protected Match postfixExpressionsMatch(@NotNull PsiPostfixExpression postfixExpression1, + @NotNull PsiPostfixExpression postfixExpression2) { if (isSideEffectUnaryOperator(postfixExpression1.getOperationTokenType())) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } - return super.postfixExpressionsAreEquivalentDecision(postfixExpression1, postfixExpression2); + return super.postfixExpressionsMatch(postfixExpression1, postfixExpression2); } private static boolean isSideEffectUnaryOperator(IElementType tokenType) { diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/EquivalenceChecker.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/EquivalenceChecker.java index 9a4abecd7202..dfc360736638 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/EquivalenceChecker.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/EquivalenceChecker.java @@ -1,5 +1,5 @@ /* - * Copyright 2003-2015 Dave Griffith, Bas Leijdekkers + * Copyright 2003-2017 Dave Griffith, Bas Leijdekkers * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -26,26 +26,26 @@ import java.util.ArrayList; import java.util.List; public class EquivalenceChecker { - protected static final Decision EXACTLY_MATCHES = new Decision(true); - protected static final Decision EXACTLY_UN_MATCHES = new Decision(false); + protected static final Match EXACT_MATCH = new Match(true); + protected static final Match EXACT_MISMATCH = new Match(false); private static final EquivalenceChecker ourCanonicalPsiEquivalence = new EquivalenceChecker(); public static EquivalenceChecker getCanonicalPsiEquivalence() { return ourCanonicalPsiEquivalence; } - public static class Decision { + public static class Match { private final PsiElement myLeftDiff; private final PsiElement myRightDiff; private final Boolean myExactlyMatches; - private Decision(boolean exactlyMatches) { + Match(boolean exactlyMatches) { myExactlyMatches = exactlyMatches; myLeftDiff = null; myRightDiff = null; } - private Decision(PsiElement leftDiff, PsiElement rightDiff) { + Match(PsiElement leftDiff, PsiElement rightDiff) { myExactlyMatches = null; myLeftDiff = leftDiff; myRightDiff = rightDiff; @@ -59,109 +59,109 @@ public class EquivalenceChecker { return myRightDiff; } - public boolean isExact() { - return myExactlyMatches != null; + public boolean isPartialMatch() { + return myExactlyMatches == null; } - public boolean getExactlyMatches() { + public boolean isExactMatch() { return myExactlyMatches != null && myExactlyMatches; } - public boolean isExactUnMatches() { + public boolean isExactMismatch() { return myExactlyMatches != null && !myExactlyMatches; } - private Decision setConcreteIfExactUnMatches(PsiElement left, PsiElement right) { - return this == EXACTLY_UN_MATCHES ? new Decision(left, right) : this; + Match setConcreteIfExactMismatch(PsiElement left, PsiElement right) { + return this == EXACT_MISMATCH ? new Match(left, right) : this; } - private static Decision exact(boolean exactMatches) { - return exactMatches ? EXACTLY_MATCHES : EXACTLY_UN_MATCHES; + static Match exact(boolean exactMatches) { + return exactMatches ? EXACT_MATCH : EXACT_MISMATCH; } } public boolean statementsAreEquivalent(@Nullable PsiStatement statement1, @Nullable PsiStatement statement2) { - return statementsAreEquivalentDecision(statement1, statement2).getExactlyMatches(); + return statementsMatch(statement1, statement2).isExactMatch(); } - public Decision statementsAreEquivalentDecision(@Nullable PsiStatement statement1, @Nullable PsiStatement statement2) { + public Match statementsMatch(@Nullable PsiStatement statement1, @Nullable PsiStatement statement2) { statement1 = ControlFlowUtils.stripBraces(statement1); statement2 = ControlFlowUtils.stripBraces(statement2); if (statement1 == null) { - return statement2 == null ? EXACTLY_MATCHES : EXACTLY_UN_MATCHES; + return Match.exact(statement2 == null); } if (statement2 == null) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } if (statement1.getClass() != statement2.getClass()) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } if (statement1 instanceof PsiAssertStatement) { - return assertStatementsAreEquivalentDecision((PsiAssertStatement)statement1, (PsiAssertStatement)statement2); + return assertStatementsMatch((PsiAssertStatement)statement1, (PsiAssertStatement)statement2); } if (statement1 instanceof PsiBlockStatement) { - return blockStatementsAreEquivalentDecision((PsiBlockStatement)statement1, (PsiBlockStatement)statement2); + return blockStatementsMatch((PsiBlockStatement)statement1, (PsiBlockStatement)statement2); } if (statement1 instanceof PsiBreakStatement) { - return breakStatementsAreEquivalentDecision((PsiBreakStatement)statement1, (PsiBreakStatement)statement2); + return breakStatementsMatch((PsiBreakStatement)statement1, (PsiBreakStatement)statement2); } if (statement1 instanceof PsiContinueStatement) { - return continueStatementsAreEquivalentDecision((PsiContinueStatement)statement1, (PsiContinueStatement)statement2); + return continueStatementsMatch((PsiContinueStatement)statement1, (PsiContinueStatement)statement2); } if (statement1 instanceof PsiDeclarationStatement) { - return declarationStatementsAreEquivalentDecision((PsiDeclarationStatement)statement1, (PsiDeclarationStatement)statement2); + return declarationStatementsMatch((PsiDeclarationStatement)statement1, (PsiDeclarationStatement)statement2); } if (statement1 instanceof PsiDoWhileStatement) { - return doWhileStatementsAreEquivalentDecision((PsiDoWhileStatement)statement1, (PsiDoWhileStatement)statement2); + return doWhileStatementsMatch((PsiDoWhileStatement)statement1, (PsiDoWhileStatement)statement2); } if (statement1 instanceof PsiEmptyStatement) { - return EXACTLY_MATCHES; + return EXACT_MATCH; } if (statement1 instanceof PsiExpressionListStatement) { - return expressionListStatementsAreEquivalentDecision((PsiExpressionListStatement)statement1, (PsiExpressionListStatement)statement2); + return expressionListStatementsMatch((PsiExpressionListStatement)statement1, (PsiExpressionListStatement)statement2); } if (statement1 instanceof PsiExpressionStatement) { - return expressionStatementsAreEquivalentDecision((PsiExpressionStatement)statement1, (PsiExpressionStatement)statement2); + return expressionStatementsMatch((PsiExpressionStatement)statement1, (PsiExpressionStatement)statement2); } if (statement1 instanceof PsiForStatement) { - return forStatementsAreEquivalentDecision((PsiForStatement)statement1, (PsiForStatement)statement2); + return forStatementsMatch((PsiForStatement)statement1, (PsiForStatement)statement2); } if (statement1 instanceof PsiForeachStatement) { - return forEachStatementsAreEquivalentDecision((PsiForeachStatement)statement1, (PsiForeachStatement)statement2); + return forEachStatementsMatch((PsiForeachStatement)statement1, (PsiForeachStatement)statement2); } if (statement1 instanceof PsiIfStatement) { - return ifStatementsAreEquivalentDecision((PsiIfStatement)statement1, (PsiIfStatement)statement2); + return ifStatementsMatch((PsiIfStatement)statement1, (PsiIfStatement)statement2); } if (statement1 instanceof PsiLabeledStatement) { - return labeledStatementsAreEquivalentDecision((PsiLabeledStatement)statement1, (PsiLabeledStatement)statement2); + return labeledStatementsMatch((PsiLabeledStatement)statement1, (PsiLabeledStatement)statement2); } if (statement1 instanceof PsiReturnStatement) { - return returnStatementsAreEquivalentDecision((PsiReturnStatement)statement1, (PsiReturnStatement)statement2); + return returnStatementsMatch((PsiReturnStatement)statement1, (PsiReturnStatement)statement2); } if (statement1 instanceof PsiSwitchStatement) { - return switchStatementsAreEquivalentDecision((PsiSwitchStatement)statement1, (PsiSwitchStatement)statement2); + return switchStatementsMatch((PsiSwitchStatement)statement1, (PsiSwitchStatement)statement2); } if (statement1 instanceof PsiSwitchLabelStatement) { - return switchLabelStatementsAreEquivalentDecision((PsiSwitchLabelStatement)statement1, (PsiSwitchLabelStatement)statement2); + return switchLabelStatementsMatch((PsiSwitchLabelStatement)statement1, (PsiSwitchLabelStatement)statement2); } if (statement1 instanceof PsiSynchronizedStatement) { - return synchronizedStatementsAreEquivalentDecision((PsiSynchronizedStatement)statement1, (PsiSynchronizedStatement)statement2); + return synchronizedStatementsMatch((PsiSynchronizedStatement)statement1, (PsiSynchronizedStatement)statement2); } if (statement1 instanceof PsiThrowStatement) { - return throwStatementsAreEquivalentDecision((PsiThrowStatement)statement1, (PsiThrowStatement)statement2); + return throwStatementsMatch((PsiThrowStatement)statement1, (PsiThrowStatement)statement2); } if (statement1 instanceof PsiTryStatement) { - return tryStatementsAreEquivalentDecision((PsiTryStatement)statement1, (PsiTryStatement)statement2); + return tryStatementsMatch((PsiTryStatement)statement1, (PsiTryStatement)statement2); } if (statement1 instanceof PsiWhileStatement) { - return whileStatementsAreEquivalentDecision((PsiWhileStatement)statement1, (PsiWhileStatement)statement2); + return whileStatementsMatch((PsiWhileStatement)statement1, (PsiWhileStatement)statement2); } final String text1 = statement1.getText(); final String text2 = statement2.getText(); - return text1.equals(text2) ? EXACTLY_MATCHES : EXACTLY_UN_MATCHES; + return Match.exact(text1.equals(text2)); } - protected Decision declarationStatementsAreEquivalentDecision(@NotNull PsiDeclarationStatement statement1, @NotNull PsiDeclarationStatement statement2) { + protected Match declarationStatementsMatch(@NotNull PsiDeclarationStatement statement1, @NotNull PsiDeclarationStatement statement2) { final PsiElement[] elements1 = statement1.getDeclaredElements(); final List vars1 = new ArrayList<>(elements1.length); @@ -180,66 +180,66 @@ public class EquivalenceChecker { } final int size = vars1.size(); if (size != vars2.size()) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } for (int i = 0; i < size; i++) { final PsiLocalVariable var1 = vars1.get(i); final PsiLocalVariable var2 = vars2.get(i); - if (!localVariablesAreEquivalent(var1, var2).getExactlyMatches()) { - return EXACTLY_UN_MATCHES; + if (!localVariablesAreEquivalent(var1, var2).isExactMatch()) { + return EXACT_MISMATCH; } } - return EXACTLY_MATCHES; + return EXACT_MATCH; } - protected Decision localVariablesAreEquivalent(@NotNull PsiLocalVariable localVariable1, @NotNull PsiLocalVariable localVariable2) { + protected Match localVariablesAreEquivalent(@NotNull PsiLocalVariable localVariable1, @NotNull PsiLocalVariable localVariable2) { final PsiType type1 = localVariable1.getType(); final PsiType type2 = localVariable2.getType(); if (!typesAreEquivalent(type1, type2)) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } final String name1 = localVariable1.getName(); final String name2 = localVariable2.getName(); if (name1 == null) { - return Decision.exact(name2 == null); + return Match.exact(name2 == null); } if (!name1.equals(name2)) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } final PsiExpression initializer1 = localVariable1.getInitializer(); final PsiExpression initializer2 = localVariable2.getInitializer(); - return expressionsAreEquivalentDecision(initializer1, initializer2).setConcreteIfExactUnMatches(initializer1, initializer2); + return expressionsMatch(initializer1, initializer2).setConcreteIfExactMismatch(initializer1, initializer2); } - protected Decision tryStatementsAreEquivalentDecision(@NotNull PsiTryStatement statement1, @NotNull PsiTryStatement statement2) { + protected Match tryStatementsMatch(@NotNull PsiTryStatement statement1, @NotNull PsiTryStatement statement2) { final PsiCodeBlock tryBlock1 = statement1.getTryBlock(); final PsiCodeBlock tryBlock2 = statement2.getTryBlock(); - if (!codeBlocksAreEquivalentDecision(tryBlock1, tryBlock2).getExactlyMatches()) { - return EXACTLY_UN_MATCHES; + if (!codeBlocksMatch(tryBlock1, tryBlock2).isExactMatch()) { + return EXACT_MISMATCH; } final PsiCodeBlock finallyBlock1 = statement1.getFinallyBlock(); final PsiCodeBlock finallyBlock2 = statement2.getFinallyBlock(); - if (!codeBlocksAreEquivalentDecision(finallyBlock1, finallyBlock2).getExactlyMatches()) { - return EXACTLY_UN_MATCHES; + if (!codeBlocksMatch(finallyBlock1, finallyBlock2).isExactMatch()) { + return EXACT_MISMATCH; } final PsiCodeBlock[] catchBlocks1 = statement1.getCatchBlocks(); final PsiCodeBlock[] catchBlocks2 = statement2.getCatchBlocks(); if (catchBlocks1.length != catchBlocks2.length) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } for (int i = 0; i < catchBlocks2.length; i++) { - if (!codeBlocksAreEquivalentDecision(catchBlocks1[i], catchBlocks2[i]).getExactlyMatches()) { - return EXACTLY_UN_MATCHES; + if (!codeBlocksMatch(catchBlocks1[i], catchBlocks2[i]).isExactMatch()) { + return EXACT_MISMATCH; } } final PsiResourceList resourceList1 = statement1.getResourceList(); final PsiResourceList resourceList2 = statement2.getResourceList(); if (resourceList1 != null) { if (resourceList2 == null) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } if (resourceList1.getResourceVariablesCount() != resourceList2.getResourceVariablesCount()) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } final List resources1 = PsiTreeUtil.getChildrenOfTypeAsList(resourceList1, PsiResourceListElement.class); final List resources2 = PsiTreeUtil.getChildrenOfTypeAsList(resourceList2, PsiResourceListElement.class); @@ -247,49 +247,49 @@ public class EquivalenceChecker { final PsiResourceListElement resource1 = resources1.get(i); final PsiResourceListElement resource2 = resources2.get(i); if (resource1 instanceof PsiResourceVariable && resource2 instanceof PsiResourceVariable) { - if (!localVariablesAreEquivalent((PsiLocalVariable)resource1, (PsiLocalVariable)resource2).getExactlyMatches()) { - return EXACTLY_UN_MATCHES; + if (!localVariablesAreEquivalent((PsiLocalVariable)resource1, (PsiLocalVariable)resource2).isExactMatch()) { + return EXACT_MISMATCH; } } else if (resource1 instanceof PsiResourceExpression && resource2 instanceof PsiResourceExpression) { - if (!expressionsAreEquivalentDecision(((PsiResourceExpression)resource1).getExpression(), - ((PsiResourceExpression)resource2).getExpression()).getExactlyMatches()) { - return EXACTLY_UN_MATCHES; + if (!expressionsMatch(((PsiResourceExpression)resource1).getExpression(), + ((PsiResourceExpression)resource2).getExpression()).isExactMatch()) { + return EXACT_MISMATCH; } } else { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } } } else if (resourceList2 != null) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } final PsiParameter[] catchParameters1 = statement1.getCatchBlockParameters(); final PsiParameter[] catchParameters2 = statement2.getCatchBlockParameters(); if (catchParameters1.length != catchParameters2.length) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } for (int i = 0; i < catchParameters2.length; i++) { - if (!parametersAreEquivalent(catchParameters2[i], catchParameters1[i]).getExactlyMatches()) { - return EXACTLY_UN_MATCHES; + if (!parametersAreEquivalent(catchParameters2[i], catchParameters1[i]).isExactMatch()) { + return EXACT_MISMATCH; } } - return EXACTLY_MATCHES; + return EXACT_MATCH; } - protected Decision parametersAreEquivalent(@NotNull PsiParameter parameter1, @NotNull PsiParameter parameter2) { + protected Match parametersAreEquivalent(@NotNull PsiParameter parameter1, @NotNull PsiParameter parameter2) { final PsiType type1 = parameter1.getType(); final PsiType type2 = parameter2.getType(); if (!typesAreEquivalent(type1, type2)) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } final String name1 = parameter1.getName(); final String name2 = parameter2.getName(); if (name1 == null) { - return Decision.exact(name2 == null); + return Match.exact(name2 == null); } - return Decision.exact(name1.equals(name2)); + return Match.exact(name1.equals(name2)); } public boolean typesAreEquivalent(@Nullable PsiType type1, @Nullable PsiType type2) { @@ -304,221 +304,221 @@ public class EquivalenceChecker { return type1Text.equals(type2Text); } - protected Decision whileStatementsAreEquivalentDecision(@NotNull PsiWhileStatement statement1, @NotNull PsiWhileStatement statement2) { + protected Match whileStatementsMatch(@NotNull PsiWhileStatement statement1, @NotNull PsiWhileStatement statement2) { final PsiExpression condition1 = statement1.getCondition(); final PsiExpression condition2 = statement2.getCondition(); final PsiStatement body1 = statement1.getBody(); final PsiStatement body2 = statement2.getBody(); - final Decision conditionEquivalence = expressionsAreEquivalentDecision(condition1, condition2); - final Decision bodyEquivalence = statementsAreEquivalentDecision(body1, body2); + final Match conditionEquivalence = expressionsMatch(condition1, condition2); + final Match bodyEquivalence = statementsMatch(body1, body2); return getComplexElementDecision(bodyEquivalence, conditionEquivalence, body1, body2, condition1, condition2); } - protected Decision forStatementsAreEquivalentDecision(@NotNull PsiForStatement statement1, @NotNull PsiForStatement statement2) { + protected Match forStatementsMatch(@NotNull PsiForStatement statement1, @NotNull PsiForStatement statement2) { final PsiExpression condition1 = statement1.getCondition(); final PsiExpression condition2 = statement2.getCondition(); - if (!expressionsAreEquivalentDecision(condition1, condition2).getExactlyMatches()) { - return EXACTLY_UN_MATCHES; + if (!expressionsMatch(condition1, condition2).isExactMatch()) { + return EXACT_MISMATCH; } final PsiStatement initialization1 = statement1.getInitialization(); final PsiStatement initialization2 = statement2.getInitialization(); - if (!statementsAreEquivalentDecision(initialization1, initialization2).getExactlyMatches()) { - return EXACTLY_UN_MATCHES; + if (!statementsMatch(initialization1, initialization2).isExactMatch()) { + return EXACT_MISMATCH; } final PsiStatement update1 = statement1.getUpdate(); final PsiStatement update2 = statement2.getUpdate(); - if (!statementsAreEquivalentDecision(update1, update2).getExactlyMatches()) { - return EXACTLY_UN_MATCHES; + if (!statementsMatch(update1, update2).isExactMatch()) { + return EXACT_MISMATCH; } final PsiStatement body1 = statement1.getBody(); final PsiStatement body2 = statement2.getBody(); - return statementsAreEquivalentDecision(body1, body2).setConcreteIfExactUnMatches(body1, body2); + return statementsMatch(body1, body2).setConcreteIfExactMismatch(body1, body2); } - protected Decision forEachStatementsAreEquivalentDecision(@NotNull PsiForeachStatement statement1, @NotNull PsiForeachStatement statement2) { + protected Match forEachStatementsMatch(@NotNull PsiForeachStatement statement1, @NotNull PsiForeachStatement statement2) { final PsiExpression value1 = statement1.getIteratedValue(); final PsiExpression value2 = statement2.getIteratedValue(); - if (!expressionsAreEquivalentDecision(value1, value2).getExactlyMatches()) { - return EXACTLY_UN_MATCHES; + if (!expressionsMatch(value1, value2).isExactMatch()) { + return EXACT_MISMATCH; } final PsiParameter parameter1 = statement1.getIterationParameter(); final PsiParameter parameter2 = statement1.getIterationParameter(); final String name1 = parameter1.getName(); if (name1 == null) { - return Decision.exact(parameter2.getName() == null); + return Match.exact(parameter2.getName() == null); } if (!name1.equals(parameter2.getName())) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } final PsiType type1 = parameter1.getType(); if (!type1.equals(parameter2.getType())) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } final PsiStatement body1 = statement1.getBody(); final PsiStatement body2 = statement2.getBody(); - return statementsAreEquivalentDecision(body1, body2).setConcreteIfExactUnMatches(body1, body2); + return statementsMatch(body1, body2).setConcreteIfExactMismatch(body1, body2); } - protected Decision switchStatementsAreEquivalentDecision(@NotNull PsiSwitchStatement statement1, @NotNull PsiSwitchStatement statement2) { + protected Match switchStatementsMatch(@NotNull PsiSwitchStatement statement1, @NotNull PsiSwitchStatement statement2) { final PsiExpression switchExpression1 = statement1.getExpression(); final PsiExpression switchExpression2 = statement2.getExpression(); final PsiCodeBlock body1 = statement1.getBody(); final PsiCodeBlock body2 = statement2.getBody(); - final Decision bodyEq = codeBlocksAreEquivalentDecision(body1, body2); - if (bodyEq != EXACTLY_MATCHES) { - return EXACTLY_UN_MATCHES; + final Match bodyEq = codeBlocksMatch(body1, body2); + if (bodyEq != EXACT_MATCH) { + return EXACT_MISMATCH; } - return expressionsAreEquivalentDecision(switchExpression1, switchExpression2).setConcreteIfExactUnMatches(switchExpression1, switchExpression2); + return expressionsMatch(switchExpression1, switchExpression2).setConcreteIfExactMismatch(switchExpression1, switchExpression2); } - protected Decision doWhileStatementsAreEquivalentDecision(@NotNull PsiDoWhileStatement statement1, @NotNull PsiDoWhileStatement statement2) { + protected Match doWhileStatementsMatch(@NotNull PsiDoWhileStatement statement1, @NotNull PsiDoWhileStatement statement2) { final PsiExpression condition1 = statement1.getCondition(); final PsiExpression condition2 = statement2.getCondition(); final PsiStatement body1 = statement1.getBody(); final PsiStatement body2 = statement2.getBody(); - final Decision conditionEq = expressionsAreEquivalentDecision(condition1, condition2); - final Decision bodyEq = statementsAreEquivalentDecision(body1, body2); + final Match conditionEq = expressionsMatch(condition1, condition2); + final Match bodyEq = statementsMatch(body1, body2); return getComplexElementDecision(bodyEq, conditionEq, body1, body2, condition1, condition2); } - protected Decision assertStatementsAreEquivalentDecision(@NotNull PsiAssertStatement statement1, @NotNull PsiAssertStatement statement2) { + protected Match assertStatementsMatch(@NotNull PsiAssertStatement statement1, @NotNull PsiAssertStatement statement2) { final PsiExpression condition1 = statement1.getAssertCondition(); final PsiExpression condition2 = statement2.getAssertCondition(); final PsiExpression description1 = statement1.getAssertDescription(); final PsiExpression description2 = statement2.getAssertDescription(); - final Decision condEq = expressionsAreEquivalentDecision(condition1, condition2); - final Decision exprEq = expressionsAreEquivalentDecision(description1, description2); + final Match condEq = expressionsMatch(condition1, condition2); + final Match exprEq = expressionsMatch(description1, description2); return getComplexElementDecision(condEq, exprEq, condition1, condition2, description1, description2); } - protected Decision synchronizedStatementsAreEquivalentDecision(@NotNull PsiSynchronizedStatement statement1, @NotNull PsiSynchronizedStatement statement2) { + protected Match synchronizedStatementsMatch(@NotNull PsiSynchronizedStatement statement1, @NotNull PsiSynchronizedStatement statement2) { final PsiExpression lock1 = statement1.getLockExpression(); final PsiExpression lock2 = statement2.getLockExpression(); final PsiCodeBlock body1 = statement1.getBody(); final PsiCodeBlock body2 = statement2.getBody(); - final Decision lockEq = expressionsAreEquivalentDecision(lock1, lock2); - final Decision blockEq = codeBlocksAreEquivalentDecision(body1, body2); + final Match lockEq = expressionsMatch(lock1, lock2); + final Match blockEq = codeBlocksMatch(body1, body2); return getComplexElementDecision(blockEq, lockEq, body1, body2, lock1, lock2); } - protected Decision blockStatementsAreEquivalentDecision(@NotNull PsiBlockStatement statement1, @NotNull PsiBlockStatement statement2) { + protected Match blockStatementsMatch(@NotNull PsiBlockStatement statement1, @NotNull PsiBlockStatement statement2) { final PsiCodeBlock block1 = statement1.getCodeBlock(); final PsiCodeBlock block2 = statement2.getCodeBlock(); - return codeBlocksAreEquivalentDecision(block1, block2); + return codeBlocksMatch(block1, block2); } - protected Decision breakStatementsAreEquivalentDecision(@NotNull PsiBreakStatement statement1, @NotNull PsiBreakStatement statement2) { + protected Match breakStatementsMatch(@NotNull PsiBreakStatement statement1, @NotNull PsiBreakStatement statement2) { final PsiIdentifier identifier1 = statement1.getLabelIdentifier(); final PsiIdentifier identifier2 = statement2.getLabelIdentifier(); if (identifier1 == null) { - return Decision.exact(identifier2 == null); + return Match.exact(identifier2 == null); } if (identifier2 == null) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } final String text1 = identifier1.getText(); final String text2 = identifier2.getText(); - return Decision.exact(text1.equals(text2)); + return Match.exact(text1.equals(text2)); } - protected Decision continueStatementsAreEquivalentDecision(@NotNull PsiContinueStatement statement1, @NotNull PsiContinueStatement statement2) { + protected Match continueStatementsMatch(@NotNull PsiContinueStatement statement1, @NotNull PsiContinueStatement statement2) { final PsiIdentifier identifier1 = statement1.getLabelIdentifier(); final PsiIdentifier identifier2 = statement2.getLabelIdentifier(); if (identifier1 == null) { - return Decision.exact(identifier2 == null); + return Match.exact(identifier2 == null); } if (identifier2 == null) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } final String text1 = identifier1.getText(); final String text2 = identifier2.getText(); - return Decision.exact(text1.equals(text2)); + return Match.exact(text1.equals(text2)); } - protected Decision switchLabelStatementsAreEquivalentDecision(@NotNull PsiSwitchLabelStatement statement1, @NotNull PsiSwitchLabelStatement statement2) { + protected Match switchLabelStatementsMatch(@NotNull PsiSwitchLabelStatement statement1, @NotNull PsiSwitchLabelStatement statement2) { if (statement1.isDefaultCase()) { - return Decision.exact(statement2.isDefaultCase()); + return Match.exact(statement2.isDefaultCase()); } if (statement2.isDefaultCase()) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } final PsiExpression caseExpression1 = statement1.getCaseValue(); final PsiExpression caseExpression2 = statement2.getCaseValue(); - return expressionsAreEquivalentDecision(caseExpression1, caseExpression2).setConcreteIfExactUnMatches(caseExpression1, caseExpression2); + return expressionsMatch(caseExpression1, caseExpression2).setConcreteIfExactMismatch(caseExpression1, caseExpression2); } - protected Decision labeledStatementsAreEquivalentDecision(@NotNull PsiLabeledStatement statement1, @NotNull PsiLabeledStatement statement2) { + protected Match labeledStatementsMatch(@NotNull PsiLabeledStatement statement1, @NotNull PsiLabeledStatement statement2) { final PsiIdentifier identifier1 = statement1.getLabelIdentifier(); final PsiIdentifier identifier2 = statement2.getLabelIdentifier(); final String text1 = identifier1.getText(); final String text2 = identifier2.getText(); - return Decision.exact(text1.equals(text2)); + return Match.exact(text1.equals(text2)); } public boolean codeBlocksAreEquivalent(@Nullable PsiCodeBlock block1, @Nullable PsiCodeBlock block2) { - return codeBlocksAreEquivalentDecision(block1, block2).getExactlyMatches(); + return codeBlocksMatch(block1, block2).isExactMatch(); } - protected Decision codeBlocksAreEquivalentDecision(@Nullable PsiCodeBlock block1, @Nullable PsiCodeBlock block2) { + protected Match codeBlocksMatch(@Nullable PsiCodeBlock block1, @Nullable PsiCodeBlock block2) { if (block1 == null && block2 == null) { - return EXACTLY_MATCHES; + return EXACT_MATCH; } if (block1 == null || block2 == null) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } final PsiStatement[] statements1 = block1.getStatements(); final PsiStatement[] statements2 = block2.getStatements(); if (statements2.length != statements1.length) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } for (int i = 0; i < statements2.length; i++) { - if (!statementsAreEquivalentDecision(statements2[i], statements1[i]).getExactlyMatches()) { - return EXACTLY_UN_MATCHES; + if (!statementsMatch(statements2[i], statements1[i]).isExactMatch()) { + return EXACT_MISMATCH; } } - return EXACTLY_MATCHES; + return EXACT_MATCH; } - protected Decision ifStatementsAreEquivalentDecision(@NotNull PsiIfStatement statement1, @NotNull PsiIfStatement statement2) { + protected Match ifStatementsMatch(@NotNull PsiIfStatement statement1, @NotNull PsiIfStatement statement2) { final PsiExpression condition1 = statement1.getCondition(); final PsiExpression condition2 = statement2.getCondition(); final PsiStatement thenBranch1 = statement1.getThenBranch(); final PsiStatement thenBranch2 = statement2.getThenBranch(); final PsiStatement elseBranch1 = statement1.getElseBranch(); final PsiStatement elseBranch2 = statement2.getElseBranch(); - final Decision conditionEq = expressionsAreEquivalentDecision(condition1, condition2); - final Decision thenEq = statementsAreEquivalentDecision(thenBranch1, thenBranch2); - final Decision elseEq = statementsAreEquivalentDecision(elseBranch1, elseBranch2); - if (conditionEq == EXACTLY_MATCHES && thenEq == EXACTLY_MATCHES && elseEq == EXACTLY_MATCHES) { - return EXACTLY_MATCHES; + final Match conditionEq = expressionsMatch(condition1, condition2); + final Match thenEq = statementsMatch(thenBranch1, thenBranch2); + final Match elseEq = statementsMatch(elseBranch1, elseBranch2); + if (conditionEq == EXACT_MATCH && thenEq == EXACT_MATCH && elseEq == EXACT_MATCH) { + return EXACT_MATCH; } - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } - protected Decision expressionStatementsAreEquivalentDecision(@NotNull PsiExpressionStatement statement1, @NotNull PsiExpressionStatement statement2) { + protected Match expressionStatementsMatch(@NotNull PsiExpressionStatement statement1, @NotNull PsiExpressionStatement statement2) { final PsiExpression expression1 = statement1.getExpression(); final PsiExpression expression2 = statement2.getExpression(); - return expressionsAreEquivalentDecision(expression1, expression2); + return expressionsMatch(expression1, expression2); } - protected Decision returnStatementsAreEquivalentDecision(@NotNull PsiReturnStatement statement1, @NotNull PsiReturnStatement statement2) { + protected Match returnStatementsMatch(@NotNull PsiReturnStatement statement1, @NotNull PsiReturnStatement statement2) { final PsiExpression returnValue1 = statement1.getReturnValue(); final PsiExpression returnValue2 = statement2.getReturnValue(); - final Decision decision = expressionsAreEquivalentDecision(returnValue1, returnValue2); - if (decision.isExactUnMatches()) { - return new Decision(returnValue1, returnValue2); + final Match match = expressionsMatch(returnValue1, returnValue2); + if (match.isExactMismatch()) { + return new Match(returnValue1, returnValue2); } - return decision; + return match; } - protected Decision throwStatementsAreEquivalentDecision(@NotNull PsiThrowStatement statement1, @NotNull PsiThrowStatement statement2) { + protected Match throwStatementsMatch(@NotNull PsiThrowStatement statement1, @NotNull PsiThrowStatement statement2) { final PsiExpression exception1 = statement1.getException(); final PsiExpression exception2 = statement2.getException(); - return expressionsAreEquivalentDecision(exception1, exception2); + return expressionsMatch(exception1, exception2); } - protected Decision expressionListStatementsAreEquivalentDecision(@NotNull PsiExpressionListStatement statement1, @NotNull PsiExpressionListStatement statement2) { + protected Match expressionListStatementsMatch(@NotNull PsiExpressionListStatement statement1, @NotNull PsiExpressionListStatement statement2) { final PsiExpressionList expressionList1 = statement1.getExpressionList(); final PsiExpression[] expressions1 = expressionList1.getExpressions(); @@ -529,168 +529,162 @@ public class EquivalenceChecker { } public boolean expressionsAreEquivalent(@Nullable PsiExpression expression1, @Nullable PsiExpression expression2) { - return expressionsAreEquivalentDecision(expression1, expression2).getExactlyMatches(); + return expressionsMatch(expression1, expression2).isExactMatch(); } - public Decision expressionsAreEquivalentDecision(@Nullable PsiExpression expression1, @Nullable PsiExpression expression2) { + public Match expressionsMatch(@Nullable PsiExpression expression1, @Nullable PsiExpression expression2) { expression1 = ParenthesesUtils.stripParentheses(expression1); expression2 = ParenthesesUtils.stripParentheses(expression2); if (expression1 == null) { - return Decision.exact(expression2 == null); + return Match.exact(expression2 == null); } if (expression2 == null) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } if (expression1.getClass() != expression2.getClass()) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } if (expression1 instanceof PsiThisExpression) { - return EXACTLY_MATCHES; + return EXACT_MATCH; } if (expression1 instanceof PsiSuperExpression) { - return EXACTLY_MATCHES; + return EXACT_MATCH; } if (expression1 instanceof PsiLiteralExpression) { - return literalExpressionsAreEquivalentDecision((PsiLiteralExpression)expression1, (PsiLiteralExpression)expression2); + return literalExpressionsMatch((PsiLiteralExpression)expression1, (PsiLiteralExpression)expression2); } if (expression1 instanceof PsiClassObjectAccessExpression) { - return classObjectAccessExpressionsAreEquivalentDecision((PsiClassObjectAccessExpression)expression1, + return classObjectAccessExpressionsMatch((PsiClassObjectAccessExpression)expression1, (PsiClassObjectAccessExpression)expression2); } if (expression1 instanceof PsiReferenceExpression) { - return referenceExpressionsAreEquivalentDecision((PsiReferenceExpression)expression1, (PsiReferenceExpression)expression2); + return referenceExpressionsMatch((PsiReferenceExpression)expression1, (PsiReferenceExpression)expression2); } if (expression1 instanceof PsiMethodCallExpression) { - return methodCallExpressionsAreEquivalentDecision((PsiMethodCallExpression)expression1, (PsiMethodCallExpression)expression2); + return methodCallExpressionsMatch((PsiMethodCallExpression)expression1, (PsiMethodCallExpression)expression2); } if (expression1 instanceof PsiNewExpression) { - return newExpressionsAreEquivalentDecision((PsiNewExpression)expression1, (PsiNewExpression)expression2); + return newExpressionsMatch((PsiNewExpression)expression1, (PsiNewExpression)expression2); } if (expression1 instanceof PsiArrayInitializerExpression) { - return arrayInitializerExpressionsAreEquivalentDecision((PsiArrayInitializerExpression)expression1, + return arrayInitializerExpressionsMatch((PsiArrayInitializerExpression)expression1, (PsiArrayInitializerExpression)expression2); } if (expression1 instanceof PsiTypeCastExpression) { - return typeCastExpressionsAreEquivalentDecision((PsiTypeCastExpression)expression1, (PsiTypeCastExpression)expression2); + return typeCastExpressionsMatch((PsiTypeCastExpression)expression1, (PsiTypeCastExpression)expression2); } if (expression1 instanceof PsiArrayAccessExpression) { - return arrayAccessExpressionsAreEquivalentDecision((PsiArrayAccessExpression)expression2, (PsiArrayAccessExpression)expression1); + return arrayAccessExpressionsMatch((PsiArrayAccessExpression)expression2, (PsiArrayAccessExpression)expression1); } if (expression1 instanceof PsiPrefixExpression) { - return prefixExpressionsAreEquivalentDecision((PsiPrefixExpression)expression1, (PsiPrefixExpression)expression2); + return prefixExpressionsMatch((PsiPrefixExpression)expression1, (PsiPrefixExpression)expression2); } if (expression1 instanceof PsiPostfixExpression) { - return postfixExpressionsAreEquivalentDecision((PsiPostfixExpression)expression1, (PsiPostfixExpression)expression2); + return postfixExpressionsMatch((PsiPostfixExpression)expression1, (PsiPostfixExpression)expression2); } if (expression1 instanceof PsiPolyadicExpression) { - return polyadicExpressionsAreEquivalentDecision((PsiPolyadicExpression)expression1, (PsiPolyadicExpression)expression2); + return polyadicExpressionsMatch((PsiPolyadicExpression)expression1, (PsiPolyadicExpression)expression2); } if (expression1 instanceof PsiAssignmentExpression) { - return assignmentExpressionsAreEquivalentDecision((PsiAssignmentExpression)expression1, (PsiAssignmentExpression)expression2); + return assignmentExpressionsMatch((PsiAssignmentExpression)expression1, (PsiAssignmentExpression)expression2); } if (expression1 instanceof PsiConditionalExpression) { - return conditionalExpressionsAreEquivalentDecision((PsiConditionalExpression)expression1, (PsiConditionalExpression)expression2); + return conditionalExpressionsMatch((PsiConditionalExpression)expression1, (PsiConditionalExpression)expression2); } if (expression1 instanceof PsiInstanceOfExpression) { - return instanceOfExpressionsAreEquivalentDecision((PsiInstanceOfExpression)expression1, (PsiInstanceOfExpression)expression2); + return instanceOfExpressionsMatch((PsiInstanceOfExpression)expression1, (PsiInstanceOfExpression)expression2); } - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } - protected Decision literalExpressionsAreEquivalentDecision(PsiLiteralExpression expression1, PsiLiteralExpression expression2) { + protected Match literalExpressionsMatch(PsiLiteralExpression expression1, PsiLiteralExpression expression2) { final Object value1 = expression1.getValue(); final Object value2 = expression2.getValue(); if (value1 == null) { - return Decision.exact(value2 == null); + return Match.exact(value2 == null); } if (value2 == null) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } - return Decision.exact(value1.equals(value2)); + return Match.exact(value1.equals(value2)); } - protected Decision classObjectAccessExpressionsAreEquivalentDecision(PsiClassObjectAccessExpression expression1, - PsiClassObjectAccessExpression expression2) { + protected Match classObjectAccessExpressionsMatch(PsiClassObjectAccessExpression expression1, + PsiClassObjectAccessExpression expression2) { final PsiTypeElement operand1 = expression1.getOperand(); final PsiTypeElement operand2 = expression2.getOperand(); return typeElementsAreEquivalent(operand1, operand2); } - protected Decision referenceExpressionsAreEquivalentDecision(PsiReferenceExpression referenceExpression1, PsiReferenceExpression referenceExpression2) { + protected Match referenceExpressionsMatch(PsiReferenceExpression referenceExpression1, PsiReferenceExpression referenceExpression2) { final PsiElement element1 = referenceExpression1.resolve(); final PsiElement element2 = referenceExpression2.resolve(); if (element1 != null) { if (!element1.equals(element2)) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } } else { - return EXACTLY_UN_MATCHES; // incomplete code + return EXACT_MISMATCH; // incomplete code } if (element1 instanceof PsiMember) { final PsiMember member1 = (PsiMember)element1; if (member1.hasModifierProperty(PsiModifier.STATIC)) { - return EXACTLY_MATCHES; + return EXACT_MATCH; } if (member1 instanceof PsiClass) { - return EXACTLY_MATCHES; + return EXACT_MATCH; } } else { - return EXACTLY_MATCHES; + return EXACT_MATCH; } final PsiExpression qualifier1 = referenceExpression1.getQualifierExpression(); final PsiExpression qualifier2 = referenceExpression2.getQualifierExpression(); - if (qualifier1 != null && - !(qualifier1 instanceof PsiThisExpression || - qualifier1 instanceof PsiSuperExpression)) { + if (qualifier1 != null && !(qualifier1 instanceof PsiThisExpression || qualifier1 instanceof PsiSuperExpression)) { if (qualifier2 == null) { - return EXACTLY_UN_MATCHES; - } - if (!expressionsAreEquivalentDecision(qualifier1, qualifier2).getExactlyMatches()) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } + return expressionsMatch(qualifier1, qualifier2); } else { - if (qualifier2 != null && - !(qualifier2 instanceof PsiThisExpression || - qualifier2 instanceof PsiSuperExpression)) { - return EXACTLY_UN_MATCHES; + if (qualifier2 != null && !(qualifier2 instanceof PsiThisExpression || qualifier2 instanceof PsiSuperExpression)) { + return EXACT_MISMATCH; } } - return EXACTLY_MATCHES; + return EXACT_MATCH; } - protected Decision instanceOfExpressionsAreEquivalentDecision(PsiInstanceOfExpression instanceOfExpression1, PsiInstanceOfExpression instanceOfExpression2) { + protected Match instanceOfExpressionsMatch(PsiInstanceOfExpression instanceOfExpression1, PsiInstanceOfExpression instanceOfExpression2) { final PsiExpression operand1 = instanceOfExpression1.getOperand(); final PsiExpression operand2 = instanceOfExpression2.getOperand(); - if (!expressionsAreEquivalentDecision(operand1, operand2).getExactlyMatches()) { - return EXACTLY_UN_MATCHES; + if (!expressionsMatch(operand1, operand2).isExactMatch()) { + return EXACT_MISMATCH; } final PsiTypeElement typeElement1 = instanceOfExpression1.getCheckType(); final PsiTypeElement typeElement2 = instanceOfExpression2.getCheckType(); return typeElementsAreEquivalent(typeElement1, typeElement2); } - protected Decision typeElementsAreEquivalent(PsiTypeElement typeElement1, PsiTypeElement typeElement2) { + protected Match typeElementsAreEquivalent(PsiTypeElement typeElement1, PsiTypeElement typeElement2) { if (typeElement1 == null) { - return Decision.exact(typeElement2 == null); + return Match.exact(typeElement2 == null); } if (typeElement2 == null) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } final PsiType type1 = typeElement1.getType(); final PsiType type2 = typeElement2.getType(); - return Decision.exact(typesAreEquivalent(type1, type2)); + return Match.exact(typesAreEquivalent(type1, type2)); } - protected Decision methodCallExpressionsAreEquivalentDecision(@NotNull PsiMethodCallExpression methodCallExpression1, @NotNull PsiMethodCallExpression methodCallExpression2) { + protected Match methodCallExpressionsMatch(@NotNull PsiMethodCallExpression methodCallExpression1, @NotNull PsiMethodCallExpression methodCallExpression2) { final PsiReferenceExpression methodExpression1 = methodCallExpression1.getMethodExpression(); final PsiReferenceExpression methodExpression2 = methodCallExpression2.getMethodExpression(); - if (!expressionsAreEquivalentDecision(methodExpression1, methodExpression2).getExactlyMatches()) { - return EXACTLY_UN_MATCHES; + if (!expressionsMatch(methodExpression1, methodExpression2).isExactMatch()) { + return EXACT_MISMATCH; } final PsiExpressionList argumentList1 = methodCallExpression1.getArgumentList(); @@ -698,65 +692,65 @@ public class EquivalenceChecker { final PsiExpressionList argumentList2 = methodCallExpression2.getArgumentList(); final PsiExpression[] args2 = argumentList2.getExpressions(); - final Decision decision = expressionListsAreEquivalent(args1, args2); + final Match match = expressionListsAreEquivalent(args1, args2); - if (args1.length != 0 && (!decision.isExact() || !decision.isExactUnMatches())) { - final PsiElement leftDiff = decision.getLeftDiff(); - PsiExpression lastArg = args1[args1.length - 1]; + if (match.isPartialMatch()) { + final PsiElement leftDiff = match.getLeftDiff(); + final PsiExpression lastArg = args1[args1.length - 1]; if (Comparing.equal(leftDiff, lastArg)) { final PsiType type1 = lastArg.getType(); final PsiType type2 = args2[args2.length - 1].getType(); if (type2 instanceof PsiArrayType && !(type1 instanceof PsiArrayType)) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } if (type1 instanceof PsiArrayType && !(type2 instanceof PsiArrayType)) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } } } - return decision; + return match; } - protected Decision newExpressionsAreEquivalentDecision(@NotNull PsiNewExpression newExpression1, @NotNull PsiNewExpression newExpression2) { + protected Match newExpressionsMatch(@NotNull PsiNewExpression newExpression1, @NotNull PsiNewExpression newExpression2) { final PsiJavaCodeReferenceElement classReference1 = newExpression1.getClassReference(); final PsiJavaCodeReferenceElement classReference2 = newExpression2.getClassReference(); if (classReference1 == null || classReference2 == null) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } final PsiElement target1 = classReference1.resolve(); if (target1 == null) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } final PsiElement target2 = classReference2.resolve(); if (!target1.equals(target2)) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } final PsiExpression[] arrayDimensions1 = newExpression1.getArrayDimensions(); final PsiExpression[] arrayDimensions2 = newExpression2.getArrayDimensions(); - if (!expressionListsAreEquivalent(arrayDimensions1, arrayDimensions2).getExactlyMatches()) { - return EXACTLY_UN_MATCHES; + if (!expressionListsAreEquivalent(arrayDimensions1, arrayDimensions2).isExactMatch()) { + return EXACT_MISMATCH; } final PsiArrayInitializerExpression arrayInitializer1 = newExpression1.getArrayInitializer(); final PsiArrayInitializerExpression arrayInitializer2 = newExpression2.getArrayInitializer(); - if (!expressionsAreEquivalentDecision(arrayInitializer1, arrayInitializer2).getExactlyMatches()) { - return EXACTLY_UN_MATCHES; + if (!expressionsMatch(arrayInitializer1, arrayInitializer2).isExactMatch()) { + return EXACT_MISMATCH; } final PsiMethod constructor1 = newExpression1.resolveConstructor(); final PsiMethod constructor2 = newExpression2.resolveConstructor(); if (!Comparing.equal(constructor1, constructor2)) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } final PsiExpression qualifier1 = newExpression1.getQualifier(); final PsiExpression qualifier2 = newExpression2.getQualifier(); - if (!expressionsAreEquivalentDecision(qualifier1, qualifier2).getExactlyMatches()) { - return EXACTLY_UN_MATCHES; + if (!expressionsMatch(qualifier1, qualifier2).isExactMatch()) { + return EXACT_MISMATCH; } final PsiExpressionList argumentList1 = newExpression1.getArgumentList(); final PsiExpression[] args1 = argumentList1 == null ? null : argumentList1.getExpressions(); @@ -765,7 +759,7 @@ public class EquivalenceChecker { return expressionListsAreEquivalent(args1, args2); } - protected Decision arrayInitializerExpressionsAreEquivalentDecision(@NotNull PsiArrayInitializerExpression arrayInitializerExpression1, @NotNull PsiArrayInitializerExpression arrayInitializerExpression2) { + protected Match arrayInitializerExpressionsMatch(@NotNull PsiArrayInitializerExpression arrayInitializerExpression1, @NotNull PsiArrayInitializerExpression arrayInitializerExpression2) { final PsiExpression[] initializers1 = arrayInitializerExpression1.getInitializers(); final PsiExpression[] initializers2 = @@ -773,21 +767,21 @@ public class EquivalenceChecker { return expressionListsAreEquivalent(initializers1, initializers2); } - protected Decision typeCastExpressionsAreEquivalentDecision(@NotNull PsiTypeCastExpression typeCastExpression1, @NotNull PsiTypeCastExpression typeCastExpression2) { + protected Match typeCastExpressionsMatch(@NotNull PsiTypeCastExpression typeCastExpression1, @NotNull PsiTypeCastExpression typeCastExpression2) { final PsiTypeElement typeElement1 = typeCastExpression1.getCastType(); final PsiTypeElement typeElement2 = typeCastExpression2.getCastType(); - if (!typeElementsAreEquivalent(typeElement1, typeElement2).getExactlyMatches()) { - return EXACTLY_UN_MATCHES; + if (!typeElementsAreEquivalent(typeElement1, typeElement2).isExactMatch()) { + return EXACT_MISMATCH; } final PsiExpression operand1 = typeCastExpression1.getOperand(); final PsiExpression operand2 = typeCastExpression2.getOperand(); if (operand1 instanceof PsiFunctionalExpression || operand2 instanceof PsiFunctionalExpression) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } - return expressionsAreEquivalentDecision(operand1, operand2).setConcreteIfExactUnMatches(operand1, operand2); + return expressionsMatch(operand1, operand2).setConcreteIfExactMismatch(operand1, operand2); } - protected Decision arrayAccessExpressionsAreEquivalentDecision(@NotNull PsiArrayAccessExpression arrayAccessExpression1, @NotNull PsiArrayAccessExpression arrayAccessExpression2) { + protected Match arrayAccessExpressionsMatch(@NotNull PsiArrayAccessExpression arrayAccessExpression1, @NotNull PsiArrayAccessExpression arrayAccessExpression2) { final PsiExpression arrayExpression2 = arrayAccessExpression1.getArrayExpression(); final PsiExpression arrayExpression1 = @@ -796,76 +790,76 @@ public class EquivalenceChecker { arrayAccessExpression1.getIndexExpression(); final PsiExpression indexExpression1 = arrayAccessExpression2.getIndexExpression(); - final Decision arrayExpressionEq = expressionsAreEquivalentDecision(arrayExpression2, arrayExpression1); - if (arrayExpressionEq != EXACTLY_MATCHES) { - return EXACTLY_UN_MATCHES; + final Match arrayExpressionEq = expressionsMatch(arrayExpression2, arrayExpression1); + if (arrayExpressionEq != EXACT_MATCH) { + return EXACT_MISMATCH; } - return expressionsAreEquivalentDecision(indexExpression1, indexExpression2).setConcreteIfExactUnMatches(indexExpression1, indexExpression2); + return expressionsMatch(indexExpression1, indexExpression2).setConcreteIfExactMismatch(indexExpression1, indexExpression2); } - protected Decision prefixExpressionsAreEquivalentDecision(@NotNull PsiPrefixExpression prefixExpression1, @NotNull PsiPrefixExpression prefixExpression2) { + protected Match prefixExpressionsMatch(@NotNull PsiPrefixExpression prefixExpression1, @NotNull PsiPrefixExpression prefixExpression2) { final IElementType tokenType1 = prefixExpression1.getOperationTokenType(); if (!tokenType1.equals(prefixExpression2.getOperationTokenType())) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } final PsiExpression operand1 = prefixExpression1.getOperand(); final PsiExpression operand2 = prefixExpression2.getOperand(); - return expressionsAreEquivalentDecision(operand1, operand2); + return expressionsMatch(operand1, operand2); } - protected Decision postfixExpressionsAreEquivalentDecision(@NotNull PsiPostfixExpression postfixExpression1, @NotNull PsiPostfixExpression postfixExpression2) { + protected Match postfixExpressionsMatch(@NotNull PsiPostfixExpression postfixExpression1, @NotNull PsiPostfixExpression postfixExpression2) { final IElementType tokenType1 = postfixExpression1.getOperationTokenType(); if (!tokenType1.equals(postfixExpression2.getOperationTokenType())) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } final PsiExpression operand1 = postfixExpression1.getOperand(); final PsiExpression operand2 = postfixExpression2.getOperand(); - return expressionsAreEquivalentDecision(operand1, operand2); + return expressionsMatch(operand1, operand2); } - protected Decision polyadicExpressionsAreEquivalentDecision(@NotNull PsiPolyadicExpression polyadicExpression1, @NotNull PsiPolyadicExpression polyadicExpression2) { + protected Match polyadicExpressionsMatch(@NotNull PsiPolyadicExpression polyadicExpression1, @NotNull PsiPolyadicExpression polyadicExpression2) { final IElementType tokenType1 = polyadicExpression1.getOperationTokenType(); final IElementType tokenType2 = polyadicExpression2.getOperationTokenType(); if (!tokenType1.equals(tokenType2)) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } final PsiExpression[] operands1 = polyadicExpression1.getOperands(); final PsiExpression[] operands2 = polyadicExpression2.getOperands(); if (operands1.length != operands2.length) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } - Decision incompleteDecision = null; + Match incompleteMatch = null; for (int i = 0; i < operands1.length; i++) { - final Decision decisionForCurrentOperand = expressionsAreEquivalentDecision(operands1[i], operands2[i]); - if (!decisionForCurrentOperand.getExactlyMatches()) { - if (incompleteDecision == null) { - incompleteDecision = - decisionForCurrentOperand.isExactUnMatches() ? new Decision(operands1[i], operands2[i]) : decisionForCurrentOperand; + final Match match = expressionsMatch(operands1[i], operands2[i]); + if (!match.isExactMatch()) { + if (incompleteMatch == null) { + incompleteMatch = + match.isExactMismatch() ? new Match(operands1[i], operands2[i]) : match; } else { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } } } - return incompleteDecision != null ? incompleteDecision : EXACTLY_MATCHES; + return incompleteMatch != null ? incompleteMatch : EXACT_MATCH; } - protected Decision assignmentExpressionsAreEquivalentDecision(@NotNull PsiAssignmentExpression assignmentExpression1, @NotNull PsiAssignmentExpression assignmentExpression2) { + protected Match assignmentExpressionsMatch(@NotNull PsiAssignmentExpression assignmentExpression1, @NotNull PsiAssignmentExpression assignmentExpression2) { final IElementType tokenType1 = assignmentExpression1.getOperationTokenType(); if (!tokenType1.equals(assignmentExpression2.getOperationTokenType())) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } final PsiExpression lhs1 = assignmentExpression1.getLExpression(); final PsiExpression lhs2 = assignmentExpression2.getLExpression(); final PsiExpression rhs1 = assignmentExpression1.getRExpression(); final PsiExpression rhs2 = assignmentExpression2.getRExpression(); - final Decision leftEq = expressionsAreEquivalentDecision(lhs1, lhs2); - final Decision rightEq = expressionsAreEquivalentDecision(rhs1, rhs2); + final Match leftEq = expressionsMatch(lhs1, lhs2); + final Match rightEq = expressionsMatch(rhs1, rhs2); return getComplexElementDecision(leftEq, rightEq, lhs1, lhs2, rhs1, rhs2); } - protected Decision conditionalExpressionsAreEquivalentDecision(@NotNull PsiConditionalExpression conditionalExpression1, @NotNull PsiConditionalExpression conditionalExpression2) { + protected Match conditionalExpressionsMatch(@NotNull PsiConditionalExpression conditionalExpression1, @NotNull PsiConditionalExpression conditionalExpression2) { final PsiExpression condition1 = conditionalExpression1.getCondition(); final PsiExpression condition2 = conditionalExpression2.getCondition(); final PsiExpression thenExpression1 = @@ -876,65 +870,63 @@ public class EquivalenceChecker { conditionalExpression1.getElseExpression(); final PsiExpression elseExpression2 = conditionalExpression2.getElseExpression(); - if (expressionsAreEquivalentDecision(condition1, condition2) == EXACTLY_MATCHES && - expressionsAreEquivalentDecision(thenExpression1, thenExpression2) == EXACTLY_MATCHES && - expressionsAreEquivalentDecision(elseExpression1, elseExpression2) == EXACTLY_MATCHES) { - return EXACTLY_MATCHES; + if (expressionsMatch(condition1, condition2) == EXACT_MATCH && + expressionsMatch(thenExpression1, thenExpression2) == EXACT_MATCH && + expressionsMatch(elseExpression1, elseExpression2) == EXACT_MATCH) { + return EXACT_MATCH; } - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } - protected Decision expressionListsAreEquivalent( - @Nullable PsiExpression[] expressions1, - @Nullable PsiExpression[] expressions2) { + protected Match expressionListsAreEquivalent(@Nullable PsiExpression[] expressions1, @Nullable PsiExpression[] expressions2) { if (expressions1 == null && expressions2 == null) { - return Decision.exact(true); + return EXACT_MATCH; } if (expressions1 == null || expressions2 == null) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } if (expressions1.length != expressions2.length) { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } - Decision oneUnMatchedDecision = null; + Match incompleteMatch = null; for (int i = 0; i < expressions1.length; i++) { - final Decision currentDecision = expressionsAreEquivalentDecision(expressions1[i], expressions2[i]); - if (!currentDecision.getExactlyMatches()) { - if (oneUnMatchedDecision == null) { - oneUnMatchedDecision = currentDecision.isExactUnMatches() ? new Decision(expressions1[i], expressions2[i]) : currentDecision; + final Match match = expressionsMatch(expressions1[i], expressions2[i]); + if (!match.isExactMatch()) { + if (incompleteMatch == null) { + incompleteMatch = match.isExactMismatch() ? new Match(expressions1[i], expressions2[i]) : match; } else { - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } } } - return oneUnMatchedDecision == null ? EXACTLY_MATCHES : oneUnMatchedDecision; + return incompleteMatch == null ? EXACT_MATCH : incompleteMatch; } @NotNull - private Decision getComplexElementDecision(Decision equivalence1, - Decision equivalence2, - PsiElement left1, - PsiElement right1, - PsiElement left2, - PsiElement right2) { - if (equivalence2 == EXACTLY_MATCHES) { - if (equivalence1 == EXACTLY_MATCHES) { - return EXACTLY_MATCHES; + private static Match getComplexElementDecision(Match equivalence1, + Match equivalence2, + PsiElement left1, + PsiElement right1, + PsiElement left2, + PsiElement right2) { + if (equivalence2 == EXACT_MATCH) { + if (equivalence1 == EXACT_MATCH) { + return EXACT_MATCH; } - else if (equivalence1 == EXACTLY_UN_MATCHES) { - return new Decision(left1, right1); + else if (equivalence1 == EXACT_MISMATCH) { + return new Match(left1, right1); } } - else if (equivalence2 == EXACTLY_UN_MATCHES) { - if (equivalence1 == EXACTLY_UN_MATCHES) { - return EXACTLY_UN_MATCHES; + else if (equivalence2 == EXACT_MISMATCH) { + if (equivalence1 == EXACT_MISMATCH) { + return EXACT_MISMATCH; } - else if (equivalence1 == EXACTLY_MATCHES) { - return new Decision(left2, right2); + else if (equivalence1 == EXACT_MATCH) { + return new Match(left2, right2); } } - return EXACTLY_UN_MATCHES; + return EXACT_MISMATCH; } } \ No newline at end of file