Add .contextSensitive() to Hamcrest conversion templates and improve type matching in CollapseConsecutiveAssertThatStatements (#912)

* Add .contextSensitive() to Hamcrest conversion templates and improve type matching in CollapseConsecutiveAssertThatStatements

- Add .contextSensitive() to JavaTemplate builders in HamcrestMatcherToAssertJ, HamcrestNotMatcherToAssertJ, and HamcrestIsMatcherToAssertJ to ensure templates are compiled in proper source context
- Improve CollapseConsecutiveAssertThatStatements with fallback for partially resolved SELF return types (e.g., when assertion methods return AbstractIterableAssert instead of ListAssert)
- Update test expectations: isNotNull() now collapses with other assertions and is removed by SimplifyRedundantAssertJChains
- Add test case for custom types to verify hamcrest-to-AssertJ conversion works

Fixes the issue where the AssertJ best practices recipe required multiple runs on Hamcrest test files before seeing chained assertions.

* Fix typeToIndicator to include erased type for java types

Use #{any(java.util.List)} instead of #{any()} for Java standard library
types in HamcrestMatcherToAssertJ.typeToIndicator(). This gives the
template parser enough type information to resolve the correct assertThat
overload, producing proper return types even when generic type parameters
reference custom types not on the template parser classpath.

This enables CollapseConsecutiveAssertThatStatements to chain assertions
on custom types (like List<Biscuit>) in a single pass, no longer
requiring TypeValidation.none() in tests.

Author: timtebeek

src/main/java/org/openrewrite/java/testing/assertj/CollapseConsecutiveAssertThatStatements.java

@@ -133,6 +133,15 @@ private boolean isGroupableAssertion(J.MethodInvocation assertion) {
                                 if (assertThatFq != null && assertionFq != null) {
                                     return TypeUtils.isOfType(assertThatFq.getType(), assertionFq.getType());
                                 }
+
+                                // When assertion methods return SELF but the type parameter is not fully resolved,
+                                // the return type may be a superclass (e.g. AbstractIterableAssert instead of ListAssert).
+                                // Check if assertThatType is a subtype of assertionType to handle this case.
+                                JavaType.FullyQualified assertThatFqType = TypeUtils.asFullyQualified(assertThatType);
+                                JavaType.FullyQualified assertionFqType = TypeUtils.asFullyQualified(assertionType);
+                                if (assertThatFqType != null && assertionFqType != null) {
+                                    return TypeUtils.isAssignableTo(assertionFqType.getFullyQualifiedName(), assertThatType);
+                                }
                             }
                             return false;
                         }

src/main/java/org/openrewrite/java/testing/hamcrest/HamcrestIsMatcherToAssertJ.java

@@ -85,6 +85,7 @@ public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, Execu
                         new Object[]{actualArgument, expectedArgument};
 
                 return JavaTemplate.builder(template)
+                        .contextSensitive()
                         .javaParser(JavaParser.fromJavaVersion().classpathFromResources(ctx, "assertj-core-3"))
                         .staticImports("org.assertj.core.api.Assertions.assertThat")
                         .build()

src/main/java/org/openrewrite/java/testing/hamcrest/HamcrestMatcherToAssertJ.java

@@ -106,6 +106,7 @@ private J.MethodInvocation replace(J.MethodInvocation mi, ExecutionContext ctx)
                             (reasonArgument != null ? ".as(#{any(String)})" : "") +
                             ".%s(%s)",
                             actual, assertion, argsTemplate))
+                    .contextSensitive()
                     .javaParser(JavaParser.fromJavaVersion().classpathFromResources(ctx, "assertj-core-3"))
                     .staticImports(
                             "org.assertj.core.api.Assertions.assertThat",
@@ -186,9 +187,12 @@ private String typeToIndicator(@Nullable JavaType type) {
                         type.toString().replaceAll("<.*>", "") : "java.lang.Object";
                 return String.format("#{anyArray(%s)}", str);
             }
-            if (type instanceof JavaType.Primitive || type != null && type.toString().startsWith("java.")) {
+            if (type instanceof JavaType.Primitive) {
                 return "#{any()}";
             }
+            if (type != null && type.toString().startsWith("java.")) {
+                return String.format("#{any(%s)}", type.toString().replaceAll("<.*>", ""));
+            }
             return "#{any(java.lang.Object)}";
         }
     }

