Recipe ReplaceAWTGetPeerMethod in Java 11 Migration

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

@@ -23,6 +23,7 @@
 import org.openrewrite.xml.XmlVisitor;
 import org.openrewrite.xml.tree.Xml;
 
+import java.util.List;
 import java.util.Map;
 
 import static java.util.stream.Collectors.toMap;

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

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2024 the original author or authors.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.openrewrite.java.migrate;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.EqualsAndHashCode;
+import lombok.Value;
+import org.openrewrite.ExecutionContext;
+import org.openrewrite.Preconditions;
+import org.openrewrite.Recipe;
+import org.openrewrite.TreeVisitor;
+import org.openrewrite.java.ChangeMethodName;
+import org.openrewrite.java.JavaVisitor;
+import org.openrewrite.java.search.UsesMethod;
+import org.openrewrite.java.tree.Expression;
+import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.JavaType;
+
+@Value
+@EqualsAndHashCode(callSuper = false)
+@AllArgsConstructor(access = AccessLevel.PACKAGE) // For tests
+class DetectAWTGetPeerMethod extends Recipe {
+    String methodPatternGetPeer;
+    String methodUpdateIsDisplayable;
+    String className;
+    String methodUpdateIsLightweight;
+
+    @Override
+    public String getDisplayName() {
+        return "Replace `getPeer()` method";
+    }
+
+    @Override
+    public String getDescription() {
+        return " All methods that refer to types defined in the java.awt.peer package are removed in Java 11. "
+               + "This recipe replaces the use of getPeer() method in the java.awt.Component, java.awt.Font, and java.awt.MenuComponent classes and direct known subclasse."
+               + "The occurrence of  `(component.getPeer() != null) { .. }` is replaced with `(component.isDisplayable())` "
+               + "and the occurrence of `(component.getPeer() instanceof LightweightPeer)` "
+               + "is replaced with `(component.isLightweight())`.";
+    }
+
+    @JsonCreator
+    public DetectAWTGetPeerMethod() {
+        this.methodPatternGetPeer = "java.awt.* getPeer()";
+        this.methodUpdateIsDisplayable = "java.awt.* isDisplayable()";
+        this.className = "java.awt.peer.LightweightPeer";
+        this.methodUpdateIsLightweight = "java.awt.*  isLightweight()";
+    }
+
+    @Override
+    public TreeVisitor<?, ExecutionContext> getVisitor() {
+        return Preconditions.check(new UsesMethod<>(methodPatternGetPeer), new JavaVisitor<ExecutionContext>() {
+            @Override
+            public <T extends J> J.ControlParentheses<T> visitControlParentheses(J.ControlParentheses<T> cp, ExecutionContext ctx) {
+                Expression ifCExp = (Expression) cp.getTree();
+                //Check if there is a Binary or an instanceOf inside the paranthesis
+                if (!(ifCExp instanceof J.Binary) && !(ifCExp instanceof J.InstanceOf)) {
+                    return cp;
+                }
+                if (ifCExp instanceof J.Binary) {
+                    J.Binary binaryCondition = (J.Binary) ifCExp;
+                    //check if(x.getPeer() != null)
+                    if (binaryCondition.getLeft() instanceof J.MethodInvocation && binaryCondition.getRight() instanceof J.Literal && binaryCondition.getOperator().name().equals("NotEqual")) {
+                        J.MethodInvocation mi = (J.MethodInvocation) binaryCondition.getLeft();
+                        J.Literal lt = (J.Literal) binaryCondition.getRight();
+                        if (mi.getName().getSimpleName().equals("getPeer") && lt.getValueSource().equals("null")) {
+                            mi = (J.MethodInvocation) new ChangeMethodName(methodPatternGetPeer, "isDisplayable", true, null
+                            ).getVisitor().visit(mi, ctx);
+                            mi = (J.MethodInvocation) new ChangeMethodInvocationReturnType(methodUpdateIsDisplayable, "boolean").getVisitor().visit(mi, ctx);
+                            return cp.withTree((T) mi);
+                        }
+                    }
+                } else if (ifCExp instanceof J.InstanceOf) {
+                    J.InstanceOf instanceOfVar = (J.InstanceOf) ifCExp;
+                    if ((instanceOfVar.getExpression() instanceof J.MethodInvocation)) {
+                        J.MethodInvocation mi = ((J.MethodInvocation) instanceOfVar.getExpression());
+                        if (mi.getName().getSimpleName().equals("getPeer") && checkClassNameIsEqualToFQCN(instanceOfVar)) {
+                            mi = (J.MethodInvocation) new ChangeMethodName(methodPatternGetPeer, "isLightweight", true, null
+                            ).getVisitor().visit(mi, ctx);
+                            mi = (J.MethodInvocation) new ChangeMethodInvocationReturnType(methodUpdateIsLightweight, "boolean").getVisitor().visit(mi, ctx);
+                            return cp.withTree((T) mi);
+                        }
+                    }
+                }
+                return cp;
+            }
+        });
+    }
+
+    private boolean checkClassNameIsEqualToFQCN(J.InstanceOf instOf) {
+        if (instOf.getClazz() instanceof J.Identifier) {
+            J.Identifier id = (J.Identifier) instOf.getClazz();
+            return ((JavaType.Class) id.getType()).getFullyQualifiedName().toString().equals(className);
+        } else if (instOf.getClazz() instanceof J.FieldAccess) {
+            J.FieldAccess fid = (J.FieldAccess) instOf.getClazz();
+            return ((JavaType.Class) fid.getType()).getFullyQualifiedName().toString().equals(className);
+        } else {
+            return false;
+        }
+    }
+}

