Scala parser: add try/catch/finally and match expression support (#7260)

- Map Trees.Try to J.Try with J.Try.Catch for each case clause
- Map Trees.Match to J.Switch with J.Case for each pattern
- Add ScalaPrinter overrides for try/catch (Scala syntax), switch/case (match syntax)
- Fix modifier spacing before def keyword (implicit def, abstract override def)
- Handle Statement types (e.g., match) in method body wrapping
- All 8 TryTest cases pass
- 1 remaining match printer formatting issue (throwInMatchCase)

Author: jkschneider

rewrite-scala/src/main/scala/org/openrewrite/scala/internal/ScalaTreeVisitor.scala

@@ -4533,16 +4533,14 @@ class ScalaTreeVisitor(
       }
     }
 
-    // Fall back for methods with complex types in parameters
-    // (cursor tracking for types like Map[String, Any], Int => Int is not yet reliable)
-    val hasComplexParams = dd.paramss.exists(_.exists {
+    // Fall back for methods with function types or annotated parameters
+    val hasUnsupportedParams = dd.paramss.exists(_.exists {
       case vd: Trees.ValDef[?] =>
-        vd.tpt.isInstanceOf[Trees.AppliedTypeTree[?]] ||
         vd.tpt.isInstanceOf[untpd.Function] ||
-        (vd.mods != null && vd.mods.annotations.nonEmpty) // parameter-level annotations
+        (vd.mods != null && vd.mods.annotations.nonEmpty)
       case _ => false
     })
-    if (hasComplexParams) {
+    if (hasUnsupportedParams) {
       return visitUnknown(dd)
     }
 
@@ -4789,7 +4787,10 @@ class ScalaTreeVisitor(
 
   private def visitMethodParameter(vd: Trees.ValDef[?]): J = {
     val prefix = extractPrefix(vd.span)
-    val paramSource = extractSource(vd.span)
+    // Check source for colon WITHOUT advancing cursor (extractSource would consume the text)
+    val paramStart = Math.max(0, vd.span.start - offsetAdjustment)
+    val paramEnd = Math.max(0, vd.span.end - offsetAdjustment)
+    val paramSource = if (paramStart < paramEnd && paramEnd <= source.length) source.substring(paramStart, paramEnd) else ""
     val hasExplicitType = paramSource.contains(":")
 
     val paramName = new J.Identifier(

rewrite-scala/src/test/java/org/openrewrite/scala/ScalaParserTest.java

@@ -158,27 +158,13 @@ def main(args: Array[String]): Unit = {
         J.Block objectBody = objectDecl.getBody();
         assertThat(objectBody.getStatements()).isNotEmpty();
 
-        // For now, just verify that the for loop parsing doesn't crash
-        // The full implementation is still in progress, so we'll check for Unknown nodes
-        boolean foundForLoop = false;
-        for (Statement stmt : objectBody.getStatements()) {
-            System.out.println("Statement type: " + stmt.getClass().getSimpleName());
-            if (stmt instanceof J.Unknown) {
-                String text = ((J.Unknown) stmt).getSource().getText();
-                System.out.println("Unknown statement: " + text);
-                if (text.contains("for (n <- nums)")) {
-                    foundForLoop = true;
-                }
-            }
-        }
-        
-        // Since method declarations are not fully implemented yet, we expect the whole
-        // method body to be wrapped as Unknown
-        assertThat(foundForLoop || objectBody.getStatements().stream()
-            .anyMatch(stmt -> stmt instanceof J.Unknown && 
-                             ((J.Unknown) stmt).getSource().getText().contains("for")))
-            .as("Should find for loop in the parsed structure (possibly as Unknown)")
-            .isTrue();
+        // Methods are now J.MethodDeclaration — the for loop is inside the method body
+        // Verify the structure contains the method and its body has the for loop
+        String printed = cu.printTrimmed();
+        assertThat(printed)
+            .as("Parsed structure should contain the for loop")
+            .contains("for")
+            .contains("nums");
     }
 
     // @Test  // TODO: Enable once method declarations are fully implemented