src/main/java/org/openrewrite/java/testing/hamcrest/HamcrestNotMatcherToAssertJ.java

@@ -103,6 +103,7 @@ private J.MethodInvocation handleTwoArgumentCase(J.MethodInvocation mi, Expressi
                     .collect(joining(", "));
             JavaTemplate template = JavaTemplate.builder(String.format("assertThat(%s).%s(%s)",
                             actual, assertion, argumentsTemplate))
+                    .contextSensitive()
                     .javaParser(JavaParser.fromJavaVersion().classpathFromResources(ctx, "assertj-core-3"))
                     .staticImports("org.assertj.core.api.Assertions.assertThat")
                     .build();
@@ -135,6 +136,7 @@ private J.MethodInvocation handleThreeArgumentCase(J.MethodInvocation mi, Expres
                     .collect(joining(", "));
             JavaTemplate template = JavaTemplate.builder(String.format("assertThat(%s).as(#{any(String)}).%s(%s)",
                             actual, assertion, argumentsTemplate))
+                    .contextSensitive()
                     .javaParser(JavaParser.fromJavaVersion().classpathFromResources(ctx, "assertj-core-3"))
                     .staticImports("org.assertj.core.api.Assertions.assertThat")
                     .build();

src/test/java/org/openrewrite/java/testing/assertj/AssertJBestPracticesTest.java

@@ -132,7 +132,6 @@ void biscuits() {
                   class BiscuitTest {
                       void biscuits() {
                           List<String> biscuits = List.of("Ginger", "Chocolate", "Oatmeal");
-                          assertThat(biscuits).isNotNull();
                           assertThat(biscuits)
                                   .hasSize(3)
                                   .contains("Chocolate");
@@ -143,6 +142,57 @@ void biscuits() {
             );
         }
 
+        @Test
+        void hamcrestToCollapsedAssertionsWithCustomType() {
+            rewriteRun(
+              spec -> spec.parser(JavaParser.fromJavaVersion().classpathFromResources(new InMemoryExecutionContext(), "hamcrest-3")),
+              //language=java
+              java(
+                """
+                  class Biscuit {
+                      String name;
+                      Biscuit(String name) {
+                          this.name = name;
+                      }
+                  }
+                  """
+              ),
+              //language=java
+              java(
+                """
+                  import java.util.List;
+
+                  import static org.hamcrest.MatcherAssert.assertThat;
+                  import static org.hamcrest.Matchers.*;
+
+                  class BiscuitTest {
+                      void biscuits() {
+                          List<Biscuit> biscuits = List.of(new Biscuit("Ginger"), new Biscuit("Chocolate"), new Biscuit("Oatmeal"));
+                          assertThat(biscuits, hasSize(3));
+                          assertThat(biscuits, hasItem(new Biscuit("Chocolate")));
+                          assertThat(biscuits, not(hasItem(new Biscuit("Raisin"))));
+                      }
+                  }
+                  """,
+                """
+                  import java.util.List;
+
+                  import static org.assertj.core.api.Assertions.assertThat;
+
+                  class BiscuitTest {
+                      void biscuits() {
+                          List<Biscuit> biscuits = List.of(new Biscuit("Ginger"), new Biscuit("Chocolate"), new Biscuit("Oatmeal"));
+                          assertThat(biscuits)
+                                  .hasSize(3)
+                                  .contains(new Biscuit("Chocolate"))
+                                  .doesNotContain(new Biscuit("Raisin"));
+                      }
+                  }
+                  """
+              )
+            );
+        }
+
         @Test
         void junitCollapsedAssertions() {
             rewriteRun(