FIR: remove a couple unused type enhancement abstractions

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

@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
 import org.jetbrains.kotlin.fir.java.toConeKotlinTypeWithoutEnhancement
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.jvm.FirJavaTypeRef
 import org.jetbrains.kotlin.load.java.AnnotationQualifierApplicabilityType
 import org.jetbrains.kotlin.load.java.JavaDefaultQualifiers
@@ -40,40 +41,13 @@ internal class EnhancementSignatureParts(
         session: FirSession,
         predefined: TypeEnhancementInfo? = null,
         forAnnotationMember: Boolean = false
-    ): PartEnhancementResult {
+    ): FirResolvedTypeRef {
         val typeWithoutEnhancement = current.type
             .toConeKotlinTypeWithoutEnhancement(session, javaTypeParameterStack, forAnnotationMember)
-
-        val qualifiers = computeIndexedQualifiersForOverride(typeWithoutEnhancement)
-
-        val qualifiersWithPredefined = predefined?.let {
-            IndexedJavaTypeQualifiers(qualifiers.size) { index ->
-                predefined.map[index] ?: qualifiers(index)
-            }
-        }
-
-        val containsFunctionN = typeWithoutEnhancement.contains {
-            if (it is ConeClassErrorType) false
-            else {
-                val classId = it.lookupTag.classId
-                classId.shortClassName == JavaToKotlinClassMap.FUNCTION_N_FQ_NAME.shortName() &&
-                        classId.asSingleFqName() == JavaToKotlinClassMap.FUNCTION_N_FQ_NAME
-            }
-        }
-
-        val enhancedCurrent = current.enhance(
-            session, qualifiersWithPredefined ?: qualifiers,
-            typeWithoutEnhancement
-        )
-        return PartEnhancementResult(
-            enhancedCurrent, wereChanges = true, containsFunctionN = containsFunctionN
-        )
-    }
-
-    private fun ConeKotlinType.contains(isSpecialType: (ConeClassLikeType) -> Boolean): Boolean {
-        return when (this) {
-            is ConeClassLikeType -> isSpecialType(this)
-            else -> false
+        val qualifiers = computeIndexedQualifiersForOverride(typeWithoutEnhancement, predefined)
+        return buildResolvedTypeRef {
+            type = typeWithoutEnhancement.enhance(session, qualifiers) ?: typeWithoutEnhancement
+            annotations += current.annotations
         }
     }
 
@@ -152,7 +126,7 @@ internal class EnhancementSignatureParts(
         )
     }
 
