[FIR] drop redundant JavaTypeParameterStack usage from Java annotations

It is safe just to use `JavaTypeParameterStack.EMPTY`
as Java annotations are not expected to use containing type parameters

^KT-59342

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

@@ -113,7 +113,7 @@ abstract class FirJavaFacade(
             javaTypeParameterStack.addParameter(this@toFirTypeParameter, symbol)
             this.containingDeclarationSymbol = containingDeclarationSymbol
             for (upperBound in this@toFirTypeParameter.upperBounds) {
-                bounds += upperBound.toFirJavaTypeRef(session, javaTypeParameterStack)
+                bounds += upperBound.toFirJavaTypeRef(session)
             }
             if (bounds.isEmpty()) {
                 bounds += buildResolvedTypeRef {
@@ -122,7 +122,7 @@ abstract class FirJavaFacade(
             }
         }.apply {
             // TODO: should be lazy (in case annotations refer to the containing class)
-            setAnnotationsFromJava(session, this@toFirTypeParameter, javaTypeParameterStack)
+            setAnnotationsFromJava(session, this@toFirTypeParameter)
         }
     }
 
@@ -269,7 +269,7 @@ abstract class FirJavaFacade(
                     buildOuterClassTypeParameterRef { symbol = it.symbol }
                 }
             }
