SONARPY-1898: Subclasses of "torch.nn.Module" should call the initializer (#1974)

* SONARPY-1898 update metadata

* SONARPY-1898 implement basic detection logic

* SONARPY-1898 add test cases and clean up

* SONARPY-1898 add license header and add to checklist

* SONARPY-1898 fix sonarqube issues

* SONARPY-1898 add test coverage

* SONARPY-1898 add quickfix

* SONARPY-1898 address reviewer comments

* SONARPY-1898 add coverage

Author: Seppli11

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

@@ -369,6 +369,7 @@ public static Iterable<Class> getChecks() {
       TorchAutogradVariableShouldNotBeUsedCheck.class,
       TorchLoadLeadsToUntrustedCodeExecutionCheck.class,
       TorchModuleModeShouldBeSetAfterLoadingCheck.class,
+      TorchModuleShouldCallInitCheck.class,
       TrailingCommentCheck.class,
       TrailingWhitespaceCheck.class,
       TypeAliasAnnotationCheck.class,

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

@@ -0,0 +1,107 @@
+/*
+ * 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.Optional;
+import javax.annotation.Nullable;
+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.quickfix.PythonTextEdit;
+import org.sonar.plugins.python.api.symbols.FunctionSymbol;
+import org.sonar.plugins.python.api.symbols.Symbol;
+import org.sonar.plugins.python.api.tree.ArgList;
+import org.sonar.plugins.python.api.tree.CallExpression;
+import org.sonar.plugins.python.api.tree.ClassDef;
+import org.sonar.plugins.python.api.tree.Expression;
+import org.sonar.plugins.python.api.tree.FunctionDef;
+import org.sonar.plugins.python.api.tree.QualifiedExpression;
+import org.sonar.plugins.python.api.tree.RegularArgument;
+import org.sonar.plugins.python.api.tree.Tree;
+import org.sonar.python.checks.utils.CheckUtils;
+import org.sonar.python.quickfix.TextEditUtils;
+import org.sonar.python.tree.TreeUtils;
+
+@Rule(key = "S6978")
+public class TorchModuleShouldCallInitCheck extends PythonSubscriptionCheck {
+  private static final String TORCH_NN_MODULE = "torch.nn.Module";
+  private static final String MESSAGE = "Add a call to super().__init__().";
+  private static final String SECONDARY_MESSAGE = "Inheritance happens here";
+  public static final String QUICK_FIX_MESSAGE = "insert call to super constructor";
+
+  @Override
+  public void initialize(Context context) {
+    context.registerSyntaxNodeConsumer(Tree.Kind.FUNCDEF, ctx -> {
+      FunctionDef funcDef = (FunctionDef) ctx.syntaxNode();
+      ClassDef classDef = CheckUtils.getParentClassDef(funcDef);
+      if (isInheritingFromTorchModule(classDef) && isConstructor(funcDef) && isMissingSuperCall(funcDef)) {
+        PreciseIssue issue = ctx.addIssue(funcDef.name(), MESSAGE);
+        issue.secondary(classDef.name(), SECONDARY_MESSAGE);
+        createQuickFix(funcDef).ifPresent(issue::addQuickFix);
+      }
+    });
+  }
+
+  private static boolean isConstructor(FunctionDef funcDef) {
+    FunctionSymbol symbol = TreeUtils.getFunctionSymbolFromDef(funcDef);
+    return symbol != null && "__init__".equals(symbol.name()) && funcDef.isMethodDefinition();
+  }
+
+  private static boolean isInheritingFromTorchModule(@Nullable ClassDef classDef) {
+    if (classDef == null) return false;
+    ArgList args = classDef.args();
+    return args != null && args.arguments().stream()
+      .flatMap(TreeUtils.toStreamInstanceOfMapper(RegularArgument.class))
+      .map(arg -> getQualifiedName(arg.expression()))
+      .anyMatch(expr -> expr.filter(TORCH_NN_MODULE::equals).isPresent());
+  }
+
+  private static Optional<String> getQualifiedName(Expression node) {
+    return TreeUtils.getSymbolFromTree(node).flatMap(symbol -> Optional.ofNullable(symbol.fullyQualifiedName()));
+  }
+
+  private static boolean isMissingSuperCall(FunctionDef funcDef) {
+    ClassDef parentClassDef = CheckUtils.getParentClassDef(funcDef);
+    return parentClassDef != null && !TreeUtils.hasDescendant(parentClassDef, t -> t.is(Tree.Kind.CALL_EXPR) && isSuperConstructorCall((CallExpression) t));
+  }
+
+  private static boolean isSuperConstructorCall(CallExpression callExpr) {
+    return callExpr.callee() instanceof QualifiedExpression qualifiedCallee && isSuperCall(qualifiedCallee.qualifier()) && "__init__".equals(qualifiedCallee.name().name());
+  }
+
+  private static boolean isSuperCall(Expression qualifier) {
+    if (qualifier instanceof CallExpression callExpression) {
+      Symbol superSymbol = callExpression.calleeSymbol();
+      return superSymbol != null && "super".equals(superSymbol.name());
+    }
+    return false;
+  }
+
+  private static Optional<PythonQuickFix> createQuickFix(FunctionDef functionDef) {
+    // it is hard to find the correct indentation when the function def and the body is on the same line (e.g. def test(): pass).
+    // Thus we don't produce a quickfix in those cases
+    if(functionDef.colon().line() == functionDef.body().firstToken().line()) {
+      return Optional.empty();
+    }
+
+    PythonTextEdit pythonTextEdit = TextEditUtils.insertLineAfter(functionDef.colon(), functionDef.body(), "super().__init__()");
+    return Optional.of(PythonQuickFix.newQuickFix(QUICK_FIX_MESSAGE, pythonTextEdit));
+  }
+}

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

@@ -0,0 +1,41 @@
+<p>This rule raises an issue when a class is a Pytorch module and does not call the <code>super().__init__()</code> method in its constructor.</p>
+<h2>Why is this an issue?</h2>
+<p>To provide the AutoGrad functionality, the Pytorch library needs to set up the necessary data structures in the base class. If the
+<code>super().__init__()</code> method is not called, the module will not be able to keep track of its parameters and other attributes.</p>
+<p>For example, when trying to instantiate a module like <code>nn.Linear</code> without calling the <code>super().__init__()</code> method, the
+instantiation will fail when it tries to register it as a submodule of the parent module.</p>
+<pre>
+import torch.nn as nn
+
+class MyCustomModule(nn.Module):
+    def __init__(self, input_size, output_size):
+        self.fc = nn.Linear(input_size, output_size)
+
+model = MyCustomModule(10, 5) # AttributeError: cannot assign module before Module.__init__() call
+</pre>
+<h2>How to fix it</h2>
+<p>Add a call to <code>super().__init__()</code> at the beginning of the constructor of the class.</p>
+<h3>Code examples</h3>
+<h4>Noncompliant code example</h4>
+<pre data-diff-id="1" data-diff-type="noncompliant">
+import torch.nn as nn
+
+class MyCustomModule(nn.Module):
+    def __init__(self, input_size, output_size):
+        self.fc = nn.Linear(input_size, output_size) # Noncompliant: creating an nn.Linear without calling super().__init__()
+</pre>
+<h4>Compliant solution</h4>
+<pre data-diff-id="1" data-diff-type="compliant">
+import torch.nn as nn
+
+class MyCustomModule(nn.Module):
+    def __init__(self, input_size, output_size):
+        super().__init__()
+        self.fc = nn.Linear(input_size, output_size)
+</pre>
+<h2>Resources</h2>
+<h3>Documentation</h3>
+<ul>
+  <li> Pytorch documentation - <a href="https://pytorch.org/docs/stable/generated/torch.nn.Module.html#torch.nn.Module">torch.nn.Module</a> </li>
+</ul>
+

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

@@ -0,0 +1,21 @@
+{
+  "title": "Subclasses of \"torch.nn.Module\" should call the initializer",
+  "type": "BUG",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "1min"
+  },
+  "tags": [],
+  "defaultSeverity": "Major",
+  "ruleSpecification": "RSPEC-6978",
+  "sqKey": "S6978",
+  "scope": "All",
+  "quickfix": "targeted",
+  "code": {
+    "impacts": {
+      "RELIABILITY": "HIGH"
+    },
+    "attribute": "LOGICAL"
+  }
+}

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

@@ -246,6 +246,7 @@
     "S6972",
     "S6973",
     "S6974",
+    "S6978",
     "S6979",
     "S6982",
     "S6983",

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

@@ -0,0 +1,78 @@
+/*
+ * 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 TorchModuleShouldCallInitCheckTest {
+  @Test
+  void test() {
+    PythonCheckVerifier.verify("src/test/resources/checks/torchModuleShouldCallInit.py", new TorchModuleShouldCallInitCheck());
+  }
+
+  @Test
+  void testQuickFix() {
+    PythonQuickFixVerifier.verify(new TorchModuleShouldCallInitCheck(),
+      """
+        import torch
+        class Test(torch.nn.Module):
+          def __init__(self):
+            some_method()
+        """,
+      """
+        import torch
+        class Test(torch.nn.Module):
+          def __init__(self):
+            super().__init__()
+            some_method()
+        """);
+
+    PythonQuickFixVerifier.verify(new TorchModuleShouldCallInitCheck(),
+      """
+        import torch
+        class Test(torch.nn.Module):
+          def __init__(self):
+            ... 
+        """,
+      """
+        import torch
+        class Test(torch.nn.Module):
+          def __init__(self):
+            super().__init__()
+            ...
+        """);
+
+    PythonQuickFixVerifier.verifyNoQuickFixes(new TorchModuleShouldCallInitCheck(),
+      """
+        import torch
+        class Test(torch.nn.Module):
+          def __init__(self): some_method()
+        """);
+
+    PythonQuickFixVerifier.verifyNoQuickFixes(new TorchModuleShouldCallInitCheck(),
+      """
+        import torch
+        class Test(torch.nn.Module):
+          def __init__(self): pass
+        """);
+  }
+}

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

@@ -0,0 +1,73 @@
+import torch.nn as nn
+
+class NonCompliantModule(nn.Module):
+     #^^^^^^^^^^^^^^^^^^> {{Inheritance happens here}}
+    def __init__(self): #Noncompliant {{Add a call to super().__init__().}}
+       #^^^^^^^^
+        ...
+
+
+class NonCompliantModule(OtherModule, nn.Module):
+    def __init__(self): #Noncompliant
+        ...
+
+class CompliantModule(NonExistantClass):
+    def __init__(self, encoder, decoder):
+        ...
+
+class CompliantModule(nn.Module):
+    def __init__(self):
+        super().__init__()
+class CompliantModule(nn.Module):
+    pass
+
+class CompliantModule(nn.Module):
+    def __init__(self, cond):
+        if cond:
+            super().__init__()
+
+class CompliantModule(nn.Module):
+    def __init__(self, super):
+        super().__init__()
+
+class CompliantModule(nn.Module):
+    def __init__(self):
+        (lambda x: x)()
+        (lambda x: x)().test()
+        self.call_super()
+
+    def call_super(self):
+        super().__init__()
+
+
+class CompliantModule(nn.Module):
+    def __init__(self, fake_super):
+        fake_super().__init__()
+        super().not_init()
+
+    def call_super(self):
+        super().__init__()
+
+class CompliantModule2(nn.Module):
+    def __init__(self): #FN
+        do_something()
+
+    class Nested(Other):
+        def __init__(self):
+            super().__init__()
+
+class UnrelatedCompliantModule:
+    def __init__(self):
+        ...
+
+def __init__(test):
+    pass
+
+def some_other_func():
+    pass
+
+class CompliantModule(nn.Module):
+    if cond:
+        class some_func: pass
+    else:
+        def some_func(): pass