Scala parser: support parameterless methods, annotated methods, remove while fallback

- Parameterless methods (def name: Type) now map to J.MethodDeclaration with
  OmitBraces marker on empty param container — printer omits ()
- Annotated methods (@deprecated def ...) now map to J.MethodDeclaration with
  annotations extracted and def-modifier carrying annotation-to-def spacing
- Remove while loop fallback — while loops in method bodies handled by parser
- Remove AppliedTypeTree fallback (already fixed in #7260)
- 3 remaining fallbacks: procedure syntax, nested braces, function type params
- 5 test failures: 3 complex annotations (with args), 2 while body block whitespace

Author: jkschneider

rewrite-scala/src/main/java/org/openrewrite/scala/ScalaPrinter.java

@@ -287,24 +287,36 @@ public J visitCase(J.Case case_, PrintOutputCapture<P> p) {
     public J visitMethodDeclaration(J.MethodDeclaration method, PrintOutputCapture<P> p) {
         beforeSyntax(method, Space.Location.METHOD_DECLARATION_PREFIX, p);
         visit(method.getLeadingAnnotations(), p);
+        boolean defAlreadyPrinted = false;
         for (J.Modifier m : method.getModifiers()) {
-            visit(m, p);
+            if ("def".equals(m.getKeyword()) && m.getType() == J.Modifier.Type.LanguageExtension) {
+                visitSpace(m.getPrefix(), Space.Location.MODIFIER_PREFIX, p);
+                p.append("def");
+                defAlreadyPrinted = true;
+            } else {
+                visit(m, p);
+            }
         }
-
-        if (!method.getModifiers().isEmpty()) {
-            p.append(" ");
+        if (!defAlreadyPrinted) {
+            if (!method.getModifiers().isEmpty()) {
+                p.append(" ");
+            }
+            p.append("def");
         }
-        p.append("def");
         visit(method.getName(), p);
 
         if (method.getPadding().getTypeParameters() != null) {
             visit(method.getPadding().getTypeParameters(), p);
         }
 
-        // Print parameters (name: Type)
+        // Print parameters — skip parens for parameterless methods (marked with OmitBraces)
         JContainer<Statement> params = method.getPadding().getParameters();
-        visitSpace(params.getBefore(), Space.Location.METHOD_DECLARATION_PARAMETERS, p);
-        p.append('(');
+        boolean hasParens = !params.getMarkers().findFirst(
+                org.openrewrite.scala.marker.OmitBraces.class).isPresent();
+        if (hasParens) {
+            visitSpace(params.getBefore(), Space.Location.METHOD_DECLARATION_PARAMETERS, p);
+            p.append('(');
+        }
         List<JRightPadded<Statement>> paramList = params.getPadding().getElements();
         for (int i = 0; i < paramList.size(); i++) {
             JRightPadded<Statement> param = paramList.get(i);
@@ -342,7 +354,9 @@ public J visitMethodDeclaration(J.MethodDeclaration method, PrintOutputCapture<P
                 p.append(',');
             }
         }
-        p.append(')');
+        if (hasParens) {
+            p.append(')');
+        }
 
         if (method.getReturnTypeExpression() != null) {
             p.append(':');

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

@@ -4482,58 +4482,43 @@ class ScalaTreeVisitor(
   }
 
   private def visitDefDef(dd: Trees.DefDef[?]): J = {
-    // Fall back to J.Unknown for cases we can't handle yet
-    val hasAnnotations = dd.mods != null && dd.mods.annotations.nonEmpty
-    if (hasAnnotations) {
-      return visitUnknown(dd)
-    }
-
-    // Check for cases we need to fall back to J.Unknown
     val adjustedStart = Math.max(0, dd.span.start - offsetAdjustment)
     val adjustedEnd = Math.max(0, dd.span.end - offsetAdjustment)
+
+    // Detect procedure syntax (no = before body) and nested braces — compiler flattens these
     if (adjustedStart < adjustedEnd && adjustedEnd <= source.length) {
       val defSource = source.substring(adjustedStart, adjustedEnd)
-      // Procedure syntax (no = before body)
       val braceIdx = defSource.indexOf('{')
       val equalsIdx = defSource.indexOf('=')
       if (braceIdx >= 0 && (equalsIdx < 0 || equalsIdx > braceIdx)) {
-        return visitUnknown(dd)
+        return visitUnknown(dd) // Procedure syntax
       }
-      // Nested braces after = (compiler flattens these, breaking round-trip)
       if (equalsIdx >= 0 && braceIdx >= 0) {
         val afterFirstBrace = defSource.indexOf('{', braceIdx + 1)
-        if (afterFirstBrace >= 0) {
-          val between = defSource.substring(braceIdx + 1, afterFirstBrace).trim()
-          if (between.isEmpty) {
-            return visitUnknown(dd)
-          }
+        if (afterFirstBrace >= 0 && defSource.substring(braceIdx + 1, afterFirstBrace).trim().isEmpty) {
+          return visitUnknown(dd) // Nested braces
         }
       }
-      // Fall back for methods with while/for loops (block whitespace issues)
-      if (defSource.contains("while ") || defSource.contains("while(")) {
-        return visitUnknown(dd)
-      }
     }
 
-    // Fall back for parameterless methods like `def name: Type` (no parens in source)
+    // Detect parameterless methods (def name: Type = ...) — no parens in source
+    var hasParensInSource = true
     if (adjustedStart < adjustedEnd && adjustedEnd <= source.length) {
       val defSource = source.substring(adjustedStart, adjustedEnd)
       val defIdx = defSource.indexOf("def ")
       if (defIdx >= 0) {
         val afterDef = defSource.substring(defIdx + 4)
-        // Find end of name (first non-alphanumeric char)
         val nameEnd = afterDef.indexWhere(c => !c.isLetterOrDigit && c != '_')
         if (nameEnd >= 0) {
           val afterName = afterDef.substring(nameEnd).trim()
-          // If the next meaningful char after name is : or = (not (), the method has no parens
           if (afterName.startsWith(":") || afterName.startsWith("=")) {
-            return visitUnknown(dd)
+            hasParensInSource = false
           }
         }
       }
     }
 
-    // Fall back for methods with function types or annotated parameters
+    // Fall back for function types (Int => Int) and annotated parameters (@unchecked)
     val hasUnsupportedParams = dd.paramss.exists(_.exists {
       case vd: Trees.ValDef[?] =>
         vd.tpt.isInstanceOf[untpd.Function] ||
@@ -4546,18 +4531,28 @@ class ScalaTreeVisitor(
 
     val savedCursor = cursor
     try {
-      visitDefDefImpl(dd)
+      visitDefDefImpl(dd, hasParensInSource)
     } catch {
       case _: Exception =>
         cursor = savedCursor
         visitUnknown(dd)
     }
   }
 
-  private def visitDefDefImpl(dd: Trees.DefDef[?]): J.MethodDeclaration = {
+  private def visitDefDefImpl(dd: Trees.DefDef[?], hasParensInSource: Boolean = true): J.MethodDeclaration = {
     val leadingAnnotations = new util.ArrayList[J.Annotation]()
+    val hasAnnotations = dd.mods != null && dd.mods.annotations.nonEmpty
     val prefix = extractPrefix(dd.span)
 
+    if (hasAnnotations) {
+      for (annot <- dd.mods.annotations) {
+        visitTree(annot) match {
+          case ann: J.Annotation => leadingAnnotations.add(ann)
+          case _ =>
+        }
+      }
+    }
+
     val adjustedEnd = Math.max(0, dd.span.end - offsetAdjustment)
     var modifierText = ""
     var defIndex = -1
@@ -4573,6 +4568,12 @@ class ScalaTreeVisitor(
 
     val (modifiers, _) = extractModifiersFromText(dd.mods, modifierText)
 
+    // If annotations but no modifiers, capture the space between annotations and "def"
+    if (hasAnnotations && modifiers.isEmpty() && modifierText.nonEmpty && modifierText.trim().isEmpty) {
+      modifiers.add(new J.Modifier(Tree.randomId(), Space.format(modifierText), Markers.EMPTY,
+        "def", J.Modifier.Type.LanguageExtension, Collections.emptyList()))
+    }
+
     val defKeywordPos = if (defIndex >= 0) cursor + defIndex + "def".length else cursor
     cursor = defKeywordPos
 
@@ -4686,7 +4687,7 @@ class ScalaTreeVisitor(
       }
 
       JContainer.build(parenSpace, jParams, Markers.EMPTY)
-    } else if (valueParamLists.nonEmpty) {
+    } else if (valueParamLists.nonEmpty && hasParensInSource) {
       // Empty parameter list ()
       val searchEnd = Math.min(cursor + 50, source.length)
       val searchText = source.substring(cursor, searchEnd)
@@ -4700,7 +4701,9 @@ class ScalaTreeVisitor(
       }
       JContainer.build(parenSpace, new util.ArrayList[JRightPadded[Statement]](), Markers.EMPTY)
     } else {
-      JContainer.empty[Statement]()
+      // Parameterless method — mark so printer omits ()
+      JContainer.build(Space.EMPTY, new util.ArrayList[JRightPadded[Statement]](),
+        Markers.build(Collections.singletonList(new org.openrewrite.scala.marker.OmitBraces(Tree.randomId()))))
     }
 
     // Handle return type `: ReturnType` — only if explicitly written in source