FIR: introduce symbols + type parameter resolve #KT-24064 Fixed

2018-03-21 17:46:28 +03:00
parent 3495f09ac4
commit d15fb1963b
57 changed files with 549 additions and 147 deletions
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.name.ClassId

 class ConeClassDescriptorImpl(
    override val typeParameters: List<ConeTypeParameterDescriptor>,
-    override val fqName: ClassId,
+    override val classId: ClassId,
    override val superTypes: List<ConeKotlinType>,
    override val nestedClassifiers: List<ConeClassifierDescriptor>
 ) : ConeClassDescriptor, AbstractFirBasedDescriptor<FirResolvedClass>()
@@ -13,6 +13,6 @@ import org.jetbrains.kotlin.name.ClassId

 class ConeTypeAliasDescriptorImpl(
    override val typeParameters: List<ConeTypeParameterDescriptor>,
-    override val fqName: ClassId,
+    override val classId: ClassId,
    override val expandedType: ConeKotlinType
 ) : ConeTypeAliasDescriptor, AbstractFirBasedDescriptor<FirResolvedTypeAlias>()
@@ -0,0 +1,15 @@
+/*
+ * Copyright 2010-2018 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.descriptors
+
+import org.jetbrains.kotlin.fir.declarations.FirResolvedTypeParameter
+import org.jetbrains.kotlin.fir.descriptors.ConeTypeParameterDescriptor
+import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol
+import org.jetbrains.kotlin.name.Name
+
+class ConeTypeParameterDescriptorImpl(
+    override val symbol: ConeTypeParameterSymbol
+) : ConeTypeParameterDescriptor, AbstractFirBasedDescriptor<FirResolvedTypeParameter>()
@@ -10,14 +10,18 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedClassImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedTypeAliasImpl
+import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedTypeParameterImpl
 import org.jetbrains.kotlin.fir.descriptors.ConeClassifierDescriptor
 import org.jetbrains.kotlin.fir.descriptors.ConeTypeParameterDescriptor
+import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol
+import org.jetbrains.kotlin.fir.symbols.toSymbol
 import org.jetbrains.kotlin.fir.types.FirResolvedType
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.compose
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name

 class FirClassifierResolveTransformer : FirTransformer<Nothing?>() {
    override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
@@ -31,11 +35,11 @@ class FirClassifierResolveTransformer : FirTransformer<Nothing?>() {
        return file.also { it.transformChildren(this, null) }.compose()
    }

-    var className: FqName = FqName.ROOT
+    private var classLikeName: FqName = FqName.ROOT

    override fun transformClass(klass: FirClass, data: Nothing?): CompositeTransformResult<FirDeclaration> {
-        val actualClassName = className.child(klass.name)
-        className = actualClassName
+        val actualClassName = classLikeName.child(klass.name)
+        classLikeName = actualClassName

        klass.transformChildren(this, data)

@@ -43,7 +47,7 @@ class FirClassifierResolveTransformer : FirTransformer<Nothing?>() {
            (it as FirResolvedType).type
        }

-        className = className.parent()
+        classLikeName = classLikeName.parent()

        val typeParameters =
            klass.typeParameters.filterIsInstance<FirDescriptorOwner<*>>().mapNotNull { it.descriptor as? ConeTypeParameterDescriptor }
@@ -65,15 +69,30 @@ class FirClassifierResolveTransformer : FirTransformer<Nothing?>() {
        return resolvedClass.compose()
    }

+    var memberName: Name? = null
+
+    override fun transformNamedFunction(namedFunction: FirNamedFunction, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+        memberName = namedFunction.name
+        return super.transformNamedFunction(namedFunction, data).also {
+            memberName = null
+        }
+    }
+
    override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+        val actualClassName = classLikeName.child(typeAlias.name)
+        classLikeName = actualClassName
+
        typeAlias.transformChildren(this, data)
+
+        classLikeName = classLikeName.parent()
+
        val expandedType = (typeAlias.expandedType as FirResolvedType).type
        val typeParameters =
            typeAlias.typeParameters.filterIsInstance<FirDescriptorOwner<*>>().mapNotNull { it.descriptor as? ConeTypeParameterDescriptor }

        val descriptor = ConeTypeAliasDescriptorImpl(
            typeParameters,
-            ClassId(packageFqName, className.child(typeAlias.name), false),
+            ClassId(packageFqName, classLikeName.child(typeAlias.name), false),
            expandedType
        )

@@ -86,4 +105,18 @@ class FirClassifierResolveTransformer : FirTransformer<Nothing?>() {
    ): CompositeTransformResult<FirDeclaration> {
        return resolvedTypeAlias.compose()
    }
+
+    override fun transformResolvedTypeParameter(
+        resolvedTypeParameter: FirResolvedTypeParameter,
+        data: Nothing?
+    ): CompositeTransformResult<FirDeclaration> {
+        return resolvedTypeParameter.compose()
+    }
+
+    override fun transformTypeParameter(typeParameter: FirTypeParameter, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+        typeParameter.transformChildren(this, data)
+
+        val descriptor = ConeTypeParameterDescriptorImpl(typeParameter.symbol)
+        return FirResolvedTypeParameterImpl(typeParameter, descriptor).compose()
+    }
 }
@@ -6,16 +6,11 @@
 package org.jetbrains.kotlin.descriptors

 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.declarations.FirClass
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
+import org.jetbrains.kotlin.fir.FirRenderer
+import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.FirProvider
 import org.jetbrains.kotlin.fir.resolve.FirTypeResolver
-import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope
-import org.jetbrains.kotlin.fir.scopes.impl.FirExplicitImportingScope
-import org.jetbrains.kotlin.fir.scopes.impl.FirNestedClassifierScope
-import org.jetbrains.kotlin.fir.scopes.impl.FirSelfImportingScope
+import org.jetbrains.kotlin.fir.scopes.impl.*
 import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeImpl
@@ -26,6 +21,8 @@ import org.jetbrains.kotlin.fir.visitors.compose
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName

+fun FirElement.render(): String = buildString { this@render.accept(FirRenderer(this)) }
+
 class FirTypeResolveTransformer(val superTypesOnly: Boolean = false) : FirTransformer<Nothing?>() {
    override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
        return if (superTypesOnly) {
@@ -37,7 +34,7 @@ class FirTypeResolveTransformer(val superTypesOnly: Boolean = false) : FirTransf

    lateinit var scope: FirCompositeScope
    lateinit var packageFqName: FqName
-    var className: FqName = FqName.ROOT
+    private var classLikeName: FqName = FqName.ROOT

    override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirFile> {
        scope = FirCompositeScope(
@@ -56,26 +53,48 @@ class FirTypeResolveTransformer(val superTypesOnly: Boolean = false) : FirTransf
        return superTypesBuilder.classes
    }

-    override fun transformClass(klass: FirClass, data: Nothing?): CompositeTransformResult<FirDeclaration> {
-        klass.transformChildren(SuperTypeResolver(), null)
-        className = className.child(klass.name)
+    private fun resolveSuperTypesAndExpansions(element: FirMemberDeclaration) {
+        try {
+            element.transformChildren(SuperTypeResolver(), null)
+        } catch (e: Exception) {
+            class SuperTypeResolveException(cause: Exception) : Exception(element.render(), cause)
+            throw SuperTypeResolveException(e)
+        }
+    }

-        scope.scopes += FirNestedClassifierScope(ClassId(packageFqName, className, false), klass.session)
-        scope.scopes.addAll(lookupSuperTypes(klass).map { FirNestedClassifierScope(it, klass.session) })
+    override fun transformClass(klass: FirClass, data: Nothing?): CompositeTransformResult<FirDeclaration> {
+        classLikeName = classLikeName.child(klass.name)
+        val classId = ClassId(packageFqName, classLikeName, false)
+        scope = FirCompositeScope(mutableListOf(scope))
+        scope.scopes += FirClassLikeTypeParameterScope(classId, klass.session)
+        resolveSuperTypesAndExpansions(klass)
+
+        scope.scopes += FirNestedClassifierScope(classId, klass.session)
+        val superTypeScopes = lookupSuperTypes(klass).map { FirNestedClassifierScope(it, klass.session) }
+        scope.scopes.addAll(superTypeScopes)
        val result = super.transformClass(klass, data)
-        scope.scopes.also { it.removeAt(it.lastIndex) }
-        className = className.parent()
+        scope = scope.scopes[0] as FirCompositeScope
+        classLikeName = classLikeName.parent()

        return result
    }

    override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Nothing?): CompositeTransformResult<FirDeclaration> {
-        typeAlias.transformChildren(SuperTypeResolver(), null)
+        classLikeName = classLikeName.child(typeAlias.name)
+        val classId = ClassId(packageFqName, classLikeName, false)
+        scope = FirCompositeScope(mutableListOf(scope))
+        scope.scopes += FirClassLikeTypeParameterScope(classId, typeAlias.session)
+
+        resolveSuperTypesAndExpansions(typeAlias)
+
+        scope = scope.scopes[0] as FirCompositeScope
+        classLikeName = classLikeName.parent()
        return super.transformTypeAlias(typeAlias, data)
    }

    override fun transformType(type: FirType, data: Nothing?): CompositeTransformResult<FirType> {
        val typeResolver = FirTypeResolver.getInstance(type.session)
+        type.transformChildren(this, data)
        return FirResolvedTypeImpl(
            type.session,
            type.psi,
@@ -98,7 +117,7 @@ class FirTypeResolveTransformer(val superTypesOnly: Boolean = false) : FirTransf
        override fun transformType(type: FirType, data: Nothing?): CompositeTransformResult<FirType> {
            val transformedType = this@FirTypeResolveTransformer.transformType(type, data).single as FirResolvedType

-            val classId = (transformedType.type as? ConeClassType)?.fqName ?: return transformedType.compose()
+            val classId = (transformedType.type as? ConeClassLikeType)?.symbol?.classId ?: return transformedType.compose()
            val firProvider = FirProvider.getInstance(transformedType.session)

            val classes = generateSequence(classId) { it.outerClassId }.toList()
@@ -123,10 +142,10 @@ class FirTypeResolveTransformer(val superTypesOnly: Boolean = false) : FirTransf
            return false
        }

-        private tailrec fun ConeClassType.computePartialExpansion(): ClassId {
+        private tailrec fun ConeClassLikeType.computePartialExpansion(): ClassId {
            return when (this) {
-                !is ConeAbbreviatedType -> this.fqName
-                else -> (this.directExpansion as ConeClassType).computePartialExpansion()
+                !is ConeAbbreviatedType -> this.symbol.classId
+                else -> this.directExpansion.computePartialExpansion()
            }
        }

@@ -134,7 +153,7 @@ class FirTypeResolveTransformer(val superTypesOnly: Boolean = false) : FirTransf

        override fun visitResolvedType(resolvedType: FirResolvedType, data: Nothing?): Boolean {
            val provider = FirProvider.getInstance(resolvedType.session)
-            val targetClassId = resolvedType.coneTypeSafe<ConeClassType>()?.computePartialExpansion() ?: return false
+            val targetClassId = resolvedType.coneTypeSafe<ConeClassLikeType>()?.computePartialExpansion() ?: return false
            val classifier = provider.getFirClassifierByFqName(targetClassId)!!
            when (classifier) {
                is FirClass -> {
@@ -6,22 +6,20 @@
 package org.jetbrains.kotlin.fir.resolve

 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.service
+import org.jetbrains.kotlin.fir.symbols.ConeSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.Name

 interface FirProvider {
-    fun getFirClassifierByFqName(fqName: ClassId): FirMemberDeclaration?
-
-    fun getFirTypeParameterByFqName(fqName: ClassId, parameterName: Name): FirTypeParameter?
+    fun getFirClassifierByFqName(fqName: ClassId): FirMemberDeclaration? // FirSymbol?

    fun getFirClassifierContainerFile(fqName: ClassId): FirFile

+    fun getFirClassifierBySymbol(symbol: ConeSymbol): FirMemberDeclaration?
+
    companion object {
        fun getInstance(session: FirSession): FirProvider = session.service()
    }
@@ -9,12 +9,22 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.FirProvider
+import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
+import org.jetbrains.kotlin.fir.symbols.ConeSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.Name

 class FirProviderImpl(val session: FirSession) : FirProvider {
+    override fun getFirClassifierBySymbol(symbol: ConeSymbol): FirMemberDeclaration? {
+        return when(symbol) {
+            is FirBasedSymbol<*> -> symbol.fir as? FirMemberDeclaration
+            is ConeClassLikeSymbol -> getFirClassifierByFqName(symbol.classId)
+            else -> error("!")
+        }
+    }
+
    override fun getFirClassifierContainerFile(fqName: ClassId): FirFile {
        return classifierContainerFileMap[fqName] ?: error("Couldn't find container for $fqName")
    }
@@ -60,9 +70,4 @@ class FirProviderImpl(val session: FirSession) : FirProvider {
        return classifierMap[fqName]
    }

-    override fun getFirTypeParameterByFqName(fqName: ClassId, parameterName: Name): FirTypeParameter? {
-        val typeParameterContainer = (getFirClassifierByFqName(fqName) as? FirTypeParameterContainer) ?: return null
-        // TODO: Optimize search here
-        return typeParameterContainer.typeParameters.find { it.name == parameterName }
-    }
 }
@@ -11,11 +11,9 @@ import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.resolve.FirProvider
 import org.jetbrains.kotlin.fir.resolve.FirQualifierResolver
+import org.jetbrains.kotlin.fir.symbols.toSymbol
 import org.jetbrains.kotlin.fir.types.*
-import org.jetbrains.kotlin.fir.types.impl.ConeAbbreviatedTypeImpl
-import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl
-import org.jetbrains.kotlin.fir.types.impl.ConeKotlinTypeProjectionInImpl
-import org.jetbrains.kotlin.fir.types.impl.ConeKotlinTypeProjectionOutImpl
+import org.jetbrains.kotlin.fir.types.impl.*
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.types.Variance
@@ -42,15 +40,17 @@ class FirQualifierResolverImpl(val session: FirSession) : FirQualifierResolver {
    private fun FirMemberDeclaration.toConeKotlinType(fqName: ClassId, parts: List<FirQualifierPart>): ConeKotlinType? {
        return when (this) {
            is FirClass -> {
-                ConeClassTypeImpl(fqName, parts.toTypeProjections())
+                ConeClassTypeImpl(fqName.toSymbol(), parts.toTypeProjections())
            }
            is FirTypeAlias -> {
-                ConeAbbreviatedTypeImpl(
-                    abbreviationFqName = fqName,
-                    typeArguments = parts.toTypeProjections(),
-                    directExpansion = (this.expandedType as FirResolvedType).type
-                )
+                val expansion = expandedType.coneTypeSafe<ConeClassLikeType>()
+                        ?: return ConeKotlinErrorType("Couldn't resolve expansion")

+                ConeAbbreviatedTypeImpl(
+                    abbreviationSymbol = fqName.toSymbol(),
+                    typeArguments = parts.toTypeProjections(),
+                    directExpansion = expansion
+                )
            }
            else -> error("!")
        }
@@ -61,7 +61,7 @@ class FirQualifierResolverImpl(val session: FirSession) : FirQualifierResolver {

        val fqName = ClassId(
            prefix.packageFqName,
-            parts.fold(prefix.relativeClassName) { prefix, suffix -> prefix.child(suffix.name) },
+            parts.drop(1).fold(prefix.relativeClassName) { prefix, suffix -> prefix.child(suffix.name) },
            false
        )
        val foundClassifier = firProvider.getFirClassifierByFqName(fqName)
@@ -8,8 +8,11 @@ package org.jetbrains.kotlin.fir.resolve.impl
 import org.jetbrains.kotlin.fir.resolve.FirQualifierResolver
 import org.jetbrains.kotlin.fir.resolve.FirTypeResolver
 import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
+import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeKotlinErrorType
+import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl

 class FirTypeResolverImpl : FirTypeResolver {
    override fun resolveType(type: FirType, scope: FirScope): ConeKotlinType {
@@ -20,8 +23,17 @@ class FirTypeResolverImpl : FirTypeResolver {
                val qualifierResolver = FirQualifierResolver.getInstance(type.session)

                var resolvedType: ConeKotlinType? = null
-                scope.processClassifiersByName(type.qualifier.first().name) { fqName ->
-                    resolvedType = qualifierResolver.resolveTypeWithPrefix(type.qualifier.drop(1), fqName)
+                scope.processClassifiersByName(type.qualifier.first().name) { symbol ->
+                    resolvedType = when (symbol) {
+                        is ConeClassLikeSymbol -> {
+                            qualifierResolver.resolveTypeWithPrefix(type.qualifier, symbol.classId)
+                        }
+                        is ConeTypeParameterSymbol -> {
+                            assert(type.qualifier.size == 1)
+                            ConeTypeParameterTypeImpl(symbol)
+                        }
+                        else -> error("!")
+                    }
                    resolvedType == null
                }

@@ -5,9 +5,9 @@

 package org.jetbrains.kotlin.fir.scopes

-import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.fir.symbols.ConeSymbol
 import org.jetbrains.kotlin.name.Name

 interface FirScope {
-    fun processClassifiersByName(name: Name, processor: (ClassId) -> Boolean): Boolean
+    fun processClassifiersByName(name: Name, processor: (ConeSymbol) -> Boolean): Boolean
 }
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2010-2018 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.scopes.impl
+
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.resolve.FirProvider
+import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.symbols.ConeSymbol
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.Name
+
+class FirClassLikeTypeParameterScope(val classId: ClassId, val session: FirSession) : FirScope {
+
+    private val firProvider = FirProvider.getInstance(session)
+
+    val typeParameters = firProvider.getFirClassifierByFqName(classId)?.typeParameters.orEmpty().groupBy { it.name }
+
+    override fun processClassifiersByName(name: Name, processor: (ConeSymbol) -> Boolean): Boolean {
+        val matchedTypeParameters = typeParameters[name] ?: return true
+
+        return matchedTypeParameters.all { processor(it.symbol) }
+    }
+}
@@ -6,11 +6,11 @@
 package org.jetbrains.kotlin.fir.scopes.impl

 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.fir.symbols.ConeSymbol
 import org.jetbrains.kotlin.name.Name

 class FirCompositeScope(val scopes: MutableList<FirScope>) : FirScope {
-    override fun processClassifiersByName(name: Name, processor: (ClassId) -> Boolean): Boolean {
+    override fun processClassifiersByName(name: Name, processor: (ConeSymbol) -> Boolean): Boolean {
        for (scope in scopes) {
            if (!scope.processClassifiersByName(name, processor)) {
                return false
@@ -8,7 +8,8 @@ package org.jetbrains.kotlin.fir.scopes.impl
 import org.jetbrains.kotlin.fir.declarations.FirImport
 import org.jetbrains.kotlin.fir.declarations.FirResolvedImport
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.fir.symbols.ConeSymbol
+import org.jetbrains.kotlin.fir.symbols.toSymbol
 import org.jetbrains.kotlin.name.Name

 class FirExplicitImportingScope(imports: List<FirImport>) : FirScope {
@@ -19,10 +20,10 @@ class FirExplicitImportingScope(imports: List<FirImport>) : FirScope {
            .filter { !it.isAllUnder }
            .groupBy { it.aliasName ?: it.resolvedFqName.shortClassName }

-    override fun processClassifiersByName(name: Name, processor: (ClassId) -> Boolean): Boolean {
+    override fun processClassifiersByName(name: Name, processor: (ConeSymbol) -> Boolean): Boolean {
        val imports = simpleImports[name] ?: return true
        for (import in imports) {
-            if (!processor(import.resolvedFqName)) {
+            if (!processor(import.resolvedFqName.toSymbol())) {
                return false
            }
        }
@@ -9,6 +9,8 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.resolve.FirProvider
 import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.symbols.ConeSymbol
+import org.jetbrains.kotlin.fir.symbols.toSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name

@@ -20,8 +22,8 @@ class FirNestedClassifierScope(val classId: ClassId, val session: FirSession) :
        return firProvider.getFirClassifierByFqName(this)
    }

-    override fun processClassifiersByName(name: Name, processor: (ClassId) -> Boolean): Boolean {
+    override fun processClassifiersByName(name: Name, processor: (ConeSymbol) -> Boolean): Boolean {
        val child = ClassId(classId.packageFqName, classId.relativeClassName.child(name), false)
-        return child.getFir() == null || processor(child)
+        return child.getFir() == null || processor(child.toSymbol())
    }
 }
@@ -9,22 +9,22 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.resolve.FirProvider
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.service
+import org.jetbrains.kotlin.fir.symbols.ConeSymbol
+import org.jetbrains.kotlin.fir.symbols.toSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name

 class FirSelfImportingScope(val fqName: FqName, val session: FirSession) : FirScope {
-    override fun processClassifiersByName(name: Name, processor: (ClassId) -> Boolean): Boolean {
-
-
+    override fun processClassifiersByName(name: Name, processor: (ConeSymbol) -> Boolean): Boolean {
        val unambiguousFqName = ClassId(fqName, name)

        val firProvider = session.service<FirProvider>()

-        if (firProvider.getFirClassifierByFqName(unambiguousFqName) != null) {
-            return processor(unambiguousFqName)
+        return if (firProvider.getFirClassifierByFqName(unambiguousFqName) != null) {
+            processor(unambiguousFqName.toSymbol())
        } else {
-            return true
+            true
        }
    }
 }