Retain comments around unreachable statements if they contain "LINT.".

This is heuristicy, but helps preserve load-bearing comments even when we want to delete the unreachable code.

PiperOrigin-RevId: 756398882

Author: graememorgan

core/src/main/java/com/google/errorprone/bugpatterns/StatementSwitchToExpressionSwitch.java

@@ -41,7 +41,6 @@
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
-import com.google.common.collect.Range;
 import com.google.common.collect.Streams;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.ErrorProneFlags;
@@ -1021,7 +1020,7 @@ private static SuggestedFix convertToReturnSwitch(
       AnalysisResult analysisResult,
       boolean removeDefault) {
 
-    List<Range<Integer>> regionsToDelete = new ArrayList<>();
+    SuggestedFix.Builder suggestedFixBuilder = SuggestedFix.builder();
     List<? extends CaseTree> cases = switchTree.getCases();
     ImmutableList<ErrorProneComment> allSwitchComments =
         state.getTokensForNode(switchTree).stream()
@@ -1119,39 +1118,50 @@ private static SuggestedFix convertToReturnSwitch(
       if (tree instanceof BlockTree blockTree) {
         TreePath rootToCurrentPath = TreePath.getPath(state.getPath(), switchTree);
         int indexInBlock = findBlockStatementIndex(rootToCurrentPath, blockTree);
+        var statements = blockTree.getStatements();
         // A single mock of the immediate child statement block (or switch) is sufficient to
         // analyze reachability here; deeper-nested statements are not relevant.
         boolean nextStatementReachable =
             Reachability.canCompleteNormally(
-                blockTree.getStatements().get(indexInBlock),
-                ImmutableMap.of(cannotCompleteNormallyTree, false));
+                statements.get(indexInBlock), ImmutableMap.of(cannotCompleteNormallyTree, false));
         // If we continue to the ancestor statement block, it will be because the end of this
         // statement block is not reachable
         cannotCompleteNormallyTree = blockTree;
         if (nextStatementReachable) {
           break;
         }
 
-        // If a next statement in this block exists, then it is not reachable; similarly, none of
-        // the following statements in this block are reachable either.  So, iff further statements
-        // exist, delete them all (including their comments).
-        if (indexInBlock < blockTree.getStatements().size() - 1) {
-          regionsToDelete.add(
-              Range.closed(
-                  state.getEndPosition(blockTree.getStatements().get(indexInBlock)),
-                  state.getEndPosition(blockTree)));
+        // If a next statement in this block exists, then it is not reachable.
+        if (indexInBlock < statements.size() - 1) {
+          String deletedRegion =
+              state
+                  .getSourceCode()
+                  .subSequence(
+                      state.getEndPosition(statements.get(indexInBlock)),
+                      state.getEndPosition(blockTree))
+                  .toString();
+          // If the region we would delete looks interesting, bail out and just delete the orphaned
+          // statements.
+          if (deletedRegion.contains("LINT.")) {
+            statements
+                .subList(indexInBlock + 1, statements.size())
+                .forEach(suggestedFixBuilder::delete);
+          } else {
+            // If the region doesn't seem to contain interesting comments, delete it along with
+            // comments: those comments are often just of the form "Unreachable code".
+            suggestedFixBuilder.replace(
+                state.getEndPosition(statements.get(indexInBlock)),
+                state.getEndPosition(blockTree),
+                "}");
+          }
         }
       }
     }
 
-    SuggestedFix.Builder suggestedFixBuilder = SuggestedFix.builder();
     if (removeDefault) {
       suggestedFixBuilder.setShortDescription(REMOVE_DEFAULT_CASE_SHORT_DESCRIPTION);
     }
     suggestedFixBuilder.replace(switchTree, replacementCodeBuilder.toString());
-    // Delete dead code and its comments
-    regionsToDelete.forEach(
-        r -> suggestedFixBuilder.replace(r.lowerEndpoint(), r.upperEndpoint(), "}"));
     return suggestedFixBuilder.build();
   }
 

core/src/test/java/com/google/errorprone/bugpatterns/StatementSwitchToExpressionSwitchTest.java

@@ -2102,6 +2102,53 @@ public int foo(Suit suit) {
         .doTest(TEXT_MATCH);
   }
 
+  @Test
+  public void switchByEnum_returnSwitchWithAllEnumValues_retainTrailingLintComment() {
+    refactoringHelper
+        .addInputLines(
+            "Test.java",
+            """
+            class Test {
+              public int foo(Suit suit) {
+                // LINT.
+                switch (suit) {
+                  case HEART:
+                    return 1;
+                  case DIAMOND:
+                    return 2;
+                  case SPADE:
+                    return 3;
+                  case CLUB:
+                    return 4;
+                }
+                // LINT.
+                throw new AssertionError("unreachable!");
+              }
+            }
+            """)
+        .addOutputLines(
+            "Test.java",
+            """
+            class Test {
+              public int foo(Suit suit) {
+                // LINT.
+                return switch (suit) {
+                  case HEART -> 1;
+                  case DIAMOND -> 2;
+                  case SPADE -> 3;
+                  case CLUB -> 4;
+                };
+                // LINT.
+
+              }
+            }
+            """)
+        .setArgs(
+            "-XepOpt:StatementSwitchToExpressionSwitch:EnableReturnSwitchConversion",
+            "-XepOpt:StatementSwitchToExpressionSwitch:EnableDirectConversion=false")
+        .doTest(TEXT_MATCH);
+  }
+
   @Test
   public void switchByEnum_returnSwitchNoFollowingStatementsInBlock_errorAndNoRemoval() {
     // The switch is exhaustive but doesn't have any statements immediately following it in the