SONARPY-1915 implement S6929 for PyTorch (#1962)

* SONARPY-1915 implement S6929 for PyTorch

* Implement QuickFix for TensorFlow reduce functions

* prevent raising an issue if an unpack expression is present

* SONARPY-1915 add test case for if fqn is null

* SONARPY-1915 use Expressions.containsSpreadOperator(...)

* SONARPY-1915 extract constant in test

Author: Seppli11

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

@@ -376,7 +376,7 @@ public static Iterable<Class> getChecks() {
       TfFunctionRecursivityCheck.class,
       TfInputShapeOnModelSubclassCheck.class,
       TfGatherDeprecatedValidateIndicesCheck.class,
-      TfSpecifyReductionAxisCheck.class,
+      TfPyTorchSpecifyReductionAxisCheck.class,
       ReferencedBeforeAssignmentCheck.class,
       RegexComplexityCheck.class,
       RegexLookaheadCheck.class,

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

@@ -0,0 +1,117 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) 2011-2024 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 GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * 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 GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.python.checks;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+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.quickfix.PythonQuickFix;
+import org.sonar.plugins.python.api.symbols.Symbol;
+import org.sonar.plugins.python.api.tree.CallExpression;
+import org.sonar.plugins.python.api.tree.Tree;
+import org.sonar.python.checks.utils.Expressions;
+import org.sonar.python.quickfix.TextEditUtils;
+import org.sonar.python.tree.TreeUtils;
+
+@Rule(key = "S6929")
+public class TfPyTorchSpecifyReductionAxisCheck extends PythonSubscriptionCheck {
+
+  private static final Set<String> TF_REDUCTION_FUNCTIONS = new HashSet<>(Arrays.asList("reduce_all", "reduce_mean", "reduce_any",
+    "reduce_euclidean_norm", "reduce_logsumexp",
+    "reduce_max", "reduce_min", "reduce_prod", "reduce_std", "reduce_sum", "reduce_variance"));
+  private static final Set<String> TF_REDUCTION_FUNCTIONS_FQN = new HashSet<>();
+  private static final String TF_MESSAGE = "Provide a value for the axis argument.";
+  public static final String AXIS_PARAMETER = "axis";
+  public static final int AXIS_PARAMETER_POSITION = 1;
+
+  static {
+    for (String reductionFunction : TF_REDUCTION_FUNCTIONS) {
+      TF_REDUCTION_FUNCTIONS_FQN.add("tensorflow.math." + reductionFunction);
+      TF_REDUCTION_FUNCTIONS_FQN.add("tensorflow.tf." + reductionFunction);
+    }
+  }
+
+  private static final String PY_TORCH_MESSAGE = "Provide a value for the dim argument.";
+  public static final String DIM_PARAMETER = "dim";
+  public static final int NO_POSITIONAL_ARG = -1;
+
+  /**
+   * Contains a list of reduction functions with a {@code dim} parameter and the position of the dim argument in that function.
+   */
+  private static final Map<String, Integer> PY_TORCH_REDUCTION_FUNCTIONS_DIM_POS = Map.ofEntries(
+    Map.entry("torch.argmin", 1),
+    Map.entry("torch.aminmax", NO_POSITIONAL_ARG),
+    Map.entry("torch.nanmean", 1),
+    Map.entry("torch.mode", 1),
+    Map.entry("torch.norm", 2),
+    Map.entry("torch.quantile", 2),
+    Map.entry("torch.nanquantile", 2),
+    Map.entry("torch.std", 1),
+    Map.entry("torch.std_mean", 1),
+    Map.entry("torch.unique", 4),
+    Map.entry("torch.unique_consecutive", 3),
+    Map.entry("torch.var", 1),
+    Map.entry("torch.var_mean", 1),
+    Map.entry("torch.count_nonzero", 1)
+  );
+
+  @Override
+  public void initialize(Context context) {
+    context.registerSyntaxNodeConsumer(Tree.Kind.CALL_EXPR, TfPyTorchSpecifyReductionAxisCheck::checkCallExpr);
+  }
+
+  private static void checkCallExpr(SubscriptionContext context) {
+    CallExpression callExpression = (CallExpression) context.syntaxNode();
+    Symbol symbol = callExpression.calleeSymbol();
+    if (symbol != null && !Expressions.containsSpreadOperator(callExpression.arguments())) {
+      if (isTfReductionMissingAxisArg(symbol, callExpression)) {
+        PreciseIssue issue = context.addIssue(callExpression.callee(), TF_MESSAGE);
+        createTfQuickFix(callExpression).ifPresent(issue::addQuickFix);
+      }
+
+      if (isPyTorchReductionMissingDimArg(symbol, callExpression)) {
+        context.addIssue(callExpression.callee(), PY_TORCH_MESSAGE);
+      }
+    }
+  }
+
+  private static Optional<PythonQuickFix> createTfQuickFix(CallExpression callExpression) {
+    if(callExpression.arguments().isEmpty()) {
+      return Optional.empty();
+    }
+    return Optional.of(PythonQuickFix.newQuickFix("Add axis parameter", TextEditUtils.insertBefore(callExpression.rightPar(), ", axis=None")));
+  }
+
+  private static boolean isTfReductionMissingAxisArg(Symbol symbol, CallExpression callExpression) {
+    return TF_REDUCTION_FUNCTIONS_FQN.contains(symbol.fullyQualifiedName())
+      && TreeUtils.nthArgumentOrKeyword(AXIS_PARAMETER_POSITION, AXIS_PARAMETER, callExpression.arguments()) == null;
+  }
+
+  private static boolean isPyTorchReductionMissingDimArg(Symbol symbol, CallExpression callExpression) {
+    String fqn = symbol.fullyQualifiedName();
+    return fqn != null && PY_TORCH_REDUCTION_FUNCTIONS_DIM_POS.containsKey(fqn)
+      && TreeUtils.nthArgumentOrKeyword(PY_TORCH_REDUCTION_FUNCTIONS_DIM_POS.get(fqn), DIM_PARAMETER, callExpression.arguments()) == null;
+  }
+}

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

@@ -0,0 +1,67 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) 2011-2024 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 GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * 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 GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.python.checks;
+
+import org.junit.jupiter.api.Test;
+import org.sonar.python.checks.quickfix.PythonQuickFixVerifier;
+import org.sonar.python.checks.utils.PythonCheckVerifier;
+
+class TfPyTorchSpecifyReductionAxisCheckTest {
+  private static final TfPyTorchSpecifyReductionAxisCheck CHECK_OBJECT = new TfPyTorchSpecifyReductionAxisCheck();
+
+  @Test
+  void testTensorFlow() {
+    PythonCheckVerifier.verify("src/test/resources/checks/tfSpecifyReductionAxis.py", CHECK_OBJECT);
+  }
+
+  @Test
+  void testTensorFlowQuickFix() {
+    PythonQuickFixVerifier.verify(CHECK_OBJECT,
+      """
+        from tensorflow import math
+        math.reduce_all(input)
+        """,
+      """
+        from tensorflow import math
+        math.reduce_all(input, axis=None)
+        """);
+
+    PythonQuickFixVerifier.verify(CHECK_OBJECT,
+      """
+        from tensorflow import math
+        math.reduce_all(input, keepdims=True)
+        """,
+      """
+        from tensorflow import math
+        math.reduce_all(input, keepdims=True, axis=None)
+        """);
+
+    PythonQuickFixVerifier.verifyNoQuickFixes(CHECK_OBJECT,
+        """
+        from tensorflow import math
+        math.reduce_all()
+        """);
+  }
+
+  @Test
+  void testPyTorch() {
+    PythonCheckVerifier.verify("src/test/resources/checks/pyTorchSpecifyReductionDim.py", CHECK_OBJECT);
+  }
+}

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

