SONARPY-4047 Extend S5714 to more bitwise boolean expression types (#1080)

GitOrigin-RevId: 5dd8a75e6de674990c541c2c789684c271ac57b5

Author: guillaume-dequenne

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

@@ -41,6 +41,10 @@ public class BooleanExpressionInExceptCheck extends PythonSubscriptionCheck {
   public static final String MESSAGE = "Rewrite this \"except\" expression as a tuple of exception classes.";
   public static final String QUICK_FIX_MESSAGE = "Replace with a tuple";
 
+  private static final Kind[] FLAGGED_BINARY_KINDS = {
+    Kind.OR, Kind.AND, Kind.BITWISE_OR, Kind.BITWISE_AND
+  };
+
   @Override
   public void initialize(Context context) {
     context.registerSyntaxNodeConsumer(Kind.EXCEPT_CLAUSE, BooleanExpressionInExceptCheck::checkExceptClause);
@@ -52,7 +56,7 @@ private static void checkExceptClause(SubscriptionContext ctx) {
     Optional.of(except)
       .map(ExceptClause::exception)
       .map(Expressions::removeParentheses)
-      .filter(exception -> exception.is(Kind.OR, Kind.AND))
+      .filter(exception -> exception.is(FLAGGED_BINARY_KINDS))
       .ifPresent(exception -> {
         var issue = ctx.addIssue(exception, MESSAGE);
         addQuickFix(issue, exception);
@@ -61,7 +65,7 @@ private static void checkExceptClause(SubscriptionContext ctx) {
 
   private static List<String> collectNames(Expression expression) {
     expression = Expressions.removeParentheses(expression);
-    if (expression.is(Kind.OR, Kind.AND)) {
+    if (expression.is(FLAGGED_BINARY_KINDS)) {
       var binaryExpression = (BinaryExpression) expression;
       var leftExceptions = collectNames(binaryExpression.leftOperand());
       var rightExceptions = collectNames(binaryExpression.rightOperand());

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

@@ -74,6 +74,54 @@ void nestedQuickFixTest() {
     verifyQuickFix(before, after);
   }
 
+  @Test
+  void bitwiseOrQuickFixTest() {
+    var before = """
+      try:
+          foo()
+      except ValueError | TypeError | SomeError:
+          pass""";
+
+    var after = """
+      try:
+          foo()
+      except (ValueError, TypeError, SomeError):
+          pass""";
+    verifyQuickFix(before, after);
+  }
+
+  @Test
+  void bitwiseAndQuickFixTest() {
+    var before = """
+      try:
+          foo()
+      except ValueError & TypeError & SomeError:
+          pass""";
+
+    var after = """
+      try:
+          foo()
+      except (ValueError, TypeError, SomeError):
+          pass""";
+    verifyQuickFix(before, after);
+  }
+
+  @Test
+  void mixedOperatorsQuickFixTest() {
+    var before = """
+      try:
+          foo()
+      except (ValueError | TypeError) and SomeError:
+          pass""";
+
+    var after = """
+      try:
+          foo()
+      except (ValueError, TypeError, SomeError):
+          pass""";
+    verifyQuickFix(before, after);
+  }
+
   @Test
   void noQuickFixTest() {
     var before = """

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

@@ -29,3 +29,60 @@
     pass
 except* (ValueError):
     pass
+
+# === `|` bitwise OR ===
+try:
+    foo()
+except ValueError | TypeError:  # Noncompliant
+    pass
+except ValueError | TypeError as e:  # Noncompliant
+    pass
+except (ValueError | TypeError):  # Noncompliant
+    pass
+except ConnectionError | TimeoutError | OSError:  # Noncompliant
+    pass
+
+# === `&` bitwise AND ===
+try:
+    foo()
+except ValueError & TypeError:  # Noncompliant
+    pass
+except ValueError & TypeError as e:  # Noncompliant
+    pass
+except (ValueError & TypeError):  # Noncompliant
+    pass
+
+# === `except*` variants for bitwise operators ===
+try:
+    foo()
+except* ValueError | TypeError:  # Noncompliant
+    pass
+except* ValueError & TypeError:  # Noncompliant
+    pass
+
+# === Mixed: one valid handler, one with a bitwise operator ===
+try:
+    foo()
+except TypeError:
+    pass
+except ValueError | KeyError:  # Noncompliant
+    pass
+
+try:
+    foo()
+except* TypeError:
+    pass
+except* ValueError | KeyError:  # Noncompliant
+    pass
+
+# === Arithmetic operators are out of scope (e.g. tuple + tuple is valid Python) ===
+connection_errors = (ConnectionError, OSError)
+channel_errors = (KeyError,)
+try:
+    foo()
+except connection_errors + channel_errors as exc:
+    pass
+except connection_errors + channel_errors:
+    pass
+except (connection_errors + channel_errors):
+    pass