SPNARPY-2933 Rule S7492: Unnecessary list comprehension in <any/all>() prevents short-circuiting - rewrite as a generator (#279)

GitOrigin-RevId: b06eb8e0ee3fe61706c21c4842419dbb655436f2

Author: maksim-grebeniuk-sonarsource

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

@@ -396,6 +396,7 @@ public Stream<Class<?>> getChecks() {
       UnencryptedSqsQueueCheck.class,
       UnencryptedEbsVolumeCheck.class,
       UnionTypeExpressionCheck.class,
+      UnnecessaryListComprehensionArgumentCheck.class,
       UnnecessaryReversedCallCheck.class,
       UnnecessarySubscriptReversalCheck.class,
       UnquantifiedNonCapturingGroupCheck.class,

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

@@ -0,0 +1,94 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) 2011-2025 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 Sonar Source-Available License Version 1, as published by SonarSource SA.
+ *
+ * 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 Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Stream;
+import javax.annotation.Nullable;
+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.CallExpression;
+import org.sonar.plugins.python.api.tree.ComprehensionExpression;
+import org.sonar.plugins.python.api.tree.Expression;
+import org.sonar.plugins.python.api.tree.Name;
+import org.sonar.plugins.python.api.tree.RegularArgument;
+import org.sonar.plugins.python.api.tree.Tree;
+import org.sonar.plugins.python.api.types.v2.TriBool;
+import org.sonar.python.checks.utils.Expressions;
+import org.sonar.python.semantic.v2.SymbolV2;
+import org.sonar.python.tree.TreeUtils;
+import org.sonar.python.types.v2.TypeCheckBuilder;
+
+@Rule(key = "S7492")
+public class UnnecessaryListComprehensionArgumentCheck extends PythonSubscriptionCheck {
+  private TypeCheckBuilder isAllTypeCheck;
+  private TypeCheckBuilder isAnyTypeCheck;
+  private TypeCheckBuilder isListTypeCheck;
+
+  @Override
+  public void initialize(Context context) {
+    context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, this::initChecks);
+    context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, this::check);
+  }
+
+  private void initChecks(SubscriptionContext ctx) {
+    isAllTypeCheck = ctx.typeChecker().typeCheckBuilder().isTypeWithName("all");
+    isAnyTypeCheck = ctx.typeChecker().typeCheckBuilder().isTypeWithName("any");
+    isListTypeCheck = ctx.typeChecker().typeCheckBuilder().isInstanceOf("list");
+  }
+
+  private void check(SubscriptionContext ctx) {
+    var callExpression = (CallExpression) ctx.syntaxNode();
+    if (!isSensitiveCall(callExpression)) {
+      return;
+    }
+    TreeUtils.nthArgumentOrKeywordOptional(0, "", callExpression.arguments())
+      .map(RegularArgument::expression)
+      .ifPresent(argumentExpression -> {
+        if (isListComprehensionExpression(argumentExpression) || isAssignedToListComprehensionExpression(argumentExpression)) {
+          ctx.addIssue(callExpression, "Unpack this comprehension expression");
+        }
+      });
+  }
+
+  private boolean isListComprehensionExpression(@Nullable Expression expression) {
+    return expression instanceof ComprehensionExpression comprehensionExpression
+           && isListTypeCheck.check(comprehensionExpression.typeV2()) == TriBool.TRUE;
+  }
+
+  private boolean isAssignedToListComprehensionExpression(Expression argumentExpression) {
+    return argumentExpression instanceof Name name
+           && getUsageCount(name) == 2
+           && isListComprehensionExpression(Expressions.singleAssignedValue(name));
+  }
+
+  private boolean isSensitiveCall(CallExpression callExpression) {
+    return Stream.of(isAllTypeCheck, isAnyTypeCheck)
+      .map(check -> check.check(callExpression.callee().typeV2()))
+      .anyMatch(TriBool.TRUE::equals);
+  }
+
+  private static int getUsageCount(Name name) {
+    return Optional.of(name)
+      .map(Name::symbolV2)
+      .map(SymbolV2::usages)
+      .map(List::size)
+      .orElse(0);
+  }
+}

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

