Run UnnecessaryCatch after UnnecessaryThrows to remove unused catch clauses (#785)

* Run `UnnecessaryCatch` after `UnnecessaryThrows` to remove unused catch clauses

- Fixes #605

* Update test name and minimize elements

Author: timtebeek

src/main/java/org/openrewrite/staticanalysis/UnnecessaryThrows.java

@@ -24,6 +24,7 @@
 import org.openrewrite.java.JavaIsoVisitor;
 import org.openrewrite.java.JavaVisitor;
 import org.openrewrite.java.JavadocVisitor;
+import org.openrewrite.java.MethodMatcher;
 import org.openrewrite.java.tree.*;
 
 import java.util.Comparator;
@@ -121,17 +122,38 @@ private void removeThrownTypes(JavaType.@Nullable Method type) {
                                 }
                             }
                         }
-                    }.visit(m, ctx);
+                    }.visit(m, ctx, getCursor().getParent());
 
                     if (!unusedThrows.isEmpty()) {
+                        MethodMatcher originalMethodMatcher = new MethodMatcher(m);
+
+                        JavaType.Method replacementMethodType = m.getMethodType().withThrownExceptions(ListUtils.map(m.getMethodType().getThrownExceptions(), t -> {
+                            JavaType.FullyQualified type = TypeUtils.asFullyQualified(t);
+                            return type != null && unusedThrows.contains(type) ? null : t;
+                        }));
                         m = m.withThrows(ListUtils.map(m.getThrows(), t -> {
-                            JavaType.FullyQualified type = TypeUtils.asFullyQualified(t.getType());
-                            if (type != null && unusedThrows.contains(type)) {
-                                maybeRemoveImport(type);
-                                return null;
+                                    JavaType.FullyQualified type = TypeUtils.asFullyQualified(t.getType());
+                                    if (type != null && unusedThrows.contains(type)) {
+                                        maybeRemoveImport(type);
+                                        return null;
+                                    }
+                                    return t;
+                                }))
+                                .withMethodType(replacementMethodType)
+                                .withName(m.getName().withType(replacementMethodType));
+
+                        // Remove the thrown exceptions from the method type, such that UnnecessaryCatch can continue
+                        doAfterVisit(new JavaIsoVisitor<ExecutionContext>() {
+                            @Override
+                            public J.MethodInvocation visitMethodInvocation(J.MethodInvocation invocation, ExecutionContext ctx) {
+                                if (originalMethodMatcher.matches(invocation)) {
+                                    invocation =  invocation.withMethodType(replacementMethodType)
+                                            .withName(invocation.getName().withType(replacementMethodType));
+                                }
+                                return super.visitMethodInvocation(invocation, ctx);
                             }
-                            return t;
-                        }));
+                        });
+                        doAfterVisit(new UnnecessaryCatch(true, false).getVisitor());
                     }
                 }
 

src/test/java/org/openrewrite/staticanalysis/UnnecessaryThrowsTest.java

@@ -457,4 +457,36 @@ protected void method() {
           )
         );
     }
+
+    @Issue("https://github.com/openrewrite/rewrite-static-analysis/issues/605")
+    @Test
+    void removeUnnecessaryCatchAfterRemovingThrows() {
+        rewriteRun(
+          java(
+            """
+              class UnnecessaryThrowsTest {
+
+                  void methodThrowing() throws NoSuchMethodException { }
+
+                  void methodCatching() {
+                      try {
+                          methodThrowing();
+                      }
+                      catch (NoSuchMethodException e) { }
+                  }
+              }
+              """,
+            """
+              class UnnecessaryThrowsTest {
+
+                  void methodThrowing() { }
+
+                  void methodCatching() {
+                      methodThrowing();
+                  }
+              }
+              """
+          )
+        );
+    }
 }