Kotlin missing type information

rewrite-java-test/build.gradle.kts

@@ -2,9 +2,14 @@ plugins {
     id("org.openrewrite.build.language-library")
 }
 
+recipeDependencies {
+    parserClasspath("jakarta.persistence:jakarta.persistence-api:3.1.0")
+}
+
 dependencies {
     implementation("org.assertj:assertj-core:latest.release")
     implementation(project(":rewrite-java"))
+    implementation(project(":rewrite-gradle"))
     implementation(project(":rewrite-groovy"))
     implementation(project(":rewrite-test"))
 

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

@@ -17,13 +17,17 @@
 
 import org.junit.jupiter.api.Test;
 import org.openrewrite.DocumentExample;
+import org.openrewrite.InMemoryExecutionContext;
 import org.openrewrite.Issue;
 import org.openrewrite.java.search.FindMissingTypes;
+import org.openrewrite.kotlin.KotlinParser;
 import org.openrewrite.test.RecipeSpec;
 import org.openrewrite.test.RewriteTest;
 import org.openrewrite.test.TypeValidation;
 
+import static org.openrewrite.gradle.Assertions.buildGradleKts;
 import static org.openrewrite.java.Assertions.java;
+import static org.openrewrite.kotlin.Assertions.kotlin;
 
 @SuppressWarnings("ClassInitializerMayBeStatic")
 class FindMissingTypesTest implements RewriteTest {
@@ -240,4 +244,71 @@ interface Foo {
           )
         );
     }
+
+    // Groovy Kotlin DSL seems to be missing from the classpath
+    @Test
+    void repositoryByUrlAndPurposeProjectKts() {
+        rewriteRun(
+          buildGradleKts(
+            """
+              plugins {
+                  id("java")
+                  id("kotlin") version "1.9.22"
+                  `maven-publish`
+              }
+
+              group = "com.some.project"
+              version = "1.0.0"
+
+              java {
+                  withJavadocJar()
+                  withSourcesJar()
+                  toolchain {
+                      languageVersion.set(JavaLanguageVersion.of(JavaVersion.VERSION_21.majorVersion))
+                  }
+              }
+
+              repositories {
+                  mavenCentral()
+              }
+
+              dependencies {
+
+              }
+
+              tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
+                  kotlinOptions.jvmTarget = "21"
+              }
+              """
+          )
+        );
+    }
+
+    @Test
+    void kotlinClassReference() {
+        rewriteRun(
+          spec -> spec.parser(
+            KotlinParser.builder().classpathFromResources(new InMemoryExecutionContext(), "jakarta.persistence-api")),
+          kotlin(
+            """
+              package com.some.other
+
+              class EventPublisher {
+              }
+              """
+          ),
+          kotlin(
+            """
+              package com.some.card
+
+              import com.some.other.EventPublisher
+              import jakarta.persistence.EntityListeners
+
+              @EntityListeners(EventPublisher::class)
+              data class Card(
+              )
+              """
+          )
+        );
+    }
 }

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

@@ -181,12 +181,18 @@ public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, Execu
         @Override
         public J.MemberReference visitMemberReference(J.MemberReference memberRef, ExecutionContext ctx) {
             J.MemberReference mr = super.visitMemberReference(memberRef, ctx);
-            JavaType.Method type = mr.getMethodType();
-            if (type != null) {
-                if (!isWellFormedType(type, seenTypes)) {
+            if (mr.getType() != null) {
+                JavaType type = mr.getType();
+                if (type instanceof JavaType.Parameterized) {
+                    return mr;
+                }
+            }
+            if (mr.getMethodType() != null) {
+                JavaType.Method methodType = mr.getMethodType();
+                if (!isWellFormedType(methodType, seenTypes)) {
                     mr = SearchResult.found(mr, "MemberReference type is missing or malformed");
-                } else if (!type.getName().equals(mr.getReference().getSimpleName()) && !type.isConstructor()) {
-                    mr = SearchResult.found(mr, "type information has a different method name '" + type.getName() + "'");
+                } else if (!methodType.getName().equals(mr.getReference().getSimpleName()) && !methodType.isConstructor()) {
+                    mr = SearchResult.found(mr, "type information has a different method name '" + methodType.getName() + "'");
                 }
             } else {
                 JavaType.Variable variableType = mr.getVariableType();