src/main/resources/META-INF/rewrite/java-version-11.yml

@@ -70,7 +70,7 @@ recipeList:
   - org.openrewrite.java.migrate.RemovedPolicy
   - org.openrewrite.java.migrate.ReferenceCloneMethod
   - org.openrewrite.java.migrate.ThreadStopDestroy
-
+  - org.openrewrite.java.migrate.DetectAWTGetPeerMethod
 ---
 type: specs.openrewrite.org/v1beta/recipe
 name: org.openrewrite.java.migrate.UpgradeBuildToJava11
@@ -281,4 +281,4 @@ recipeList:
       fullyQualifiedTargetTypeName: java.nio.file.Path
   - org.openrewrite.java.ChangeMethodName:
       methodPattern: java.nio.file.Path get(..)
-      newMethodName: of
+      newMethodName: of

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

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2024 the original author or authors.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.openrewrite.java.migrate;
+
+import org.junit.jupiter.api.Test;
+import org.openrewrite.DocumentExample;
+import org.openrewrite.java.JavaParser;
+import org.openrewrite.test.RecipeSpec;
+import org.openrewrite.test.RewriteTest;
+
+import static org.openrewrite.java.Assertions.java;
+
+class DetectAWTGetPeerMethodTest implements RewriteTest {
+    @Override
+    public void defaults(RecipeSpec spec) {
+        spec.recipe(new DetectAWTGetPeerMethod(
+            "com.test.Component1 getPeer()",
+            "com.test.Component1 isDisplayable()",
+            "com.test.TestDummy",
+            "com.test.Component1 isLightweight()"))
+          .parser(JavaParser.fromJavaVersion()
+            //language=java
+            .dependsOn(
+              """
+                package com.test;
+                public class Component1 {
+                    public String getPeer() {
+                        return "x";
+                    }
+                    public boolean getPeer1() {
+                        return true;
+                    }
+                    public boolean isDisplayable() {
+                        return true;
+                    }
+                    public boolean isLightweight() {
+                        return true;
+                    }
+                }
+                """,
+              """
+                 package com.test;
+                 public class TestDummy {
+                 }
+                """
+            ));
+    }
+
+
+    @DocumentExample
+    @Test
+    void instanceAndGetPeerMethod() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              package com.test;
+              class Test extends TestDummy {
+                  public void foo() {
+                      Test t1 = new Test();
+                      Component1 c = new Component1();
+                      if (c.getPeer() instanceof com.test.TestDummy) {
+                      }
+                      if (c.getPeer() instanceof TestDummy) {
+                      }
+                      Component1 y = new Component1();
+                      if (y.getPeer() != null) {
+                      }
+                  }
+              }
+              """,
+            """
+              package com.test;
+              public class Test extends TestDummy {
+                  public static void main(String args[]) {
+                      Test t1 = new Test();
+                      Component1 c = new Component1();
+                      if (c.isLightweight()) {
+                      }
+                      if (c.isLightweight()) {
+                      }
+                      Component1 y = new Component1();
+                      if (y.isDisplayable()) {
+                      }
+                  }
+              }
+              """
+          )
+        );
+    }
+}