draft recipe and test case

Author: bhavanapidapa

src/main/java/org/openrewrite/java/migrate/HandleTypeNotPresentExceptionInsteadOfArrayStoreException.java

@@ -0,0 +1,59 @@
+package org.openrewrite.java.migrate;
+
+import org.openrewrite.ExecutionContext;
+import org.openrewrite.Recipe;
+import org.openrewrite.TreeVisitor;
+import org.openrewrite.java.JavaVisitor;
+import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.JavaType;
+
+import java.util.Collections;
+import java.util.List;
+
+public class HandleTypeNotPresentExceptionInsteadOfArrayStoreException extends Recipe {
+    @Override
+    public String getDisplayName() {
+        return "Handle TypeNotPresentException instead of ArrayStoreException";
+    }
+
+    @Override
+    public String getDescription() {
+        return "This recipe replaces catch blocks for ArrayStoreException around getAnnotation() with TypeNotPresentException or both exceptions, to ensure compatibility with Java 11+.";
+    }
+
+    @Override
+    public TreeVisitor<?, ExecutionContext> getVisitor() {
+        return new JavaVisitor<ExecutionContext>() {
+            @Override
+            public J visitTry(J.Try tryStmt, ExecutionContext ctx ) {
+                if(containsGetAnnotation(tryStmt.getBody()))
+                {
+                    for (J.Try.Catch catchClause : tryStmt.getCatches()) {
+                        if(catchClause.getParameter().getType() != null && "java.lang.ArrayStoreException".equals(catchClause.getParameter().getType().toString())) {
+                            JavaType.Class typeNotPresentExceptionType = new JavaType.Class(null,0,"java.lang.TypeNotPresentException", null, null,null, null,null,null,null,null);
+                            J.Try.Catch updatedCatch = catchClause.withParameter(catchClause.getParameter().withType(typeNotPresentExceptionType));
+//                                String multiCatchType = "java.lang.ArrayStoreException | java.lang.TypeNotPresentException";
+//                                updatedCatch = updatedCatch.withParameter(catchClause.getParameter().withType(JavaType.Class.build(multicatchType)));
+                                tryStmt = tryStmt.withCatches((List<J.Try.Catch>) Collections.singleton(updatedCatch));
+                        }
+                    }
+                }
+                return super.visitTry(tryStmt,ctx);
+        }
+
+        private boolean containsGetAnnotation(J.Block body) {
+                if(body == null) return false;
+                for( J node : body.getStatements()) {
+                if (node instanceof J.MethodInvocation) {
+                    J.MethodInvocation methodInvocation = (J.MethodInvocation) node;
+                    if ("getAnnotation".equals(methodInvocation.getSimpleName())) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+}
+        };
+    }
+}
+

src/test/java/org/openrewrite/java/migrate/TypeNotPresentExceptionTest.java

@@ -0,0 +1,73 @@
+package org.openrewrite.java.migrate;
+
+import org.junit.jupiter.api.Test;
+import org.openrewrite.java.JavaParser;
+import org.openrewrite.test.RecipeSpec;
+import org.openrewrite.test.RewriteTest;
+
+import static org.openrewrite.java.Assertions.java;
+import static org.openrewrite.java.Assertions.javaVersion;
+
+public class TypeNotPresentExceptionTest implements RewriteTest {
+    @Override
+    public void defaults(RecipeSpec spec) {
+        spec.recipe(new HandleTypeNotPresentExceptionInsteadOfArrayStoreException())
+          .parser(JavaParser.fromJavaVersion()
+            //language=java
+            .dependsOn(
+            """
+              import java.lang.annotation.*;
+              import java.util.*;
+          
+              public class Test {
+                  public void testMethod() {
+                      try {
+                          Object o = "test";
+                          o.getClass().getAnnotation(Override.class);
+                      } catch (ArrayStoreException e) {
+                          System.out.println("Caught ArrayStoreException");
+                      }
+                  }
+              }
+              """,
+            """
+              import java.lang.annotation.*;
+              import java.util.*;
+              
+              public class Test {
+                  public void testMethod() {
+                      try {
+                          Object o = "test";
+                          o.getClass().getAnnotation(Override.class);
+                      } catch (TypeNotPresentException e) {
+                          System.out.println("Caught TypeNotPresentException");
+                      }
+                  }
+              }
+              """
+          )
+        );
+    }
+
+
+    @Test
+    void replaceGetLocalizedOutputStream() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+          public class Test {
+              public void testMethod() {
+                  try {
+                      Object o = "test";
+                      o.getClass().getAnnotation(Override.class);
+                  } catch (NullPointerException e) {
+                      System.out.println("Caught NullPointerException");
+                  }
+              }
+          }
+          """
+          )
+        );
+    }
+}