Verify equality of template signatures

src/main/java/org/openrewrite/java/template/processor/RefasterTemplateProcessor.java

@@ -735,11 +735,18 @@ public RuleDescriptor(JCTree.JCClassDecl classDecl, JCCompilationUnit cu, Contex
             // resolve so that we can inspect the template body
             boolean valid = resolve();
             if (valid) {
+                Set<String> signatures = new HashSet<>();
                 for (TemplateDescriptor template : beforeTemplates) {
                     valid &= template.validate();
+                    signatures.add(template.method.getParameters().stream().map(p -> p.getType().toString()).collect(Collectors.joining(",")));
                 }
                 if (afterTemplate != null) {
                     valid &= afterTemplate.validate();
+                    signatures.add(afterTemplate.method.getParameters().stream().map(p -> p.getType().toString()).collect(Collectors.joining(",")));
+                }
+                if (signatures.size() > 1) {
+                    printNoteOnce("@Before and @After methods of a single recipe must have the same method signature", classDecl.sym);
+                    valid = false;
                 }
             }
             return valid ? this : null;

src/test/java/org/openrewrite/java/template/RefasterTemplateProcessorTest.java

@@ -106,6 +106,18 @@ void stringIsEmptyPredicate() {
         assertEquals(0, compilation.generatedSourceFiles().size(), "Not yet supported");
     }
 
+    @ParameterizedTest
+    @ValueSource(strings = {
+      "Types",
+      "Count",
+    })
+    void signatureMismatch(String error) {
+        Compilation compilation = compileResource("refaster/SignatureMismatch" + error + ".java");
+        assertThat(compilation).succeeded();
+        assertThat(compilation).hadNoteContaining("must have the same method signature");
+        assertEquals(0, compilation.generatedSourceFiles().size(), "Must not generate recipe for mismatched templates");
+    }
+
     private static Compilation compileResource(String resourceName) {
         return compileResource(resourceName, new RefasterTemplateProcessor());
     }

src/test/resources/refaster/SignatureMismatchCount.java

@@ -0,0 +1,32 @@
+/*
+ * 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.
+ */
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+
+import java.io.File;
+import java.nio.file.Path;
+
+public class SignatureMismatchCount {
+    @BeforeTemplate
+    String before(File file) {
+        return "This method has 1 parameter";
+    }
+
+    @AfterTemplate
+    String after() {
+        return "This method has 0 parameters";
+    }
+}

src/test/resources/refaster/SignatureMismatchTypes.java

@@ -0,0 +1,32 @@
+/*
+ * 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.
+ */
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+
+import java.io.File;
+import java.nio.file.Path;
+
+public class SignatureMismatchTypes {
+    @BeforeTemplate
+    String before(File file) {
+        return "This method has a File typed parameter";
+    }
+
+    @AfterTemplate
+    String after(Path path) {
+        return "This method has a Path typed parameter";
+    }
+}