FIR Java: fix creation & handling of type parameter symbols

Before this commit, we created type parameter symbols each time
when type parameter was referenced or created.
In this commit, we introduced class-bound Java type parameter stack
and use it to find referenced type parameter symbol.
So now they are created only when Java type parameter is created

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt

@@ -9,6 +9,8 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaConstructor
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaField
@@ -26,16 +28,19 @@ import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFieldSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassErrorType
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.load.java.JavaClassFinder
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.load.java.structure.JavaClass
+import org.jetbrains.kotlin.load.java.structure.JavaTypeParameter
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade
+import org.jetbrains.kotlin.types.Variance.INVARIANT
 
 class JavaSymbolProvider(
     val session: FirSession,
@@ -98,6 +103,35 @@ class JavaSymbolProvider(
         }
     }
 
+    private fun JavaTypeParameter.toFirTypeParameter(javaTypeParameterStack: JavaTypeParameterStack): FirTypeParameter {
+        val stored = javaTypeParameterStack.safeGet(this)
+        if (stored != null) return stored.fir
+        val firSymbol = FirTypeParameterSymbol()
+        val result = FirTypeParameterImpl(session, null, firSymbol, name, variance = INVARIANT, isReified = false)
+        javaTypeParameterStack.add(this, result)
+        return result
+    }
+
+    private fun FirTypeParameter.addBounds(
+        javaTypeParameter: JavaTypeParameter,
+        stack: JavaTypeParameterStack
+    ) {
+        require(this is FirTypeParameterImpl)
+        for (upperBound in javaTypeParameter.upperBounds) {
+            bounds += upperBound.toFirResolvedTypeRef(this@JavaSymbolProvider.session, stack)
+        }
+    }
+
+    private fun List<JavaTypeParameter>.convertTypeParameters(stack: JavaTypeParameterStack): List<FirTypeParameter> {
+        return this
+            .map { it.toFirTypeParameter(stack) }
+            .also {
+                it.forEachIndexed { index, typeParameter ->
+                    typeParameter.addBounds(this[index], stack)
+                }
+            }
+    }
+
     override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? {
         if (!hasTopLevelClassOf(classId)) return null
         return classCache.lookupCacheOrCalculateWithPostCompute(classId, {
@@ -109,18 +143,28 @@ class JavaSymbolProvider(
             }
         }) { firSymbol, foundClass ->
             foundClass?.let { javaClass ->
+                val javaTypeParameterStack = JavaTypeParameterStack()
+                val parentFqName = classId.relativeClassName.parent()
+                val isTopLevel = parentFqName.isRoot
+                if (!isTopLevel) {
+                    val parentId = ClassId(classId.packageFqName, parentFqName, false)
+                    val parentClassSymbol = getClassLikeSymbolByFqName(parentId) as? FirClassSymbol
+                    val parentClass = parentClassSymbol?.fir
+                    if (parentClass is FirJavaClass) {
+                        javaTypeParameterStack.addStack(parentClass.javaTypeParameterStack)
+                    }
+                }
                 FirJavaClass(
                     session, firSymbol as FirClassSymbol, javaClass.name,
                     javaClass.visibility, javaClass.modality,
-                    javaClass.classKind,
-                    isTopLevel = classId.relativeClassName.parent().isRoot, isStatic = javaClass.isStatic
+                    javaClass.classKind, isTopLevel = isTopLevel,
+                    isStatic = javaClass.isStatic,
+                    javaTypeParameterStack = javaTypeParameterStack
                 ).apply {
-                    for (typeParameter in javaClass.typeParameters) {
-                        typeParameters += createTypeParameterSymbol(this@JavaSymbolProvider.session, typeParameter.name).fir
-                    }
-                    addAnnotationsFrom(this@JavaSymbolProvider.session, javaClass)
+                    this.typeParameters += foundClass.typeParameters.convertTypeParameters(javaTypeParameterStack)
+                    addAnnotationsFrom(this@JavaSymbolProvider.session, javaClass, javaTypeParameterStack)
                     for (supertype in javaClass.supertypes) {
-                        superTypeRefs += supertype.toFirResolvedTypeRef(this@JavaSymbolProvider.session)
+                        superTypeRefs += supertype.toFirResolvedTypeRef(this@JavaSymbolProvider.session, javaTypeParameterStack)
                     }
                     // TODO: may be we can process fields & methods later.
                     // However, they should be built up to override resolve stage
@@ -132,11 +176,11 @@ class JavaSymbolProvider(
                         val firJavaField = FirJavaField(
                             this@JavaSymbolProvider.session, fieldSymbol, fieldName,
                             javaField.visibility, javaField.modality,
-                            returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session),
+                            returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session, javaTypeParameterStack),
                             isVar = !javaField.isFinal,
                             isStatic = javaField.isStatic
                         ).apply {
-                            addAnnotationsFrom(this@JavaSymbolProvider.session, javaField)
+                            addAnnotationsFrom(this@JavaSymbolProvider.session, javaField, javaTypeParameterStack)
                         }
                         declarations += firJavaField
                     }
@@ -148,15 +192,15 @@ class JavaSymbolProvider(
                         val firJavaMethod = FirJavaMethod(
                             this@JavaSymbolProvider.session, methodSymbol, methodName,
                             javaMethod.visibility, javaMethod.modality,
-                            returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session),
+                            returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session, javaTypeParameterStack),
                             isStatic = javaMethod.isStatic
                         ).apply {
-                            for (typeParameter in javaMethod.typeParameters) {
-                                typeParameters += createTypeParameterSymbol(this@JavaSymbolProvider.session, typeParameter.name).fir
-                            }
-                            addAnnotationsFrom(this@JavaSymbolProvider.session, javaMethod)
+                            this.typeParameters += javaMethod.typeParameters.convertTypeParameters(javaTypeParameterStack)
+                            addAnnotationsFrom(this@JavaSymbolProvider.session, javaMethod, javaTypeParameterStack)
                             for (valueParameter in javaMethod.valueParameters) {
-                                valueParameters += valueParameter.toFirValueParameters(this@JavaSymbolProvider.session)
+                                valueParameters += valueParameter.toFirValueParameters(
+                                    this@JavaSymbolProvider.session, javaTypeParameterStack
+                                )
                             }
                         }
                         declarations += firJavaMethod
@@ -164,12 +208,8 @@ class JavaSymbolProvider(
                     for (javaConstructor in javaClass.constructors) {
                         val constructorId = CallableId(classId.packageFqName, classId.relativeClassName, classId.shortClassName)
                         val constructorSymbol = FirFunctionSymbol(constructorId)
-                        val classTypeParameters = typeParameters.map {
-                            createTypeParameterSymbol(this@JavaSymbolProvider.session, it.name).fir
-                        }
-                        val constructorTypeParameters = javaConstructor.typeParameters.map {
-                            createTypeParameterSymbol(this@JavaSymbolProvider.session, it.name).fir
-                        }
+                        val classTypeParameters = javaClass.typeParameters.convertTypeParameters(javaTypeParameterStack)
+                        val constructorTypeParameters = javaConstructor.typeParameters.convertTypeParameters(javaTypeParameterStack)
                         val typeParameters = classTypeParameters + constructorTypeParameters
                         val firJavaConstructor = FirJavaConstructor(
                             this@JavaSymbolProvider.session, constructorSymbol, javaConstructor.visibility,
@@ -182,9 +222,11 @@ class JavaSymbolProvider(
                             )
                         ).apply {
                             this.typeParameters += typeParameters
-                            addAnnotationsFrom(this@JavaSymbolProvider.session, javaConstructor)
+                            addAnnotationsFrom(this@JavaSymbolProvider.session, javaConstructor, javaTypeParameterStack)
                             for (valueParameter in javaConstructor.valueParameters) {
-                                valueParameters += valueParameter.toFirValueParameters(this@JavaSymbolProvider.session)
+                                valueParameters += valueParameter.toFirValueParameters(
+                                    this@JavaSymbolProvider.session, javaTypeParameterStack
+                                )
                             }
                         }
                         declarations += firJavaConstructor

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaTypeParameterStack.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.java
+
+import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
+import org.jetbrains.kotlin.load.java.structure.JavaTypeParameter
+
+internal class JavaTypeParameterStack {
+
+    private val typeParameterMap = mutableMapOf<JavaTypeParameter, FirTypeParameterSymbol>()
+
+    fun add(javaTypeParameter: JavaTypeParameter, firTypeParameter: FirTypeParameter) {
+        typeParameterMap[javaTypeParameter] = firTypeParameter.symbol
+    }
+
+    fun addStack(javaTypeParameterStack: JavaTypeParameterStack) {
+        typeParameterMap += javaTypeParameterStack.typeParameterMap
+    }
+
+    fun remove(javaTypeParameter: JavaTypeParameter) {
+        typeParameterMap.remove(javaTypeParameter)
+    }
+
+    operator fun get(javaTypeParameter: JavaTypeParameter): FirTypeParameterSymbol {
+        return safeGet(javaTypeParameter)
+            ?: throw IllegalArgumentException("Cannot find Java type parameter $javaTypeParameter in stack")
+    }
+
+    fun safeGet(javaTypeParameter: JavaTypeParameter) = typeParameterMap[javaTypeParameter]
+
+    companion object {
+        val EMPTY: JavaTypeParameterStack = JavaTypeParameterStack()
+    }
+}

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt

@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
-import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
@@ -26,7 +25,6 @@ import org.jetbrains.kotlin.fir.service
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
@@ -34,7 +32,6 @@ import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.ir.expressions.IrConstKind
 import org.jetbrains.kotlin.load.java.structure.*
 import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.Variance.*
 
@@ -61,37 +58,48 @@ internal fun ClassId.toConeKotlinType(
     return ConeClassTypeImpl(lookupTag, typeArguments, isNullable)
 }
 
-internal fun FirTypeRef.toNotNullConeKotlinType(session: FirSession): ConeKotlinType =
+internal fun FirTypeRef.toNotNullConeKotlinType(
+    session: FirSession, javaTypeParameterStack: JavaTypeParameterStack
+): ConeKotlinType =
     when (this) {
         is FirResolvedTypeRef -> type
         is FirJavaTypeRef -> {
             val javaType = type
-            javaType.toNotNullConeKotlinType(session)
+            javaType.toNotNullConeKotlinType(session, javaTypeParameterStack)
         }
         else -> ConeKotlinErrorType("Unexpected type reference in JavaClassUseSiteScope: ${this::class.java}")
     }
 
-internal fun JavaType?.toNotNullConeKotlinType(session: FirSession): ConeLookupTagBasedType {
-    return toConeKotlinTypeWithNullability(session, isNullable = false)
+internal fun JavaType?.toNotNullConeKotlinType(
+    session: FirSession, javaTypeParameterStack: JavaTypeParameterStack
+): ConeLookupTagBasedType {
+    return toConeKotlinTypeWithNullability(session, javaTypeParameterStack, isNullable = false)
 }
 
-internal fun JavaType.toFirJavaTypeRef(session: FirSession): FirJavaTypeRef {
+internal fun JavaType.toFirJavaTypeRef(session: FirSession, javaTypeParameterStack: JavaTypeParameterStack): FirJavaTypeRef {
     val annotations = (this as? JavaClassifierType)?.annotations.orEmpty()
-    return FirJavaTypeRef(session, annotations = annotations.map { it.toFirAnnotationCall(session) }, type = this)
-}
-
-internal fun JavaClassifierType.toFirResolvedTypeRef(session: FirSession): FirResolvedTypeRef {
-    val coneType = this.toConeKotlinTypeWithNullability(session, isNullable = false)
-    return FirResolvedTypeRefImpl(
-        session, psi = null, type = coneType,
-        isMarkedNullable = false, annotations = annotations.map { it.toFirAnnotationCall(session) }
+    return FirJavaTypeRef(
+        session,
+        annotations = annotations.map { it.toFirAnnotationCall(session, javaTypeParameterStack) }, type = this
     )
 }
 
-internal fun JavaType?.toConeKotlinTypeWithNullability(session: FirSession, isNullable: Boolean): ConeLookupTagBasedType {
+internal fun JavaClassifierType.toFirResolvedTypeRef(
+    session: FirSession, javaTypeParameterStack: JavaTypeParameterStack
+): FirResolvedTypeRef {
+    val coneType = this.toConeKotlinTypeWithNullability(session, javaTypeParameterStack, isNullable = false)
+    return FirResolvedTypeRefImpl(
+        session, psi = null, type = coneType, isMarkedNullable = false,
+        annotations = annotations.map { it.toFirAnnotationCall(session, javaTypeParameterStack) }
+    )
+}
+
+internal fun JavaType?.toConeKotlinTypeWithNullability(
+    session: FirSession, javaTypeParameterStack: JavaTypeParameterStack, isNullable: Boolean
+): ConeLookupTagBasedType {
     return when (this) {
         is JavaClassifierType -> {
-            toConeKotlinTypeWithNullability(session, isNullable)
+            toConeKotlinTypeWithNullability(session, isNullable, javaTypeParameterStack)
         }
         is JavaPrimitiveType -> {
             val primitiveType = type
@@ -107,8 +115,8 @@ internal fun JavaType?.toConeKotlinTypeWithNullability(session: FirSession, isNu
             if (componentType !is JavaPrimitiveType) {
                 val classId = StandardClassIds.Array
                 val argumentType = ConeFlexibleType(
-                    componentType.toConeKotlinTypeWithNullability(session, isNullable = false),
-                    componentType.toConeKotlinTypeWithNullability(session, isNullable = true)
+                    componentType.toConeKotlinTypeWithNullability(session, javaTypeParameterStack, isNullable = false),
+                    componentType.toConeKotlinTypeWithNullability(session, javaTypeParameterStack, isNullable = true)
                 )
                 classId.toConeKotlinType(arrayOf(argumentType), isNullable)
             } else {
@@ -117,7 +125,7 @@ internal fun JavaType?.toConeKotlinTypeWithNullability(session: FirSession, isNu
                 classId.toConeKotlinType(emptyArray(), isNullable)
             }
         }
-        is JavaWildcardType -> bound?.toNotNullConeKotlinType(session) ?: run {
+        is JavaWildcardType -> bound?.toNotNullConeKotlinType(session, javaTypeParameterStack) ?: run {
             val classId = StandardClassIds.Any
             classId.toConeKotlinType(emptyArray(), isNullable)
         }
@@ -129,7 +137,9 @@ internal fun JavaType?.toConeKotlinTypeWithNullability(session: FirSession, isNu
     }
 }
 
-internal fun JavaClassifierType.toConeKotlinTypeWithNullability(session: FirSession, isNullable: Boolean): ConeLookupTagBasedType {
+internal fun JavaClassifierType.toConeKotlinTypeWithNullability(
+    session: FirSession, isNullable: Boolean, javaTypeParameterStack: JavaTypeParameterStack
+): ConeLookupTagBasedType {
     return when (val classifier = classifier) {
         is JavaClass -> {
             val classId = classifier.classId!!
@@ -137,29 +147,23 @@ internal fun JavaClassifierType.toConeKotlinTypeWithNullability(session: FirSess
             lookupTag.constructClassType(
                 typeArguments.mapIndexed { index, argument ->
                     argument.toConeProjection(
-                        session, null
+                        session, javaTypeParameterStack, null
                         //symbol.fir.typeParameters.getOrNull(index)
                     )
                 }.toTypedArray(), isNullable
             )
         }
         is JavaTypeParameter -> {
-            // TODO: it's unclear how to identify type parameter by the symbol
-            // TODO: some type parameter cache (provider?)
-            val symbol = createTypeParameterSymbol(session, classifier.name)
+            val symbol = javaTypeParameterStack[classifier]
             ConeTypeParameterTypeImpl(symbol, isNullable)
         }
         else -> ConeClassErrorType(reason = "Unexpected classifier: $classifier")
     }
 }
 
-internal fun createTypeParameterSymbol(session: FirSession, name: Name): FirTypeParameterSymbol {
-    val firSymbol = FirTypeParameterSymbol()
-    FirTypeParameterImpl(session, null, firSymbol, name, variance = INVARIANT, isReified = false)
-    return firSymbol
-}
-
-internal fun JavaAnnotation.toFirAnnotationCall(session: FirSession): FirAnnotationCall {
+internal fun JavaAnnotation.toFirAnnotationCall(
+    session: FirSession, javaTypeParameterStack: JavaTypeParameterStack
+): FirAnnotationCall {
     return FirAnnotationCallImpl(
         session, psi = null, useSiteTarget = null,
         annotationTypeRef = FirResolvedTypeRefImpl(
@@ -171,28 +175,34 @@ internal fun JavaAnnotation.toFirAnnotationCall(session: FirSession): FirAnnotat
         )
     ).apply {
         for (argument in this@toFirAnnotationCall.arguments) {
-            arguments += argument.toFirExpression(session)
+            arguments += argument.toFirExpression(session, javaTypeParameterStack)
         }
     }
 }
 
-internal fun FirAbstractAnnotatedElement.addAnnotationsFrom(session: FirSession, javaAnnotationOwner: JavaAnnotationOwner) {
+internal fun FirAbstractAnnotatedElement.addAnnotationsFrom(
+    session: FirSession, javaAnnotationOwner: JavaAnnotationOwner, javaTypeParameterStack: JavaTypeParameterStack
+) {
     for (annotation in javaAnnotationOwner.annotations) {
-        annotations += annotation.toFirAnnotationCall(session)
+        annotations += annotation.toFirAnnotationCall(session, javaTypeParameterStack)
     }
 }
 
-internal fun JavaValueParameter.toFirValueParameters(session: FirSession): FirValueParameter {
+internal fun JavaValueParameter.toFirValueParameters(
+    session: FirSession, javaTypeParameterStack: JavaTypeParameterStack
+): FirValueParameter {
     return FirJavaValueParameter(
         session, name ?: Name.special("<anonymous Java parameter>"),
-        returnTypeRef = type.toFirJavaTypeRef(session),
+        returnTypeRef = type.toFirJavaTypeRef(session, javaTypeParameterStack),
         isVararg = isVararg
     ).apply {
-        addAnnotationsFrom(session, this@toFirValueParameters)
+        addAnnotationsFrom(session, this@toFirValueParameters, javaTypeParameterStack)
     }
 }
 
-internal fun JavaType?.toConeProjection(session: FirSession, boundTypeParameter: FirTypeParameter?): ConeKotlinTypeProjection {
+internal fun JavaType?.toConeProjection(
+    session: FirSession, javaTypeParameterStack: JavaTypeParameterStack, boundTypeParameter: FirTypeParameter?
+): ConeKotlinTypeProjection {
     return when (this) {
         null -> ConeStarProjection
         is JavaWildcardType -> {
@@ -202,7 +212,7 @@ internal fun JavaType?.toConeProjection(session: FirSession, boundTypeParameter:
             if (bound == null || parameterVariance != INVARIANT && parameterVariance != argumentVariance) {
                 ConeStarProjection
             } else {
-                val boundType = bound.toConeKotlinTypeWithNullability(session, isNullable = false)
+                val boundType = bound.toConeKotlinTypeWithNullability(session, javaTypeParameterStack, isNullable = false)
                 if (argumentVariance == OUT_VARIANCE) {
                     ConeKotlinTypeProjectionOut(boundType)
                 } else {
@@ -210,12 +220,14 @@ internal fun JavaType?.toConeProjection(session: FirSession, boundTypeParameter:
                 }
             }
         }
-        is JavaClassifierType -> toConeKotlinTypeWithNullability(session, isNullable = false)
+        is JavaClassifierType -> toConeKotlinTypeWithNullability(session, javaTypeParameterStack, isNullable = false)
         else -> ConeClassErrorType("Unexpected type argument: $this")
     }
 }
 
-private fun JavaAnnotationArgument.toFirExpression(session: FirSession): FirExpression {
+private fun JavaAnnotationArgument.toFirExpression(
+    session: FirSession, javaTypeParameterStack: JavaTypeParameterStack
+): FirExpression {
     // TODO: this.name
     return when (this) {
         is JavaLiteralAnnotationArgument -> {
@@ -233,7 +245,7 @@ private fun JavaAnnotationArgument.toFirExpression(session: FirSession): FirExpr
         }
         is JavaArrayAnnotationArgument -> FirArrayOfCallImpl(session, null).apply {
             for (element in getElements()) {
-                arguments += element.toFirExpression(session)
+                arguments += element.toFirExpression(session, javaTypeParameterStack)
             }
         }
         is JavaEnumValueAnnotationArgument -> {
@@ -256,9 +268,11 @@ private fun JavaAnnotationArgument.toFirExpression(session: FirSession): FirExpr
         }
         is JavaClassObjectAnnotationArgument -> FirGetClassCallImpl(session, null).apply {
             val referencedType = getReferencedType()
-            arguments += FirClassReferenceExpressionImpl(session, null, referencedType.toFirResolvedTypeRef(session))
+            arguments += FirClassReferenceExpressionImpl(
+                session, null, referencedType.toFirResolvedTypeRef(session, javaTypeParameterStack)
+            )
         }
-        is JavaAnnotationAsAnnotationArgument -> getAnnotation().toFirAnnotationCall(session)
+        is JavaAnnotationAsAnnotationArgument -> getAnnotation().toFirAnnotationCall(session, javaTypeParameterStack)
         else -> FirErrorExpressionImpl(session, null, "Unknown JavaAnnotationArgument: ${this::class.java}")
     }
 }
@@ -289,8 +303,10 @@ private fun Any?.createConstant(session: FirSession): FirExpression {
     }
 }
 
-private fun JavaType.toFirResolvedTypeRef(session: FirSession): FirResolvedTypeRef {
-    if (this is JavaClassifierType) return toFirResolvedTypeRef(session)
+private fun JavaType.toFirResolvedTypeRef(
+    session: FirSession, javaTypeParameterStack: JavaTypeParameterStack
+): FirResolvedTypeRef {
+    if (this is JavaClassifierType) return toFirResolvedTypeRef(session, javaTypeParameterStack)
     return FirResolvedTypeRefImpl(
         session, psi = null, type = ConeClassErrorType("Unexpected JavaType: $this"),
         isMarkedNullable = false, annotations = emptyList()

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt

@@ -13,11 +13,12 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.impl.FirAbstractMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableClass
+import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name
 
-class FirJavaClass(
+class FirJavaClass internal constructor(
     session: FirSession,
     override val symbol: FirClassSymbol,
     name: Name,
@@ -25,7 +26,8 @@ class FirJavaClass(
     modality: Modality?,
     override val classKind: ClassKind,
     isTopLevel: Boolean,
-    isStatic: Boolean
+    isStatic: Boolean,
+    internal val javaTypeParameterStack: JavaTypeParameterStack
 ) : FirAbstractMemberDeclaration(
     session, psi = null, name = name,
     visibility = visibility, modality = modality,

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.expressions.resolvedFqName
+import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
 import org.jetbrains.kotlin.fir.java.toConeKotlinTypeWithNullability
 import org.jetbrains.kotlin.fir.java.toFirJavaTypeRef
 import org.jetbrains.kotlin.fir.java.toNotNullConeKotlinType
@@ -30,6 +31,7 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 internal class EnhancementSignatureParts(
     private val typeQualifierResolver: FirAnnotationTypeQualifierResolver,
     private val typeContainer: FirAnnotationContainer?,
+    private val javaTypeParameterStack: JavaTypeParameterStack,
     private val current: FirJavaTypeRef,
     private val fromOverridden: Collection<FirTypeRef>,
     private val isCovariant: Boolean,
@@ -54,7 +56,7 @@ internal class EnhancementSignatureParts(
             }
         }
 
-        val containsFunctionN = current.toNotNullConeKotlinType(session).contains {
+        val containsFunctionN = current.toNotNullConeKotlinType(session, javaTypeParameterStack).contains {
             if (it is ConeClassErrorType) false
             else {
                 val classId = it.lookupTag.classId
@@ -63,7 +65,7 @@ internal class EnhancementSignatureParts(
             }
         }
 
-        val enhancedCurrent = current.enhance(session, qualifiersWithPredefined ?: qualifiers)
+        val enhancedCurrent = current.enhance(session, javaTypeParameterStack, qualifiersWithPredefined ?: qualifiers)
         return PartEnhancementResult(
             enhancedCurrent, wereChanges = true, containsFunctionN = containsFunctionN
         )
@@ -100,7 +102,7 @@ internal class EnhancementSignatureParts(
                     if (arg is JavaWildcardType || arg == null) {
                         add(null)
                     } else {
-                        add(arg.toFirJavaTypeRef(context.session))
+                        add(arg.toFirJavaTypeRef(context.session, javaTypeParameterStack))
                     }
                 }
             } else if (type != null) {
@@ -148,8 +150,8 @@ internal class EnhancementSignatureParts(
             is FirJavaTypeRef -> {
                 Pair(
                     // TODO: optimize
-                    type.toConeKotlinTypeWithNullability(session, isNullable = false),
-                    type.toConeKotlinTypeWithNullability(session, isNullable = true)
+                    type.toConeKotlinTypeWithNullability(session, javaTypeParameterStack, isNullable = false),
+                    type.toConeKotlinTypeWithNullability(session, javaTypeParameterStack, isNullable = true)
                 )
             }
             else -> return JavaTypeQualifiers.NONE

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirConstExpressionImpl
 import org.jetbrains.kotlin.fir.expressions.impl.FirQualifiedAccessExpressionImpl
-import org.jetbrains.kotlin.fir.java.createTypeParameterSymbol
+import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaField
 import org.jetbrains.kotlin.fir.java.toConeProjection
@@ -51,8 +51,12 @@ internal class IndexedJavaTypeQualifiers(private val data: Array<JavaTypeQualifi
     val size: Int get() = data.size
 }
 
-internal fun FirJavaTypeRef.enhance(session: FirSession, qualifiers: IndexedJavaTypeQualifiers): FirResolvedTypeRef {
-    return type.enhancePossiblyFlexible(session, annotations, qualifiers, 0)
+internal fun FirJavaTypeRef.enhance(
+    session: FirSession,
+    javaTypeParameterStack: JavaTypeParameterStack,
+    qualifiers: IndexedJavaTypeQualifiers
+): FirResolvedTypeRef {
+    return type.enhancePossiblyFlexible(session, javaTypeParameterStack, annotations, qualifiers, 0)
 }
 
 // The index in the lambda is the position of the type component:
@@ -61,6 +65,7 @@ internal fun FirJavaTypeRef.enhance(session: FirSession, qualifiers: IndexedJava
 // For flexible types, both bounds are indexed in the same way: `(A<B>..C<D>)` gives `0 - (A<B>..C<D>), 1 - B and D`.
 private fun JavaType?.enhancePossiblyFlexible(
     session: FirSession,
+    javaTypeParameterStack: JavaTypeParameterStack,
     annotations: List<FirAnnotationCall>,
     qualifiers: IndexedJavaTypeQualifiers,
     index: Int
@@ -70,10 +75,10 @@ private fun JavaType?.enhancePossiblyFlexible(
     return when (type) {
         is JavaClassifierType -> {
             val lowerResult = type.enhanceInflexibleType(
-                session, annotations, arguments, TypeComponentPosition.FLEXIBLE_LOWER, qualifiers, index
+                session, javaTypeParameterStack, annotations, arguments, TypeComponentPosition.FLEXIBLE_LOWER, qualifiers, index
             )
             val upperResult = type.enhanceInflexibleType(
-                session, annotations, arguments, TypeComponentPosition.FLEXIBLE_UPPER, qualifiers, index
+                session, javaTypeParameterStack, annotations, arguments, TypeComponentPosition.FLEXIBLE_UPPER, qualifiers, index
             )
 
             FirResolvedTypeRefImpl(
@@ -83,7 +88,7 @@ private fun JavaType?.enhancePossiblyFlexible(
             )
         }
         else -> {
-            val enhanced = type.toNotNullConeKotlinType(session)
+            val enhanced = type.toNotNullConeKotlinType(session, javaTypeParameterStack)
             FirResolvedTypeRefImpl(session, psi = null, type = enhanced, isMarkedNullable = false, annotations = annotations)
         }
     }
@@ -125,6 +130,7 @@ private fun ClassId.mutableToReadOnly(): ClassId? {
 
 private fun JavaClassifierType.enhanceInflexibleType(
     session: FirSession,
+    javaTypeParameterStack: JavaTypeParameterStack,
     annotations: List<FirAnnotationCall>,
     arguments: List<JavaType?>,
     position: TypeComponentPosition,
@@ -143,8 +149,8 @@ private fun JavaClassifierType.enhanceInflexibleType(
             val kotlinClassId = mappedId ?: classId
             ConeClassLikeLookupTagImpl(kotlinClassId)
         }
-        is JavaTypeParameter -> createTypeParameterSymbol(session, classifier.name)
-        else -> return toNotNullConeKotlinType(session)
+        is JavaTypeParameter -> javaTypeParameterStack[classifier]
+        else -> return toNotNullConeKotlinType(session, javaTypeParameterStack)
     }
 
     val effectiveQualifiers = qualifiers(index)
@@ -156,10 +162,11 @@ private fun JavaClassifierType.enhanceInflexibleType(
             globalArgIndex++
             arg.toConeProjection(
                 session,
+                javaTypeParameterStack,
                 ((originalTag as? FirBasedSymbol<*>)?.fir as? FirCallableMemberDeclaration)?.typeParameters?.getOrNull(localArgIndex)
             )
         } else {
-            val argEnhancedTypeRef = arg.enhancePossiblyFlexible(session, annotations, qualifiers, globalArgIndex)
+            val argEnhancedTypeRef = arg.enhancePossiblyFlexible(session, javaTypeParameterStack, annotations, qualifiers, globalArgIndex)
             globalArgIndex += arg.subtreeSize()
             argEnhancedTypeRef.type.type.toTypeProjection(Variance.INVARIANT)
         }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt

@@ -11,10 +11,8 @@ import org.jetbrains.kotlin.fir.declarations.impl.*
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirConstExpressionImpl
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaConstructor
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaField
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaMethod
-import org.jetbrains.kotlin.fir.java.declarations.FirJavaValueParameter
+import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
+import org.jetbrains.kotlin.fir.java.declarations.*
 import org.jetbrains.kotlin.fir.java.enhancement.*
 import org.jetbrains.kotlin.fir.java.enhancement.EnhancementSignatureParts
 import org.jetbrains.kotlin.fir.java.toNotNullConeKotlinType
@@ -42,7 +40,10 @@ class JavaClassEnhancementScope(
     private val session: FirSession,
     private val useSiteScope: JavaClassUseSiteScope
 ) : FirScope {
-    private val owner: FirRegularClass get() = useSiteScope.symbol.fir
+    private val owner: FirRegularClass = useSiteScope.symbol.fir
+
+    private val javaTypeParameterStack: JavaTypeParameterStack =
+        if (owner is FirJavaClass) owner.javaTypeParameterStack else JavaTypeParameterStack.EMPTY
 
     private val jsr305State: Jsr305State = session.jsr305State ?: Jsr305State.DEFAULT
 
@@ -188,12 +189,14 @@ class JavaClassEnhancementScope(
                 newReceiverTypeRef, newReturnTypeRef
             ).apply {
                 this.valueParameters += newValueParameters
+                this.typeParameters += firMethod.typeParameters
             }
             else -> FirMemberFunctionImpl(
                 this@JavaClassEnhancementScope.session, null, symbol, name,
                 newReceiverTypeRef, newReturnTypeRef
             ).apply {
                 this.valueParameters += newValueParameters
+                this.typeParameters += firMethod.typeParameters
             }
         }
         function.apply {
@@ -226,7 +229,7 @@ class JavaClassEnhancementScope(
     private fun StringBuilder.appendErasedType(typeRef: FirTypeRef) {
         when (typeRef) {
             is FirResolvedTypeRef -> appendConeType(typeRef.type)
-            is FirJavaTypeRef -> appendConeType(typeRef.toNotNullConeKotlinType(session))
+            is FirJavaTypeRef -> appendConeType(typeRef.toNotNullConeKotlinType(session, javaTypeParameterStack))
         }
     }
 
@@ -390,6 +393,7 @@ class JavaClassEnhancementScope(
         return EnhancementSignatureParts(
             typeQualifierResolver,
             typeContainer,
+            javaTypeParameterStack,
             typeRef as FirJavaTypeRef,
             overriddenMembers.map {
                 typeInSignature.getTypeRef(it)

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteScope.kt

@@ -9,6 +9,8 @@ import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
+import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
 import org.jetbrains.kotlin.fir.java.toNotNullConeKotlinType
 import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe
 import org.jetbrains.kotlin.fir.scopes.FirScope
@@ -33,6 +35,9 @@ class JavaClassUseSiteScope(
 ) : FirAbstractProviderBasedScope(session, lookupInFir = true) {
     internal val symbol = klass.symbol
 
+    private val javaTypeParameterStack: JavaTypeParameterStack =
+        if (klass is FirJavaClass) klass.javaTypeParameterStack else JavaTypeParameterStack.EMPTY
+
     //base symbol as key, overridden as value
     private val overriddenByBase = mutableMapOf<ConeCallableSymbol, ConeFunctionSymbol?>()
 
@@ -54,7 +59,10 @@ class JavaClassUseSiteScope(
     }
 
     private fun isEqualTypes(a: FirTypeRef, b: FirTypeRef) =
-        isEqualTypes(a.toNotNullConeKotlinType(session), b.toNotNullConeKotlinType(session))
+        isEqualTypes(
+            a.toNotNullConeKotlinType(session, javaTypeParameterStack),
+            b.toNotNullConeKotlinType(session, javaTypeParameterStack)
+        )
 
     private fun isOverriddenFunCheck(overriddenInJava: FirFunction, base: FirFunction): Boolean {
         val receiverTypeRef = (base as FirCallableMemberDeclaration).receiverTypeRef

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/types/FirJavaTypeRef.kt

@@ -14,7 +14,7 @@ class FirJavaTypeRef(
     session: FirSession,
     annotations: List<FirAnnotationCall>,
     val type: JavaType
-) : FirUserTypeRefImpl(session, psi = null,isMarkedNullable = false) {
+) : FirUserTypeRefImpl(session, psi = null, isMarkedNullable = false) {
     init {
         this.annotations += annotations
     }