SONARPY-2940 Rule S7498: Unnecessary empty <dict/list/tuple> call - rewrite as a literal (#261)

GitOrigin-RevId: e4ce22778fbcddd91e4d6cdd4133842cf6042532

Author: Seppli11

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

@@ -0,0 +1,90 @@
+/*
+ * 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.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.sonar.check.Rule;
+import org.sonar.plugins.python.api.PythonSubscriptionCheck;
+import org.sonar.plugins.python.api.tree.Argument;
+import org.sonar.plugins.python.api.tree.CallExpression;
+import org.sonar.plugins.python.api.tree.Expression;
+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 = "S7498")
+public class EmptyCollectionConstructorCheck extends PythonSubscriptionCheck {
+
+  private static final String MESSAGE = "Replace this constructor call with a literal.";
+  private static final List<String> COLLECTION_CONSTRUCTORS = Arrays.asList("dict", "list", "tuple");
+
+  private List<TypeCheckBuilder> collectionConstructorTypeCheckers = null;
+  private TypeCheckBuilder dictChecker = null;
+
+  @Override
+  public void initialize(Context context) {
+    context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, ctx -> {
+      dictChecker = ctx.typeChecker().typeCheckBuilder().isTypeWithFqn("dict");
+
+      collectionConstructorTypeCheckers = new ArrayList<>();
+      for (String constructor : COLLECTION_CONSTRUCTORS) {
+        collectionConstructorTypeCheckers.add(ctx.typeChecker().typeCheckBuilder().isTypeWithFqn(constructor));
+      }
+    });
+
+    context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> {
+      CallExpression callExpression = (CallExpression) ctx.syntaxNode();
+
+      if (isUnnecessaryCollectionConstructor(callExpression)) {
+        ctx.addIssue(callExpression.callee(), MESSAGE);
+      }
+    });
+  }
+
+  private boolean isUnnecessaryCollectionConstructor(CallExpression callExpression) {
+    return (isCollectionConstructor(callExpression.callee()) && isEmptyCall(callExpression))
+      || isDictConstructorWithOnlyMappings(callExpression);
+  }
+
+  private boolean isCollectionConstructor(Expression calleeExpression) {
+    var type = calleeExpression.typeV2();
+    return collectionConstructorTypeCheckers.stream().map(checker -> checker.check(type)).anyMatch(TriBool.TRUE::equals);
+  }
+
+  private static boolean isEmptyCall(CallExpression callExpression) {
+    return callExpression.arguments().isEmpty();
+  }
+
+  private boolean isDictConstructorWithOnlyMappings(CallExpression callExpression) {
+    return isDictConstructor(callExpression) && hasOnlyKeywordArguments(callExpression);
+  }
+
+  private boolean isDictConstructor(CallExpression callExpression) {
+    return dictChecker.check(callExpression.callee().typeV2()) == TriBool.TRUE;
+  }
+
+  private static boolean hasOnlyKeywordArguments(CallExpression callExpression) {
+    return callExpression.arguments().stream().allMatch(EmptyCollectionConstructorCheck::isKeywordArg);
+  }
+
+  private static boolean isKeywordArg(Argument arg) {
+    return arg instanceof RegularArgument regularArg && regularArg.keywordArgument() != null;
+  }
+}

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

@@ -177,6 +177,7 @@ public Stream<Class<?>> getChecks() {
       ElseAfterLoopsWithoutBreakCheck.class,
       EmailSendingCheck.class,
       EmptyAlternativeCheck.class,
+      EmptyCollectionConstructorCheck.class,
       EmptyGroupCheck.class,
       EmptyFunctionCheck.class,
       EmptyNestedBlockCheck.class,

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

@@ -0,0 +1,48 @@
+<p>This rule raises an issue when <code>dict()</code>, <code>list()</code>, or <code>tuple()</code> are used to create empty collections or to
+initialize dictionaries with keyword arguments.</p>
+<h2>Why is this an issue?</h2>
+<p>Python provides concise literal syntax for creating empty dictionaries (<code>{}</code>), lists (<code>[]</code>), and tuples (<code>()</code>). It
+also offers a direct literal syntax for initializing dictionaries with key-value pairs (e.g., <code>{'a': 1, 'b': 2}</code>).</p>
+<p>Using the function calls <code>dict()</code>, <code>list()</code>, and <code>tuple()</code> for these purposes is generally less preferred for a
+few reasons:</p>
+<ul>
+  <li> Readability and Directness: Literals are often considered more "Pythonic" and directly express the intent of creating an empty container or a
+  dictionary with specific initial values. </li>
+  <li> Consistency: Python encourages the use of literals where they are clear and effective. </li>
+  <li> Performance: Calling a function involves overhead, including name lookup for <code>dict</code>, <code>list</code>, or <code>tuple</code> in the
+  current scope. While often negligible for single calls, using literals is a direct instruction to the interpreter and can be marginally faster,
+  especially in performance-sensitive code or tight loops. </li>
+</ul>
+<p>Specifically, the following patterns are discouraged:</p>
+<ul>
+  <li> Using <code>dict()</code> to create an empty dictionary instead of <code>{}</code>. </li>
+  <li> Using <code>list()</code> to create an empty list instead of <code>[]</code>. </li>
+  <li> Using <code>tuple()</code> to create an empty tuple instead of <code>()</code>. </li>
+  <li> Using <code>dict(key='value', …​)</code> to initialize a dictionary instead of <code>{'key': 'value', …​}</code> when keys are simple strings
+  valid as identifiers. </li>
+</ul>
+<p>While the functional difference is minimal for creating empty collections or simple dictionaries, adopting literals promotes a more direct and
+idiomatic coding style.</p>
+<h2>How to fix it</h2>
+<p>To fix this replace the function calls <code>dict()</code>, <code>list()</code>, and <code>tuple()</code> with their equivalent literal syntax.</p>
+<ul>
+  <li> To create an empty dictionary, replace <code>dict()</code> with <code>{}</code>. </li>
+  <li> To create an empty list, replace <code>list()</code> with <code>[]</code>. </li>
+  <li> To create an empty tuple, replace <code>tuple()</code> with <code>()</code>. </li>
+  <li> To initialize a dictionary with keyword arguments (where keys are simple strings that are valid identifiers), replace <code>dict(key1=value1,
+  key2=value2)</code> with <code>{'key1': value1, 'key2': value2}</code>. </li>
+</ul>
+<pre data-diff-id="1" data-diff-type="noncompliant">
+empty_d = dict() # Noncompliant: the dict constructor is used instead of the literal syntax
+</pre>
+<pre data-diff-id="1" data-diff-type="compliant">
+empty_d = {} # Compliant
+</pre>
+<h2>Resources</h2>
+<h3>Documentation</h3>
+<ul>
+  <li> Python Documentation - <a href="https://docs.python.org/3/library/stdtypes.html#dict">dict()</a> </li>
+  <li> Python Documentation - <a href="https://docs.python.org/3/library/stdtypes.html#list">list()</a> </li>
+  <li> Python Documentation - <a href="https://docs.python.org/3/library/stdtypes.html#tuple">tuple()</a> </li>
+</ul>
+

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

@@ -0,0 +1,21 @@
+{
+  "title": "Literal syntax should be preferred when creating empty collections or dictionaries with keyword arguments",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [],
+  "defaultSeverity": "Minor",
+  "ruleSpecification": "RSPEC-7498",
+  "sqKey": "S7498",
+  "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

@@ -258,6 +258,7 @@
     "S7488",
     "S7491",
     "S7493",
+    "S7498",
     "S7499",
     "S7501",
     "S7510"

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

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

@@ -0,0 +1,51 @@
+empty_dict1 = dict()  # Noncompliant {{Replace this constructor call with a literal.}}
+#             ^^^^
+empty_list = list()  # Noncompliant
+empty_tuple = tuple()  # Noncompliant
+empty_set = set()
+
+user = dict(name="John", age=30)  # Noncompliant
+
+empty_dict2 = {}
+empty_list2 = []
+empty_tuple2 = ()
+
+user2 = {"name": "John", "age": 30}
+
+nums_list = list([1, 2, 3])
+nums_tuple = tuple([1, 2, 3])
+combined_dict = dict({"a": 1})
+
+
+dict_from_items = dict([('a', 1), ('b', 2)])
+dict_from_mapping = dict({'one': 1, 'two': 2})
+
+def passing_variable(collection):
+    list(collection)
+    tuple(collection)
+    set(collection)
+    dict(collection)
+    dict(collection, b=2)
+    dict(*collection)
+    dict(**collection)
+
+dict_comp = dict((k, v) for k, v in [('a', 1), ('b', 2)])
+list_comp = list(x for x in range(3))
+tuple_comp = tuple(x for x in range(3))
+
+dict({"a": 1}, b=2)
+
+some_unrelated_method()
+a.some_unrelated_method()
+
+def overwriting_collection_constructors():
+    def list(): pass
+    def tuple(): pass
+    def set(): pass
+    def dict(): pass
+
+    # compliant since the built-in functions are shadowed
+    list()
+    tuple()
+    set()
+    dict()