fix: KotlinVisitor.visitAnnotatedExpression now traverses inner expression (#6870)

* fix: KotlinVisitor.visitAnnotatedExpression now traverses inner expression

The visitAnnotatedExpression method visited the annotation list but
silently skipped visitAndCast on ae.getExpression(). This caused any
visitor override (e.g. visitMethodInvocation) to miss nodes inside
an annotated expression like @Suppress try { ... }.

Fixes #6868

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* fix: restore accidentally removed annotatedTypeInFunctionTypeParens test

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* Fix the AnnotatedExpression inner expression traversal

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Tim te Beek <tim@moderne.io>
Co-authored-by: Jente Sondervorst <jentesondervorst@gmail.com>

Author: 4 people

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

@@ -69,6 +69,7 @@ public J visitAnnotatedExpression(K.AnnotatedExpression annotatedExpression, P p
         K.AnnotatedExpression ae = annotatedExpression;
         ae = ae.withMarkers(visitMarkers(ae.getMarkers(), p));
         ae = ae.withAnnotations(ListUtils.map(ae.getAnnotations(), a -> visitAndCast(a, p)));
+        ae = ae.withExpression(visitAndCast(ae.getExpression(), p));
         Expression temp = (Expression) visitExpression(ae, p);
         if (!(temp instanceof K.AnnotatedExpression)) {
             return temp;

rewrite-kotlin/src/main/java/org/openrewrite/kotlin/format/MergeSpacesVisitor.java

@@ -77,6 +77,7 @@ public J visitAnnotatedExpression(K.AnnotatedExpression annotatedExpression, @Nu
         K.AnnotatedExpression ae = annotatedExpression;
         ae = ae.withMarkers(visitMarkers(ae.getMarkers(), newAnnotatedExpression.getMarkers()));
         ae = ae.withAnnotations(ListUtils.map(ae.getAnnotations(), (index, a) -> visitAndCast(a, newAnnotatedExpression.getAnnotations().get(index))));
+        ae = ae.withExpression(visitAndCast(ae.getExpression(), newAnnotatedExpression.getExpression()));
         Expression temp = (Expression) visitExpression(ae, newAnnotatedExpression);
         if (!(temp instanceof K.AnnotatedExpression)) {
             return temp;

rewrite-kotlin/src/main/java/org/openrewrite/kotlin/format/TabsAndIndentsVisitor.java

@@ -163,7 +163,10 @@ public Space visitSpace(Space space, Space.Location loc, P p) {
         } else if (parent != null && !getCursor().getParentOrThrow().getPath(J.Annotation.class::isInstance).hasNext()) {
             // when annotations are on their own line, other parts of the declaration that follow are aligned left to it
             alignToAnnotation = getCursor().pollNearestMessage("afterAnnotation") != null &&
-                    !(getCursor().getParentOrThrow().getValue() instanceof J.Annotation);
+                    !(getCursor().getParentOrThrow().getValue() instanceof J.Annotation) &&
+                    //Unlike Java LST element, where the parent has a list of annotations, AnnotatedExpression has sibling annotation and Expression in this one.
+                    //As the getCursor().pollNearestMessage("afterAnnotation") will not have been null, still the message will be gone if it was an AnnotatedExpression so no further action needed.
+                    !(getCursor().getParentOrThrow().getValue() instanceof K.AnnotatedExpression);
 
             if ((loc == Space.Location.CLASS_KIND ||
                     loc == Space.Location.METHOD_DECLARATION_PREFIX) &&

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

@@ -18,8 +18,10 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
+import org.openrewrite.ExecutionContext;
 import org.openrewrite.Issue;
 import org.openrewrite.java.tree.J;
+import org.openrewrite.kotlin.KotlinIsoVisitor;
 import org.openrewrite.kotlin.KotlinParser;
 import org.openrewrite.test.RewriteTest;
 import org.openrewrite.test.TypeValidation;
@@ -28,6 +30,7 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.openrewrite.kotlin.Assertions.kotlin;
+import static org.openrewrite.test.RewriteTest.toRecipe;
 
 @SuppressWarnings({"RedundantSuppression", "RedundantNullableReturnType", "RedundantVisibilityModifier", "UnusedReceiverParameter", "SortModifiers", "TrailingComma", "RedundantGetter", "RedundantSetter"})
 class AnnotationTest implements RewriteTest {
@@ -782,4 +785,40 @@ fun method ( ) {
           )
         );
     }
+
+    @Issue("https://github.com/openrewrite/rewrite/issues/6868")
+    @Test
+    void visitAnnotatedExpressionTraversesInnerExpression() {
+        rewriteRun(
+          spec -> spec
+            .recipe(toRecipe(() -> new KotlinIsoVisitor<>() {
+                @Override
+                public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) {
+                    if ("foo".equals(method.getSimpleName())) {
+                        return method.withName(method.getName().withSimpleName("bar"));
+                    }
+                    return super.visitMethodInvocation(method, ctx);
+                }
+            }))
+            .typeValidationOptions(TypeValidation.none()),
+          kotlin(
+            """
+              fun main() {
+                  @Suppress("UNCHECKED_CAST")
+                  try {
+                      foo()
+                  } catch (e: Exception) {}
+              }
+              """,
+            """
+              fun main() {
+                  @Suppress("UNCHECKED_CAST")
+                  try {
+                      bar()
+                  } catch (e: Exception) {}
+              }
+              """
+          )
+        );
+    }
 }