SONARPY-253: Rule S2761: Double prefix operators not and ~ should not be used (#1096)

* SONARPY-253: Rule 2761: Double prefix operators not and ~ should not be used

* Correct test

* SONARPY-253: Rule S2761: Double prefix operators not and ~ should not be used

* Add updated rules

* Update rule and add exception for overloaded invert function

* Uncomment tests

* Adjust code according to review

Author: marco-bearzi-sonarsource

its/ruling/src/test/resources/expected/python-S2761.json

@@ -0,0 +1,11 @@
+{
+'project:buildbot-0.8.6p1/buildbot/process/properties.py':[
+75,
+],
+'project:numpy-1.16.4/numpy/distutils/command/build_clib.py':[
+151,
+],
+'project:twisted-12.1.0/twisted/names/server.py':[
+49,
+],
+}

python-checks/src/main/java/org/sonar/python/checks/CheckList.java

@@ -112,6 +112,7 @@ public static Iterable<Class> getChecks() {
       DictionaryDuplicateKeyCheck.class,
       DisabledHtmlAutoEscapeCheck.class,
       DisabledHtmlAutoEscapeLegacyCheck.class,
+      DoublePrefixOperatorCheck.class,
       DuplicateArgumentCheck.class,
       DuplicatedMethodFieldNamesCheck.class,
       DuplicatedMethodImplementationCheck.class,

python-checks/src/main/java/org/sonar/python/checks/DoublePrefixOperatorCheck.java

@@ -0,0 +1,67 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) 2011-2022 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.python.checks;
+
+import org.sonar.check.Rule;
+import org.sonar.plugins.python.api.PythonSubscriptionCheck;
+import org.sonar.plugins.python.api.SubscriptionContext;
+import org.sonar.plugins.python.api.tree.Expression;
+import org.sonar.plugins.python.api.tree.ParenthesizedExpression;
+import org.sonar.plugins.python.api.tree.Tree;
+import org.sonar.plugins.python.api.tree.UnaryExpression;
+import org.sonar.python.types.InferredTypes;
+
+@Rule(key = "S2761")
+
+public class DoublePrefixOperatorCheck extends PythonSubscriptionCheck {
+
+  private static final String MESSAGE = "Use the \"%s\" operator just once or not at all.";
+  private static final String MESSAGE_NOT = "Use the \"bool()\" builtin function instead of calling \"not\" twice.";
+
+  @Override
+  public void initialize(Context context) {
+    context.registerSyntaxNodeConsumer(Tree.Kind.BITWISE_COMPLEMENT, ctx -> doubleInversionCheck(ctx, (UnaryExpression) ctx.syntaxNode()));
+    context.registerSyntaxNodeConsumer(Tree.Kind.NOT, ctx -> doubleInversionCheck(ctx, (UnaryExpression) ctx.syntaxNode()));
+  }
+
+  private static void doubleInversionCheck(SubscriptionContext ctx, UnaryExpression original) {
+    Expression invertedExpr = original.expression();
+    boolean doubleInversionFollowed = true;
+    while (invertedExpr.is(Tree.Kind.PARENTHESIZED)) {
+      doubleInversionFollowed = false;
+      invertedExpr = ((ParenthesizedExpression) invertedExpr).expression();
+    }
+
+    if (invertedExpr.is(Tree.Kind.NOT, Tree.Kind.BITWISE_COMPLEMENT) && original.is(invertedExpr.getKind())) {
+      if (doubleInversionFollowed) {
+        // Overloaded __invert__ should not raise any warning
+        if (invertedExpr.is(Tree.Kind.NOT)) {
+          ctx.addIssue(original, MESSAGE_NOT);
+        } else {
+          if (((UnaryExpression) invertedExpr).expression().type() == InferredTypes.INT) {
+            ctx.addIssue(original, String.format(MESSAGE, original.operator().value()));
+          }
+        }
+      } else {
+        ctx.addIssue(original, String.format(MESSAGE, original.operator().value()));
+      }
+    }
+  }
+}

python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2761.html

@@ -0,0 +1,24 @@
+<p>Calling the <code>not</code> or <code>~</code> prefix operator twice might be redundant: the second invocation undoes the first. Such mistakes are
+typically caused by accidentally double-tapping the key in question without noticing. Either this is a bug, if the operator was actually meant to be
+called once, or misleading if done on purpose. Calling <code>not</code> twice is commonly done instead of using the dedicated "bool()" builtin
+function. However, the latter one increases the code readability and should be used.</p>
+<h2>Noncompliant Code Example</h2>
+<pre>
+a = 0
+b = False
+
+c = not not a # Noncompliant
+d = ~~b # Noncompliant
+</pre>
+<h2>Compliant Solution</h2>
+<pre>
+a = 0
+b = False
+
+c = bool(a)
+d = ~b
+</pre>
+<h2>Exceptions</h2>
+<p>If the <code>~</code> function has been overloaded in a customised class and has been called twice, no warning is raised as it is assumed to be an
+expected usage.</p>
+

python-checks/src/main/resources/org/sonar/l10n/py/rules/python/S2761.json

@@ -0,0 +1,15 @@
+{
+  "title": "Doubled prefix operators \"not\" and \"~\" should not be used",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-2761",
+  "sqKey": "S2761",
+  "scope": "All",
+  "quickfix": "unknown"
+}

python-checks/src/main/resources/org/sonar/l10n/py/rules/python/Sonar_way_profile.json

@@ -62,6 +62,7 @@
     "S2737",
     "S2755",
     "S2757",
+    "S2761",
     "S2772",
     "S2823",
     "S2836",

python-checks/src/test/java/org/sonar/python/checks/DoublePrefixOperatorCheckTest.java

@@ -0,0 +1,32 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) 2011-2022 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.python.checks;
+
+import org.junit.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+public class DoublePrefixOperatorCheckTest {
+
+  @Test
+  public void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/doublePrefixOperator.py", new DoublePrefixOperatorCheck());
+  }
+
+}

python-checks/src/test/resources/checks/doublePrefixOperator.py

@@ -0,0 +1,29 @@
+def start():
+    a = 1
+    b = not not a  # Noncompliant {{Use the "bool()" builtin function instead of calling "not" twice.}}
+    #   ^^^^^^^^^
+
+    c = ~~a  # Noncompliant {{Use the "~" operator just once or not at all.}}
+    #   ^^^
+    d = not (not (not (not a)))  # Noncompliant 3
+
+    e = ~~~~~a  # Noncompliant
+    f = ~(((((~a)))))  # Noncompliant {{Use the "~" operator just once or not at all.}}
+
+    g = not (a == b)
+    h = ~(a and not b)
+    i = not a and ~b
+
+    j = not (not (a is not b))  # Noncompliant {{Use the "not" operator just once or not at all.}}
+    #   ^^^^^^^^^^^^^^^^^^^^^^
+
+    k = not (~a)
+
+    i = not(not(a)) # Noncompliant {{Use the "not" operator just once or not at all.}}
+
+    class Foo:
+        def __invert__(self):
+            return self.bar == 42
+
+    foo  = Foo()
+    ~~foo # here ~~ it might have a different semantic