-            javaClass.supertypes.mapTo(superTypeRefs) { it.toFirJavaTypeRef(session, javaTypeParameterStack) }
+            javaClass.supertypes.mapTo(superTypeRefs) { it.toFirJavaTypeRef(session) }
             if (superTypeRefs.isEmpty()) {
                 superTypeRefs.add(
                     buildResolvedTypeRef {
@@ -375,7 +375,6 @@ abstract class FirJavaFacade(
                     javaClass,
                     classId,
                     moduleData,
-                    javaTypeParameterStack,
                     dispatchReceiver,
                     classTypeParameters,
                     declarations
@@ -412,7 +411,6 @@ abstract class FirJavaFacade(
         javaClass: JavaClass,
         classId: ClassId,
         moduleData: FirModuleData,
-        javaTypeParameterStack: JavaTypeParameterStack,
         classType: ConeClassLikeType,
         classTypeParameters: List<FirTypeParameter>,
         destination: MutableList<FirDeclaration>
@@ -430,7 +428,7 @@ abstract class FirJavaFacade(
                 symbol = FirNamedFunctionSymbol(componentId)
                 this.name = name
                 isFromSource = recordComponent.isFromSource
-                returnTypeRef = recordComponent.type.toFirJavaTypeRef(session, javaTypeParameterStack)
+                returnTypeRef = recordComponent.type.toFirJavaTypeRef(session)
                 annotationBuilder = { emptyList() }
                 status = FirResolvedDeclarationStatusImpl(
                     Visibilities.Public,
@@ -474,7 +472,7 @@ abstract class FirJavaFacade(
                         source = component.toSourceElement(KtFakeSourceElementKind.ImplicitRecordConstructorParameter)
                         this.moduleData = moduleData
                         isFromSource = component.isFromSource
-                        returnTypeRef = component.type.toFirJavaTypeRef(session, javaTypeParameterStack)
+                        returnTypeRef = component.type.toFirJavaTypeRef(session)
                         name = component.name
                         isVararg = component.isVararg
                         annotationBuilder = { emptyList() }
@@ -509,14 +507,14 @@ abstract class FirJavaFacade(
                 ).apply {
                     isStatic = javaField.isStatic
                 }
-                returnTypeRef = returnType.toFirJavaTypeRef(session, javaTypeParameterStack)
+                returnTypeRef = returnType.toFirJavaTypeRef(session)
                     .resolveIfJavaType(session, javaTypeParameterStack, mode = FirJavaTypeConversionMode.ANNOTATION_MEMBER)
                 resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
                 origin = javaOrigin(javaField.isFromSource)
             }.apply {
                 containingClassForStaticMemberAttr = classId.toLookupTag()
                 // TODO: check if this works properly with annotations that take the enum class as an argument
-                setAnnotationsFromJava(session, javaField, javaTypeParameterStack)
+                setAnnotationsFromJava(session, javaField)
             }
             else -> buildJavaField {
                 source = javaField.toSourceElement()
@@ -533,10 +531,10 @@ abstract class FirJavaFacade(
                 }
                 visibility = javaField.visibility
                 modality = javaField.modality
-                returnTypeRef = returnType.toFirJavaTypeRef(session, javaTypeParameterStack)
+                returnTypeRef = returnType.toFirJavaTypeRef(session)
                 isVar = !javaField.isFinal
                 isStatic = javaField.isStatic
-                annotationBuilder = { javaField.convertAnnotationsToFir(session, javaTypeParameterStack) }
+                annotationBuilder = { javaField.convertAnnotationsToFir(session) }
 
                 lazyInitializer = lazy {
                     // NB: null should be converted to null
@@ -572,13 +570,13 @@ abstract class FirJavaFacade(
             symbol = methodSymbol
             name = methodName
             isFromSource = javaMethod.isFromSource
-            returnTypeRef = returnType.toFirJavaTypeRef(session, javaTypeParameterStack)
+            returnTypeRef = returnType.toFirJavaTypeRef(session)
             isStatic = javaMethod.isStatic
             typeParameters += javaMethod.typeParameters.convertTypeParameters(javaTypeParameterStack, methodSymbol, moduleData)
             for ((index, valueParameter) in javaMethod.valueParameters.withIndex()) {
-                valueParameters += valueParameter.toFirValueParameter(session, methodSymbol, moduleData, index, javaTypeParameterStack)
+                valueParameters += valueParameter.toFirValueParameter(session, methodSymbol, moduleData, index)
             }
-            annotationBuilder = { javaMethod.convertAnnotationsToFir(session, javaTypeParameterStack) }
+            annotationBuilder = { javaMethod.convertAnnotationsToFir(session) }
             status = FirResolvedDeclarationStatusImpl(
                 javaMethod.visibility,
                 javaMethod.modality,
@@ -654,9 +652,9 @@ abstract class FirJavaFacade(
 
             if (javaConstructor != null) {
                 this.typeParameters += javaConstructor.typeParameters.convertTypeParameters(javaTypeParameterStack, constructorSymbol, moduleData)
-                annotationBuilder = { javaConstructor.convertAnnotationsToFir(session, javaTypeParameterStack) }
+                annotationBuilder = { javaConstructor.convertAnnotationsToFir(session) }
                 for ((index, valueParameter) in javaConstructor.valueParameters.withIndex()) {
-                    valueParameters += valueParameter.toFirValueParameter(session, constructorSymbol, moduleData, index, javaTypeParameterStack)
+                    valueParameters += valueParameter.toFirValueParameter(session, constructorSymbol, moduleData, index)
                 }
             } else {
                 annotationBuilder = { emptyList() }

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

@@ -56,11 +56,9 @@ internal fun FirTypeRef.toConeKotlinTypeProbablyFlexible(
     (resolveIfJavaType(session, javaTypeParameterStack, mode) as? FirResolvedTypeRef)?.type
         ?: ConeErrorType(ConeSimpleDiagnostic("Type reference in Java not resolved: ${this::class.java}", DiagnosticKind.Java))
 
-internal fun JavaType.toFirJavaTypeRef(session: FirSession, javaTypeParameterStack: JavaTypeParameterStack): FirJavaTypeRef {
-    return buildJavaTypeRef {
-        annotationBuilder = { convertAnnotationsToFir(session, javaTypeParameterStack) }
-        type = this@toFirJavaTypeRef
-    }
+internal fun JavaType.toFirJavaTypeRef(session: FirSession): FirJavaTypeRef = buildJavaTypeRef {
+    annotationBuilder = { convertAnnotationsToFir(session) }
+    type = this@toFirJavaTypeRef
 }
 
 internal fun JavaType?.toFirResolvedTypeRef(
@@ -90,10 +88,11 @@ private fun JavaType?.toConeTypeProjection(
     val attributes = if (this != null && (annotations.isNotEmpty() || additionalAnnotations != null)) {
         val convertedAnnotations = buildList {
             if (annotations.isNotEmpty()) {
-                addAll(this@toConeTypeProjection.convertAnnotationsToFir(session, javaTypeParameterStack))
+                addAll(this@toConeTypeProjection.convertAnnotationsToFir(session))
             }
+
             if (additionalAnnotations != null) {
-                addAll(additionalAnnotations.convertAnnotationsToFir(session, javaTypeParameterStack))
+                addAll(additionalAnnotations.convertAnnotationsToFir(session))
             }
         }
 

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

@@ -75,7 +75,7 @@ class FirJavaClass @FirImplementationDetail internal constructor(
 
     // TODO: the lazy annotations is a workaround for KT-55387, some non-lazy solution should probably be used instead
     override val annotations: List<FirAnnotation> by lazy {
-        unEnhancedAnnotations.convertAnnotationsToFir(moduleData.session, javaTypeParameterStack)
+        unEnhancedAnnotations.convertAnnotationsToFir(moduleData.session)
     }
 
     // TODO: the lazy deprecationsProvider is a workaround for KT-55387, some non-lazy solution should probably be used instead

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

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSessionComponent
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
 import org.jetbrains.kotlin.fir.java.convertAnnotationsToFir
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
 import org.jetbrains.kotlin.fir.references.FirFromMissingDependenciesNamedReference
@@ -71,9 +70,9 @@ class FirAnnotationTypeQualifierResolver(
                 ?.let { extractDefaultQualifiers(it) }
         } else {
             val forModule = javaModuleAnnotationsProvider.getAnnotationsForModuleOwnerOfClass(classId)
-                ?.let { extractAndMergeDefaultQualifiers(null, it.convertAnnotationsToFir(session, JavaTypeParameterStack.EMPTY)) }
+                ?.let { extractAndMergeDefaultQualifiers(null, it.convertAnnotationsToFir(session)) }
             val forPackage = (firClass as? FirJavaClass)?.javaPackage
-                ?.let { extractAndMergeDefaultQualifiers(forModule, it.convertAnnotationsToFir(session, JavaTypeParameterStack.EMPTY)) }
+                ?.let { extractAndMergeDefaultQualifiers(forModule, it.convertAnnotationsToFir(session)) }
             forPackage ?: forModule
         }
         return extractAndMergeDefaultQualifiers(parentQualifiers, firClass.annotations)

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

@@ -52,20 +52,19 @@ import org.jetbrains.kotlin.utils.addToStdlib.ifNotEmpty
 import java.util.*
 
 internal fun Iterable<JavaAnnotation>.convertAnnotationsToFir(
-    session: FirSession, javaTypeParameterStack: JavaTypeParameterStack
-): List<FirAnnotation> = map { it.toFirAnnotationCall(session, javaTypeParameterStack) }
+    session: FirSession,
+): List<FirAnnotation> = map { it.toFirAnnotationCall(session) }
 
 internal fun JavaAnnotationOwner.convertAnnotationsToFir(
-    session: FirSession, javaTypeParameterStack: JavaTypeParameterStack
-): List<FirAnnotation> = annotations.convertAnnotationsToFir(session, javaTypeParameterStack)
+    session: FirSession,
+): List<FirAnnotation> = annotations.convertAnnotationsToFir(session)
 
 internal fun FirAnnotationContainer.setAnnotationsFromJava(
     session: FirSession,
     javaAnnotationOwner: JavaAnnotationOwner,
-    javaTypeParameterStack: JavaTypeParameterStack
 ) {
     val annotations = mutableListOf<FirAnnotation>()
-    javaAnnotationOwner.annotations.mapTo(annotations) { it.toFirAnnotationCall(session, javaTypeParameterStack) }
+    javaAnnotationOwner.annotations.mapTo(annotations) { it.toFirAnnotationCall(session) }
     replaceAnnotations(annotations)
 }
 
@@ -74,18 +73,15 @@ internal fun JavaValueParameter.toFirValueParameter(
     functionSymbol: FirFunctionSymbol<*>,
     moduleData: FirModuleData,
     index: Int,
-    javaTypeParameterStack: JavaTypeParameterStack,
-): FirValueParameter {
-    return buildJavaValueParameter {
-        source = (this@toFirValueParameter as? JavaElementImpl<*>)?.psi?.toKtPsiSourceElement()
-        isFromSource = this@toFirValueParameter.isFromSource
-        this.moduleData = moduleData
-        containingFunctionSymbol = functionSymbol
-        name = this@toFirValueParameter.name ?: Name.identifier("p$index")
-        returnTypeRef = type.toFirJavaTypeRef(session, javaTypeParameterStack)
-        isVararg = this@toFirValueParameter.isVararg
-        annotationBuilder = { convertAnnotationsToFir(session, javaTypeParameterStack) }
-    }
+): FirValueParameter = buildJavaValueParameter {
+    source = (this@toFirValueParameter as? JavaElementImpl<*>)?.psi?.toKtPsiSourceElement()
+    isFromSource = this@toFirValueParameter.isFromSource
+    this.moduleData = moduleData
+    containingFunctionSymbol = functionSymbol
+    name = this@toFirValueParameter.name ?: Name.identifier("p$index")
+    returnTypeRef = type.toFirJavaTypeRef(session)
+    isVararg = this@toFirValueParameter.isVararg
+    annotationBuilder = { convertAnnotationsToFir(session) }
 }
 
 internal fun JavaAnnotationArgument.toFirExpression(
@@ -121,7 +117,7 @@ internal fun JavaAnnotationArgument.toFirExpression(
             )
             typeRef = resolvedTypeRef
         }
-        is JavaAnnotationAsAnnotationArgument -> getAnnotation().toFirAnnotationCall(session, javaTypeParameterStack)
+        is JavaAnnotationAsAnnotationArgument -> getAnnotation().toFirAnnotationCall(session)
         else -> buildErrorExpression {
             diagnostic = ConeSimpleDiagnostic("Unknown JavaAnnotationArgument: ${this::class.java}", DiagnosticKind.Java)
         }
@@ -235,9 +231,7 @@ private fun fillAnnotationArgumentMapping(
     }
 }
 
-private fun JavaAnnotation.toFirAnnotationCall(
-    session: FirSession, javaTypeParameterStack: JavaTypeParameterStack
-): FirAnnotation = buildAnnotation {
+private fun JavaAnnotation.toFirAnnotationCall(session: FirSession): FirAnnotation = buildAnnotation {
     val lookupTag = when (classId) {
         StandardClassIds.Annotations.Java.Target -> StandardClassIds.Annotations.Target
         StandardClassIds.Annotations.Java.Retention -> StandardClassIds.Annotations.Retention