fix: Check for flow breaks before patching with the repair for S2142

src/main/java/sorald/processor/InterruptedExceptionProcessor.java

@@ -6,6 +6,7 @@
 import spoon.reflect.code.CtCatch;
 import spoon.reflect.code.CtIf;
 import spoon.reflect.code.CtInvocation;
+import spoon.reflect.code.CtLabelledFlowBreak;
 import spoon.reflect.code.CtReturn;
 import spoon.reflect.code.CtStatement;
 import spoon.reflect.code.CtThrow;
@@ -44,26 +45,30 @@ protected void repairInternal(CtCatch element) {
      * Return the last index that is safe to insert at, safe meaning that the interrupt is certain
      * to actually be invoked.
      *
-     * <p>This is either the first index at which a return statement or throw is found, or the index
-     * past the last index if no returns or throws are found.
+     * <p>This is either the first index at which some flow breaks are found, or the index past the
+     * last index if none found.
      */
     private static int lastSafeInterruptIndex(CtBlock<?> block) {
         for (int i = 0; i < block.getStatements().size(); i++) {
-            if (containsReturnOrThrow(block.getStatement(i))) {
+            if (containsReturnOrThrowOrLabelledFlowBreak(block.getStatement(i))) {
                 return i;
             }
         }
         return block.getStatements().size();
     }
 
     /**
-     * Check if the given statement contains a return or throw.
+     * Check if the given statement contains a return, throw, or a labelled flow break.
      *
      * <p>TODO recursively check method declarations if there are method calls.
      */
-    private static boolean containsReturnOrThrow(CtStatement statement) {
+    private static boolean containsReturnOrThrowOrLabelledFlowBreak(CtStatement statement) {
         return !statement
-                .filterChildren(e -> e instanceof CtReturn || e instanceof CtThrow)
+                .filterChildren(
+                        e ->
+                                e instanceof CtReturn
+                                        || e instanceof CtThrow
+                                        || e instanceof CtLabelledFlowBreak)
                 .list()
                 .isEmpty();
     }

src/test/resources/processor_test_files/S2142_InterruptedException/CatchBlockWithBreak.expected

@@ -0,0 +1,12 @@
+public  class CatchBlockWithBreak {
+    public static void main() {
+        while (true) {
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException exception) {
+                Thread.currentThread().interrupt();
+                break;
+            }
+        }
+    }
+}

src/test/resources/processor_test_files/S2142_InterruptedException/CatchBlockWithBreak.java

@@ -0,0 +1,11 @@
+public  class CatchBlockWithBreak {
+    public static void main() {
+        while (true) {
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException exception) {
+                break;
+            }
+        }
+    }
+}

src/test/resources/processor_test_files/S2142_InterruptedException/CatchBlockWithContinue.expected

@@ -0,0 +1,12 @@
+public  class CatchBlockWithContinue {
+    public static void main() {
+        while (true) {
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException exception) {
+                Thread.currentThread().interrupt();
+                continue;
+            }
+        }
+    }
+}

src/test/resources/processor_test_files/S2142_InterruptedException/CatchBlockWithContinue.java

@@ -0,0 +1,11 @@
+public  class CatchBlockWithContinue {
+    public static void main() {
+        while (true) {
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException exception) {
+                continue;
+            }
+        }
+    }
+}