Add support for Kotlin 2.x

rewrite-kotlin/build.gradle.kts

@@ -2,10 +2,10 @@ import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 plugins {
     id("org.openrewrite.build.language-library")
-    kotlin("jvm") version "1.9.25"
+    kotlin("jvm") version "2.1.20"
 }
 
-val kotlinVersion = "1.9.25"
+val kotlinVersion = "2.1.21"
 
 dependencies {
     compileOnly(project(":rewrite-core"))

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

@@ -17,7 +17,7 @@
 
 import lombok.AllArgsConstructor;
 import lombok.Data;
-import org.jetbrains.kotlin.KtFakeSourceElement;
+import org.jetbrains.kotlin.KtFakePsiSourceElement;
 import org.jetbrains.kotlin.KtRealPsiSourceElement;
 import org.jetbrains.kotlin.KtSourceElement;
 import org.jetbrains.kotlin.com.intellij.openapi.util.TextRange;
@@ -29,7 +29,6 @@
 import org.jetbrains.kotlin.fir.declarations.FirProperty;
 import org.jetbrains.kotlin.fir.expressions.*;
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference;
-import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag;
 import org.jetbrains.kotlin.fir.types.*;
 import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor;
 import org.jetbrains.kotlin.ir.IrElement;
@@ -486,7 +485,7 @@ public static String printFirElement(FirElement firElement) {
 
             if (source instanceof KtRealPsiSourceElement) {
                 sb.append("Real ");
-            } else if (source instanceof KtFakeSourceElement) {
+            } else if (source instanceof KtFakePsiSourceElement) {
                 sb.append("Fake ");
             } else {
                 sb.append(source.getClass().getSimpleName());
@@ -545,7 +544,7 @@ private static String printConeKotlinType(ConeTypeProjection coneKotlinType) {
             return ((FirProperty) firElement).getName().toString();
         } else if (firElement instanceof FirResolvedTypeRef) {
             FirResolvedTypeRef resolvedTypeRef = (FirResolvedTypeRef) firElement;
-            ConeKotlinType coneKotlinType = resolvedTypeRef.getType();
+            ConeKotlinType coneKotlinType = resolvedTypeRef.getConeType();
             return printConeKotlinType(coneKotlinType);
         } else if (firElement instanceof FirResolvedNamedReference) {
             return ((FirResolvedNamedReference) firElement).getName().toString();
@@ -575,8 +574,8 @@ private static String printConeKotlinType(ConeTypeProjection coneKotlinType) {
                 }
                 return sb.toString();
             }
-        } else if (firElement instanceof FirConstExpression) {
-            Object value = ((FirConstExpression<?>) firElement).getValue();
+        } else if (firElement instanceof FirLiteralExpression) {
+            Object value = ((FirLiteralExpression) firElement).getValue();
             return value != null ? value.toString() : null;
             // return ((FirConstExpression<?>) firElement).getKind().toString();
         } else if (firElement instanceof FirWhenBranch) {

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

@@ -95,7 +95,7 @@ class KotlinIrTypeMapping(private val typeCache: JavaTypeCache) : JavaTypeMappin
                 return type(baseType.type)
             }
 
-            is IrConst<*> -> {
+            is IrConst -> {
                 return primitive(baseType)
             }
 
@@ -536,7 +536,7 @@ class KotlinIrTypeMapping(private val typeCache: JavaTypeCache) : JavaTypeMappin
 
     fun primitive(type: Any?): JavaType.Primitive {
         return when (type) {
-            is IrConst<*> -> {
+            is IrConst -> {
                 when (type.kind) {
                     IrConstKind.Int -> JavaType.Primitive.Int
                     IrConstKind.Boolean -> JavaType.Primitive.Boolean

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

@@ -63,7 +63,7 @@ class KotlinTypeIrSignatureBuilder : JavaTypeSignatureBuilder {
                 return signature(baseType.type)
             }
 
-            is IrConst<*> -> {
+            is IrConst -> {
                 return primitiveSignature(baseType)
             }
 
@@ -265,7 +265,7 @@ class KotlinTypeIrSignatureBuilder : JavaTypeSignatureBuilder {
 
     override fun primitiveSignature(type: Any): String {
         return when (type) {
-            is IrConst<*> -> type.type.classFqName!!.asString()
+            is IrConst -> type.type.classFqName!!.asString()
             else -> {
                 throw UnsupportedOperationException("Unsupported primitive type" + type.javaClass)
             }

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

@@ -39,8 +39,7 @@ import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.references.FirSuperReference
 import org.jetbrains.kotlin.fir.references.toResolvedBaseSymbol
 import org.jetbrains.kotlin.fir.resolve.calls.FirSyntheticFunctionSymbol
-import org.jetbrains.kotlin.fir.resolve.providers.toSymbol
-import org.jetbrains.kotlin.fir.resolve.toFirRegularClass
+import org.jetbrains.kotlin.fir.resolve.toRegularClassSymbol
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
 import org.jetbrains.kotlin.fir.symbols.impl.*
@@ -75,7 +74,7 @@ class KotlinTypeMapping(
     private val signatureBuilder: KotlinTypeSignatureBuilder = KotlinTypeSignatureBuilder(firSession, firFile)
 
     override fun type(type: Any?): JavaType {
-        if (type == null || type is FirErrorTypeRef || type is FirExpression && type.typeRef is FirErrorTypeRef || type is FirResolvedQualifier && type.classId == null) {
+        if (type == null || type is FirErrorTypeRef || type is FirExpression && type.resolvedType is FirErrorTypeRef || type is FirResolvedQualifier && type.classId == null) {
             return Unknown.getInstance()
         }
 
@@ -89,7 +88,7 @@ class KotlinTypeMapping(
     }
 
     fun type(type: Any?, parent: Any?): JavaType? {
-        if (type == null || type is FirErrorTypeRef || type is FirExpression && type.typeRef is FirErrorTypeRef || type is FirResolvedQualifier && type.classId == null) {
+        if (type == null || type is FirErrorTypeRef || type is FirExpression && type.resolvedType is FirErrorTypeRef || type is FirResolvedQualifier && type.classId == null) {
             return Unknown.getInstance()
         }
         val signature = signatureBuilder.signature(type, parent)
@@ -201,11 +200,11 @@ class KotlinTypeMapping(
             }
 
             is FirVariableAssignment -> {
-                type(type.lValue.typeRef, parent, signature)
+                type(type.lValue.resolvedType, parent, signature)
             }
 
             is FirExpression -> {
-                type(type.typeRef, parent, signature)
+                type(type.resolvedType, parent, signature)
             }
 
             is JavaElement -> {
@@ -312,7 +311,7 @@ class KotlinTypeMapping(
         val firClass = when (type) {
             is FirClass -> type
             is FirResolvedQualifier -> {
-                val ref = type.typeRef.toRegularClassSymbol(firSession)
+                val ref = type.resolvedType.toRegularClassSymbol(firSession)
                 if (type.typeArguments.isNotEmpty()) {
                     params = type.typeArguments
                 }
@@ -326,7 +325,7 @@ class KotlinTypeMapping(
             is ConeClassLikeType -> {
                 if (type.toSymbol(firSession) is FirTypeAliasSymbol) {
                     return classType(
-                        (type.toSymbol(firSession) as FirTypeAliasSymbol).resolvedExpandedTypeRef.type,
+                        (type.toSymbol(firSession) as FirTypeAliasSymbol).resolvedExpandedTypeRef.coneType,
                         parent,
                         signature
                     )
@@ -499,7 +498,7 @@ class KotlinTypeMapping(
 
     @OptIn(SymbolInternals::class)
     fun methodDeclarationType(enumEntry: FirEnumEntry): Method? {
-        val type = when (val fir = enumEntry.symbol.getContainingClassSymbol(firSession)?.fir) {
+        val type = when (val fir = enumEntry.symbol.getContainingClassSymbol()?.fir) {
             is FirClass -> {
                 when (val primary = fir.declarations.firstOrNull { it is FirPrimaryConstructor }) {
                     is FirPrimaryConstructor -> type(primary as FirFunction)
@@ -549,8 +548,8 @@ class KotlinTypeMapping(
         var parentType = when {
             function.symbol is FirConstructorSymbol -> type(function.returnTypeRef)
             function.dispatchReceiverType != null -> type(function.dispatchReceiverType!!)
-            function.symbol.getOwnerLookupTag()?.toFirRegularClass(firSession) != null -> {
-                type(function.symbol.getOwnerLookupTag()!!.toFirRegularClass(firSession)!!)
+            function.symbol.getOwnerLookupTag()?.toRegularClassSymbol(firSession) != null -> {
+                type(function.symbol.getOwnerLookupTag()!!.toRegularClassSymbol(firSession)!!)
             }
 
             parent is FirRegularClass || parent != null -> type(parent)
@@ -672,7 +671,8 @@ class KotlinTypeMapping(
     }
 
     fun methodInvocationType(fir: FirFunctionCall): Method? {
-        if (fir.typeRef is FirErrorTypeRef) {
+        //TODO is this correct?
+        if (!fir.isResolved) {
             return null
         }
         val signature = signatureBuilder.methodCallSignature(fir)
@@ -742,11 +742,11 @@ class KotlinTypeMapping(
             if (resolvedSymbol.dispatchReceiverType is ConeClassLikeType) {
                 declaringType = TypeUtils.asFullyQualified(type(resolvedSymbol.dispatchReceiverType))
             } else if (resolvedSymbol.containingClassLookupTag() != null &&
-                resolvedSymbol.containingClassLookupTag()!!.toFirRegularClass(firSession) != null
+                resolvedSymbol.containingClassLookupTag()!!.toRegularClassSymbol(firSession) != null
             ) {
                 declaringType = TypeUtils.asFullyQualified(
                     type(
-                        resolvedSymbol.containingClassLookupTag()!!.toFirRegularClass(firSession)
+                        resolvedSymbol.containingClassLookupTag()!!.toRegularClassSymbol(firSession)
                     )
                 )
             } else if (resolvedSymbol.origin == FirDeclarationOrigin.Library) {
@@ -766,19 +766,19 @@ class KotlinTypeMapping(
                     declaringType = createShallowClass("kotlin.Library")
                 }
             } else if (resolvedSymbol.origin == FirDeclarationOrigin.SamConstructor) {
-                declaringType = when(val type = type(function.typeRef)) {
+                declaringType = when(val type = type(function.resolvedType)) {
                     is Class -> type
                     is Parameterized -> type.type
                     else -> Unknown.getInstance()
                 }
             }
         } else {
-            declaringType = TypeUtils.asFullyQualified(type(function.typeRef))
+            declaringType = TypeUtils.asFullyQualified(type(function.resolvedType))
         }
         if (declaringType == null) {
             declaringType = TypeUtils.asFullyQualified(type(firFile))
         }
-        val returnType = type(function.typeRef)
+        val returnType = type(function.resolvedType)
 
         if (function.toResolvedCallableSymbol()?.receiverParameter != null) {
             paramTypes!!.add(type(function.toResolvedCallableSymbol()?.receiverParameter!!.typeRef))
@@ -805,12 +805,12 @@ class KotlinTypeMapping(
             if (t is GenericTypeVariable) {
                 if (mapNames && args != null) {
                     if (args.containsKey(p.name.asString())) {
-                        paramTypes.add(type(args[p.name.asString()]!!.typeRef, function)!!)
+                        paramTypes.add(type(args[p.name.asString()]!!.resolvedType, function)!!)
                     } else {
                         paramTypes.add(t)
                     }
                 } else if (index < valueParams.size) {
-                    paramTypes.add(type(function.arguments[index].typeRef, function)!!)
+                    paramTypes.add(type(function.arguments[index].resolvedType, function)!!)
                 }
             } else {
                 paramTypes.add(t)
@@ -896,9 +896,9 @@ class KotlinTypeMapping(
                 declaringType = type(variable.symbol.dispatchReceiverType)
             }
 
-            variable.symbol.getContainingClassSymbol(firSession) != null -> {
-                if (variable.symbol.getContainingClassSymbol(firSession) !is FirAnonymousObjectSymbol) {
-                    declaringType = type(variable.symbol.getContainingClassSymbol(firSession)!!.fir)
+            variable.symbol.getContainingClassSymbol() != null -> {
+                if (variable.symbol.getContainingClassSymbol() !is FirAnonymousObjectSymbol) {
+                    declaringType = type(variable.symbol.getContainingClassSymbol()!!.fir)
                 }
             }
 
@@ -1233,7 +1233,7 @@ class KotlinTypeMapping(
     private fun listAnnotations(firAnnotations: List<FirAnnotation>): MutableList<FullyQualified>? {
         var annotations: MutableList<FullyQualified>? = null
         for (firAnnotation in firAnnotations) {
-            val fir = firAnnotation.typeRef.toRegularClassSymbol(firSession)?.fir
+            val fir = firAnnotation.resolvedType.toRegularClassSymbol(firSession)?.fir
             if (fir != null && isNotSourceRetention(fir.annotations)) {
                 if (annotations == null) {
                     annotations = ArrayList()
@@ -1267,9 +1267,10 @@ class KotlinTypeMapping(
 
     private fun isNotSourceRetention(annotations: List<FirAnnotation>): Boolean {
         for (ann in annotations) {
-            if ("kotlin.annotation.Retention" == convertClassIdToFqn(ann.typeRef.coneType.classId)) {
+            if ("kotlin.annotation.Retention" == convertClassIdToFqn(ann.resolvedType.classId)) {
                 for (v in ann.argumentMapping.mapping.values) {
-                    if (v.calleeReference is FirResolvedNamedReference && (v.calleeReference as FirResolvedNamedReference).name.asString() == "SOURCE") {
+                    val reference = v.toReference(firSession)
+                    if (reference is FirResolvedNamedReference && reference.name.asString() == "SOURCE") {
                         return false
                     }
                 }
@@ -1345,7 +1346,7 @@ class KotlinTypeMapping(
 
     fun primitive(type: FirElement): Primitive {
         return when (type) {
-            is FirConstExpression<*> -> {
+            is FirLiteralExpression -> {
                 when (type.kind) {
                     ConstantValueKind.Boolean -> Primitive.Boolean
                     ConstantValueKind.Byte, ConstantValueKind.UnsignedByte -> Primitive.Byte