Refactor FIR symbols to make them and their FIR element types more clear

This commit also fixes work with Java synthetic properties
2019-06-24 15:17:11 +03:00
parent 701b9ce166
commit c35d7eab70
99 changed files with 609 additions and 610 deletions
@@ -21,17 +21,11 @@ import org.jetbrains.kotlin.fir.java.declarations.FirJavaMethod
 import org.jetbrains.kotlin.fir.java.scopes.JavaClassEnhancementScope
 import org.jetbrains.kotlin.fir.java.scopes.JavaClassUseSiteScope
 import org.jetbrains.kotlin.fir.resolve.*
-import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirSuperTypeScope
 import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope
 import org.jetbrains.kotlin.fir.symbols.CallableId
-import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
-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.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.ConeClassErrorType
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
@@ -59,7 +53,7 @@ class JavaSymbolProvider(
        content: KotlinClassFinder.Result.ClassFileContent?
    ): JavaClass? = facade.findClass(JavaClassFinder.Request(classId, previouslyFoundClassFileContent = content?.content), searchScope)

-    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<ConeCallableSymbol> =
+    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<FirCallableSymbol<*>> =
        emptyList()

    override fun getClassDeclaredMemberScope(classId: ClassId): FirScope? {
@@ -72,9 +66,8 @@ class JavaSymbolProvider(
        useSiteSession: FirSession,
        scopeSession: ScopeSession
    ): FirScope? {
-        val symbol = this.getClassLikeSymbolByFqName(classId) ?: return null
-        val javaClass = symbol.firUnsafe<FirJavaClass>()
-        return buildJavaEnhancementScope(useSiteSession, javaClass.symbol, scopeSession)
+        val symbol = this.getClassLikeSymbolByFqName(classId) as? FirClassSymbol ?: return null
+        return buildJavaEnhancementScope(useSiteSession, symbol, scopeSession)
    }

    private fun buildJavaEnhancementScope(
@@ -140,9 +133,9 @@ class JavaSymbolProvider(
            }
    }

-    override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? = getFirJavaClass(classId)
+    override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? = getFirJavaClass(classId)

-    fun getFirJavaClass(classId: ClassId, content: KotlinClassFinder.Result.ClassFileContent? = null): ConeClassLikeSymbol? {
+    fun getFirJavaClass(classId: ClassId, content: KotlinClassFinder.Result.ClassFileContent? = null): FirClassLikeSymbol<*>? {
        if (!hasTopLevelClassOf(classId)) return null
        return classCache.lookupCacheOrCalculateWithPostCompute(classId, {
            val foundClass = findClass(classId, content)
@@ -197,7 +190,7 @@ class JavaSymbolProvider(
                    for (javaMethod in javaClass.methods) {
                        val methodName = javaMethod.name
                        val methodId = CallableId(classId.packageFqName, classId.relativeClassName, methodName)
-                        val methodSymbol = FirFunctionSymbol(methodId)
+                        val methodSymbol = FirNamedFunctionSymbol(methodId)
                        val returnType = javaMethod.returnType
                        val firJavaMethod = FirJavaMethod(
                            this@JavaSymbolProvider.session, methodSymbol, methodName,
@@ -219,7 +212,7 @@ class JavaSymbolProvider(
                    val constructorId = CallableId(classId.packageFqName, classId.relativeClassName, classId.shortClassName)

                    fun addJavaConstructor(visibility: Visibility = Visibilities.PUBLIC): FirJavaConstructor {
-                        val constructorSymbol = FirFunctionSymbol(constructorId)
+                        val constructorSymbol = FirConstructorSymbol(constructorId)
                        val classTypeParameters = javaClass.typeParameters.convertTypeParameters(javaTypeParameterStack)
                        val firJavaConstructor = FirJavaConstructor(
                            this@JavaSymbolProvider.session, constructorSymbol, visibility,
@@ -14,15 +14,15 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirAbstractCallableMember
 import org.jetbrains.kotlin.fir.declarations.impl.FirConstructorImpl.Companion.NAME
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef

 class FirJavaConstructor(
    session: FirSession,
-    override val symbol: FirFunctionSymbol,
+    override val symbol: FirConstructorSymbol,
    visibility: Visibility,
    delegatedSelfTypeRef: FirTypeRef
-) : FirAbstractCallableMember(
+) : FirAbstractCallableMember<FirConstructor>(
    session,
    psi = null,
    name = NAME,
@@ -11,21 +11,20 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirField
 import org.jetbrains.kotlin.fir.declarations.impl.FirAbstractCallableMember
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.java.types.FirJavaTypeRef
-import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirFieldSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name

 class FirJavaField(
    session: FirSession,
-    override val symbol: FirPropertySymbol,
+    override val symbol: FirFieldSymbol,
    name: Name,
    visibility: Visibility,
    modality: Modality?,
    returnTypeRef: FirTypeRef,
    override val isVar: Boolean,
    isStatic: Boolean
-) : FirAbstractCallableMember(
+) : FirAbstractCallableMember<FirField>(
    session, psi = null, name = name,
    visibility = visibility, modality = modality,
    isExpect = false, isActual = false, isOverride = false,
@@ -10,13 +10,12 @@ import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.impl.FirMemberFunctionImpl
 import org.jetbrains.kotlin.fir.java.types.FirJavaTypeRef
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
-import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.name.Name

 class FirJavaMethod(
    session: FirSession,
-    symbol: FirFunctionSymbol,
+    symbol: FirNamedFunctionSymbol,
    name: Name,
    visibility: Visibility,
    modality: Modality?,
@@ -24,16 +24,15 @@ import org.jetbrains.kotlin.fir.java.topLevelName
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedCallableReferenceImpl
 import org.jetbrains.kotlin.fir.resolve.*
-import org.jetbrains.kotlin.fir.resolve.transformers.firSafeNullable
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope
 import org.jetbrains.kotlin.fir.service
 import org.jetbrains.kotlin.fir.symbols.*
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
-import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
 import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.load.java.JavaClassFinder
@@ -145,12 +144,12 @@ class KotlinDeserializedJvmSymbolsProvider(
        useSiteSession: FirSession,
        scopeSession: ScopeSession
    ): FirScope? {
-        val symbol = this.getClassLikeSymbolByFqName(classId) ?: return null
+        val symbol = this.getClassLikeSymbolByFqName(classId) as? FirClassSymbol ?: return null

-        return symbol.firSafeNullable<FirRegularClass>()?.buildDefaultUseSiteScope(session, scopeSession)
+        return symbol.fir.buildDefaultUseSiteScope(session, scopeSession)
    }

-    override fun getClassLikeSymbolByFqName(classId: ClassId): ConeClassLikeSymbol? {
+    override fun getClassLikeSymbolByFqName(classId: ClassId): FirClassLikeSymbol<*>? {
        return findAndDeserializeClass(classId) ?: findAndDeserializeTypeAlias(classId)
    }

@@ -316,8 +315,7 @@ class KotlinDeserializedJvmSymbolsProvider(

        if (classId in handledByJava) return null

-        val result = kotlinClassFinder.findKotlinClassOrContent(classId)
-        val kotlinJvmBinaryClass = when (result) {
+        val kotlinJvmBinaryClass = when (val result = kotlinClassFinder.findKotlinClassOrContent(classId)) {
            is KotlinClassFinder.Result.KotlinClass -> result.kotlinJvmBinaryClass
            is KotlinClassFinder.Result.ClassFileContent -> {
                handledByJava.add(classId)
@@ -360,7 +358,7 @@ class KotlinDeserializedJvmSymbolsProvider(
 //        }
    }

-    private fun loadFunctionsByName(part: PackagePartsCacheData, name: Name): List<FirCallableSymbol> {
+    private fun loadFunctionsByName(part: PackagePartsCacheData, name: Name): List<FirCallableSymbol<*>> {
        val functionIds = part.topLevelFunctionNameIndex[name] ?: return emptyList()
        return functionIds.map { part.proto.getFunction(it) }
            .map {
@@ -370,7 +368,7 @@ class KotlinDeserializedJvmSymbolsProvider(
            }
    }

-    private fun loadPropertiesByName(part: PackagePartsCacheData, name: Name): List<FirCallableSymbol> {
+    private fun loadPropertiesByName(part: PackagePartsCacheData, name: Name): List<FirCallableSymbol<*>> {
        val propertyIds = part.topLevelPropertyNameIndex[name] ?: return emptyList()
        return propertyIds.map { part.proto.getProperty(it) }
            .map {
@@ -380,7 +378,7 @@ class KotlinDeserializedJvmSymbolsProvider(
            }
    }

-    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<ConeCallableSymbol> {
+    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): List<FirCallableSymbol<*>> {
        return getPackageParts(packageFqName).flatMap { part ->
            loadFunctionsByName(part, name) + loadPropertiesByName(part, name)
        }
@@ -163,7 +163,7 @@ private fun JavaClassifierType.enhanceInflexibleType(
            arg.toConeProjection(
                session,
                javaTypeParameterStack,
-                ((originalTag as? FirBasedSymbol<*>)?.fir as? FirCallableMemberDeclaration)?.typeParameters?.getOrNull(localArgIndex)
+                ((originalTag as? FirBasedSymbol<*>)?.fir as? FirCallableMemberDeclaration<*>)?.typeParameters?.getOrNull(localArgIndex)
            )
        } else {
            val argEnhancedTypeRef = arg.enhancePossiblyFlexible(session, javaTypeParameterStack, annotations, qualifiers, globalArgIndex)
@@ -18,13 +18,10 @@ import org.jetbrains.kotlin.fir.java.enhancement.EnhancementSignatureParts
 import org.jetbrains.kotlin.fir.java.toNotNullConeKotlinType
 import org.jetbrains.kotlin.fir.java.types.FirJavaTypeRef
 import org.jetbrains.kotlin.fir.render
-import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.*
-import org.jetbrains.kotlin.fir.symbols.impl.FirAccessorSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.ir.expressions.IrConstKind
 import org.jetbrains.kotlin.load.java.AnnotationTypeQualifierResolver
@@ -53,42 +50,42 @@ class JavaClassEnhancementScope(
    private val context: FirJavaEnhancementContext =
        FirJavaEnhancementContext(session) { null }.copyWithNewDefaultTypeQualifiers(typeQualifierResolver, jsr305State, owner.annotations)

-    private val enhancements = mutableMapOf<ConeCallableSymbol, ConeCallableSymbol>()
+    private val enhancements = mutableMapOf<FirCallableSymbol<*>, FirCallableSymbol<*>>()

-    override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
        useSiteScope.processPropertiesByName(name) process@{ original ->

            val field = enhancements.getOrPut(original) { enhance(original, name) }
-            processor(field as ConeVariableSymbol)
+            processor(field)
        }

        return super.processPropertiesByName(name, processor)
    }

-    override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
        useSiteScope.processFunctionsByName(name) process@{ original ->

            val function = enhancements.getOrPut(original) { enhance(original, name) }
-            processor(function as ConeFunctionSymbol)
+            processor(function as FirFunctionSymbol<*>)
        }

        return super.processFunctionsByName(name, processor)
    }

    private fun enhance(
-        original: ConeVariableSymbol,
+        original: FirCallableSymbol<*>,
        name: Name
-    ): ConeVariableSymbol {
-        when (val firElement = (original as FirBasedSymbol<*>).fir) {
+    ): FirCallableSymbol<*> {
+        when (val firElement = original.fir) {
            is FirJavaField -> {
                if (firElement.returnTypeRef !is FirJavaTypeRef) return original
                val memberContext = context.copyWithNewDefaultTypeQualifiers(typeQualifierResolver, jsr305State, firElement.annotations)
                val newReturnTypeRef = enhanceReturnType(firElement, emptyList(), memberContext, null)

-                val symbol = FirPropertySymbol(original.callableId)
+                val symbol = FirFieldSymbol(original.callableId)
                with(firElement) {
                    FirJavaField(
-                        session,
+                        this@JavaClassEnhancementScope.session,
                        symbol,
                        name,
                        visibility,
@@ -116,23 +113,24 @@ class JavaClassEnhancementScope(
    }

    private fun enhance(
-        original: ConeFunctionSymbol,
+        original: FirFunctionSymbol<*>,
        name: Name
-    ): FirFunctionSymbol {
-        val firMethod = (original as FirFunctionSymbol).fir as? FirFunction
+    ): FirFunctionSymbol<*> {
+        val firMethod = original.fir

-        if (firMethod !is FirJavaMethod && firMethod !is FirJavaConstructor || firMethod !is FirCallableMemberDeclaration) return original
-        return enhanceMethod(firMethod, original.callableId, name) as FirFunctionSymbol
+        if (firMethod !is FirJavaMethod && firMethod !is FirJavaConstructor) {
+            return original
+        }
+        return enhanceMethod(firMethod, original.callableId, name)
    }

    private fun enhanceMethod(
-        firMethod: FirFunction,
+        firMethod: FirMemberFunction<*>,
        methodId: CallableId,
        name: Name,
        isAccessor: Boolean = false,
        propertyId: CallableId? = null
-    ): ConeCallableSymbol {
-        require(firMethod is FirCallableMemberDeclaration)
+    ): FirFunctionSymbol<*> {
        val memberContext = context.copyWithNewDefaultTypeQualifiers(typeQualifierResolver, jsr305State, firMethod.annotations)

        val predefinedEnhancementInfo =
@@ -169,7 +167,6 @@ class JavaClassEnhancementScope(
            )
        }

-        val symbol = if (!isAccessor) FirFunctionSymbol(methodId) else FirAccessorSymbol(callableId = propertyId!!, accessorId = methodId)
        val newValueParameters = firMethod.valueParameters.zip(newValueParameterInfo) { valueParameter, newInfo ->
            val (newTypeRef, newDefaultValue) = newInfo
            with(valueParameter) {
@@ -182,27 +179,29 @@ class JavaClassEnhancementScope(
                }
            }
        }
-        val function = when (firMethod) {
+        val function: FirMemberFunction<*> = when (firMethod) {
            is FirJavaConstructor -> FirConstructorImpl(
-                this@JavaClassEnhancementScope.session, null, symbol as FirFunctionSymbol,
+                this@JavaClassEnhancementScope.session, null, FirConstructorSymbol(methodId),
                newReceiverTypeRef, newReturnTypeRef
            ).apply {
                this.valueParameters += newValueParameters
                this.typeParameters += firMethod.typeParameters
            }
            else -> FirMemberFunctionImpl(
-                this@JavaClassEnhancementScope.session, null, symbol, name,
-                newReceiverTypeRef, newReturnTypeRef
+                this@JavaClassEnhancementScope.session, null,
+                if (!isAccessor) FirNamedFunctionSymbol(methodId)
+                else FirAccessorSymbol(callableId = propertyId!!, accessorId = methodId),
+                name, newReceiverTypeRef, newReturnTypeRef
            ).apply {
                this.valueParameters += newValueParameters
                this.typeParameters += firMethod.typeParameters
            }
        }
-        function.apply {
+        (function as FirAbstractCallableMember<*>).apply {
            status = firMethod.status as FirDeclarationStatusImpl
            annotations += firMethod.annotations
        }
-        return symbol
+        return function.symbol
    }

    private fun FirFunction.computeJvmDescriptor(): String = buildString {
@@ -255,7 +254,7 @@ class JavaClassEnhancementScope(

    private fun enhanceReceiverType(
        ownerFunction: FirJavaMethod,
-        overriddenMembers: List<FirCallableMemberDeclaration>,
+        overriddenMembers: List<FirCallableMemberDeclaration<*>>,
        memberContext: FirJavaEnhancementContext
    ): FirResolvedTypeRef {
        val signatureParts = ownerFunction.partsForValueParameter(
@@ -272,8 +271,8 @@ class JavaClassEnhancementScope(
    private data class EnhanceValueParameterResult(val typeRef: FirResolvedTypeRef, val defaultValue: FirExpression?)

    private fun enhanceValueParameter(
-        ownerFunction: FirCallableMemberDeclaration,
-        overriddenMembers: List<FirCallableMemberDeclaration>,
+        ownerFunction: FirCallableMemberDeclaration<*>,
+        overriddenMembers: List<FirCallableMemberDeclaration<*>>,
        hasReceiver: Boolean,
        memberContext: FirJavaEnhancementContext,
        predefinedEnhancementInfo: PredefinedFunctionEnhancementInfo?,
@@ -297,8 +296,8 @@ class JavaClassEnhancementScope(
    }

    private fun enhanceReturnType(
-        owner: FirCallableMemberDeclaration,
-        overriddenMembers: List<FirCallableMemberDeclaration>,
+        owner: FirCallableMemberDeclaration<*>,
+        overriddenMembers: List<FirCallableMemberDeclaration<*>>,
        memberContext: FirJavaEnhancementContext,
        predefinedEnhancementInfo: PredefinedFunctionEnhancementInfo?
    ): FirResolvedTypeRef {
@@ -315,9 +314,9 @@ class JavaClassEnhancementScope(
        return signatureParts.type
    }

-    private val overrideBindCache = mutableMapOf<Name, Map<ConeCallableSymbol?, List<ConeCallableSymbol>>>()
+    private val overrideBindCache = mutableMapOf<Name, Map<FirCallableSymbol<*>?, List<FirCallableSymbol<*>>>>()

-    private fun FirCallableMemberDeclaration.overriddenMembers(): List<FirCallableMemberDeclaration> {
+    private fun FirCallableMemberDeclaration<*>.overriddenMembers(): List<FirCallableMemberDeclaration<*>> {
        val backMap = overrideBindCache.getOrPut(this.name) {
            useSiteScope.bindOverrides(this.name)
            useSiteScope
@@ -325,36 +324,36 @@ class JavaClassEnhancementScope(
                .toList()
                .groupBy({ (_, key) -> key }, { (value) -> value })
        }
-        return backMap[this.symbol]?.map { it.firUnsafe() } ?: emptyList()
+        return backMap[this.symbol]?.map { it.fir as FirCallableMemberDeclaration<*> } ?: emptyList()
    }

    private sealed class TypeInSignature {
-        abstract fun getTypeRef(member: FirCallableMemberDeclaration): FirTypeRef
+        abstract fun getTypeRef(member: FirCallableMemberDeclaration<*>): FirTypeRef

        object Return : TypeInSignature() {
-            override fun getTypeRef(member: FirCallableMemberDeclaration): FirTypeRef = member.returnTypeRef
+            override fun getTypeRef(member: FirCallableMemberDeclaration<*>): FirTypeRef = member.returnTypeRef
        }

        object Receiver : TypeInSignature() {
-            override fun getTypeRef(member: FirCallableMemberDeclaration): FirTypeRef {
+            override fun getTypeRef(member: FirCallableMemberDeclaration<*>): FirTypeRef {
                if (member is FirJavaMethod) return member.valueParameters[0].returnTypeRef
                return member.receiverTypeRef!!
            }
        }

        class ValueParameter(val hasReceiver: Boolean, val index: Int) : TypeInSignature() {
-            override fun getTypeRef(member: FirCallableMemberDeclaration): FirTypeRef {
+            override fun getTypeRef(member: FirCallableMemberDeclaration<*>): FirTypeRef {
                if (hasReceiver && member is FirJavaMethod) {
-                    return (member as FirFunction).valueParameters[index + 1].returnTypeRef
+                    return member.valueParameters[index + 1].returnTypeRef
                }
                return (member as FirFunction).valueParameters[index].returnTypeRef
            }
        }
    }

-    private fun FirCallableMemberDeclaration.partsForValueParameter(
+    private fun FirCallableMemberDeclaration<*>.partsForValueParameter(
        typeQualifierResolver: FirAnnotationTypeQualifierResolver,
-        overriddenMembers: List<FirCallableMemberDeclaration>,
+        overriddenMembers: List<FirCallableMemberDeclaration<*>>,
        // TODO: investigate if it's really can be a null (check properties' with extension overrides in Java)
        parameterContainer: FirAnnotationContainer?,
        methodContext: FirJavaEnhancementContext,
@@ -370,9 +369,9 @@ class JavaClassEnhancementScope(
        typeInSignature
    )

-    private fun FirCallableMemberDeclaration.parts(
+    private fun FirCallableMemberDeclaration<*>.parts(
        typeQualifierResolver: FirAnnotationTypeQualifierResolver,
-        overriddenMembers: List<FirCallableMemberDeclaration>,
+        overriddenMembers: List<FirCallableMemberDeclaration<*>>,
        typeContainer: FirAnnotationContainer?,
        isCovariant: Boolean,
        containerContext: FirJavaEnhancementContext,
@@ -13,18 +13,12 @@ import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
 import org.jetbrains.kotlin.fir.java.toNotNullConeKotlinType
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap
-import org.jetbrains.kotlin.fir.resolve.transformers.firUnsafe
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction.*
 import org.jetbrains.kotlin.fir.scopes.impl.FirAbstractProviderBasedScope
-import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol
-import org.jetbrains.kotlin.fir.symbols.ConeVariableSymbol
 import org.jetbrains.kotlin.fir.symbols.*
-import org.jetbrains.kotlin.fir.symbols.impl.FirAccessorSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.typeContext
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
@@ -42,7 +36,7 @@ class JavaClassUseSiteScope(
        if (klass is FirJavaClass) klass.javaTypeParameterStack else JavaTypeParameterStack.EMPTY

    //base symbol as key, overridden as value
-    internal val overriddenByBase = mutableMapOf<ConeCallableSymbol, ConeCallableSymbol?>()
+    internal val overriddenByBase = mutableMapOf<FirCallableSymbol<*>, FirCallableSymbol<*>?>()

    private val context: ConeTypeContext = session.typeContext

@@ -64,9 +58,8 @@ class JavaClassUseSiteScope(
            substitutor
        )

-    private fun isOverriddenFunCheck(overriddenInJava: FirFunction, base: FirFunction): Boolean {
-        overriddenInJava as FirCallableMemberDeclaration
-        val receiverTypeRef = (base as FirCallableMemberDeclaration).receiverTypeRef
+    private fun isOverriddenFunCheck(overriddenInJava: FirNamedFunction, base: FirNamedFunction): Boolean {
+        val receiverTypeRef = base.receiverTypeRef
        val baseParameterTypes = listOfNotNull(receiverTypeRef) + base.valueParameters.map { it.returnTypeRef }

        if (overriddenInJava.valueParameters.size != baseParameterTypes.size) return false
@@ -111,7 +104,7 @@ class JavaClassUseSiteScope(
    }

    internal fun bindOverrides(name: Name) {
-        val overrideCandidates = mutableSetOf<ConeFunctionSymbol>()
+        val overrideCandidates = mutableSetOf<FirFunctionSymbol<*>>()
        declaredMemberScope.processFunctionsByName(name) {
            overrideCandidates += it
            NEXT
@@ -124,29 +117,31 @@ class JavaClassUseSiteScope(
        }
    }

-    private fun ConeCallableSymbol.getOverridden(candidates: Set<ConeCallableSymbol>): ConeCallableSymbol? {
+    private fun FirCallableSymbol<*>.getOverridden(candidates: Set<FirCallableSymbol<*>>): FirCallableSymbol<*>? {
        if (overriddenByBase.containsKey(this)) return overriddenByBase[this]

        val overriding = when (this) {
-            is FirFunctionSymbol -> {
-                val self = firUnsafe<FirFunction>()
-                self as FirCallableMemberDeclaration
+            is FirNamedFunctionSymbol -> {
+                val self = this.fir
                candidates.firstOrNull {
-                    val overridden = (it as? FirFunctionSymbol)?.fir as? FirFunction
+                    val overridden = (it as? FirNamedFunctionSymbol)?.fir
                    overridden != null && self.modality != Modality.FINAL && isOverriddenFunCheck(overridden, self)
                }
            }
+            is FirConstructorSymbol, is FirFieldSymbol -> {
+                null
+            }
            is FirPropertySymbol -> {
-                val self = fir as? FirProperty ?: return null
+                val self = fir
                candidates.firstOrNull {
                    when (it) {
-                        is FirFunctionSymbol -> {
-                            val overridden = it.fir as FirNamedFunction
+                        is FirNamedFunctionSymbol -> {
+                            val overridden = it.fir
                            self.modality != Modality.FINAL && isOverriddenPropertyCheck(overridden, self)
                        }
                        is FirPropertySymbol -> {
                            val overridden = it.fir
-                            overridden is FirProperty && self.modality != Modality.FINAL && isOverriddenPropertyCheck(overridden, self)
+                            self.modality != Modality.FINAL && isOverriddenPropertyCheck(overridden, self)
                        }
                        else -> false
                    }
@@ -154,9 +149,9 @@ class JavaClassUseSiteScope(
                }
            }
            is FirAccessorSymbol -> {
-                val self = fir as FirNamedFunction
+                val self = fir
                candidates.firstOrNull {
-                    val overridden = (it as? FirFunctionSymbol)?.fir as? FirNamedFunction
+                    val overridden = (it as? FirNamedFunctionSymbol)?.fir
                    overridden != null && self.modality != Modality.FINAL && isOverriddenFunCheck(overridden, self)
                }
            }
@@ -167,8 +162,8 @@ class JavaClassUseSiteScope(
        return overriding
    }

-    override fun processFunctionsByName(name: Name, processor: (ConeFunctionSymbol) -> ProcessorAction): ProcessorAction {
-        val overrideCandidates = mutableSetOf<ConeFunctionSymbol>()
+    override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> ProcessorAction): ProcessorAction {
+        val overrideCandidates = mutableSetOf<FirFunctionSymbol<*>>()
        if (!declaredMemberScope.processFunctionsByName(name) {
                overrideCandidates += it
                processor(it)
@@ -190,9 +185,9 @@ class JavaClassUseSiteScope(
        propertyName: Name,
        accessorName: Name,
        isGetter: Boolean,
-        processor: (ConeVariableSymbol) -> ProcessorAction
+        processor: (FirCallableSymbol<*>) -> ProcessorAction
    ): ProcessorAction {
-        val overrideCandidates = mutableSetOf<ConeCallableSymbol>()
+        val overrideCandidates = mutableSetOf<FirCallableSymbol<*>>()
        val klass = symbol.fir
        if (!declaredMemberScope.processPropertiesByName(propertyName) { variableSymbol ->
                overrideCandidates += variableSymbol
@@ -201,19 +196,17 @@ class JavaClassUseSiteScope(
        ) return STOP
        if (klass is FirJavaClass) {
            if (!declaredMemberScope.processFunctionsByName(accessorName) { functionSymbol ->
-                    if (functionSymbol is FirFunctionSymbol) {
+                    if (functionSymbol is FirNamedFunctionSymbol) {
                        val fir = functionSymbol.fir
-                        if (fir is FirNamedFunction) {
-                            if (fir.isStatic) {
+                        if (fir.isStatic) {
+                            return@processFunctionsByName NEXT
+                        }
+                        when (isGetter) {
+                            true -> if (fir.valueParameters.isNotEmpty()) {
                                return@processFunctionsByName NEXT
                            }
-                            when (isGetter) {
-                                true -> if (fir.valueParameters.isNotEmpty()) {
-                                    return@processFunctionsByName NEXT
-                                }
-                                false -> if (fir.valueParameters.size != 1) {
-                                    return@processFunctionsByName NEXT
-                                }
+                            false -> if (fir.valueParameters.size != 1) {
+                                return@processFunctionsByName NEXT
                            }
                        }
                    }
@@ -222,8 +215,8 @@ class JavaClassUseSiteScope(
                        accessorId = functionSymbol.callableId,
                        callableId = CallableId(functionSymbol.callableId.packageName, functionSymbol.callableId.className, propertyName)
                    )
-                    if (functionSymbol is FirBasedSymbol<*>) {
-                        (functionSymbol.fir as? FirCallableMemberDeclaration)?.let { callableMember -> accessorSymbol.bind(callableMember) }
+                    if (functionSymbol is FirNamedFunctionSymbol) {
+                        functionSymbol.fir.let { callableMember -> accessorSymbol.bind(callableMember) }
                    }
                    processor(accessorSymbol)
                }
@@ -231,12 +224,12 @@ class JavaClassUseSiteScope(
        }

        return superTypesScope.processPropertiesByName(propertyName) {
-            val firCallableMember = (it as FirBasedSymbol<*>).fir as? FirCallableMemberDeclaration
+            val firCallableMember = it.fir as? FirCallableMemberDeclaration<*>
            if (firCallableMember?.isStatic == true) {
                NEXT
            } else {
                val overriddenBy = it.getOverridden(overrideCandidates)
-                if (overriddenBy == null && it is ConePropertySymbol) {
+                if (overriddenBy == null && it is FirVariableSymbol<*>) {
                    processor(it)
                } else {
                    NEXT
@@ -245,7 +238,7 @@ class JavaClassUseSiteScope(
        }
    }

-    override fun processPropertiesByName(name: Name, processor: (ConeVariableSymbol) -> ProcessorAction): ProcessorAction {
+    override fun processPropertiesByName(name: Name, processor: (FirCallableSymbol<*>) -> ProcessorAction): ProcessorAction {
        val getterName = Name.identifier(getterPrefix + name.asString().capitalize())
        return processAccessorFunctionsAndPropertiesByName(name, getterName, isGetter = true, processor = processor)
    }