@@ -0,0 +1,99 @@
+import torch
+
+def argmin(input, dict_args):
+    torch.argmin(input) # Noncompliant {{Provide a value for the dim argument.}}
+   #^^^^^^^^^^^^
+
+    torch.argmin(**dict_args)
+    torch.argmin(input, 2)
+    torch.argmin(input, dim=2)
+
+
+def aminmax(input):
+    torch.aminmax(input) # Noncompliant
+    torch.aminmax(input, 2) #Noncompliant
+
+    torch.aminmax(input, dim=2)
+
+def nanmean(input):
+    torch.nanmean(input) # Noncompliant
+
+    torch.nanmean(input, 2)
+    torch.nanmean(input, dim=2)
+
+def mode(input):
+    torch.mode(input) # Noncompliant
+
+    torch.mode(input, 2)
+    torch.mode(input, dim=2)
+
+def norm(input, p):
+    torch.norm(input) # Noncompliant
+    torch.norm(input, 2) #Noncompliant
+
+    torch.norm(input, p, 2)
+    torch.norm(input, dim=2)
+
+def quantile(input, q):
+    torch.quantile(input) # Noncompliant
+    torch.quantile(input, 2) #Noncompliant
+
+    torch.quantile(input, q, 2)
+    torch.quantile(input, dim=2)
+
+def nanquantile(input, q):
+    torch.nanquantile(input) # Noncompliant
+    torch.nanquantile(input, 2) #Noncompliant
+
+    torch.nanquantile(input, q, 2)
+    torch.nanquantile(input, dim=2)
+
+def std(input):
+    torch.std(input) # Noncompliant
+
+    torch.std(input, 2)
+    torch.std(input, dim=2)
+
+def std_mean(input):
+    torch.std_mean(input) # Noncompliant
+
+    torch.std_mean(input, 2)
+    torch.std_mean(input, dim=2)
+
+def unique(input, sorted, return_inverse, return_counts):
+    torch.unique(input) # Noncompliant
+    torch.unique(input, sorted, return_inverse, 2) #Noncompliant
+
+    torch.unique(input, sorted, return_inverse, return_counts, 2)
+    torch.unique(input, dim=2)
+
+def unique_consecutive(input, return_inverse, return_counts):
+    torch.unique_consecutive(input) # Noncompliant
+    torch.unique_consecutive(input, return_inverse, return_counts) #Noncompliant
+
+    torch.unique_consecutive(input, return_inverse, return_counts, 2)
+    torch.unique_consecutive(input, dim=2)
+
+def var(input):
+    torch.var(input) # Noncompliant
+
+    torch.var(input, 2)
+    torch.var(input, dim=2)
+
+def var_mean(input):
+    torch.var_mean(input) # Noncompliant
+
+    torch.var_mean(input, 2)
+    torch.var_mean(input, dim=2)
+
+def count_nonzero(input):
+    torch.count_nonzero(input) # Noncompliant
+
+    torch.count_nonzero(input, 2)
+    torch.count_nonzero(input, dim=2)
+
+def multiple_imports():
+    from torch import var_mean
+    from other_module import var_mean
+
+    var_mean()