Allow AddMethodParameter to match overridden methods (#6294)

* Issue #6287: enable AddMethodParameter to match overridden methods

* Minimize changes to `MethodMatcher`

* Rename variable to clarify meaning in this context

* Expand tests in DeclaresTypeTest

---------

Co-authored-by: Tim te Beek <tim@moderne.io>

Author: Anmol202005

rewrite-java/src/main/java/org/openrewrite/java/AddMethodParameter.java

@@ -83,14 +83,18 @@ public TreeVisitor<?, ExecutionContext> getVisitor() {
         int idx = methodPattern.indexOf('#');
         idx = idx == -1 ? methodPattern.indexOf(' ') : idx;
         boolean typePattern = idx != -1 && methodPattern.lastIndexOf('*', idx) != -1;
-        return Preconditions.check(typePattern ? new DeclaresMatchingType(methodPattern.substring(0, idx)) : new DeclaresType<>(methodPattern.substring(0, idx)), new AddNullMethodArgumentVisitor(methodPattern));
+        return Preconditions.check(
+                typePattern ?
+                        new DeclaresMatchingType(methodPattern.substring(0, idx)) :
+                        new DeclaresType<>(methodPattern.substring(0, idx), true),
+                new AddNullMethodArgumentVisitor(methodPattern));
     }
 
     private class AddNullMethodArgumentVisitor extends JavaIsoVisitor<ExecutionContext> {
         private final MethodMatcher methodMatcher;
 
         public AddNullMethodArgumentVisitor(String methodPattern) {
-            this.methodMatcher = new MethodMatcher(methodPattern);
+            this.methodMatcher = new MethodMatcher(methodPattern, true);
         }
 
         @Override
@@ -263,7 +267,7 @@ private static class DeclaresMatchingType extends JavaIsoVisitor<ExecutionContex
         private final TypeMatcher typeMatcher;
 
         public DeclaresMatchingType(String type) {
-            this.typeMatcher = new TypeMatcher(type);
+            this.typeMatcher = new TypeMatcher(type, true);
         }
 
         @Override

rewrite-java/src/main/java/org/openrewrite/java/search/DeclaresType.java

@@ -22,15 +22,24 @@
 
 public class DeclaresType<P> extends JavaIsoVisitor<P> {
     private final String type;
+    private final boolean includeSubtypes;
 
     public DeclaresType(String type) {
+        this(type, false);
+    }
+
+    public DeclaresType(String type, boolean includeSubtypes) {
         this.type = type;
+        this.includeSubtypes = includeSubtypes;
     }
 
     @Override
     public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, P p) {
-        if (classDecl.getType() != null && TypeUtils.isOfClassType(classDecl.getType(), type)) {
-            return SearchResult.found(classDecl);
+        if (classDecl.getType() != null) {
+            if (includeSubtypes && TypeUtils.isAssignableTo(type, classDecl.getType()) ||
+                    TypeUtils.isOfClassType(classDecl.getType(), type)) {
+                return SearchResult.found(classDecl);
+            }
         }
         return super.visitClassDeclaration(classDecl, p);
     }

rewrite-java/src/test/java/org/openrewrite/java/AddMethodParameterTest.java

@@ -305,4 +305,91 @@ public void bar(Object o) {
           )
         );
     }
+
+    @Test
+    void matchesMethodsInClassesThatImplementInterface() {
+        rewriteRun(
+          spec -> spec.recipe(new AddMethodParameter("foo.A count(foo.Sheep)", "Wolf", "wolf", null)),
+          java(
+            """
+            package foo;
+            
+            public interface A {
+                int count(Sheep flock);
+            }
+            """,
+            """
+            package foo;
+            
+            public interface A {
+                int count(Sheep flock, Wolf wolf);
+            }
+            """
+          ),
+          java(
+            """
+            package foo;
+            
+            public class Sheep {
+                public int size() {
+                    return 0;
+                }
+            }
+            """
+          ),
+          java(
+            """
+            package foo;
+            
+            public class Wolf {
+            }
+            """
+          ),
+          java(
+            """
+            package foo;
+            
+            public class Sleep implements A {
+                @Override
+                public int count(Sheep flock) {
+                    return flock.size();
+                }
+            }
+            """,
+            """
+            package foo;
+            
+            public class Sleep implements A {
+                @Override
+                public int count(Sheep flock, Wolf wolf) {
+                    return flock.size();
+                }
+            }
+            """
+          ),
+          java(
+            """
+            package foo;
+            
+            public class Awake implements A {
+                @Override
+                public int count(Sheep flock) {
+                    return 0;
+                }
+            }
+            """,
+            """
+            package foo;
+            
+            public class Awake implements A {
+                @Override
+                public int count(Sheep flock, Wolf wolf) {
+                    return 0;
+                }
+            }
+            """
+          )
+        );
+    }
+
 }

rewrite-java/src/test/java/org/openrewrite/java/search/DeclaresTypeTest.java

@@ -19,6 +19,7 @@
 import org.openrewrite.DocumentExample;
 import org.openrewrite.test.RecipeSpec;
 import org.openrewrite.test.RewriteTest;
+import org.openrewrite.test.SourceSpec;
 
 import static org.openrewrite.java.Assertions.java;
 
@@ -31,23 +32,72 @@ public void defaults(RecipeSpec spec) {
     @DocumentExample
     @Test
     void declares() {
-        rewriteRun(java(
-                """
-        package com.sample;
-        public class Foo{}
-        """,
-                """
-        package com.sample;
-        /*~~>*/public class Foo{}
-        """));
+        rewriteRun(
+          java(
+            """
+              package com.sample;
+              public class Foo{}
+              """,
+            """
+              package com.sample;
+              /*~~>*/public class Foo{}
+              """
+          )
+        );
+    }
+
+    @Test
+    void detectSubtypeWhenEnabled() {
+        rewriteRun(
+          spec -> spec.recipe(RewriteTest.toRecipe(() -> new DeclaresType<>("com.sample.Foo", true))),
+          java(
+            """
+              package com.sample;
+              public interface Foo{}
+              """,
+            SourceSpec::skip
+          ),
+          java(
+            """
+              import com.sample.Foo;
+              class A implements Foo{}
+              """,
+            """
+              import com.sample.Foo;
+              /*~~>*/class A implements Foo{}
+              """
+          )
+        );
+    }
+
+    @Test
+    void subtypeNotEnabledByDefault() {
+        rewriteRun(
+          java(
+            """
+              package com.sample;
+              public interface Foo{}
+              """,
+            SourceSpec::skip
+          ),
+          java(
+            """
+              import com.sample.Foo;
+              class A implements Foo{}
+              """
+          )
+        );
     }
 
     @Test
     void notDeclares() {
-        rewriteRun(java(
-                """
-        package com.sample;
-        public class Fooz{}
-        """));
+        rewriteRun(
+          java(
+            """
+              package com.sample;
+              public class Fooz{}
+              """
+          )
+        );
     }
 }