Catch Throwable instead of Exception in KotlinParser and PythonParser (#6633)

* Catch StackOverflowError during Kotlin parsing

When parsing Kotlin files with deeply nested binary expressions (e.g., very
long string concatenations like "a" + "b" + "c" + ...), the Kotlin compiler's
FIR builder uses recursive descent which can exceed the JVM stack limit.

Changed the catch block from catching Exception to Throwable so that
StackOverflowError is caught and converted to a ParseError instead of
crashing the entire parsing process. This allows mass ingest to continue
processing other files when one file has this issue.

Added a test case that verifies deeply nested concatenations (2000+ operations)
result in a ParseError with StackOverflowError rather than crashing.

Fixes moderneinc/customer-requests#1694

* Also catch Throwable in PythonParser

Apply the same fix to PythonParser for consistency with all other parsers.

Author: Jenson3210

rewrite-kotlin/src/main/java/org/openrewrite/kotlin/KotlinParser.java

@@ -169,9 +169,9 @@ public Stream<SourceFile> parseInputs(Iterable<Input> sources, @Nullable Path re
         List<Input> acceptedInputs = ListUtils.concatAll(dependsOn, acceptedInputs(sources).collect(toList()));
         try {
             compilerCus = parse(acceptedInputs, disposable, pctx);
-        } catch (Exception e) {
+        } catch (Throwable t) {
             disposable.dispose();
-            return acceptedInputs.stream().map(input -> ParseError.build(this, input, relativeTo, ctx, e));
+            return acceptedInputs.stream().map(input -> ParseError.build(this, input, relativeTo, ctx, t));
         }
 
         FirSession firSession = compilerCus.getFirSession();

rewrite-kotlin/src/test/java/org/openrewrite/kotlin/tree/BinaryTest.java

@@ -19,8 +19,15 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 import org.openrewrite.Issue;
+import org.openrewrite.ParseExceptionResult;
+import org.openrewrite.SourceFile;
+import org.openrewrite.kotlin.KotlinParser;
 import org.openrewrite.test.RewriteTest;
+import org.openrewrite.tree.ParseError;
 
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.openrewrite.kotlin.Assertions.kotlin;
 
 @SuppressWarnings({"KotlinConstantConditions", "ControlFlowWithEmptyBody"})
@@ -363,4 +370,29 @@ fun method ( ) {
           )
         );
     }
+
+    @Issue("https://github.com/moderneinc/customer-requests/issues/1694")
+    @Test
+    void deeplyNestedStringConcatenation() {
+        // Test parsing deeply nested string concatenations (many + operations)
+        // With very deep nesting, the Kotlin compiler's FIR builder causes a StackOverflowError
+        // which should be gracefully caught and converted to a ParseError
+        StringBuilder sb = new StringBuilder();
+        sb.append("val s = ");
+        for (int i = 0; i < 2000; i++) {
+            sb.append("\"line").append(i).append("\\n\" + ");
+        }
+        sb.append("\"end\"");
+
+        Optional<SourceFile> sf = KotlinParser.builder().build()
+                .parse(sb.toString())
+                .findFirst();
+        assertThat(sf).isPresent();
+        assertThat(sf.get()).isInstanceOf(ParseError.class);
+        ParseError parseError = (ParseError) sf.get();
+        ParseExceptionResult ex = parseError.getMarkers()
+                .findFirst(ParseExceptionResult.class)
+                .orElseThrow();
+        assertThat(ex.getExceptionType()).isEqualTo("StackOverflowError");
+    }
 }

rewrite-python/src/main/java/org/openrewrite/python/PythonParser.java

@@ -74,11 +74,11 @@ public Stream<SourceFile> parseInputs(Iterable<Input> sources, @Nullable Path re
                 try {
                     validator.visit(source, 0);
                     return source;
-                } catch (Exception e) {
+                } catch (Throwable t) {
                     Optional<Input> input = smallFiles.stream()
                             .filter(i -> i.getRelativePath(relativeTo).equals(source.getSourcePath()))
                             .findFirst();
-                    return ParseError.build(this, input.orElseThrow(NoSuchElementException::new), relativeTo, ctx, e);
+                    return ParseError.build(this, input.orElseThrow(NoSuchElementException::new), relativeTo, ctx, t);
                 }
             });
         }