SONARPY-2998 Rule S7519: Unnecessary dict comprehension - rewrite using dict.fromkeys() (#308)

GitOrigin-RevId: 88768da1ca860eb29e8fd52f5199fbd6303cfc4b

Author: maksim-grebeniuk-sonarsource

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

@@ -0,0 +1,64 @@
+/*
+ * 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.sonar.check.Rule;
+import org.sonar.plugins.python.api.PythonSubscriptionCheck;
+import org.sonar.plugins.python.api.SubscriptionContext;
+import org.sonar.plugins.python.api.tree.DictCompExpression;
+import org.sonar.plugins.python.api.tree.Name;
+import org.sonar.plugins.python.api.tree.Tree;
+import org.sonar.python.semantic.v2.UsageV2;
+import org.sonar.python.tree.TreeUtils;
+
+@Rule(key = "S7519")
+public class ConstantValueDictComprehensionCheck extends PythonSubscriptionCheck {
+  public static final String MESSAGE = "Replace with dict fromkeys method call";
+
+
+  @Override
+  public void initialize(Context context) {
+    context.registerSyntaxNodeConsumer(Tree.Kind.DICT_COMPREHENSION, ConstantValueDictComprehensionCheck::checkDictComprehension);
+  }
+
+  private static void checkDictComprehension(SubscriptionContext ctx) {
+    var dictComprehension = (DictCompExpression) ctx.syntaxNode();
+    if (isConstantValueDictComprehension(dictComprehension)) {
+      ctx.addIssue(dictComprehension, MESSAGE);
+    }
+  }
+
+  private static boolean isConstantValueDictComprehension(DictCompExpression dictComprehension) {
+    if (!(dictComprehension.keyExpression() instanceof Name)
+        || dictComprehension.comprehensionFor().nestedClause() != null) {
+      return false;
+    }
+
+    if (dictComprehension.valueExpression() instanceof Name valueName) {
+      var valueSymbol = valueName.symbolV2();
+      return valueSymbol == null || !valueSymbol
+        .usages()
+        .stream()
+        .map(UsageV2::tree)
+        .allMatch(ut -> TreeUtils.firstAncestor(ut, dictComprehension::equals) != null);
+    } else {
+      return dictComprehension.valueExpression().is(Tree.Kind.NONE, Tree.Kind.STRING_LITERAL, Tree.Kind.NUMERIC_LITERAL, Tree.Kind.BOOLEAN_LITERAL_PATTERN);
+    }
+  }
+
+
+}

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

@@ -156,6 +156,7 @@ public Stream<Class<?>> getChecks() {
       ConfusingWalrusCheck.class,
       ConsistentReturnCheck.class,
       ConstantConditionCheck.class,
+      ConstantValueDictComprehensionCheck.class,
       CorsCheck.class,
       CsrfDisabledCheck.class,
       DataEncryptionCheck.class,

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

@@ -0,0 +1,28 @@
+<p>This rule raises an issue when a dictionary comprehension is used to create a dictionary where all values are the same constant.</p>
+<h2>Why is this an issue?</h2>
+<p>Using a dictionary comprehension to build a dictionary where every key maps to the exact same constant value e.g., <code>{k: 1 for k in
+keys}</code> is less efficient and less idiomatic than using the <code>dict.fromkeys()</code> class method. <code>dict.fromkeys()</code> is
+specifically designed for this use case and offers better performance, especially for large iterables, as it avoids the overhead of creating and
+processing individual key-value pairs in a comprehension.</p>
+<h2>How to fix it</h2>
+<p>Rewrite the dictionary comprehension <code>{x: constant for x in iterable}</code> as <code>dict.fromkeys(iterable, constant)</code>. If the
+constant value is <code>None</code>, you can omit the value argument in <code>dict.fromkeys()</code>, as it defaults to <code>None</code>.</p>
+<h3>Code examples</h3>
+<h4>Noncompliant code example</h4>
+<pre data-diff-id="1" data-diff-type="noncompliant">
+keys = ['a', 'b', 'c']
+
+dict_comp_one = {k: 1 for k in keys} # Noncompliant
+</pre>
+<h4>Compliant solution</h4>
+<pre data-diff-id="1" data-diff-type="compliant">
+keys = ['a', 'b', 'c']
+
+dict_fromkeys_one = dict.fromkeys(keys, 1)
+</pre>
+<h2>Resources</h2>
+<h3>Documentation</h3>
+<ul>
+  <li> Python Documentation - <a href="https://docs.python.org/3/library/stdtypes.html#dict.fromkeys">dict.fromkeys</a> </li>
+</ul>
+

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

@@ -0,0 +1,21 @@
+{
+  "title": "Populating a dictionary with a constant value should be done with dict.fromkeys() method call",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "1min"
+  },
+  "tags": [],
+  "defaultSeverity": "Minor",
+  "ruleSpecification": "RSPEC-7519",
+  "sqKey": "S7519",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "LOW"
+    },
+    "attribute": "CONVENTIONAL"
+  }
+}

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

@@ -282,6 +282,7 @@
     "S7511",
     "S7512",
     "S7516",
-    "S7517"
+    "S7517",
+    "S7519"
   ]
 }

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

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

@@ -0,0 +1,21 @@
+def case1():
+    keys = ['a', 'b', 'c']
+    some_v = "v"
+    # Non-compliant
+    dict_comp_one = {k: 1 for k in keys} # Noncompliant
+    dict_comp_one = {k: "1" for k in keys} # Noncompliant
+    dict_comp_one = {k: True for k in keys} # Noncompliant
+    dict_comp_none = {k: None for k in keys} # Noncompliant
+    dict_comp_v = {k: some_v for k in keys} # Noncompliant
+
+    some_dict = {"a": "1", "b": "2"}
+    one_more = {k: some_v for k, v in some_dict} # Noncompliant
+    one_more = {k: v for k, v in some_dict}
+
+def case2():
+    dict_of_dicts = [{"a": 1, "b": 2}, {"c": 3, "d": 4}]
+    result = {k: v for result in dict_of_dicts for k, v in result.items()}
+
+def case3():
+    some_list = ["a/b", "c/d"]
+    result = {q.split("/")[-1]: q for q in some_list}