SONARPY-2943: Rule S7504 When iterating over an iterable object, using \\"list()\\" should be avoided (#285)

Co-authored-by: Sebastian Zumbrunn <sebastian.zumbrunn@sonarsource.com>
GitOrigin-RevId: a99b228c0c6801349c291111096c389d10888bb5

Author: 2 people

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

@@ -402,6 +402,7 @@ public Stream<Class<?>> getChecks() {
       UnnecessaryListComprehensionArgumentCheck.class,
       UnnecessaryComprehensionCheck.class,
       UnnecessaryLambdaMapCallCheck.class,
+      UnnecessaryListCastCheck.class,
       UnnecessaryReversedCallCheck.class,
       UnnecessarySubscriptReversalCheck.class,
       UnquantifiedNonCapturingGroupCheck.class,

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

@@ -0,0 +1,80 @@
+/*
+ * 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 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.ComprehensionFor;
+import org.sonar.plugins.python.api.tree.Expression;
+import org.sonar.plugins.python.api.tree.ForStatement;
+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.types.v2.TypeCheckBuilder;
+
+@Rule(key = "S7504")
+public class UnnecessaryListCastCheck extends PythonSubscriptionCheck {
+  private TypeCheckBuilder isListCallCheck;
+
+  @Override
+  public void initialize(Context context) {
+    context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, this::initChecks);
+    context.registerSyntaxNodeConsumer(Tree.Kind.FOR_STMT, this::checkForStatements);
+    context.registerSyntaxNodeConsumer(Tree.Kind.COMP_FOR, this::checkComprehensions);
+  }
+
+  private void initChecks(SubscriptionContext ctx) {
+    isListCallCheck = ctx.typeChecker().typeCheckBuilder().isBuiltinWithName("list");
+  }
+
+  private void checkForStatements(SubscriptionContext ctx) {
+    ForStatement stmt = ((ForStatement) ctx.syntaxNode());
+    checkListCastCheck(stmt.testExpressions(), ctx);
+  }
+
+  private void checkComprehensions(SubscriptionContext ctx) {
+    ComprehensionFor comprehensionFor = ((ComprehensionFor) ctx.syntaxNode());
+    checkListCastCheck(List.of(comprehensionFor.iterable()), ctx);
+  }
+
+  private void checkListCastCheck(List<Expression> expressions, SubscriptionContext ctx) {
+    hasListCallOnIterable(expressions)
+      .ifPresent(listCall -> ctx.addIssue(listCall.callee(), "Remove this unnecessary `list()` call on an already iterable object."));
+  }
+
+  private Optional<CallExpression> hasListCallOnIterable(List<Expression> testExpressions) {
+    if (testExpressions.size() == 1
+      && testExpressions.get(0) instanceof CallExpression callExpression
+      && isListCall(callExpression)
+      && hasOnlyOneRegularArg(callExpression)) {
+      return Optional.of(callExpression);
+    }
+    return Optional.empty();
+  }
+
+  private boolean isListCall(CallExpression callExpression) {
+    return isListCallCheck.check(callExpression.callee().typeV2()) == TriBool.TRUE;
+  }
+
+  private static boolean hasOnlyOneRegularArg(CallExpression callExpression) {
+    return callExpression.arguments().size() == 1 && callExpression.arguments().get(0) instanceof RegularArgument;
+  }
+}

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

@@ -0,0 +1,29 @@
+<p>This rule raises an issue when <code>list()</code> calls are applied to types that are already directly iterable with for-loops or
+comprehensions.</p>
+<h2>Why is this an issue?</h2>
+<p>When iterating over an already iterable object with a for loop or a comprehension, wrapping it with <code>list()</code> adds meaningless clutter
+that doesn’t provide any functional value. Additionally, it creates unnecessary overhead by generating an intermediate list in memory, which
+inefficiently consumes memory and can degrade performance, especially with large data structures. Iterating directly over the original object is
+cleaner and more efficient.</p>
+<h2>How to fix it</h2>
+<p>Remove the redundant <code>list()</code> call and iterate directly over the original iterable.</p>
+<h3>Code examples</h3>
+<h4>Noncompliant code example</h4>
+<pre data-diff-id="1" data-diff-type="noncompliant">
+some_iterable = range(10)
+for i in list(some_iterable): # Noncompliant: unnecessary list() call
+    print(i)
+</pre>
+<h4>Compliant solution</h4>
+<pre data-diff-id="1" data-diff-type="compliant">
+some_iterable = range(10)
+for i in some_iterable: # Compliant
+    print(i)
+</pre>
+<h2>Resources</h2>
+<h3>Documentation</h3>
+<ul>
+  <li> Python Documentation - <a href="https://docs.python.org/3/glossary.html#term-iterable">Iterable Glossary Entry</a> </li>
+  <li> Python Documentation - <a href="https://docs.python.domainunion.de/3/library/stdtypes.html#list">list()</a> </li>
+</ul>
+

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

@@ -0,0 +1,21 @@
+{
+  "title": "When iterating over an iterable object, using \"list()\" should be avoided",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [],
+  "defaultSeverity": "Minor",
+  "ruleSpecification": "RSPEC-7504",
+  "sqKey": "S7504",
+  "scope": "All",
+  "quickfix": "targeted",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "LOW"
+    },
+    "attribute": "CONVENTIONAL"
+  }
+}

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

@@ -272,6 +272,7 @@
     "S7501",
     "S7502",
     "S7503",
+    "S7504",
     "S7505",
     "S7506",
     "S7507",

python-checks/src/test/java/org/sonar/python/checks/UnnecessaryListCastCheckTest.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 UnnecessaryListCastCheckTest {
+
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/unnecessaryListCast.py", new UnnecessaryListCastCheck());
+  }
+
+}

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

@@ -0,0 +1,48 @@
+
+[i for i in list([1,2,3])] # Noncompliant {{Remove this unnecessary `list()` call on an already iterable object.}}
+#           ^^^^
+
+{i for i in list([1,2,3])} # Noncompliant
+#           ^^^^
+
+for i in list(range(2)): # Noncompliant 
+#        ^^^^
+    print(i)
+
+
+some_iter = [1,2,5]
+for i in list(some_iter): # Noncompliant 
+    #    ^^^^
+    print(i)
+
+def foo(a: Union[str, Iterable[str]]):
+  for i in list(a): # Noncompliant
+      print(i)
+
+
+list(range(32)) # Ok we only raise in for loops and comprehensions
+
+
+for i in list(*some_iter): # Ok
+    print(i)
+
+from module import some_val
+
+for i in list(some_val): # Noncompliant
+    print(i)
+
+#=============== COVERAGE =============
+
+for i,y in list(range(3)), list(range(4)): 
+    print(i)
+
+for i in list([3,5], [1,3]): # incorrect syntax
+    print(i)
+
+for i in [1,2]:
+    print(i)
+
+from module import test
+
+for i in test("1"):
+    print(i)