New J2K: Fix KotlinType to JKType conversion

j2k/newSrc/org/jetbrains/kotlin/j2k/expressions.kt

@@ -103,7 +103,7 @@ private fun JKKtOperatorToken.unaryExpressionMethodType(
             classSymbol.target.declarations.asSequence()
                 .filterIsInstance<KtNamedFunction>()
                 .filter { it.name == operatorName }
-                .mapNotNull { it.typeReference?.typeElement?.toJK(symbolProvider) }
+                .mapNotNull { it.typeReference?.toJK(symbolProvider) }
                 .firstOrNull() ?: TODO(classSymbol::class.toString() + this.operatorName)
         null -> TODO(" No class symbol")
         else -> TODO(classSymbol::class.toString())

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/symbols.kt

@@ -150,10 +150,10 @@ class JKMultiverseMethodSymbol(override val target: PsiMethod, private val symbo
 
 class JKMultiverseFunctionSymbol(override val target: KtNamedFunction, private val symbolProvider: JKSymbolProvider) : JKMethodSymbol {
     override val receiverType: JKType?
-        get() = target.receiverTypeReference?.typeElement?.toJK(symbolProvider)
+        get() = target.receiverTypeReference?.toJK(symbolProvider)
     override val parameterTypes: List<JKType>?
         get() = target.valueParameters.map { parameter ->
-            val type = parameter.typeReference?.typeElement?.toJK(symbolProvider)
+            val type = parameter.typeReference?.toJK(symbolProvider)
             type?.let {
                 if (parameter.isVarArg) {
                     JKClassTypeImpl(
@@ -165,7 +165,7 @@ class JKMultiverseFunctionSymbol(override val target: KtNamedFunction, private v
         }.takeIf { parameters -> parameters.all { it != null } } as? List<JKType>
 
     override val returnType: JKType?
-        get() = target.typeReference?.typeElement?.toJK(symbolProvider)
+        get() = target.typeReference?.toJK(symbolProvider)
     override val name: String
         get() = target.name!!
     override val declaredIn: JKSymbol
@@ -199,7 +199,7 @@ class JKMultiverseFieldSymbol(override val target: PsiVariable, private val symb
 
 class JKMultiversePropertySymbol(override val target: KtCallableDeclaration, private val symbolProvider: JKSymbolProvider) : JKFieldSymbol {
     override val fieldType: JKType?
-        get() = target.typeReference?.typeElement?.toJK(symbolProvider)
+        get() = target.typeReference?.toJK(symbolProvider)
     override val name: String
         get() = target.name!!
     override val declaredIn: JKSymbol

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/types.kt

@@ -18,11 +18,9 @@ import org.jetbrains.kotlin.j2k.ast.Nullability
 import org.jetbrains.kotlin.j2k.conversions.resolveFqName
 import org.jetbrains.kotlin.j2k.kotlinTypeByName
 import org.jetbrains.kotlin.j2k.tree.impl.*
+import org.jetbrains.kotlin.js.descriptorUtils.getJetTypeFqName
 import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.psi.KtNullableType
-import org.jetbrains.kotlin.psi.KtTypeElement
-import org.jetbrains.kotlin.psi.KtUserType
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
@@ -124,21 +122,20 @@ fun JKType.isSubtypeOf(other: JKType, symbolProvider: JKSymbolProvider): Boolean
         ?.let { otherType -> this.toKtType(symbolProvider)?.isSubtypeOf(otherType) } == true
 
 
-fun KtTypeElement.toJK(symbolProvider: JKSymbolProvider): JKType? {
+
-    return when (this) {
+fun KotlinType.toJK(symbolProvider: JKSymbolProvider): JKClassTypeImpl =
-        is KtUserType -> {
+    JKClassTypeImpl(
-            val qualifiedName = qualifier?.text?.let { it + "." }.orEmpty() + referencedName
+        symbolProvider.provideByFqName(getJetTypeFqName(false)),
-            val typeParameters = typeArguments.map { it.typeReference?.typeElement?.toJK(symbolProvider) }
+        arguments.map { it.type.toJK(symbolProvider) },
-            if (typeParameters.any { it == null }) return null
+        if (isNullable()) Nullability.Nullable else Nullability.NotNull
-            val fqName = resolveFqName(ClassId.fromString(qualifiedName), this) ?: return null
+    )
-            val symbol = symbolProvider.provideDirectSymbol(fqName) as? JKClassSymbol ?: return null
+
-            JKClassTypeImpl(symbol, typeParameters as List<JKType>)
+
-        }
+fun KtTypeReference.toJK(symbolProvider: JKSymbolProvider): JKType? =
-        is KtNullableType ->
+    analyze()
-            innerType?.toJK(symbolProvider)?.updateNullability(Nullability.Nullable)
+        .get(BindingContext.TYPE, this)
-        else -> null
+        ?.toJK(symbolProvider)
-    }
+
-}
 
 fun JKType.toKtType(symbolProvider: JKSymbolProvider): KotlinType? =
     when (this) {