Switched off and made optional Simplify comparison to zero (PY-6876)

python/src/com/jetbrains/python/inspections/PySimplifyBooleanCheckInspection.java

@@ -1,7 +1,9 @@
 package com.jetbrains.python.inspections;
 
+import com.google.common.collect.ImmutableList;
 import com.intellij.codeInspection.LocalInspectionToolSession;
 import com.intellij.codeInspection.ProblemsHolder;
+import com.intellij.codeInspection.ui.MultipleCheckboxOptionsPanel;
 import com.intellij.psi.PsiElementVisitor;
 import com.jetbrains.python.PyBundle;
 import com.jetbrains.python.PyTokenTypes;
@@ -14,10 +16,19 @@ import org.jetbrains.annotations.Nls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import javax.swing.*;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
 /**
  * @author Alexey.Ivanov
  */
 public class PySimplifyBooleanCheckInspection extends PyInspection {
+  private static List<String> COMPARISON_LITERALS = ImmutableList.of("True", "False", "[]");
+
+  public boolean ignoreComparisonToZero = true;
+
   @Nls
   @NotNull
   @Override
@@ -30,12 +41,22 @@ public class PySimplifyBooleanCheckInspection extends PyInspection {
   public PsiElementVisitor buildVisitor(@NotNull ProblemsHolder holder,
                                         boolean isOnTheFly,
                                         @NotNull LocalInspectionToolSession session) {
-    return new Visitor(holder, session);
+    return new Visitor(holder, session, ignoreComparisonToZero);
+  }
+
+  @Override
+  public JComponent createOptionsPanel() {
+    MultipleCheckboxOptionsPanel panel = new MultipleCheckboxOptionsPanel(this);
+    panel.addCheckbox("Ignore comparison to zero", "ignoreComparisonToZero");
+    return panel;
   }
 
   private static class Visitor extends PyInspectionVisitor {
-    public Visitor(@Nullable ProblemsHolder holder, @NotNull LocalInspectionToolSession session) {
+    private final boolean myIgnoreComparisonToZero;
+
+    public Visitor(@Nullable ProblemsHolder holder, @NotNull LocalInspectionToolSession session, boolean ignoreComparisonToZero) {
       super(holder, session);
+      myIgnoreComparisonToZero = ignoreComparisonToZero;
     }
 
     @Override
@@ -43,14 +64,19 @@ public class PySimplifyBooleanCheckInspection extends PyInspection {
       super.visitPyConditionalStatementPart(node);
       final PyExpression condition = node.getCondition();
       if (condition != null) {
-        condition.accept(new PyBinaryExpressionVisitor(getHolder(), getSession()));
+        condition.accept(new PyBinaryExpressionVisitor(getHolder(), getSession(), myIgnoreComparisonToZero));
       }
     }
   }
 
   private static class PyBinaryExpressionVisitor extends PyInspectionVisitor {
-    public PyBinaryExpressionVisitor(@Nullable ProblemsHolder holder, @NotNull LocalInspectionToolSession session) {
+    private final boolean myIgnoreComparisonToZero;
+
+    public PyBinaryExpressionVisitor(@Nullable ProblemsHolder holder,
+                                     @NotNull LocalInspectionToolSession session,
+                                     boolean ignoreComparisonToZero) {
       super(holder, session);
+      myIgnoreComparisonToZero = ignoreComparisonToZero;
     }
 
     @Override
@@ -62,22 +88,26 @@ public class PySimplifyBooleanCheckInspection extends PyInspection {
           node.getLeftExpression() instanceof PyBinaryExpression) {
         return;
       }
-      final String leftExpressionText = node.getLeftExpression().getText();
-      final String rightExpressionText = rightExpression.getText();
-      if ("True".equals(leftExpressionText) ||
-          "False".equals(leftExpressionText) ||
-          "0".equals(leftExpressionText) ||
-          "[]".equals(leftExpressionText) ||
-          "True".equals(rightExpressionText) ||
-          "False".equals(rightExpressionText) ||
-          "0".equals(rightExpressionText) ||
-          "[]".equals(rightExpressionText)) {
-        if (PyTokenTypes.EQUALITY_OPERATIONS.contains(operator)) {
+      if (PyTokenTypes.EQUALITY_OPERATIONS.contains(operator)) {
+        if (operandsEqualTo(node, COMPARISON_LITERALS) ||
+            (!myIgnoreComparisonToZero && operandsEqualTo(node, Collections.singleton("0")))) {
           registerProblem(node);
         }
       }
     }
 
+    private static boolean operandsEqualTo(@NotNull PyBinaryExpression expr, @NotNull Collection<String> literals) {
+      final String leftExpressionText = expr.getLeftExpression().getText();
+      final PyExpression rightExpression = expr.getRightExpression();
+      final String rightExpressionText = rightExpression != null ? rightExpression.getText() : null;
+      for (String literal : literals) {
+        if (literal.equals(leftExpressionText) || literal.equals(rightExpressionText)) {
+          return true;
+        }
+      }
+      return false;
+    }
+
     private void registerProblem(PyBinaryExpression binaryExpression) {
       registerProblem(binaryExpression, PyBundle.message("INSP.expression.can.be.simplified"), new SimplifyBooleanCheckQuickFix(binaryExpression));
     }

python/testData/inspections/PySimplifyBooleanCheckInspection/test.py

@@ -6,3 +6,7 @@ if <weak_warning descr="Expression can be simplified">a == True</weak_warning>:
 if a is False:
   pass
 var = a is not True
+
+# PY-6876
+if a == 0:
+    pass