SONARPY-2994 Rule S7516: Unnecessary sort inside set (#305)

GitOrigin-RevId: 0666265776081f8127c1ce5b13e777337c61f638

Author: joke1196

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

@@ -408,6 +408,7 @@ public Stream<Class<?>> getChecks() {
       UnnecessaryLambdaMapCallCheck.class,
       UnnecessaryListCastCheck.class,
       UnnecessaryReversedCallCheck.class,
+      UnnecessarySortInsideSetCheck.class,
       UnnecessarySubscriptReversalCheck.class,
       UnquantifiedNonCapturingGroupCheck.class,
       UnreachableExceptCheck.class,

python-checks/src/main/java/org/sonar/python/checks/UnnecessarySortInsideSetCheck.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.Optional;
+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.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.tree.TreeUtils;
+import org.sonar.python.types.v2.TypeCheckBuilder;
+
+@Rule(key = "S7516")
+public class UnnecessarySortInsideSetCheck extends PythonSubscriptionCheck {
+
+  private static final String MESSAGE = "Remove either the call to set or sorted.";
+  private TypeCheckBuilder isSetTypeCheck;
+  private TypeCheckBuilder isSortedTypeCheck;
+
+  @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) {
+    isSetTypeCheck = ctx.typeChecker().typeCheckBuilder().isBuiltinWithName("set");
+    isSortedTypeCheck = ctx.typeChecker().typeCheckBuilder().isBuiltinWithName("sorted");
+  }
+
+  private void check(SubscriptionContext ctx) {
+    if (ctx.syntaxNode() instanceof CallExpression callExpression && isSetCall(callExpression)) {
+      TreeUtils.nthArgumentOrKeywordOptional(0, "", callExpression.arguments())
+        .map(RegularArgument::expression)
+        .ifPresent(argumentExpression -> {
+          if (isSortedCall(argumentExpression)) {
+            ctx.addIssue(callExpression.callee(), MESSAGE);
+          } else {
+            isAssignedToSortedCall(argumentExpression).ifPresent(sortedCallExpr -> {
+              PreciseIssue issue = ctx.addIssue(callExpression.callee(), MESSAGE);
+              issue.secondary(sortedCallExpr.callee(), "The list is sorted here.");
+            });
+          }
+        });
+    }
+  }
+
+  private Optional<CallExpression> isAssignedToSortedCall(Expression argumentExpression) {
+    if (argumentExpression instanceof Name name && getUsageCount(name) == 2) {
+      var assignedValue = Expressions.singleAssignedValue(name);
+      if (isSortedCall(assignedValue)) {
+        return Optional.of((CallExpression) assignedValue);
+      }
+    }
+    return Optional.empty();
+  }
+
+  private boolean isSetCall(CallExpression callExpression) {
+    return isSetTypeCheck.check(callExpression.callee().typeV2()) == TriBool.TRUE;
+  }
+
+  private boolean isSortedCall(@Nullable Expression expression) {
+    return expression instanceof CallExpression callExpression && isSortedTypeCheck.check(callExpression.callee().typeV2()) == TriBool.TRUE;
+  }
+
+  private static int getUsageCount(Name name) {
+    var symbol = name.symbolV2();
+    if (symbol == null) {
+      return 0;
+    }
+    return symbol.usages().size();
+  }
+}

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

@@ -0,0 +1,35 @@
+<p>This raises an issue when <code>set()</code> is directly around the output of <code>sorted()</code>.</p>
+<h2>Why is this an issue?</h2>
+<p>Calling <code>set(sorted(iterable))</code> is usually an indication of a misunderstanding of the desired outcome or an inefficient way to achieve
+it. The <code>sorted()</code> function produces a <strong>list</strong> of items in sorted order. Applying <code>set()</code> to this sorted list
+converts it into a set, which is an <strong>unordered</strong> collection of unique elements. The effort spent on sorting is immediately negated if
+the final result is an unordered set, as the order established by <code>sorted()</code> is discarded.</p>
+<p>If the intention is to obtain a sorted list of unique elements from an iterable, the pattern <code>set(sorted(iterable))</code> is inefficient. It
+first sorts all elements, including duplicates (which can be computationally expensive for large lists with many duplicates), and then removes these
+duplicates while also discarding the order established by <code>sorted()</code>. The more efficient and standard idiom for getting unique, sorted
+items is to deduplicate <strong>first</strong> using <code>set()</code>, and then sort the unique items: <code>sorted(set(iterable))</code>. This way,
+<code>sorted()</code> operates on a potentially smaller collection of unique items.</p>
+<h2>How to fix it</h2>
+<p>To fix this issue remove the call to either <code>set()</code> or <code>sorted()</code>, or call <code>sorted()</code> on the output of
+<code>set()</code>. If the goal is just to obtain unique items (and order is not important), then <code>set(iterable)</code> is sufficient; the
+<code>sorted()</code> call can be removed. If the goal is to obtain sorted items with duplicates preserved, then <code>sorted(iterable)</code> is
+sufficient; the <code>set()</code> call can be removed. If the goal is to obtain sorted items with duplicates removed, then
+<code>sorted(set(iterable))</code> is the correct way to proceed.</p>
+<h3>Code examples</h3>
+<h4>Noncompliant code example</h4>
+<pre data-diff-id="1" data-diff-type="noncompliant">
+data = [3, 4, 1 , 2]
+set(sorted(data)) # Noncompliant: set is called on a sorted list
+</pre>
+<h4>Compliant solution</h4>
+<pre data-diff-id="1" data-diff-type="compliant">
+data = [3, 4, 1 , 2]
+sorted(data) # Compliant
+</pre>
+<h2>Resources</h2>
+<h3>Documentation</h3>
+<ul>
+  <li> Python Documentation - <a href="https://docs.python.org/3/library/functions.html#sorted">sorted</a> </li>
+  <li> Python Documentation - <a href="https://docs.python.org/3/tutorial/datastructures.html#sets">sets</a> </li>
+</ul>
+

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

@@ -0,0 +1,21 @@
+{
+  "title": "\"sorted\" should not be wrapped directly inside \"set\"",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [],
+  "defaultSeverity": "Minor",
+  "ruleSpecification": "RSPEC-7516",
+  "sqKey": "S7516",
+  "scope": "All",
+  "quickfix": "targeted",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "LOW"
+    },
+    "attribute": "EFFICIENT"
+  }
+}

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

@@ -281,6 +281,7 @@
     "S7510",
     "S7511",
     "S7512",
+    "S7516",
     "S7517"
   ]
 }

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

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

@@ -0,0 +1,27 @@
+data = [3, 1, 4, 1, 5, 9]
+result = set(sorted(data)) # Noncompliant {{Remove either the call to set or sorted.}}
+#        ^^^
+
+sorted_data = sorted(data)
+#             ^^^^^^> {{The list is sorted here.}}
+assigned = set(sorted_data) # Noncompliant
+#          ^^^
+just_set = set(data) 
+
+unique_sorted = sorted(set(data)) 
+
+# ============== COVERAGE ================
+
+a = list(sorted(data))
+a = set([1,2])
+
+multiple_assignement = sorted(data)
+multiple_assignement = [1,3,3]
+b = set(multiple_assignement)
+
+unsorted = list(data)
+c = set(unsorted)
+
+from module import something
+assignment = something[0:1]
+d = set(assignement)