IG: improve EquivalenceChecker naming

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());
         }
       }
 

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);
       }
     }

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) {

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) {