SONARPY-2950 Rule S7507 Incorrect default_factory keyword argument for defaultdict (#276)

GitOrigin-RevId: 67d157016615cfcd59e3b9995114a78097e44dbd

Author: thomas-serre-sonarsource

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

@@ -0,0 +1,49 @@
+/*
+ * 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.tree.CallExpression;
+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.tree.TreeUtils;
+import org.sonar.python.types.v2.TypeCheckBuilder;
+
+@Rule(key = "S7507")
+public class DefaultFactoryArgumentCheck extends PythonSubscriptionCheck {
+
+  private TypeCheckBuilder defaultDictTypeChecker = null;
+
+  @Override
+  public void initialize(Context context) {
+    context.registerSyntaxNodeConsumer(Tree.Kind.FILE_INPUT, ctx ->
+      defaultDictTypeChecker = ctx.typeChecker().typeCheckBuilder().isTypeWithFqn("collections.defaultdict")
+    );
+    context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> {
+      CallExpression callExpression = (CallExpression) ctx.syntaxNode();
+      if (defaultDictTypeChecker.check(callExpression.callee().typeV2()) != TriBool.TRUE) {
+        return;
+      }
+      RegularArgument defaultFactoryKeywordArgument = TreeUtils.argumentByKeyword("default_factory", callExpression.arguments());
+      if (defaultFactoryKeywordArgument != null) {
+        ctx.addIssue(defaultFactoryKeywordArgument, "Replace this keyword argument with a positional argument at the first place.");
+      }
+    });
+  }
+}

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

@@ -159,6 +159,7 @@ public Stream<Class<?>> getChecks() {
       DeadStoreCheck.class,
       DebugModeCheck.class,
       DedicatedAssertionCheck.class,
+      DefaultFactoryArgumentCheck.class,
       DeprecatedNumpyTypesCheck.class,
       DictionaryDuplicateKeyCheck.class,
       DictionaryStaticKeyCheck.class,

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

@@ -0,0 +1,34 @@
+<p>This rule raises an issue when <code>default_factory</code> is incorrectly supplied as a keyword argument during the initialization of
+<code>collections.defaultdict</code>.</p>
+<h2>Why is this an issue?</h2>
+<p>The <code>collections.defaultdict</code> class provides a dictionary-like structure that calls a factory function to supply missing values. This
+factory function (like <code>list</code>, <code>int</code>, or a <code>lambda</code>) is specified during initialization.</p>
+<p>Crucially, the <code>defaultdict</code> constructor signature requires the <code>default_factory</code> as its <strong>first positional
+argument</strong>. Any subsequent positional or keyword arguments are used to initialize the contents of the dictionary. This mirrors the behavior of
+the standard <code>dict</code> constructor.</p>
+<p>Providing the factory using the keyword <code>default_factory=…​</code>, as in <code>defaultdict(default_factory=list)</code>, is therefore
+incorrect and leads to unexpected behavior:</p>
+<ul>
+  <li> It does <strong>not</strong> set the default factory for missing keys. The <code>defaultdict</code> behaves like a regular <code>dict</code> in
+  this regard and will raise a <code>KeyError</code> when a missing key is accessed. </li>
+  <li> It <strong>does</strong> initialize the dictionary with a single key-value pair: <code>{'default_factory': list}</code>. </li>
+</ul>
+<h2>How to fix it</h2>
+<p>To fix this issue correctly initialize the <code>defaultdict</code> with a default factory by providing the factory callable as the first
+positional argument, not as a keyword argument.</p>
+<pre data-diff-id="1" data-diff-type="noncompliant">
+from collections import defaultdict
+
+d1 = defaultdict(default_factory=int) # Noncompliant: this creates a dictionary with a single key-value pair.
+</pre>
+<pre data-diff-id="1" data-diff-type="noncompliant">
+from collections import defaultdict
+
+d1 = defaultdict(int) # Compliant
+</pre>
+<h2>Resources</h2>
+<h3>Documentation</h3>
+<ul>
+  <li> Python Documentation - <a href="https://docs.python.org/3/library/collections.html#collections.defaultdict">collections.defaultdict</a> </li>
+</ul>
+

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

@@ -0,0 +1,21 @@
+{
+  "title": "\"defaultdict\" should not be initialized with \"default_factory\" as a keyword argument",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-7507",
+  "sqKey": "S7507",
+  "scope": "All",
+  "quickfix": "targeted",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "MEDIUM"
+    },
+    "attribute": "CONVENTIONAL"
+  }
+}

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

@@ -266,6 +266,7 @@
     "S7502",
     "S7503",
     "S7506",
+    "S7507",
     "S7510",
     "S7511"
   ]

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

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

@@ -0,0 +1,11 @@
+from collections import defaultdict, namedtuple
+
+d1 = defaultdict(default_factory=int) # Noncompliant {{Replace this keyword argument with a positional argument at the first place.}}
+#                ^^^^^^^^^^^^^^^^^^^
+
+d2 = defaultdict(int, default_factory=list) # Noncompliant {{Replace this keyword argument with a positional argument at the first place.}}
+#                     ^^^^^^^^^^^^^^^^^^^^
+
+d1 = defaultdict(int) # Compliant
+
+named_tuple = namedtuple('Point', ['x', 'y']) # Compliant, for coverage