SONARPY-2945 Rule S7505: Unnecessary map usage - rewrite using a generator expression/<list/set/dict> comprehension (#288)

GitOrigin-RevId: 8e2cd0a07312662226af9c8d7ed9923775be49c3

Author: maksim-grebeniuk-sonarsource

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

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

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

@@ -0,0 +1,84 @@
+/*
+ * 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 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.LambdaExpression;
+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.semantic.v2.SymbolV2;
+import org.sonar.python.tree.TreeUtils;
+import org.sonar.python.types.v2.TypeCheckBuilder;
+
+@Rule(key = "S7505")
+public class UnnecessaryLambdaMapCallCheck extends PythonSubscriptionCheck {
+  private TypeCheckBuilder isMapTypeCheck;
+
+  @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) {
+    isMapTypeCheck = ctx.typeChecker().typeCheckBuilder().isTypeWithName("map");
+  }
+
+  private void check(SubscriptionContext ctx) {
+    var callExpression = (CallExpression) ctx.syntaxNode();
+    if (isMapCall(callExpression)) {
+      TreeUtils.nthArgumentOrKeywordOptional(0, "", callExpression.arguments())
+        .map(RegularArgument::expression)
+        .ifPresent(argumentExpression -> {
+          if (isLambda(argumentExpression) || isAssignedToLambda(argumentExpression)) {
+            ctx.addIssue(callExpression, "Replace this map call with a comprehension.");
+          }
+        });
+    }
+  }
+
+  private boolean isMapCall(CallExpression callExpression) {
+    return isMapTypeCheck.check(callExpression.callee().typeV2()) == TriBool.TRUE;
+  }
+
+  private static boolean isLambda(@Nullable Expression argumentExpression) {
+    return argumentExpression instanceof LambdaExpression;
+  }
+
+  private static boolean isAssignedToLambda(Expression argumentExpression) {
+    return argumentExpression instanceof Name name
+           && getUsageCount(name) == 2
+           && isLambda(Expressions.singleAssignedValue(name));
+  }
+
+  private static int getUsageCount(Name name) {
+    return Optional.ofNullable(name.symbolV2())
+      .map(SymbolV2::usages)
+      .map(List::size)
+      .orElse(0);
+  }
+}

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

@@ -0,0 +1,38 @@
+<p>This rule raises an issue when a collection is created with the use of a <code>lambda</code> function inside of <code>map()</code>.</p>
+<h2>Why is this an issue?</h2>
+<p>The <code>map()</code> function applies a given function to each item of an iterable. When this function is a <code>lambda</code>, especially a
+simple one, the resulting code can sometimes be less readable than its comprehension or generator expression equivalent. For example: A comprehension
+like <code>[x * 2 for x in nums]</code> is more straightforward to read and understand at a glance than <code>list(map(lambda x: x * 2, nums))</code>.
+The logic is more self-contained and doesn’t require mentally parsing the <code>map</code> and <code>lambda</code> separately.</p>
+<p>Using <code>map()</code> could also have an impact on performance. While <code>map()</code> can be very efficient when used with built-in functions
+or pre-defined functions written in C, the use of a Python <code>lambda</code> introduces function call overhead for each element in the iterable.</p>
+<h2>How to fix it</h2>
+<p>To fix this issue replace the <code>map(lambda …​)</code> construct with an equivalent generator expression or a list, set, or dictionary
+comprehension.</p>
+<ul>
+  <li> Replace <code>map(lambda var: expression, iterable)</code> with the generator expression <code>(expression for var in iterable)</code>. </li>
+  <li> Replace <code>list(map(lambda var: expression, iterable))</code> with the list comprehension <code>[expression for var in iterable]</code>.
+  </li>
+  <li> Replace <code>set(map(lambda var: expression, iterable))</code> with the set comprehension <code>{expression for var in iterable}</code>. </li>
+  <li> Replace <code>dict(map(lambda var: (key_expr, value_expr), iterable))</code> with the dictionary comprehension <code>{key_expr: value_expr for
+  var in iterable}</code> . </li>
+</ul>
+<pre data-diff-id="1" data-diff-type="noncompliant">
+nums = [1, 2, 3, 4]
+
+list_map = list(map(lambda num: num * 2, nums)) # Noncompliant: the map and lambda function can be replaced by a list-comprehension
+</pre>
+<pre data-diff-id="1" data-diff-type="compliant">
+nums = [1, 2, 3, 4]
+
+list_comp = [num * 2 for num in nums] # Compliant
+</pre>
+<h2>Resources</h2>
+<h3>Documentation</h3>
+<ul>
+  <li> Python Documentation - <a href="https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions">List Comprehensions</a> </li>
+  <li> Python Documentation - <a href="https://docs.python.org/3/tutorial/classes.html#generator-expressions">Generator Expressions</a> </li>
+  <li> Python Documentation - <a href="https://docs.python.org/3/library/functions.html#map">map()</a> </li>
+  <li> Python Documentation - <a href="https://docs.python.org/3/reference/expressions.html#lambda">Lambdas</a> </li>
+</ul>
+

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

@@ -0,0 +1,21 @@
+{
+  "title": "Generators and comprehensions should be preferred over the usage of \"map\" and \"lambda\" when creating collection",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-7505",
+  "sqKey": "S7505",
+  "scope": "All",
+  "quickfix": "infeasible",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "LOW"
+    },
+    "attribute": "CONVENTIONAL"
+  }
+}

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

@@ -270,6 +270,7 @@
     "S7501",
     "S7502",
     "S7503",
+    "S7505",
     "S7506",
     "S7507",
     "S7510",

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

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

@@ -0,0 +1,31 @@
+
+def case1():
+  nums = [1, 2, 3, 4]
+  gen_map = map(lambda x: x + 1, nums) # Noncompliant
+  l = lambda x: x + 1
+  gen_map = map(l, nums) # Noncompliant
+
+
+def case2():
+  nums = [1, 2, 3, 4]
+  gen_map = not_a_map_call(lambda x: x + 1, nums)
+
+def case3():
+  nums = [1, 2, 3, 4]
+  l = not_a_lambda
+  gen_map = map(l, nums)
+
+def case4():
+  gen_map = map()
+
+def case5():
+  nums = [1, 2, 3, 4]
+  l = lambda x: x + 1
+  usage_of_lambda(l)
+  gen_map = map(l, nums)
+
+def case5():
+  nums = [1, 2, 3, 4]
+  l = "not a lambda with more usages"
+  x = l
+  gen_map = map(l, nums)