SONARPY-2973 add quickfixes to S7498 (#275)

Co-authored-by: Thomas Serre <118730793+thomas-serre-sonarsource@users.noreply.github.com>
GitOrigin-RevId: 3f7a97bc58dd2d5d30df1e4bc82e3755b466c477

Author: 2 people

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

@@ -16,44 +16,52 @@
  */
 package org.sonar.python.checks;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 import org.sonar.check.Rule;
 import org.sonar.plugins.python.api.PythonSubscriptionCheck;
+import org.sonar.plugins.python.api.quickfix.PythonQuickFix;
 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.quickfix.TextEditUtils;
 import org.sonar.python.types.v2.TypeCheckBuilder;
+import org.sonar.python.types.v2.TypeCheckMap;
 
 @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 static final Map<String, String> COLLECTION_CONSTRUCTORS = Map.ofEntries(
+    Map.entry("list", "[]"),
+    Map.entry("tuple", "()"),
+    Map.entry("dict", "{}")
+  );
 
-  private List<TypeCheckBuilder> collectionConstructorTypeCheckers = null;
+  private TypeCheckMap<String> 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));
+      collectionConstructorTypeCheckers = new TypeCheckMap<>();
+      for (var constructorEntry : COLLECTION_CONSTRUCTORS.entrySet()) {
+        TypeCheckBuilder constructorTypeChecker = ctx.typeChecker().typeCheckBuilder().isTypeWithFqn(constructorEntry.getKey());
+        collectionConstructorTypeCheckers.put(constructorTypeChecker, constructorEntry.getValue());
       }
     });
 
     context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, ctx -> {
       CallExpression callExpression = (CallExpression) ctx.syntaxNode();
 
       if (isUnnecessaryCollectionConstructor(callExpression)) {
-        ctx.addIssue(callExpression.callee(), MESSAGE);
+        var issue = ctx.addIssue(callExpression.callee(), MESSAGE);
+        createQuickFix(callExpression).ifPresent(issue::addQuickFix);
       }
     });
   }
@@ -65,7 +73,7 @@ private boolean isUnnecessaryCollectionConstructor(CallExpression callExpression
 
   private boolean isCollectionConstructor(Expression calleeExpression) {
     var type = calleeExpression.typeV2();
-    return collectionConstructorTypeCheckers.stream().map(checker -> checker.check(type)).anyMatch(TriBool.TRUE::equals);
+    return collectionConstructorTypeCheckers.getOptionalForType(type).isPresent();
   }
 
   private static boolean isEmptyCall(CallExpression callExpression) {
@@ -87,4 +95,11 @@ private static boolean hasOnlyKeywordArguments(CallExpression callExpression) {
   private static boolean isKeywordArg(Argument arg) {
     return arg instanceof RegularArgument regularArg && regularArg.keywordArgument() != null;
   }
+
+  private Optional<PythonQuickFix> createQuickFix(CallExpression callExpression) {
+    return Optional.of(callExpression)
+      .filter(EmptyCollectionConstructorCheck::isEmptyCall)
+      .flatMap(callExpr -> collectionConstructorTypeCheckers.getOptionalForType(callExpression.callee().typeV2()))
+      .map(replacementStr -> PythonQuickFix.newQuickFix("Replace with literal", TextEditUtils.replace(callExpression, replacementStr)));
+  }
 }

python-checks/src/test/java/org/sonar/python/checks/EmptyCollectionConstructorCheckTest.java

@@ -16,7 +16,12 @@
  */
 package org.sonar.python.checks;
 
+import java.util.stream.Stream;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.sonar.python.checks.quickfix.PythonQuickFixVerifier;
 import org.sonar.python.checks.utils.PythonCheckVerifier;
 
 class EmptyCollectionConstructorCheckTest {
@@ -26,4 +31,29 @@ void test() {
     PythonCheckVerifier.verify("src/test/resources/checks/emptyCollectionConstructor.py", new EmptyCollectionConstructorCheck());
   }
 
+  private static Stream<Arguments> testQuickFixListConstructorSource() {
+    return Stream.of(
+      Arguments.of("dict()", "{}"),
+      Arguments.of("tuple()", "()"),
+      Arguments.of("list()", "[]")
+    );
+  }
+
+  @ParameterizedTest
+  @MethodSource("testQuickFixListConstructorSource")
+  void testQuickFixListConstructor(String before, String after) {
+    PythonQuickFixVerifier.verify(
+      new EmptyCollectionConstructorCheck(),
+      before,
+      after
+    );
+
+    PythonQuickFixVerifier.verifyQuickFixMessages(new EmptyCollectionConstructorCheck(), before, "Replace with literal");
+  }
+
+  @Test
+  void testNoQuickFix() {
+    PythonQuickFixVerifier.verifyNoQuickFixes(new EmptyCollectionConstructorCheck(), "dict(test=1)");
+  }
+
 }