-    private fun computeIndexedQualifiersForOverride(current: ConeKotlinType?): IndexedJavaTypeQualifiers {
+    private fun computeIndexedQualifiersForOverride(current: ConeKotlinType?, predefined: TypeEnhancementInfo?): IndexedJavaTypeQualifiers {
         val indexedFromSupertypes = fromOverridden.map { it.toConeKotlinType(context.session).toIndexed(context) }
         val indexedThisType = current.toIndexed(context)
 
@@ -169,17 +143,9 @@ internal class EnhancementSignatureParts(
             val superQualifiers = indexedFromSupertypes.mapNotNull { it.getOrNull(index)?.type?.extractQualifiers() }
             qualifiers.computeQualifiersForOverride(superQualifiers, index == 0 && isCovariant, index == 0 && isForVarargParameter)
         }
-
-        return IndexedJavaTypeQualifiers(computedResult)
+        return { index -> predefined?.map?.get(index) ?: computedResult.getOrNull(index) ?: JavaTypeQualifiers.NONE }
     }
 
-    @Suppress("unused")
-    internal open class PartEnhancementResult(
-        val type: FirResolvedTypeRef,
-        val wereChanges: Boolean,
-        val containsFunctionN: Boolean
-    )
-
     private data class TypeAndDefaultQualifiers(
         val type: ConeKotlinType?, // null denotes '*' here
         val defaultQualifiers: JavaDefaultQualifiers?

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

@@ -309,7 +309,7 @@ class FirSignatureEnhancement(
         overriddenMembers: List<FirCallableDeclaration>,
         memberContext: FirJavaEnhancementContext
     ): FirResolvedTypeRef {
-        val signatureParts = ownerFunction.partsForValueParameter(
+        return ownerFunction.partsForValueParameter(
             typeQualifierResolver,
             overriddenMembers,
             // TODO: check me
@@ -317,7 +317,6 @@ class FirSignatureEnhancement(
             methodContext = memberContext,
             typeInSignature = TypeInSignature.Receiver
         ).enhance(session)
-        return signatureParts.type
     }
 
     private fun enhanceValueParameterType(
@@ -332,7 +331,7 @@ class FirSignatureEnhancement(
         if (ownerParameter.returnTypeRef is FirResolvedTypeRef) {
             return ownerParameter.returnTypeRef as FirResolvedTypeRef
         }
-        val signatureParts = ownerFunction.partsForValueParameter(
+        return ownerFunction.partsForValueParameter(
             typeQualifierResolver,
             overriddenMembers,
             parameterContainer = ownerParameter,
@@ -343,7 +342,6 @@ class FirSignatureEnhancement(
             predefinedEnhancementInfo?.parametersInfo?.getOrNull(index),
             forAnnotationMember = owner.classKind == ClassKind.ANNOTATION_CLASS
         )
-        return signatureParts.type
     }
 
     private fun enhanceReturnType(
@@ -352,7 +350,7 @@ class FirSignatureEnhancement(
         memberContext: FirJavaEnhancementContext,
         predefinedEnhancementInfo: PredefinedFunctionEnhancementInfo?
     ): FirResolvedTypeRef {
-        val signatureParts = owner.parts(
+        return owner.parts(
             typeQualifierResolver,
             overriddenMembers,
             typeContainer = owner, isCovariant = true,
@@ -364,7 +362,6 @@ class FirSignatureEnhancement(
         ).enhance(
             session, predefinedEnhancementInfo?.returnTypeInfo, forAnnotationMember = this.owner.classKind == ClassKind.ANNOTATION_CLASS
         )
-        return signatureParts.type
     }
 
     private sealed class TypeInSignature {

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

@@ -26,10 +26,6 @@ import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.typeContext
 import org.jetbrains.kotlin.fir.types.*
-import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
-import org.jetbrains.kotlin.fir.types.jvm.FirJavaTypeRef
-import org.jetbrains.kotlin.load.java.structure.JavaClassifierType
-import org.jetbrains.kotlin.load.java.structure.JavaType
 import org.jetbrains.kotlin.load.java.typeEnhancement.*
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
@@ -38,24 +34,10 @@ import org.jetbrains.kotlin.types.AbstractStrictEqualityTypeChecker
 import org.jetbrains.kotlin.types.ConstantValueKind
 import org.jetbrains.kotlin.utils.extractRadix
 
-internal class IndexedJavaTypeQualifiers(private val data: Array<JavaTypeQualifiers>) {
-    constructor(size: Int, compute: (Int) -> JavaTypeQualifiers) : this(Array(size) { compute(it) })
+typealias IndexedJavaTypeQualifiers = (Int) -> JavaTypeQualifiers
 
-    operator fun invoke(index: Int): JavaTypeQualifiers = data.getOrElse(index) { JavaTypeQualifiers.NONE }
-
-    val size: Int get() = data.size
-}
-
-internal fun FirJavaTypeRef.enhance(
-    session: FirSession,
-    qualifiers: IndexedJavaTypeQualifiers,
-    typeWithoutEnhancement: ConeKotlinType,
-): FirResolvedTypeRef =
-    buildResolvedTypeRef {
-        val subtreeSizes = mutableListOf<Int>().apply { typeWithoutEnhancement.computeSubtreeSizes(this) }
-        type = typeWithoutEnhancement.enhanceConeKotlinType(session, qualifiers, 0, subtreeSizes) ?: typeWithoutEnhancement
-        annotations += this@enhance.annotations
-    }
+internal fun ConeKotlinType.enhance(session: FirSession, qualifiers: IndexedJavaTypeQualifiers): ConeKotlinType? =
+    enhanceConeKotlinType(session, qualifiers, 0, mutableListOf<Int>().apply { computeSubtreeSizes(this) })
 
 // The index in the lambda is the position of the type component in a depth-first walk of the tree.
 // Example: A<B<C, D>, E<F>> - 0<1<2, 3>, 4<5>>. For flexible types, the number of nodes in the lower
@@ -222,8 +204,6 @@ private fun ConeClassifierLookupTag.enhanceMutability(
     return this
 }
 
-internal fun JavaType.typeArguments(): List<JavaType?> = (this as? JavaClassifierType)?.typeArguments.orEmpty()
-
 internal fun ConeKotlinType.lexicalCastFrom(session: FirSession, value: String): FirExpression? {
     val lookupTagBasedType = when (this) {
         is ConeLookupTagBasedType -> this