Sonar codemod for declaring a variable in a separate line (#268)

Reference: https://rules.sonarsource.com/java/RSPEC-1659/

Example:
https://sonarcloud.io/project/issues?languages=java&resolved=false&id=nahsra_WebGoat_10_23&open=AYxkqUZwlAj1v1V7lso3

Declaring a variable can happen as:
* A field declaration inside a class-interface
* A variable declaration expression inside a block statement

DOCS PR -> pixee/docs#115

Author: carlosu7

core-codemods/src/main/java/io/codemodder/codemods/DeclareVariableOnSeparateLine.java

@@ -0,0 +1,69 @@
+package io.codemodder.codemods;
+
+import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.NodeList;
+import com.github.javaparser.ast.body.VariableDeclarator;
+import com.github.javaparser.ast.nodeTypes.NodeWithVariables;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+abstract class DeclareVariableOnSeparateLine {
+
+  protected final NodeWithVariables<?> parentNode;
+
+  protected DeclareVariableOnSeparateLine(final NodeWithVariables<?> parentNode) {
+    this.parentNode = Objects.requireNonNull(parentNode);
+  }
+
+  /**
+   * Splits multiple inline variables within a parent node into separate variable declaration
+   * statements.
+   */
+  protected boolean splitVariablesIntoTheirOwnStatements() {
+
+    final List<VariableDeclarator> inlineVariables = parentNode.getVariables().stream().toList();
+
+    final List<VariableDeclarator> remainingVariables =
+        inlineVariables.subList(1, inlineVariables.size());
+
+    final List<Node> newVariableNodes = createVariableNodesToAdd(remainingVariables);
+
+    if (!addNewNodesToParentNode(newVariableNodes)) {
+      return false;
+    }
+    // Replace parent's node that has all inline variables with only the first variable
+    parentNode.setVariables(new NodeList<>(inlineVariables.get(0)));
+
+    return true;
+  }
+
+  /** Returns a list of nodes created from the list of inline variables. */
+  protected abstract List<Node> createVariableNodesToAdd(List<VariableDeclarator> inlineVariables);
+
+  /** Adds new variable nodes to the parent node. */
+  protected abstract boolean addNewNodesToParentNode(List<Node> nodesToAdd);
+
+  /**
+   * Inserts a list of nodes after a specified reference node within an original list of nodes. The
+   * result of this operation is a new list containing the original nodes with the additional nodes
+   * inserted after the specified reference node while maintaining the original order of elements.
+   */
+  static <T> List<T> insertNodesAfterReference(
+      final List<T> originalNodes, final Node referenceNode, final List<Node> nodesToAdd) {
+
+    // Find the index of the reference node in the original list
+    final int referenceIndex = originalNodes.indexOf(referenceNode);
+
+    // Split the original list into elements before and after the reference node
+    final List<T> elementsBefore = originalNodes.subList(0, referenceIndex + 1);
+    final List<T> elementsAfter = originalNodes.subList(referenceIndex + 1, originalNodes.size());
+
+    // Create a new list with nodes inserted after the reference node
+    final List<T> newElements = new ArrayList<>(elementsBefore);
+    nodesToAdd.forEach(node -> newElements.add((T) node));
+    newElements.addAll(elementsAfter);
+
+    return newElements;
+  }
+}

core-codemods/src/main/java/io/codemodder/codemods/DeclareVariableOnSeparateLineCodemod.java

@@ -0,0 +1,58 @@
+package io.codemodder.codemods;
+
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.body.FieldDeclaration;
+import com.github.javaparser.ast.body.VariableDeclarator;
+import com.github.javaparser.ast.expr.VariableDeclarationExpr;
+import com.github.javaparser.ast.nodeTypes.NodeWithVariables;
+import io.codemodder.*;
+import io.codemodder.providers.sonar.ProvidedSonarScan;
+import io.codemodder.providers.sonar.RuleIssues;
+import io.codemodder.providers.sonar.SonarPluginJavaParserChanger;
+import io.codemodder.providers.sonar.api.Issue;
+import java.util.Optional;
+import javax.inject.Inject;
+
+/** A codemod for declaring a variable on a separate line. */
+@Codemod(
+    id = "sonar:java/declare-variable-on-separate-line-s1659",
+    reviewGuidance = ReviewGuidance.MERGE_WITHOUT_REVIEW,
+    executionPriority = CodemodExecutionPriority.HIGH)
+public final class DeclareVariableOnSeparateLineCodemod
+    extends SonarPluginJavaParserChanger<VariableDeclarator> {
+  @Inject
+  public DeclareVariableOnSeparateLineCodemod(
+      @ProvidedSonarScan(ruleId = "java:S1659") final RuleIssues issues) {
+    super(issues, VariableDeclarator.class);
+  }
+
+  @Override
+  public boolean onIssueFound(
+      final CodemodInvocationContext context,
+      final CompilationUnit cu,
+      final VariableDeclarator variableDeclarator,
+      final Issue issue) {
+
+    final Optional<Node> parentOptional = variableDeclarator.getParentNode();
+
+    if (parentOptional.isEmpty()) {
+      return false;
+    }
+
+    final NodeWithVariables<?> parentNode = (NodeWithVariables<?>) parentOptional.get();
+
+    final DeclareVariableOnSeparateLine declareVariableOnSeparateLine;
+
+    if (parentNode instanceof FieldDeclaration fieldDeclaration) {
+      declareVariableOnSeparateLine =
+          new DeclareVariableOnSeparateLineForFieldDeclaration(fieldDeclaration);
+    } else {
+      declareVariableOnSeparateLine =
+          new DeclareVariableOnSeparateLineForVariableDeclarationExpr(
+              (VariableDeclarationExpr) parentNode);
+    }
+
+    return declareVariableOnSeparateLine.splitVariablesIntoTheirOwnStatements();
+  }
+}

core-codemods/src/main/java/io/codemodder/codemods/DeclareVariableOnSeparateLineForFieldDeclaration.java

@@ -0,0 +1,63 @@
+package io.codemodder.codemods;
+
+import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.NodeList;
+import com.github.javaparser.ast.body.BodyDeclaration;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.FieldDeclaration;
+import com.github.javaparser.ast.body.VariableDeclarator;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+final class DeclareVariableOnSeparateLineForFieldDeclaration extends DeclareVariableOnSeparateLine {
+
+  private final FieldDeclaration fieldDeclaration;
+
+  DeclareVariableOnSeparateLineForFieldDeclaration(final FieldDeclaration parentNode) {
+    super(parentNode);
+    this.fieldDeclaration = Objects.requireNonNull(parentNode);
+  }
+
+  /**
+   * Returns a list of {@link FieldDeclaration} nodes created from a list of {@link
+   * VariableDeclarator}s.
+   */
+  protected List<Node> createVariableNodesToAdd(List<VariableDeclarator> inlineVariables) {
+    final List<Node> nodesToAdd = new ArrayList<>();
+    for (VariableDeclarator inlineVariable : inlineVariables) {
+
+      final FieldDeclaration newFieldDeclaration =
+          new FieldDeclaration(
+              fieldDeclaration.getModifiers(),
+              ((FieldDeclaration) parentNode).getAnnotations(),
+              new NodeList<>(inlineVariable));
+      nodesToAdd.add(newFieldDeclaration);
+    }
+    return nodesToAdd;
+  }
+
+  /**
+   * Adds a list of nodes to the parent node {@link ClassOrInterfaceDeclaration} after the
+   * fieldDeclaration.
+   */
+  protected boolean addNewNodesToParentNode(List<Node> nodesToAdd) {
+    final Optional<Node> classOrInterfaceDeclarationOptional = fieldDeclaration.getParentNode();
+    if (classOrInterfaceDeclarationOptional.isPresent()
+        && classOrInterfaceDeclarationOptional.get()
+            instanceof ClassOrInterfaceDeclaration classOrInterfaceDeclaration) {
+
+      final List<BodyDeclaration<?>> allMembers =
+          insertNodesAfterReference(
+              classOrInterfaceDeclaration.getMembers().stream().toList(),
+              fieldDeclaration,
+              nodesToAdd);
+
+      classOrInterfaceDeclaration.setMembers(new NodeList<>(allMembers));
+      return true;
+    }
+
+    return false;
+  }
+}

core-codemods/src/main/java/io/codemodder/codemods/DeclareVariableOnSeparateLineForVariableDeclarationExpr.java

@@ -0,0 +1,61 @@
+package io.codemodder.codemods;
+
+import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.NodeList;
+import com.github.javaparser.ast.body.VariableDeclarator;
+import com.github.javaparser.ast.expr.VariableDeclarationExpr;
+import com.github.javaparser.ast.stmt.BlockStmt;
+import com.github.javaparser.ast.stmt.ExpressionStmt;
+import com.github.javaparser.ast.stmt.Statement;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+final class DeclareVariableOnSeparateLineForVariableDeclarationExpr
+    extends DeclareVariableOnSeparateLine {
+
+  private final VariableDeclarationExpr variableDeclarationExpr;
+
+  DeclareVariableOnSeparateLineForVariableDeclarationExpr(
+      final VariableDeclarationExpr parentNode) {
+    super(parentNode);
+    this.variableDeclarationExpr = Objects.requireNonNull(parentNode);
+  }
+
+  /**
+   * Returns a list of {@link VariableDeclarationExpr} nodes created from a list of {@link
+   * VariableDeclarator}s.
+   */
+  protected List<Node> createVariableNodesToAdd(List<VariableDeclarator> inlineVariables) {
+    final List<Node> nodesToAdd = new ArrayList<>();
+    for (VariableDeclarator inlineVariable : inlineVariables) {
+      final VariableDeclarationExpr newVariableDeclarationExpr =
+          new VariableDeclarationExpr(
+              variableDeclarationExpr.getModifiers(), new NodeList<>(inlineVariable));
+      final ExpressionStmt expressionStmt = new ExpressionStmt(newVariableDeclarationExpr);
+      nodesToAdd.add(expressionStmt);
+    }
+    return nodesToAdd;
+  }
+
+  /** Adds a list of nodes to the parent BlockStmt after the expressionStmt. */
+  protected boolean addNewNodesToParentNode(List<Node> nodesToAdd) {
+    final Optional<Node> expressionStmtOptional = variableDeclarationExpr.getParentNode();
+    if (expressionStmtOptional.isPresent()
+        && expressionStmtOptional.get() instanceof ExpressionStmt expressionStmt) {
+      final Optional<Node> blockStmtOptional = expressionStmt.getParentNode();
+      if (blockStmtOptional.isPresent() && blockStmtOptional.get() instanceof BlockStmt blockStmt) {
+
+        final List<Statement> allStmts =
+            insertNodesAfterReference(blockStmt.getStatements(), expressionStmt, nodesToAdd);
+
+        blockStmt.setStatements(new NodeList<>(allStmts));
+
+        return true;
+      }
+    }
+
+    return false;
+  }
+}

core-codemods/src/main/java/io/codemodder/codemods/DefaultCodemods.java

@@ -14,8 +14,13 @@ public final class DefaultCodemods {
   public static List<Class<? extends CodeChanger>> asList() {
     return List.of(
         AddClarifyingBracesCodemod.class,
+        AddMissingOverrideCodemod.class,
+        AvoidImplicitPublicConstructorCodemod.class,
+        DeclareVariableOnSeparateLineCodemod.class,
         DisableAutomaticDirContextDeserializationCodemod.class,
+        FixRedundantStaticOnEnumCodemod.class,
         HardenJavaDeserializationCodemod.class,
+        HardenStringParseToPrimitivesCodemod.class,
         HardenProcessCreationCodemod.class,
         HardenXMLDecoderCodemod.class,
         HardenXMLInputFactoryCodemod.class,
@@ -32,12 +37,18 @@ public static List<Class<? extends CodeChanger>> asList() {
         OutputResourceLeakCodemod.class,
         PreventFileWriterLeakWithFilesCodemod.class,
         RandomizeSeedCodemod.class,
+        RemoveRedundantVariableCreationCodemod.class,
+        RemoveUnusedLocalVariableCodemod.class,
+        RemoveUselessParenthesesCodemod.class,
         ReplaceDefaultHttpClientCodemod.class,
+        ReplaceStreamCollectorsToListCodemod.class,
         SanitizeApacheMultipartFilenameCodemod.class,
         SanitizeHttpHeaderCodemod.class,
         SanitizeSpringMultipartFilenameCodemod.class,
         SecureRandomCodemod.class,
         SemgrepOverlyPermissiveFilePermissionsCodemod.class,
+        SimplifyRestControllerAnnotationsCodemod.class,
+        SubstituteReplaceAllCodemod.class,
         SQLParameterizerCodemod.class,
         SSRFCodemod.class,
         StackTraceExposureCodemod.class,

core-codemods/src/main/resources/io/codemodder/codemods/DeclareVariableOnSeparateLineCodemod/description.md

@@ -0,0 +1,11 @@
+This change splits variable assignments onto their own lines. [Many](https://wiki.sei.cmu.edu/confluence/display/java/DCL52-J.+Do+not+declare+more+than+one+variable+per+declaration) [sources](https://rules.sonarsource.com/java/RSPEC-1659/) [believe](https://dart.dev/tools/linter-rules/avoid_multiple_declarations_per_line) it is easier to review code where the variables are separate statements on their own individual line.
+
+Our changes look something like this:
+
+```diff
+-   int i = 0, limit = 10;
++   int i = 0;
++   int limit = 10;
+
+    while (i < limit){
+```

core-codemods/src/main/resources/io/codemodder/codemods/DeclareVariableOnSeparateLineCodemod/report.json

@@ -0,0 +1,8 @@
+{
+  "summary" : "Split variable declarations into their own statements (Sonar)",
+  "change" : "Split variable declarations into their own statements.",
+  "references" : [
+    "https://rules.sonarsource.com/java/RSPEC-1659/",
+    "https://wiki.sei.cmu.edu/confluence/display/java/DCL52-J.+Do+not+declare+more+than+one+variable+per+declaration"
+  ]
+}

core-codemods/src/test/java/io/codemodder/codemods/DeclareVariableOnSeparateLineCodemodTest.java

@@ -0,0 +1,12 @@
+package io.codemodder.codemods;
+
+import io.codemodder.testutils.CodemodTestMixin;
+import io.codemodder.testutils.Metadata;
+
+@Metadata(
+    codemodType = DeclareVariableOnSeparateLineCodemod.class,
+    testResourceDir = "declare-variable-on-separate-line-s1659",
+    renameTestFile =
+        "src/main/java/org/owasp/webgoat/container/assignments/AssignmentEndpoint.java",
+    dependencies = {})
+final class DeclareVariableOnSeparateLineCodemodTest implements CodemodTestMixin {}