Kotlin: remap builtins on Java-origin method/field types (#7428)

* Kotlin: remap builtins on method parameter, return, and variable types

`KotlinTypeMapping` applied `remapKotlinBuiltin` to supertypes,
interfaces, generic bounds, and annotations in #7364, but not to
method parameter types, return types, receiver types, or field
types. A Kotlin `IllegalArgumentException("msg", cause)` therefore
produced a constructor whose parameter types were `kotlin.String` /
`kotlin.Throwable`, so a `MethodMatcher` written against the Java
FQNs (`java.lang.String` / `java.lang.Throwable`) failed to match on
Kotlin sources even though the bytecode signature is identical.

Wire `remapKotlinBuiltin` through both `methodDeclarationType` and
`methodInvocationType` (parameter types, return type, receiver) and
through `variableType` (field/property type).

* Scope Kotlin builtin remap to Java-origin classes

Following review on #7428, only remap kotlin.* parameter/return/field
types when the declaring class is a FirJavaClass (third-party Java
libraries on the classpath). Kotlin-declared signatures —
`kotlin.io.ConsoleKt.println(kotlin.Any)`, user properties of type
`String`, etc. — keep their author-intended Kotlin builtin names.

The motivating case (#7427) is Jackson's JsonGenerationException,
which is FirJavaClass; the test now uses that directly. JDK classes
go through Kotlin's classfile loader as something other than
FirJavaClass and are out of scope here — recipes that target JDK
signatures over Kotlin code need a Kotlin-aware MethodMatcher.

* Use reduce() to assign found in new test

Author: timtebeek

rewrite-kotlin/src/main/kotlin/org/openrewrite/kotlin/KotlinTypeMapping.kt

@@ -33,6 +33,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.modality
 import org.jetbrains.kotlin.fir.declarations.utils.visibility
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedArgumentList
+import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaField
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
@@ -702,7 +703,15 @@ class KotlinTypeMapping(
             parentType = parentType.type
         }
         val resolvedDeclaringType = TypeUtils.asFullyQualified(parentType)
-        var returnType = type(function.returnTypeRef)
+        // Only remap kotlin.* builtins to JVM FQNs for methods declared on Java-origin
+        // classes (third-party Java libraries loaded as FirJavaClass). The Kotlin compiler's
+        // FIR renders a Java method's `String` parameter as `kotlin.String` even though the
+        // bytecode signature is `java.lang.String`; remapping puts the parser's output back
+        // in line with the JVM signature so MethodMatcher patterns written against Java
+        // FQNs match. Kotlin-declared methods are left alone — `kotlin.Any` there is the
+        // author's intent, and Kotlin-aware matching belongs in KotlinTypeUtils.
+        val javaOrigin = parent is FirJavaClass
+        var returnType = if (javaOrigin) remapKotlinBuiltin(type(function.returnTypeRef)) else type(function.returnTypeRef)
         // Java parser uses the raw Class for a constructor's returnType, not the
         // class's parameterized form. Kotlin's FIR renders a constructor's
         // `returnTypeRef` as the class instantiated with its own type parameters
@@ -719,13 +728,14 @@ class KotlinTypeMapping(
             else -> null
         }
         if (function.receiverParameter != null) {
-            parameterTypes!!.add(type(function.receiverParameter!!.typeRef))
+            val rt = type(function.receiverParameter!!.typeRef)
+            parameterTypes!!.add(if (javaOrigin) remapKotlinBuiltin(rt)!! else rt)
         }
         if (function.valueParameters.isNotEmpty()) {
             for (p in function.valueParameters) {
                 val t = type(p.returnTypeRef, function)
                 if (t != null) {
-                    parameterTypes!!.add(t)
+                    parameterTypes!!.add(if (javaOrigin) remapKotlinBuiltin(t)!! else t)
                 }
             }
         }
@@ -971,10 +981,20 @@ class KotlinTypeMapping(
         if (declaringType == null) {
             declaringType = TypeUtils.asFullyQualified(type(firFile))
         }
-        val returnType = type(function.resolvedType)
+        // See methodDeclarationType: only remap for Java-origin methods so Kotlin-declared
+        // signatures (e.g. `kotlin.io.ConsoleKt.println(kotlin.Any)`) are preserved.
+        // The discriminator is the containing class FIR — Java-origin classes (third-party
+        // Java libraries on the classpath) are loaded as FirJavaClass even when the
+        // synthesized member FIR is FirConstructorImpl with an Enhancement origin. JDK
+        // classes are special-cased by Kotlin's classfile loader and aren't FirJavaClass —
+        // recipes targeting JDK signatures need a Kotlin-aware matcher instead.
+        val javaOrigin = (sym as? FirCallableSymbol<*>)
+            ?.containingClassLookupTag()?.toRegularClassSymbol(firSession)?.fir is FirJavaClass
+        val returnType = if (javaOrigin) remapKotlinBuiltin(type(function.resolvedType)) else type(function.resolvedType)
 
         if (function.toResolvedCallableSymbol()?.receiverParameterSymbol != null) {
-            paramTypes!!.add(type(function.toResolvedCallableSymbol()?.receiverParameterSymbol!!.fir.typeRef))
+            val rt = type(function.toResolvedCallableSymbol()?.receiverParameterSymbol!!.fir.typeRef)
+            paramTypes!!.add(if (javaOrigin) remapKotlinBuiltin(rt)!! else rt)
         }
         // Build a mapping from parameter name to its corresponding argument expression
         val paramToArg: Map<String, FirExpression>? =
@@ -991,12 +1011,13 @@ class KotlinTypeMapping(
             if (t is GenericTypeVariable) {
                 val arg = paramToArg?.get(p.name.asString())
                 if (arg != null) {
-                    paramTypes.add(type(arg.resolvedType, function)!!)
+                    val argType = type(arg.resolvedType, function)!!
+                    paramTypes.add(if (javaOrigin) remapKotlinBuiltin(argType)!! else argType)
                 } else {
                     paramTypes.add(t)
                 }
             } else {
-                paramTypes.add(t)
+                paramTypes.add(if (javaOrigin) remapKotlinBuiltin(t)!! else t)
             }
         }
         method.unsafeSet(
@@ -1112,6 +1133,18 @@ class KotlinTypeMapping(
         return type.fqName.asString()
     }
 
+    /**
+     * Convenience overload: apply [remapKotlinBuiltin] to any [JavaType], returning the
+     * input unchanged when it is not a [FullyQualified]. Callers use this on method
+     * parameter, receiver, return, and field types so Kotlin builtins (kotlin.String /
+     * kotlin.Throwable / ...) surface as the JVM FQN the Java parser would produce.
+     */
+    private fun remapKotlinBuiltin(t: JavaType?): JavaType? {
+        if (t == null) return null
+        val fq = TypeUtils.asFullyQualified(t)
+        return if (fq != null) remapKotlinBuiltin(fq) else t
+    }
+
     private fun remapKotlinBuiltin(fq: FullyQualified): FullyQualified {
         // For a Parameterized (e.g. kotlin.Enum<Foo>) remap the underlying raw type but
         // keep the parameterization so we don't lose type argument information.
@@ -1277,7 +1310,13 @@ class KotlinTypeMapping(
             declaringType = declaringType.type
         }
 
-        val typeRef = type(variable.returnTypeRef)
+        // See methodDeclarationType: only remap for Java-origin variables (e.g. fields read
+        // from a Java class file) so Kotlin properties keep their author-intended types.
+        val typeRef = if (variable is FirJavaField) {
+            remapKotlinBuiltin(type(variable.returnTypeRef))
+        } else {
+            type(variable.returnTypeRef)
+        }
         vt.unsafeSet(declaringType!!, typeRef, annotations)
         return vt
     }

rewrite-kotlin/src/test/java/org/openrewrite/kotlin/KotlinTypeMappingTest.java

@@ -547,6 +547,44 @@ public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, Atomi
             );
         }
 
+        @Issue("https://github.com/openrewrite/rewrite/issues/7427")
+        @Test
+        void constructorParameterTypesRemapKotlinBuiltinsForJavaOrigin() {
+            // A Kotlin call into a Java-origin constructor taking `String` / `Throwable`
+            // must surface parameter types as the JVM `java.lang.String` /
+            // `java.lang.Throwable`, not the Kotlin builtins, so `MethodMatcher` patterns
+            // written against the Java FQN match. Jackson's JsonGenerationException is the
+            // motivating case from #7427. Kotlin-declared signatures are intentionally
+            // left as-is — see #7428 review discussion.
+            rewriteRun(
+              kotlin(
+                """
+                  import com.fasterxml.jackson.core.JsonGenerationException
+                  import com.fasterxml.jackson.core.JsonGenerator
+
+                  fun example(gen: JsonGenerator, cause: Throwable) {
+                      throw JsonGenerationException("message", cause, gen)
+                  }
+                  """,
+                spec -> spec.afterRecipe(cu -> {
+                    var matcher = new MethodMatcher("com.fasterxml.jackson.core.JsonGenerationException <constructor>(String, Throwable, com.fasterxml.jackson.core.JsonGenerator)");
+                    AtomicBoolean found = new KotlinIsoVisitor<AtomicBoolean>() {
+                        @Override
+                        public J.NewClass visitNewClass(J.NewClass newClass, AtomicBoolean found) {
+                            var paramTypes = newClass.getConstructorType().getParameterTypes();
+                            assertThat(paramTypes.get(0).toString()).isEqualTo("java.lang.String");
+                            assertThat(paramTypes.get(1).toString()).isEqualTo("java.lang.Throwable");
+                            assertThat(matcher.matches(newClass)).isTrue();
+                            found.set(true);
+                            return super.visitNewClass(newClass, found);
+                        }
+                    }.reduce(cu, new AtomicBoolean());
+                    assertThat(found.get()).isTrue();
+                })
+              )
+            );
+        }
+
         @Test
         void whenExpression() {
             rewriteRun(