Fix Kotlin parser handling of unresolved callable references (#7469)

`visitCallableReferenceExpression` looked up the FIR for the callable
reference's right-hand side (`expression.getCallableReference()`) to
decide whether to accept the reference. When the type is unresolved
(e.g. `JavaLanguageVersion::of` in a `.gradle.kts` parsed without the
full Gradle classpath), the RHS maps to `FirErrorNamedReferenceImpl`
even though the whole expression still maps cleanly to
`FirCallableReferenceAccess`. The visitor then threw, the declaration
bubbled up into `J.Unknown`, and its PSI text range (which includes the
trailing newline) got duplicated against the file's EOF space, causing
a print idempotency failure.

Check the FIR mapping of the whole expression for validity instead, and
use the reference-level FIR only for optional type resolution. Types
simply remain `null` when the reference cannot be resolved, which
matches how other unresolved-type scenarios are handled.

Re-enables the previously `@Disabled` `firCallableReferenceAccess`
regression test.

Author: knutwannheden

rewrite-gradle/src/test/java/org/openrewrite/gradle/GradleParserTest.java

@@ -275,6 +275,17 @@ void kotlinDsl() {
         );
     }
 
+    @Test
+    void kotlinDslWithUnresolvedCallableReference() {
+        rewriteRun(
+          buildGradleKts(
+            """
+              kotlin { jvmToolchain { languageVersion.set(libs.versions.jdk.map(JavaLanguageVersion::of)) } }
+              """
+          )
+        );
+    }
+
     @Test
     void escapedAndNonEscapedDollarSignsInSingleDoubleQuotes() {
         var gradleParser = new GradleParser(new GradleParser.Builder());

rewrite-kotlin/src/main/java/org/openrewrite/kotlin/internal/KotlinTreeParserVisitor.java

@@ -269,13 +269,14 @@ public J visitBreakExpression(KtBreakExpression expression, ExecutionContext dat
 
     @Override
     public J visitCallableReferenceExpression(KtCallableReferenceExpression expression, ExecutionContext data) {
-        FirElement firElement = psiElementAssociations.primary(expression.getCallableReference());
-        if (!(firElement instanceof FirResolvedCallableReference || firElement instanceof FirCallableReferenceAccess)) {
+        FirElement exprFir = psiElementAssociations.primary(expression);
+        if (!(exprFir instanceof FirCallableReferenceAccess)) {
             throw new UnsupportedOperationException(java.lang.String.format("Unsupported callable reference: fir class: %s, fir: %s, psi class: %s.",
-                    firElement == null ? "null" : firElement.getClass().getName(),
-                    PsiTreePrinter.print(psiElementAssociations.primary(expression)),
+                    exprFir == null ? "null" : exprFir.getClass().getName(),
+                    PsiTreePrinter.print(exprFir),
                     expression.getClass().getName()));
         }
+        FirElement firElement = psiElementAssociations.primary(expression.getCallableReference());
         JavaType.Method methodReferenceType = null;
         JavaType.Variable fieldReferenceType = null;
         if (firElement instanceof FirResolvedCallableReference) {

rewrite-kotlin/src/test/java/org/openrewrite/kotlin/tree/CompilationUnitTest.java

@@ -22,6 +22,7 @@
 import org.openrewrite.test.SourceSpec;
 
 import static org.openrewrite.kotlin.Assertions.kotlin;
+import static org.openrewrite.kotlin.Assertions.kotlinScript;
 
 class CompilationUnitTest implements RewriteTest {
 
@@ -69,6 +70,18 @@ class A /*C1*/
         );
     }
 
+    @Test
+    void unresolvedCallableReference() {
+        rewriteRun(
+          spec -> spec.typeValidationOptions(org.openrewrite.test.TypeValidation.none()),
+          kotlinScript(
+            """
+              kotlin { jvmToolchain { languageVersion.set(libs.versions.jdk.map(JavaLanguageVersion::of)) } }
+              """
+          )
+        );
+    }
+
     @ParameterizedTest
     @ValueSource(strings = {
       "class Foo",

rewrite-kotlin/src/test/java/org/openrewrite/kotlin/tree/MemberReferenceTest.java

@@ -15,7 +15,6 @@
  */
 package org.openrewrite.kotlin.tree;
 
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.openrewrite.Issue;
 import org.openrewrite.test.RewriteTest;
@@ -142,7 +141,6 @@ fun method ( s: List<String   ? > ) {
         );
     }
 
-    @Disabled("K2 produces J.Unknown for unresolved callable references (::unresolved)")
     @Issue("https://github.com/openrewrite/rewrite-kotlin/issues/386")
     @Test
     void firCallableReferenceAccess() {