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

@@ -322,26 +322,25 @@ class ScalaTreeVisitor(
     // Check if this is an annotation pattern (will be handled specially when called from visitClassDef)
     // Annotations look like Apply(Select(New(...), <init>), args) with @ in source
     // Constructor calls look the same but have "new" in source
-    val isAnnotationPattern = app.fun match {
-      case sel: Trees.Select[?] if sel.name.toString == "<init>" =>
-        sel.qualifier match {
-          case newNode: Trees.New[?] =>
-            // Check if the source has @ before the type (annotation) or "new" (constructor)
-            if (app.span.exists) {
-              val adjustedStart = Math.max(0, app.span.start - offsetAdjustment)
-              val adjustedEnd = Math.max(0, app.span.end - offsetAdjustment)
-              if (adjustedStart < adjustedEnd && adjustedEnd <= source.length) {
-                val sourceText = source.substring(adjustedStart, adjustedEnd)
-                sourceText.trim.startsWith("@")
-              } else {
-                false
-              }
-            } else {
-              false
-            }
-          case _ => false
-        }
-      case _ => false
+    val isAnnotationPattern = {
+      def checkAnnotation(fun: Trees.Tree[?]): Boolean = fun match {
+        case sel: Trees.Select[?] if sel.name.toString == "<init>" =>
+          sel.qualifier match {
+            case _: Trees.New[?] =>
+              if (app.span.exists) {
+                val adjustedStart = Math.max(0, app.span.start - offsetAdjustment)
+                val adjustedEnd = Math.max(0, app.span.end - offsetAdjustment)
+                if (adjustedStart < adjustedEnd && adjustedEnd <= source.length) {
+                  source.substring(adjustedStart, adjustedEnd).trim.startsWith("@")
+                } else false
+              } else false
+            case _ => false
+          }
+        // Handle TypeApply wrapper for annotations with type params like @throws[Exception]
+        case ta: Trees.TypeApply[?] => checkAnnotation(ta.fun)
+        case _ => false
+      }
+      checkAnnotation(app.fun)
     }
 
     if (isAnnotationPattern) {
@@ -406,19 +405,24 @@ class ScalaTreeVisitor(
 
 
     // Extract the annotation type and arguments
-    val (annotationType, args) = app.fun match {
+    // Handle both direct Select(New(...), <init>) and TypeApply(Select(New(...), <init>), types)
+    def extractAnnotationType(fun: Trees.Tree[?]): Option[Trees.Ident[?]] = fun match {
       case sel: Trees.Select[?] if sel.name.toString == "<init>" =>
         sel.qualifier match {
-          case newTree: Trees.New[?] =>
-            val typeIdent = newTree.tpt match {
-              case id: Trees.Ident[?] => id
-              case _ => return visitUnknown(app)
-            }
-            (typeIdent, app.args)
-          case _ => return visitUnknown(app)
+          case newTree: Trees.New[?] => newTree.tpt match {
+            case id: Trees.Ident[?] => Some(id)
+            case _ => None
+          }
+          case _ => None
         }
-      case _ => return visitUnknown(app)
+      case ta: Trees.TypeApply[?] => extractAnnotationType(ta.fun)
+      case _ => None
     }
+    val annotationType = extractAnnotationType(app.fun) match {
+      case Some(id) => id
+      case None => return visitUnknown(app)
+    }
+    val args = app.args
 
     // Create the annotation type
     val annotTypeTree = new J.Identifier(
@@ -455,7 +459,20 @@ class ScalaTreeVisitor(
           case e: Expression => e
           case _ => visitUnknown(arg)
         }
-        argList.add(JRightPadded.build(expr.asInstanceOf[Expression]).withAfter(Space.EMPTY))
+        // Skip trailing comma between arguments
+        val afterSpace = if (i < args.size - 1) {
+          updateCursor(arg.span.end)
+          if (cursor < source.length) {
+            val after = source.substring(cursor, Math.min(cursor + 20, source.length))
+            val commaIdx = after.indexOf(',')
+            if (commaIdx >= 0) {
+              val sp = Space.format(after.substring(0, commaIdx))
+              cursor = cursor + commaIdx + 1
+              sp
+            } else Space.EMPTY
+          } else Space.EMPTY
+        } else Space.EMPTY
+        argList.add(JRightPadded.build(expr.asInstanceOf[Expression]).withAfter(afterSpace))
       }
       JContainer.build(
         Space.EMPTY,
@@ -3521,37 +3538,36 @@ class ScalaTreeVisitor(
   */
 
   private def visitBlock(block: Trees.Block[?]): J.Block = {
-    val prefix = extractPrefix(block.span)
-
-    // Move cursor past the opening brace — but only if the block starts with one
     val blockStart = Math.max(0, block.span.start - offsetAdjustment)
     val blockEndAdj = Math.max(0, block.span.end - offsetAdjustment)
-    val blockStartsWithBrace = blockStart < source.length && source.charAt(blockStart) == '{'
-    if (blockStartsWithBrace) {
+
+    // Find the opening brace — it may be at blockStart, before blockStart (while/for body),
+    // or between cursor and the first child
+    val savedCursorBeforePrefix = cursor
+    val prefix = extractPrefix(block.span) // advances cursor to blockStart
+
+    // Now find and advance past '{'
+    if (blockStart < source.length && source.charAt(blockStart) == '{') {
+      // Brace at block span start
       cursor = blockStart + 1
-    } else {
-      // Check if there's a brace between cursor and the first statement
-      val firstChildStart = if (block.stats.nonEmpty) {
-        Math.max(0, block.stats.head.span.start - offsetAdjustment)
-      } else if (!block.expr.isEmpty) {
-        Math.max(0, block.expr.span.start - offsetAdjustment)
-      } else blockStart
-
-      if (cursor < firstChildStart && firstChildStart <= source.length) {
-        val between = source.substring(cursor, firstChildStart)
-        val braceIdx = between.indexOf('{')
-        if (braceIdx >= 0) {
-          cursor = cursor + braceIdx + 1
-        }
+    } else if (savedCursorBeforePrefix < blockStart) {
+      // Check if there's a brace BEFORE the block span (e.g., while body)
+      val beforeSpan = source.substring(savedCursorBeforePrefix, blockStart)
+      val braceIdx = beforeSpan.indexOf('{')
+      if (braceIdx >= 0) {
+        // The brace is before the block span — cursor should be past it
+        cursor = savedCursorBeforePrefix + braceIdx + 1
       }
     }
 
     val statements = new util.ArrayList[JRightPadded[Statement]]()
 
+
     // Visit all statements in the block
     for (i <- block.stats.indices) {
       val stat = block.stats(i)
-      visitTree(stat) match {
+      val visitResult = visitTree(stat)
+      visitResult match {
         case null => // Skip null statements (e.g., package declarations)
         case stmt: Statement => 
           // Extract trailing space after this statement
@@ -4482,58 +4498,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 +4547,58 @@ 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) {
+        // First try the proper AST visitor
+        val savedAnnotCursor = cursor
+        val annotResult = try { visitTree(annot) } catch { case _: Exception => cursor = savedAnnotCursor; null }
+
+        annotResult match {
+          case ann: J.Annotation => leadingAnnotations.add(ann)
+          case _ =>
+            // Fallback: build annotation from source text
+            cursor = savedAnnotCursor // Reset cursor — visitTree may have advanced it incorrectly
+            if (annot.span.exists) {
+              val annotStart = Math.max(0, annot.span.start - offsetAdjustment)
+              val annotEnd = Math.max(0, annot.span.end - offsetAdjustment)
+              // Find the @ before the annotation span (it's in the source but might not be in the span)
+              val searchStart = Math.max(0, annotStart - 5)
+              val atIdx = if (searchStart < source.length) source.lastIndexOf('@', annotStart) else -1
+              val fullStart = if (atIdx >= 0 && atIdx >= searchStart) atIdx else annotStart
+
+              // Prefix = space from cursor to @ position
+              val annotPrefix = if (cursor < fullStart && fullStart <= source.length) {
+                Space.format(source.substring(cursor, fullStart))
+              } else Space.EMPTY
+
+              // Source = everything from @ to annotation end
+              val annotSource = if (fullStart < annotEnd && annotEnd <= source.length) {
+                source.substring(fullStart, annotEnd)
+              } else ""
+              val annotName = if (annotSource.startsWith("@")) annotSource.substring(1) else annotSource
+
+              val annotId = new J.Identifier(Tree.randomId(), Space.EMPTY, Markers.EMPTY,
+                Collections.emptyList(), annotName, null, null)
+              leadingAnnotations.add(new J.Annotation(Tree.randomId(), annotPrefix, Markers.EMPTY, annotId, null))
+              cursor = annotEnd
+            }
+        }
+      }
+    }
+
     val adjustedEnd = Math.max(0, dd.span.end - offsetAdjustment)
     var modifierText = ""
     var defIndex = -1
@@ -4573,6 +4614,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 +4733,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 +4747,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