@@ -0,0 +1,28 @@
+<p>This rule raises an issue when list comprehensions are used as parameters to <code>any()</code> or <code>all()</code> instead of generator
+expressions as this prevents <code>any()</code> or <code>all()</code> from short-circuiting.</p>
+<h2>Why is this an issue?</h2>
+<p>Using a list comprehension inside <code>any()</code> or <code>all()</code> forces the entire list to be created in memory before the check begins.
+This prevents the short-circuiting behavior that these functions are designed to leverage, where <code>any()</code> stops at the first
+<code>True</code> and <code>all()</code> stops at the first <code>False</code>.</p>
+<p>Using a generator expression provides the same functionality while preserving the short-circuiting behavior of these functions. This could save
+both processing time and memory, especially for large iterables or when the condition has side effects or is computationally expensive.</p>
+<h2>How to fix it</h2>
+<p>Use a generator expression instead of a list comprehension.</p>
+<h3>Code examples</h3>
+<h4>Noncompliant code example</h4>
+<pre data-diff-id="1" data-diff-type="noncompliant">
+numbers = [1, 5, 0, 10]
+res_all = all([x &gt; 2 for x in numbers])  # Noncompliant: will evaluate all numbers instead of stopping at "5"
+</pre>
+<h4>Compliant solution</h4>
+<pre data-diff-id="1" data-diff-type="compliant">
+numbers = [1, 5, 0, 10]
+res_all = all(x &gt; 2 for x in numbers)  # Compliant
+</pre>
+<h2>Resources</h2>
+<h3>Documentation</h3>
+<ul>
+  <li> Python Wiki - <a href="https://wiki.python.org/moin/Generators">Generators</a> </li>
+  <li> Python Documentation - <a href="https://docs.python.org/3/glossary.html#term-generator">Generator Glossary Entry</a> </li>
+</ul>
+

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

@@ -0,0 +1,21 @@
+{
+  "title": "List comprehensions should not be used with \"any()\" or \"all()\"",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [],
+  "defaultSeverity": "Minor",
+  "ruleSpecification": "RSPEC-7492",
+  "sqKey": "S7492",
+  "scope": "All",
+  "quickfix": "targeted",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "LOW"
+    },
+    "attribute": "EFFICIENT"
+  }
+}

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

@@ -260,6 +260,7 @@
     "S7488",
     "S7489",
     "S7491",
+    "S7492",
     "S7493",
     "S7494",
     "S7498",

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

@@ -0,0 +1,29 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) 2011-2025 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 Sonar Source-Available License Version 1, as published by SonarSource SA.
+ *
+ * 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 Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class UnnecessaryListComprehensionArgumentCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/unnecessaryListComprehensionCallArgument.py", new UnnecessaryListComprehensionArgumentCheck());
+  }
+
+}

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

@@ -0,0 +1,30 @@
+
+def case1():
+  numbers = [1, 5, 0, 10]
+  all([x > 2 for x in numbers])  # Noncompliant
+  any([x > 2 for x in numbers])  # Noncompliant
+
+def case2():
+  numbers = [1, 5, 0, 10]
+  d1 = [x > 2 for x in numbers]
+  all(d1) # Noncompliant
+  d2 = [x > 2 for x in numbers]
+  d2.append(3)
+  any(d2)
+
+def case3():
+  numbers = [1, 5, 0, 10]
+  all(x > 2 for x in numbers)
+  any(x > 2 for x in numbers)
+
+def case4():
+  numbers = [1, 5, 0, 10]
+  d1 = {x > 2 for x in numbers}
+  all(d1)
+  d2 = {x > 2 for x in numbers}
+  any(d2)
+
+def case5():
+  numbers = [1, 5, 0, 10]
+  all({x > 2 for x in numbers})
+  any({x > 2 for x in numbers})