[slc] rename fir to symbol

^KT-50241
2022-08-08 19:57:04 +02:00
parent 97ecf43b77
commit c0d6a64a8a
55 changed files with 400 additions and 399 deletions
@@ -51,7 +51,7 @@ import org.jetbrains.kotlin.fir.declarations.SealedClassInheritorsProviderImpl
 import org.jetbrains.kotlin.idea.references.KotlinFirReferenceContributor
 import org.jetbrains.kotlin.idea.references.KotlinReferenceProviderContributor
 import org.jetbrains.kotlin.idea.references.ReadWriteAccessChecker
-import org.jetbrains.kotlin.light.classes.symbol.KotlinAsJavaFirSupport
+import org.jetbrains.kotlin.light.classes.symbol.SymbolKotlinAsJavaSupport
 import org.jetbrains.kotlin.light.classes.symbol.caches.SymbolLightClassFacadeCache
 import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
 import org.jetbrains.kotlin.psi.KotlinReferenceProvidersService
@@ -157,7 +157,7 @@ public class StandaloneAnalysisAPISessionBuilder(

            registerService(SymbolLightClassFacadeCache::class.java, SymbolLightClassFacadeCache(this))
            registerService(ClsJavaStubByVirtualFileCache::class.java, ClsJavaStubByVirtualFileCache())
-            registerService(KotlinAsJavaSupport::class.java, KotlinAsJavaFirSupport(this))
+            registerService(KotlinAsJavaSupport::class.java, SymbolKotlinAsJavaSupport(this))
            registerService(ReadWriteAccessChecker::class.java, ReadWriteAccessCheckerFirImpl())
        }

@@ -11,9 +11,9 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElementFinder
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analysis.api.KtAnalysisApiInternals
-import org.jetbrains.kotlin.analysis.api.session.KtAnalysisSessionProvider
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSessionProvider
 import org.jetbrains.kotlin.analysis.api.impl.base.references.HLApiReferenceProviderService
+import org.jetbrains.kotlin.analysis.api.session.KtAnalysisSessionProvider
 import org.jetbrains.kotlin.analysis.decompiled.light.classes.ClsJavaStubByVirtualFileCache
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.services.FirSealedClassInheritorsProcessorFactory
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.services.PackagePartProviderFactory
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.fir.declarations.SealedClassInheritorsProvider
 import org.jetbrains.kotlin.fir.declarations.SealedClassInheritorsProviderImpl
 import org.jetbrains.kotlin.idea.references.KotlinFirReferenceContributor
 import org.jetbrains.kotlin.idea.references.KotlinReferenceProviderContributor
-import org.jetbrains.kotlin.light.classes.symbol.KotlinAsJavaFirSupport
+import org.jetbrains.kotlin.light.classes.symbol.SymbolKotlinAsJavaSupport
 import org.jetbrains.kotlin.light.classes.symbol.caches.SymbolLightClassFacadeCache
 import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
 import org.jetbrains.kotlin.psi.KotlinReferenceProvidersService
@@ -69,7 +69,7 @@ public fun configureApplicationEnvironment(app: MockApplication) {
 *
 * In particular, this will register:
 *   * [KtAnalysisSessionProvider]
- *   * [KotlinAsJavaFirSupport]
+ *   * [SymbolKotlinAsJavaSupport]
 *   * [SymbolLightClassFacadeCache] for FIR light class support
 *   * [ClsJavaStubByVirtualFileCache]
 *   * [KotlinModificationTrackerFactory]
@@ -179,7 +179,7 @@ private fun reRegisterJavaElementFinder(project: Project) {
        picoContainer.unregisterComponent(KotlinAsJavaSupport::class.qualifiedName)
        picoContainer.registerComponentInstance(
            KotlinAsJavaSupport::class.qualifiedName,
-            KotlinAsJavaFirSupport(project)
+            SymbolKotlinAsJavaSupport(project)
        )
    }
    @Suppress("DEPRECATION")
@@ -10,13 +10,14 @@ import com.intellij.mock.MockProject
 import com.intellij.psi.PsiElementFinder
 import com.intellij.psi.impl.PsiElementFinderImpl
 import org.jetbrains.kotlin.analysis.api.KtAnalysisApiInternals
-import org.jetbrains.kotlin.analysis.api.session.KtAnalysisSessionProvider
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSessionProvider
 import org.jetbrains.kotlin.analysis.api.fir.references.ReadWriteAccessCheckerFirImpl
+import org.jetbrains.kotlin.analysis.api.session.KtAnalysisSessionProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveSessionService
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.services.FirSealedClassInheritorsProcessorFactory
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.services.PackagePartProviderFactory
-import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.*
+import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.LLFirBuiltinsSessionFactory
+import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.LLFirLibrarySessionFactory
 import org.jetbrains.kotlin.analysis.low.level.api.fir.services.KtCompilerPluginsProviderForTests
 import org.jetbrains.kotlin.analysis.low.level.api.fir.services.LLFirSealedClassInheritorsProcessorFactoryForTests
 import org.jetbrains.kotlin.analysis.low.level.api.fir.services.PackagePartProviderTestImpl
@@ -29,7 +30,7 @@ import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrarAdapter
 import org.jetbrains.kotlin.idea.references.KotlinFirReferenceContributor
 import org.jetbrains.kotlin.idea.references.KotlinReferenceProviderContributor
 import org.jetbrains.kotlin.idea.references.ReadWriteAccessChecker
-import org.jetbrains.kotlin.light.classes.symbol.KotlinAsJavaFirSupport
+import org.jetbrains.kotlin.light.classes.symbol.SymbolKotlinAsJavaSupport
 import org.jetbrains.kotlin.light.classes.symbol.caches.SymbolLightClassFacadeCache
 import org.jetbrains.kotlin.test.TestInfrastructureInternals
 import org.jetbrains.kotlin.test.impl.testConfiguration
@@ -52,7 +53,7 @@ object AnalysisApiFirTestServiceRegistrar : AnalysisApiTestServiceRegistrar() {
            registerService(PackagePartProviderFactory::class.java, PackagePartProviderTestImpl(testServices))

            registerService(SymbolLightClassFacadeCache::class.java)
-            registerService(KotlinAsJavaSupport::class.java, KotlinAsJavaFirSupport(project))
+            registerService(KotlinAsJavaSupport::class.java, SymbolKotlinAsJavaSupport(project))
            registerService(KtCompilerPluginsProvider::class.java, KtCompilerPluginsProviderForTests(project))
            registerService(ReadWriteAccessChecker::class.java, ReadWriteAccessCheckerFirImpl())
        }
@@ -12,12 +12,12 @@ import com.intellij.psi.scope.PsiScopeProcessor
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
 import org.jetbrains.kotlin.asJava.classes.getOutermostClassOrObject
 import org.jetbrains.kotlin.asJava.elements.FakeFileForLightClass
-import org.jetbrains.kotlin.light.classes.symbol.classes.getOrCreateFirLightClass
+import org.jetbrains.kotlin.light.classes.symbol.classes.getOrCreateSymbolLightClass
 import org.jetbrains.kotlin.psi.KtClassOrObject

-class FirFakeFileImpl(private val classOrObject: KtClassOrObject, ktClass: KtLightClass) : FakeFileForLightClass(
+class SymbolFakeFile(private val classOrObject: KtClassOrObject, ktClass: KtLightClass) : FakeFileForLightClass(
    classOrObject.containingKtFile,
-    { if (classOrObject.isTopLevel()) ktClass else getOrCreateFirLightClass(getOutermostClassOrObject(classOrObject))!! },
+    { if (classOrObject.isTopLevel()) ktClass else getOrCreateSymbolLightClass(getOutermostClassOrObject(classOrObject))!! },
 ) {

    override fun findReferenceAt(offset: Int) = ktFile.findReferenceAt(offset)
@@ -19,9 +19,9 @@ import org.jetbrains.kotlin.asJava.classes.KtFakeLightClass
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
 import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName
 import org.jetbrains.kotlin.light.classes.symbol.caches.SymbolLightClassFacadeCache
-import org.jetbrains.kotlin.light.classes.symbol.classes.KtFirBasedFakeLightClass
+import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolBasedFakeLightClass
 import org.jetbrains.kotlin.light.classes.symbol.classes.analyzeForLightClasses
-import org.jetbrains.kotlin.light.classes.symbol.classes.getOrCreateFirLightClass
+import org.jetbrains.kotlin.light.classes.symbol.classes.getOrCreateSymbolLightClass
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.parentOrNull
@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtScript

-class KotlinAsJavaFirSupport(private val project: Project) : KotlinAsJavaSupport() {
+class SymbolKotlinAsJavaSupport(private val project: Project) : KotlinAsJavaSupport() {
    override fun findClassOrObjectDeclarationsInPackage(
        packageFqName: FqName,
        searchScope: GlobalSearchScope
@@ -82,7 +82,7 @@ class KotlinAsJavaFirSupport(private val project: Project) : KotlinAsJavaSupport

    override fun getLightClass(classOrObject: KtClassOrObject): KtLightClass? {
        return when (classOrObject.getKtModule(project)) {
-            is KtSourceModule -> getOrCreateFirLightClass(classOrObject)
+            is KtSourceModule -> getOrCreateSymbolLightClass(classOrObject)
            is KtLibraryModule -> DecompiledLightClassesFactory.getLightClassForDecompiledClassOrObject(classOrObject, project)
            else -> null
        }
@@ -101,7 +101,7 @@ class KotlinAsJavaFirSupport(private val project: Project) : KotlinAsJavaSupport
        error("Should not be called")

    override fun getKotlinInternalClasses(fqName: FqName, scope: GlobalSearchScope): Collection<PsiClass> =
-        emptyList() //TODO Implement if necessary for fir
+        emptyList() //TODO Implement if necessary for symbol

    override fun getFacadeClassesInPackage(packageFqName: FqName, scope: GlobalSearchScope): Collection<PsiClass> =
        project.createDeclarationProvider(scope)
@@ -124,7 +124,7 @@ class KotlinAsJavaFirSupport(private val project: Project) : KotlinAsJavaSupport
    }

    override fun getFakeLightClass(classOrObject: KtClassOrObject): KtFakeLightClass =
-        KtFirBasedFakeLightClass(classOrObject)
+        SymbolBasedFakeLightClass(classOrObject)

    override fun createFacadeForSyntheticFile(facadeClassFqName: FqName, file: KtFile): PsiClass =
        TODO("Not implemented")
@@ -15,13 +15,13 @@ import org.jetbrains.kotlin.psi.KtPropertyAccessor
 import org.jetbrains.kotlin.psi.KtSecondaryConstructor
 import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject

-internal class FirLightIdentifier(
+internal class SymbolLightIdentifier(
    lightOwner: PsiElement,
-    private val firSymbol: KtSymbol?
-) : KtLightIdentifierBase(lightOwner, (firSymbol as? KtNamedSymbol)?.name?.identifierOrNullIfSpecial) {
+    private val ktSymbol: KtSymbol?
+) : KtLightIdentifierBase(lightOwner, (ktSymbol as? KtNamedSymbol)?.name?.identifierOrNullIfSpecial) {

    override val origin: PsiElement?
-        get() = when (val ktDeclaration = firSymbol?.psi) {
+        get() = when (val ktDeclaration = ktSymbol?.psi) {
            is KtSecondaryConstructor -> ktDeclaration.getConstructorKeyword()
            is KtPrimaryConstructor -> ktDeclaration.getConstructorKeyword()
                ?: ktDeclaration.valueParameterList
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.asJava.elements.KtLightElementBase
 import org.jetbrains.kotlin.asJava.elements.KtLightMember
 import org.jetbrains.kotlin.psi.KtDeclaration

-internal abstract class FirLightMemberImpl<T : PsiMember>(
+internal abstract class SymbolLightMemberBase<T : PsiMember>(
    override val lightMemberOrigin: LightMemberOrigin?,
    private val containingClass: KtLightClass,
 ) : KtLightElementBase(containingClass), PsiMember, KtLightMember<T> {
@@ -14,14 +14,14 @@ import org.jetbrains.kotlin.asJava.elements.KtLightElementBase
 import org.jetbrains.kotlin.light.classes.symbol.toAnnotationMemberValue
 import org.jetbrains.kotlin.psi.KtElement

-internal class FirAnnotationParameterList(
-    parent: FirLightAbstractAnnotation,
+internal class SymbolAnnotationParameterList(
+    parent: SymbolLightAbstractAnnotation,
    private val arguments: List<KtNamedAnnotationValue>,
 ) : KtLightElementBase(parent), PsiAnnotationParameterList {

    private val _attributes: Array<PsiNameValuePair> by lazyPub {
        arguments.map {
-            FirNameValuePairForAnnotationArgument(it, this)
+            SymbolNameValuePairForAnnotationArgument(it, this)
        }.toTypedArray()
    }

@@ -32,7 +32,7 @@ internal class FirAnnotationParameterList(
    //TODO: EQ GHC EQIV
 }

-private class FirNameValuePairForAnnotationArgument(
+private class SymbolNameValuePairForAnnotationArgument(
    private val constantValue: KtNamedAnnotationValue,
    parent: PsiElement
 ) : KtLightElementBase(parent), PsiNameValuePair {
@@ -9,10 +9,10 @@ import com.intellij.psi.*
 import org.jetbrains.kotlin.asJava.elements.KtLightElementBase
 import org.jetbrains.kotlin.psi.KtElement

-internal class FirPsiArrayInitializerMemberValue(
+internal class SymbolPsiArrayInitializerMemberValue(
    override val kotlinOrigin: KtElement?,
    private val lightParent: PsiElement,
-    private val arguments: (FirPsiArrayInitializerMemberValue) -> List<PsiAnnotationMemberValue>
+    private val arguments: (SymbolPsiArrayInitializerMemberValue) -> List<PsiAnnotationMemberValue>
 ) : KtLightElementBase(lightParent), PsiArrayInitializerMemberValue {

    override fun getInitializers(): Array<PsiAnnotationMemberValue> = arguments(this).toTypedArray()
@@ -23,7 +23,7 @@ internal class FirPsiArrayInitializerMemberValue(
    override fun getText(): String = "{" + initializers.joinToString { it.text } + "}"
 }

-internal abstract class FirPsiAnnotationMemberValue(
+internal abstract class SymbolPsiAnnotationMemberValue(
    override val kotlinOrigin: KtElement?,
    private val lightParent: PsiElement,
 ) : KtLightElementBase(lightParent), PsiAnnotationMemberValue {
@@ -32,20 +32,20 @@ internal abstract class FirPsiAnnotationMemberValue(
    override fun isPhysical(): Boolean = false
 }

-internal class FirPsiExpression(
+internal class SymbolPsiExpression(
    override val kotlinOrigin: KtElement?,
    lightParent: PsiElement,
    private val psiExpression: PsiExpression,
-) : FirPsiAnnotationMemberValue(kotlinOrigin, lightParent), PsiExpression {
+) : SymbolPsiAnnotationMemberValue(kotlinOrigin, lightParent), PsiExpression {
    override fun getType(): PsiType? = psiExpression.type
    override fun getText(): String = psiExpression.text
 }

-internal class FirPsiLiteral(
+internal class SymbolPsiLiteral(
    override val kotlinOrigin: KtElement?,
    lightParent: PsiElement,
    private val psiLiteral: PsiLiteral,
-) : FirPsiAnnotationMemberValue(kotlinOrigin, lightParent), PsiLiteral {
+) : SymbolPsiAnnotationMemberValue(kotlinOrigin, lightParent), PsiLiteral {
    override fun getValue(): Any? = psiLiteral.value
    override fun getText(): String = psiLiteral.text
 }
@@ -10,11 +10,11 @@ import org.jetbrains.kotlin.asJava.classes.cannotModify
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.KtLightElement
 import org.jetbrains.kotlin.asJava.elements.KtLightElementBase
-import org.jetbrains.kotlin.light.classes.symbol.codeReferences.FirLightPsiJavaCodeReferenceElementWithNoReference
-import org.jetbrains.kotlin.light.classes.symbol.codeReferences.FirLightPsiJavaCodeReferenceElementWithReference
+import org.jetbrains.kotlin.light.classes.symbol.codeReferences.SymbolLightPsiJavaCodeReferenceElementWithNoReference
+import org.jetbrains.kotlin.light.classes.symbol.codeReferences.SymbolLightPsiJavaCodeReferenceElementWithReference
 import org.jetbrains.kotlin.psi.*

-internal abstract class FirLightAbstractAnnotation(parent: PsiElement) :
+internal abstract class SymbolLightAbstractAnnotation(parent: PsiElement) :
    KtLightElementBase(parent), PsiAnnotation, KtLightElement<KtCallElement, PsiAnnotation> {

    override fun getOwner() = parent as? PsiAnnotationOwner
@@ -30,18 +30,18 @@ internal abstract class FirLightAbstractAnnotation(parent: PsiElement) :
        val reference = (kotlinOrigin as? KtAnnotationEntry)?.typeReference?.reference
            ?: (kotlinOrigin?.calleeExpression?.nameReference)?.references?.firstOrNull()

-        if (reference != null) FirLightPsiJavaCodeReferenceElementWithReference(ktElement, reference)
-        else FirLightPsiJavaCodeReferenceElementWithNoReference(ktElement)
+        if (reference != null) SymbolLightPsiJavaCodeReferenceElementWithReference(ktElement, reference)
+        else SymbolLightPsiJavaCodeReferenceElementWithNoReference(ktElement)
    }

    override fun getNameReferenceElement(): PsiJavaCodeReferenceElement = _nameReferenceElement

-    private class FirAnnotationParameterList(parent: PsiAnnotation) : KtLightElementBase(parent), PsiAnnotationParameterList {
+    private class SymbolAnnotationParameterList(parent: PsiAnnotation) : KtLightElementBase(parent), PsiAnnotationParameterList {
        override val kotlinOrigin: KtElement? = null
        override fun getAttributes(): Array<PsiNameValuePair> = emptyArray() //TODO()
    }

-    private val annotationParameterList: PsiAnnotationParameterList = FirAnnotationParameterList(this)
+    private val annotationParameterList: PsiAnnotationParameterList = SymbolAnnotationParameterList(this)

    override fun getParameterList(): PsiAnnotationParameterList = annotationParameterList

@@ -15,10 +15,10 @@ import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.light.classes.symbol.basicIsEquivalentTo
 import org.jetbrains.kotlin.psi.KtCallElement

-internal class FirLightAnnotationForAnnotationCall(
+internal class SymbolLightAnnotationForAnnotationCall(
    private val annotationCall: KtAnnotationApplication,
    parent: PsiElement,
-) : FirLightAbstractAnnotation(parent) {
+) : SymbolLightAbstractAnnotation(parent) {

    override fun findAttributeValue(attributeName: String?): PsiAnnotationMemberValue? =
        PsiImplUtil.findAttributeValue(this, attributeName)
@@ -27,7 +27,7 @@ internal class FirLightAnnotationForAnnotationCall(
        PsiImplUtil.findDeclaredAttributeValue(this, attributeName)

    private val _parameterList: PsiAnnotationParameterList by lazyPub {
-        FirAnnotationParameterList(this@FirLightAnnotationForAnnotationCall, annotationCall.arguments)
+        SymbolAnnotationParameterList(this@SymbolLightAnnotationForAnnotationCall, annotationCall.arguments)
    }

    override fun getParameterList(): PsiAnnotationParameterList = _parameterList
@@ -40,7 +40,7 @@ internal class FirLightAnnotationForAnnotationCall(

    override fun equals(other: Any?): Boolean =
        this === other ||
-                (other is FirLightAnnotationForAnnotationCall &&
+                (other is SymbolLightAnnotationForAnnotationCall &&
                        kotlinOrigin == other.kotlinOrigin &&
                        annotationCall == other.annotationCall)

@@ -13,12 +13,12 @@ import org.jetbrains.kotlin.analysis.api.annotations.KtNamedAnnotationValue
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.psi.KtCallElement

-internal class FirLightSimpleAnnotation(
+internal class SymbolLightSimpleAnnotation(
    private val fqName: String?,
    parent: PsiElement,
    private val arguments: List<KtNamedAnnotationValue> = listOf(),
    override val kotlinOrigin: KtCallElement? = null,
-) : FirLightAbstractAnnotation(parent) {
+) : SymbolLightAbstractAnnotation(parent) {

    override fun getQualifiedName(): String? = fqName

@@ -26,7 +26,7 @@ internal class FirLightSimpleAnnotation(

    override fun equals(other: Any?): Boolean =
        this === other ||
-                (other is FirLightSimpleAnnotation && fqName == other.fqName && parent == other.parent)
+                (other is SymbolLightSimpleAnnotation && fqName == other.fqName && parent == other.parent)

    override fun hashCode(): Int = fqName.hashCode()

@@ -37,7 +37,7 @@ internal class FirLightSimpleAnnotation(
        PsiImplUtil.findDeclaredAttributeValue(this, attributeName)

    private val _parameterList: PsiAnnotationParameterList by lazyPub {
-        FirAnnotationParameterList(this@FirLightSimpleAnnotation, arguments)
+        SymbolAnnotationParameterList(this@SymbolLightSimpleAnnotation, arguments)
    }

    override fun getParameterList(): PsiAnnotationParameterList = _parameterList
@@ -102,7 +102,7 @@ internal fun KtAnnotatedSymbol.computeAnnotations(
        NullabilityType.Nullable -> Nullable::class.java
        else -> null
    }?.let {
-        FirLightSimpleAnnotation(it.name, parent)
+        SymbolLightSimpleAnnotation(it.name, parent)
    }

    val parentIsAnnotation = (parent as? PsiClass)?.isAnnotationType == true
@@ -127,7 +127,7 @@ internal fun KtAnnotatedSymbol.computeAnnotations(
        if ((includeAnnotationsWithoutSite && siteTarget == null) ||
            siteTarget == annotationUseSiteTarget
        ) {
-            result.add(FirLightAnnotationForAnnotationCall(annotation, parent))
+            result.add(SymbolLightAnnotationForAnnotationCall(annotation, parent))
        }
    }

@@ -145,7 +145,7 @@ internal fun KtAnnotatedSymbol.computeAnnotations(
 }

 private fun createRetentionRuntimeAnnotation(parent: PsiElement): PsiAnnotation =
-    FirLightSimpleAnnotation(
+    SymbolLightSimpleAnnotation(
        JAVA_LANG_ANNOTATION_RETENTION,
        parent,
        listOf(
@@ -14,9 +14,9 @@ import org.jetbrains.kotlin.analysis.utils.caches.softCachedValue
 import org.jetbrains.kotlin.analysis.utils.collections.ConcurrentMapBasedCache
 import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName
-import org.jetbrains.kotlin.light.classes.symbol.classes.FirLightClassForFacade
+import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassForFacade
 import org.jetbrains.kotlin.light.classes.symbol.classes.analyzeForLightClasses
-import org.jetbrains.kotlin.light.classes.symbol.decompiled.KtLightClassForDecompiledFacade
+import org.jetbrains.kotlin.light.classes.symbol.decompiled.SymbolLightClassForDecompiledFacade
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtFile
@@ -38,11 +38,11 @@ class SymbolLightClassFacadeCache(private val project: Project) {
        if (ktFilesWithoutScript.isEmpty()) return null
        val key = FacadeKey(facadeClassFqName, ktFilesWithoutScript.toSet())
        return cache.getOrPut(key) {
-            getOrCreateFirLightFacadeNoCache(ktFilesWithoutScript, facadeClassFqName)
+            getOrCreateSymbolLightFacadeNoCache(ktFilesWithoutScript, facadeClassFqName)
        }
    }

-    private fun getOrCreateFirLightFacadeNoCache(
+    private fun getOrCreateSymbolLightFacadeNoCache(
        ktFiles: List<KtFile>,
        facadeClassFqName: FqName,
    ): KtLightClassForFacade? {
@@ -50,7 +50,7 @@ class SymbolLightClassFacadeCache(private val project: Project) {
        return when {
            ktFiles.none { it.isCompiled } ->
                analyzeForLightClasses(firstFile) {
-                    FirLightClassForFacade(firstFile.manager, facadeClassFqName, ktFiles)
+                    SymbolLightClassForFacade(firstFile.manager, facadeClassFqName, ktFiles)
                }

            ktFiles.all { it.isCompiled } -> {
@@ -63,7 +63,7 @@ class SymbolLightClassFacadeCache(private val project: Project) {
                    correspondingClassOrObject = classOrObject,
                    project = project,
                ) ?: return null
-                KtLightClassForDecompiledFacade(clsDelegate, clsDelegate.parent, file, classOrObject, ktFiles)
+                SymbolLightClassForDecompiledFacade(clsDelegate, clsDelegate.parent, file, classOrObject, ktFiles)
            }

            else ->
@@ -14,13 +14,13 @@ import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject

 //TODO Make fake class symbol based

-class KtFirBasedFakeLightClass(kotlinOrigin: KtClassOrObject) :
+class SymbolBasedFakeLightClass(kotlinOrigin: KtClassOrObject) :
    KtFakeLightClass(kotlinOrigin) {

-    override fun copy(): KtFakeLightClass = KtFirBasedFakeLightClass(kotlinOrigin)
+    override fun copy(): KtFakeLightClass = SymbolBasedFakeLightClass(kotlinOrigin)

    private val _containingClass: KtFakeLightClass? by lazy {
-        kotlinOrigin.containingClassOrObject?.let { KtFirBasedFakeLightClass(it) }
+        kotlinOrigin.containingClassOrObject?.let { SymbolBasedFakeLightClass(it) }
    }

    override fun getContainingClass(): KtFakeLightClass? = _containingClass
@@ -17,10 +17,10 @@ import org.jetbrains.kotlin.asJava.elements.KtLightField
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod

 context(KtAnalysisSession)
-internal class FirLightAnnotationClassSymbol(
+internal class SymbolLightAnnotationClassSymbol(
    private val classOrObjectSymbol: KtNamedClassOrObjectSymbol,
    manager: PsiManager
-) : FirLightInterfaceOrAnnotationClassSymbol(classOrObjectSymbol, manager) {
+) : SymbolLightInterfaceOrAnnotationClass(classOrObjectSymbol, manager) {

    init {
        require(classOrObjectSymbol.classKind == KtClassKind.ANNOTATION_CLASS)
@@ -51,12 +51,12 @@ internal class FirLightAnnotationClassSymbol(
    override fun getExtendsList(): PsiReferenceList? = null

    override fun equals(other: Any?): Boolean =
-        other is FirLightAnnotationClassSymbol && classOrObjectSymbol == other.classOrObjectSymbol
+        other is SymbolLightAnnotationClassSymbol && classOrObjectSymbol == other.classOrObjectSymbol

    override fun hashCode(): Int = classOrObjectSymbol.hashCode()


    override fun isValid(): Boolean = super.isValid() && classOrObjectSymbol.isValid()

-    override fun copy(): FirLightClassForClassOrObjectSymbol = FirLightAnnotationClassSymbol(classOrObjectSymbol, manager)
+    override fun copy(): SymbolLightClassForClassOrObject = SymbolLightAnnotationClassSymbol(classOrObjectSymbol, manager)
 }
@@ -20,19 +20,19 @@ import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.KtLightField
 import org.jetbrains.kotlin.asJava.elements.KtLightIdentifier
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
-import org.jetbrains.kotlin.light.classes.symbol.FirFakeFileImpl
+import org.jetbrains.kotlin.light.classes.symbol.SymbolFakeFile
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasJvmFieldAnnotation
-import org.jetbrains.kotlin.light.classes.symbol.fields.FirLightField
+import org.jetbrains.kotlin.light.classes.symbol.fields.SymbolLightField
 import org.jetbrains.kotlin.load.java.structure.LightClassOriginKind
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.debugText.getDebugText
 import org.jetbrains.kotlin.psi.stubs.KotlinClassOrObjectStub

 context(KtAnalysisSession)
-internal class FirLightAnonymousClassForSymbol(
+internal class SymbolLightAnonymousClassForSymbol(
    private val anonymousObjectSymbol: KtAnonymousObjectSymbol,
    manager: PsiManager
-) : FirLightClassBase(manager),
+) : SymbolLightClassBase(manager),
    StubBasedPsiElement<KotlinClassOrObjectStub<out KtClassOrObject>>, PsiAnonymousClass {

    private val _baseClassType: PsiClassType by lazyPub {
@@ -68,7 +68,7 @@ internal class FirLightAnonymousClassForSymbol(

    private val _ownFields: List<KtLightField> by lazyPub {
        val result = mutableListOf<KtLightField>()
-        val nameGenerator = FirLightField.FieldNameGenerator()
+        val nameGenerator = SymbolLightField.FieldNameGenerator()

        anonymousObjectSymbol.getDeclaredMemberScope().getCallableSymbols()
            .filterIsInstance<KtPropertySymbol>()
@@ -86,7 +86,7 @@ internal class FirLightAnonymousClassForSymbol(
        result
    }

-    private val _ownInnerClasses: List<FirLightClassBase> by lazyPub {
+    private val _ownInnerClasses: List<SymbolLightClassBase> by lazyPub {
        anonymousObjectSymbol.createInnerClasses(manager, this, kotlinOrigin)
    }

@@ -132,19 +132,19 @@ internal class FirLightAnonymousClassForSymbol(
    //TODO Make containing file not null for symbol without psi
    private val _containingFile: PsiFile? by lazyPub {
        val kotlinOrigin = kotlinOrigin ?: return@lazyPub null
-        FirFakeFileImpl(kotlinOrigin, this)
+        SymbolFakeFile(kotlinOrigin, this)
    }

    override fun getContainingFile(): PsiFile? = _containingFile

    override fun equals(other: Any?): Boolean =
        this === other ||
-                (other is FirLightAnonymousClassForSymbol && anonymousObjectSymbol == other.anonymousObjectSymbol)
+                (other is SymbolLightAnonymousClassForSymbol && anonymousObjectSymbol == other.anonymousObjectSymbol)

    override fun hashCode(): Int = anonymousObjectSymbol.hashCode()

    override fun copy() =
-        FirLightAnonymousClassForSymbol(anonymousObjectSymbol, manager)
+        SymbolLightAnonymousClassForSymbol(anonymousObjectSymbol, manager)

    override fun isValid(): Boolean = super.isValid() && anonymousObjectSymbol.isValid()

@@ -23,11 +23,11 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.light.classes.symbol.*
 import org.jetbrains.kotlin.light.classes.symbol.annotations.computeAnnotations
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasJvmFieldAnnotation
-import org.jetbrains.kotlin.light.classes.symbol.fields.FirLightField
-import org.jetbrains.kotlin.light.classes.symbol.fields.FirLightFieldForEnumEntry
-import org.jetbrains.kotlin.light.classes.symbol.fields.FirLightFieldForObjectSymbol
-import org.jetbrains.kotlin.light.classes.symbol.methods.FirLightSimpleMethodForSymbol
-import org.jetbrains.kotlin.light.classes.symbol.modifierLists.FirLightClassModifierList
+import org.jetbrains.kotlin.light.classes.symbol.fields.SymbolLightField
+import org.jetbrains.kotlin.light.classes.symbol.fields.SymbolLightFieldForEnumEntry
+import org.jetbrains.kotlin.light.classes.symbol.fields.SymbolLightFieldForObject
+import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightSimpleMethod
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightClassModifierList
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.StandardClassIds
@@ -39,10 +39,10 @@ import org.jetbrains.kotlin.util.OperatorNameConventions.TO_STRING
 import org.jetbrains.kotlin.utils.addToStdlib.applyIf

 context(KtAnalysisSession)
-internal open class FirLightClassForSymbol(
+internal open class SymbolLightClass(
    private val classOrObjectSymbol: KtNamedClassOrObjectSymbol,
    manager: PsiManager
-) : FirLightClassForClassOrObjectSymbol(classOrObjectSymbol, manager) {
+) : SymbolLightClassForClassOrObject(classOrObjectSymbol, manager) {

    init {
        require(classOrObjectSymbol.classKind != KtClassKind.INTERFACE && classOrObjectSymbol.classKind != KtClassKind.ANNOTATION_CLASS)
@@ -59,12 +59,12 @@ internal open class FirLightClassForSymbol(
        }

        val annotations = classOrObjectSymbol.computeAnnotations(
-            parent = this@FirLightClassForSymbol,
+            parent = this@SymbolLightClass,
            nullability = NullabilityType.Unknown,
            annotationUseSiteTarget = null,
        )

-        FirLightClassModifierList(this@FirLightClassForSymbol, modifiers, annotations)
+        SymbolLightClassModifierList(this@SymbolLightClass, modifiers, annotations)
    }

    override fun getModifierList(): PsiModifierList? = _modifierList
@@ -120,7 +120,7 @@ internal open class FirLightClassForSymbol(
            // Similar to `copy`, synthetic members from `Any` should refer to `data` class as origin, not the function in `Any`.
            val lightMemberOrigin = LightMemberOriginForDeclaration(this.kotlinOrigin!!, JvmDeclarationOriginKind.OTHER)
            result.add(
-                FirLightSimpleMethodForSymbol(
+                SymbolLightSimpleMethod(
                    ktFunctionSymbol, lightMemberOrigin, this, METHOD_INDEX_BASE, false,
                    suppressStatic = false
                )
@@ -170,7 +170,7 @@ internal open class FirLightClassForSymbol(
            val kotlinOrigin = ktFunctionSymbol.psi as? KtDeclaration ?: kotlinOrigin!!
            val lightMemberOrigin = LightMemberOriginForDeclaration(kotlinOrigin, JvmDeclarationOriginKind.DELEGATION)
            result.add(
-                FirLightSimpleMethodForSymbol(
+                SymbolLightSimpleMethod(
                    ktFunctionSymbol,
                    lightMemberOrigin,
                    this,
@@ -220,7 +220,7 @@ internal open class FirLightClassForSymbol(
            }
        val propertyGroups = propertySymbols.groupBy { it.isFromPrimaryConstructor }

-        val nameGenerator = FirLightField.FieldNameGenerator()
+        val nameGenerator = SymbolLightField.FieldNameGenerator()

        fun addPropertyBackingField(propertySymbol: KtPropertySymbol) {
            val isJvmField = propertySymbol.hasJvmFieldAnnotation()
@@ -248,9 +248,9 @@ internal open class FirLightClassForSymbol(
    private fun addInstanceFieldIfNeeded(result: MutableList<KtLightField>) {
        if (classOrObjectSymbol.isNamedObject && !classOrObjectSymbol.isLocal) {
            result.add(
-                FirLightFieldForObjectSymbol(
+                SymbolLightFieldForObject(
                    objectSymbol = classOrObjectSymbol,
-                    containingClass = this@FirLightClassForSymbol,
+                    containingClass = this@SymbolLightClass,
                    name = JvmAbi.INSTANCE_FIELD,
                    lightMemberOrigin = null
                )
@@ -262,7 +262,7 @@ internal open class FirLightClassForSymbol(
        if (isEnum) {
            classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols()
                .filterIsInstance<KtEnumEntrySymbol>()
-                .mapTo(result) { FirLightFieldForEnumEntry(it, this@FirLightClassForSymbol, null) }
+                .mapTo(result) { SymbolLightFieldForEnumEntry(it, this@SymbolLightClass, null) }
        }
    }

@@ -278,7 +278,7 @@ internal open class FirLightClassForSymbol(
    override fun hashCode(): Int = classOrObjectSymbol.hashCode()

    override fun equals(other: Any?): Boolean =
-        this === other || (other is FirLightClassForSymbol && classOrObjectSymbol == other.classOrObjectSymbol)
+        this === other || (other is SymbolLightClass && classOrObjectSymbol == other.classOrObjectSymbol)

    override fun isInterface(): Boolean = false

@@ -287,8 +287,8 @@ internal open class FirLightClassForSymbol(
    override fun isEnum(): Boolean =
        classOrObjectSymbol.classKind == KtClassKind.ENUM_CLASS

-    override fun copy(): FirLightClassForSymbol =
-        FirLightClassForSymbol(classOrObjectSymbol, manager)
+    override fun copy(): SymbolLightClass =
+        SymbolLightClass(classOrObjectSymbol, manager)

    override fun isValid(): Boolean = super.isValid() && classOrObjectSymbol.isValid()
 }
@@ -27,10 +27,10 @@ import org.jetbrains.kotlin.idea.KotlinLanguage
 import javax.swing.Icon

 context(KtAnalysisSession)
-abstract class FirLightClassBase protected constructor(
+abstract class SymbolLightClassBase protected constructor(
    manager: PsiManager
 ) : LightElement(manager, KotlinLanguage.INSTANCE), PsiClass, KtExtensibleLightClass {
-    private class FirLightClassesLazyCreator(private val project: Project) : KotlinClassInnerStuffCache.LazyCreator() {
+    private class SymbolLightClassesLazyCreator(private val project: Project) : KotlinClassInnerStuffCache.LazyCreator() {
        @OptIn(KtAllowAnalysisOnEdt::class)
        override fun <T : Any> get(initializer: () -> T, dependencies: List<Any>): Lazy<T> = object : Lazy<T> {
            private val cachedValue = PsiCachedValueImpl(PsiManager.getInstance(project)) {
@@ -50,9 +50,9 @@ abstract class FirLightClassBase protected constructor(
    }

    private val myInnersCache = KotlinClassInnerStuffCache(
-        myClass = this@FirLightClassBase,
+        myClass = this@SymbolLightClassBase,
        dependencies = listOf(manager.project.createProjectWideOutOfBlockModificationTracker()),
-        lazyCreator = FirLightClassesLazyCreator(project)
+        lazyCreator = SymbolLightClassesLazyCreator(project)
    )

    override fun getFields(): Array<PsiField> = myInnersCache.fields
@@ -169,7 +169,7 @@ abstract class FirLightClassBase protected constructor(
    override fun getInitializers(): Array<PsiClassInitializer> = PsiClassInitializer.EMPTY_ARRAY

    override fun getElementIcon(flags: Int): Icon? =
-        throw UnsupportedOperationException("This should be done by KotlinFirIconProvider")
+        throw UnsupportedOperationException("This should be done by KotlinIconProvider")

    override fun getVisibleSignatures(): MutableCollection<HierarchicalMethodSignature> = PsiSuperMethodImplUtil.getVisibleSignatures(this)

@@ -21,12 +21,16 @@ import org.jetbrains.kotlin.asJava.classes.getParentForLocalDeclaration
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.KtLightField
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
-import org.jetbrains.kotlin.light.classes.symbol.*
+import org.jetbrains.kotlin.light.classes.symbol.SymbolFakeFile
+import org.jetbrains.kotlin.light.classes.symbol.SymbolLightIdentifier
+import org.jetbrains.kotlin.light.classes.symbol.allowLightClassesOnEdt
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasDeprecatedAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasJvmFieldAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasJvmStaticAnnotation
-import org.jetbrains.kotlin.light.classes.symbol.fields.FirLightFieldForObjectSymbol
-import org.jetbrains.kotlin.light.classes.symbol.fields.FirLightFieldForPropertySymbol
+import org.jetbrains.kotlin.light.classes.symbol.basicIsEquivalentTo
+import org.jetbrains.kotlin.light.classes.symbol.fields.SymbolLightFieldForObject
+import org.jetbrains.kotlin.light.classes.symbol.fields.SymbolLightFieldForProperty
+import org.jetbrains.kotlin.light.classes.symbol.parameters.SymbolLightTypeParameterList
 import org.jetbrains.kotlin.load.java.structure.LightClassOriginKind
 import org.jetbrains.kotlin.psi.KtClassBody
 import org.jetbrains.kotlin.psi.KtClassOrObject
@@ -38,10 +42,10 @@ import org.jetbrains.kotlin.utils.addToStdlib.ifTrue
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs

 context(KtAnalysisSession)
-internal abstract class FirLightClassForClassOrObjectSymbol(
+internal abstract class SymbolLightClassForClassOrObject(
    private val classOrObjectSymbol: KtNamedClassOrObjectSymbol,
    manager: PsiManager
-) : FirLightClassBase(manager),
+) : SymbolLightClassBase(manager),
    StubBasedPsiElement<KotlinClassOrObjectStub<out KtClassOrObject>> {

    protected val isTopLevel: Boolean = classOrObjectSymbol.symbolKind == KtSymbolKind.TOP_LEVEL
@@ -60,7 +64,7 @@ internal abstract class FirLightClassForClassOrObjectSymbol(
    abstract override fun getOwnMethods(): List<PsiMethod>

    private val _identifier: PsiIdentifier by lazyPub {
-        FirLightIdentifier(this, classOrObjectSymbol)
+        SymbolLightIdentifier(this, classOrObjectSymbol)
    }

    override fun getNameIdentifier(): PsiIdentifier? = _identifier
@@ -70,7 +74,7 @@ internal abstract class FirLightClassForClassOrObjectSymbol(

    private val _typeParameterList: PsiTypeParameterList? by lazyPub {
        hasTypeParameters().ifTrue {
-            FirLightTypeParameterListForSymbol(
+            SymbolLightTypeParameterList(
                owner = this,
                symbolWithTypeParameterList = classOrObjectSymbol,
            )
@@ -84,7 +88,7 @@ internal abstract class FirLightClassForClassOrObjectSymbol(
    override fun getTypeParameters(): Array<PsiTypeParameter> =
        _typeParameterList?.typeParameters ?: PsiTypeParameter.EMPTY_ARRAY

-    private val _ownInnerClasses: List<FirLightClassBase> by lazyPub {
+    private val _ownInnerClasses: List<SymbolLightClassBase> by lazyPub {
        classOrObjectSymbol.createInnerClasses(manager, this, kotlinOrigin)
    }

@@ -118,9 +122,9 @@ internal abstract class FirLightClassForClassOrObjectSymbol(
    protected fun addCompanionObjectFieldIfNeeded(result: MutableList<KtLightField>) {
        classOrObjectSymbol.companionObject?.run {
            result.add(
-                FirLightFieldForObjectSymbol(
+                SymbolLightFieldForObject(
                    objectSymbol = this,
-                    containingClass = this@FirLightClassForClassOrObjectSymbol,
+                    containingClass = this@SymbolLightClassForClassOrObject,
                    name = name.asString(),
                    lightMemberOrigin = null
                )
@@ -136,10 +140,10 @@ internal abstract class FirLightClassForClassOrObjectSymbol(
                    filter { it.hasJvmFieldAnnotation() || it.isConst }
                }
                .mapTo(result) {
-                    FirLightFieldForPropertySymbol(
+                    SymbolLightFieldForProperty(
                        propertySymbol = it,
                        fieldName = it.name.asString(),
-                        containingClass = this@FirLightClassForClassOrObjectSymbol,
+                        containingClass = this@SymbolLightClassForClassOrObject,
                        lightMemberOrigin = null,
                        isTopLevel = false,
                        forceStatic = true,
@@ -156,9 +160,9 @@ internal abstract class FirLightClassForClassOrObjectSymbol(

        val kotlinOrigin = kotlinOrigin ?: return@lazyPub null

-        val containingClass = isTopLevel.ifFalse { getOrCreateFirLightClass(getOutermostClassOrObject(kotlinOrigin)) } ?: this
+        val containingClass = isTopLevel.ifFalse { getOrCreateSymbolLightClass(getOutermostClassOrObject(kotlinOrigin)) } ?: this

-        FirFakeFileImpl(kotlinOrigin, containingClass)
+        SymbolFakeFile(kotlinOrigin, containingClass)
    }

    override fun getContainingFile(): PsiFile? = _containingFile
@@ -205,7 +209,7 @@ internal abstract class FirLightClassForClassOrObjectSymbol(
    override fun getContainingClass(): PsiClass? {
        val containingBody = kotlinOrigin?.parent as? KtClassBody
        val containingClass = containingBody?.parent as? KtClassOrObject
-        containingClass?.let { return getOrCreateFirLightClass(it) }
+        containingClass?.let { return getOrCreateSymbolLightClass(it) }
        return null
    }

@@ -221,5 +225,5 @@ internal abstract class FirLightClassForClassOrObjectSymbol(
    override fun isInheritorDeep(baseClass: PsiClass?, classToByPass: PsiClass?): Boolean =
        baseClass?.let { InheritanceImplUtil.isInheritorDeep(this, it, classToByPass) } ?: false

-    abstract override fun copy(): FirLightClassForClassOrObjectSymbol
+    abstract override fun copy(): SymbolLightClassForClassOrObject
 }
@@ -14,26 +14,26 @@ import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode
 import org.jetbrains.kotlin.asJava.classes.KotlinSuperTypeListBuilder
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
-import org.jetbrains.kotlin.light.classes.symbol.codeReferences.FirLightPsiJavaCodeReferenceElementWithNoReference
-import org.jetbrains.kotlin.light.classes.symbol.fields.FirLightFieldForEnumEntry
-import org.jetbrains.kotlin.light.classes.symbol.modifierLists.FirLightClassModifierList
+import org.jetbrains.kotlin.light.classes.symbol.codeReferences.SymbolLightPsiJavaCodeReferenceElementWithNoReference
+import org.jetbrains.kotlin.light.classes.symbol.fields.SymbolLightFieldForEnumEntry
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightClassModifierList
 import org.jetbrains.kotlin.load.java.structure.LightClassOriginKind
 import org.jetbrains.kotlin.psi.KtClassOrObject

 context(KtAnalysisSession)
-internal class FirLightClassForEnumEntry(
+internal class SymbolLightClassForEnumEntry(
    private val enumEntrySymbol: KtEnumEntrySymbol,
-    private val enumConstant: FirLightFieldForEnumEntry,
-    private val enumClass: FirLightClassForSymbol,
+    private val enumConstant: SymbolLightFieldForEnumEntry,
+    private val enumClass: SymbolLightClass,
    manager: PsiManager
-) : FirLightClassBase(manager), PsiEnumConstantInitializer {
+) : SymbolLightClassBase(manager), PsiEnumConstantInitializer {

    override fun getName(): String? = enumEntrySymbol.name.asString()

    override fun getBaseClassType(): PsiClassType = enumConstant.type as PsiClassType //???TODO

    override fun getBaseClassReference(): PsiJavaCodeReferenceElement =
-        FirLightPsiJavaCodeReferenceElementWithNoReference(enumConstant) //???TODO
+        SymbolLightPsiJavaCodeReferenceElementWithNoReference(enumConstant) //???TODO

    override fun getArgumentList(): PsiExpressionList? = null

@@ -42,21 +42,21 @@ internal class FirLightClassForEnumEntry(
    override fun isInQualifiedNew(): Boolean = false

    override fun equals(other: Any?): Boolean =
-        other is FirLightClassForEnumEntry &&
+        other is SymbolLightClassForEnumEntry &&
                this.enumEntrySymbol == other.enumEntrySymbol

    override fun hashCode(): Int =
        enumEntrySymbol.hashCode()

    override fun copy(): PsiElement =
-        FirLightClassForEnumEntry(enumEntrySymbol, enumConstant, enumClass, manager)
+        SymbolLightClassForEnumEntry(enumEntrySymbol, enumConstant, enumClass, manager)

-    override fun toString(): String = "FirLightClassForEnumEntry for $name"
+    override fun toString(): String = "SymbolLightClassForEnumEntry:$name"

    override fun getNameIdentifier(): PsiIdentifier? = null //TODO

    private val _modifierList: PsiModifierList by lazyPub {
-        FirLightClassModifierList(
+        SymbolLightClassModifierList(
            containingDeclaration = this,
            modifiers = setOf(PsiModifier.PUBLIC, PsiModifier.STATIC, PsiModifier.FINAL),
            annotations = emptyList()
@@ -86,7 +86,7 @@ internal class FirLightClassForEnumEntry(

    private val _extendsList: PsiReferenceList? by lazyPub {
        val mappedType =
-            enumEntrySymbol.returnType.asPsiType(this@FirLightClassForEnumEntry, KtTypeMappingMode.SUPER_TYPE) as? PsiClassType
+            enumEntrySymbol.returnType.asPsiType(this@SymbolLightClassForEnumEntry, KtTypeMappingMode.SUPER_TYPE) as? PsiClassType
                ?: return@lazyPub null


@@ -30,8 +30,8 @@ import org.jetbrains.kotlin.light.classes.symbol.annotations.computeAnnotations
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasInlineOnlyAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasJvmFieldAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasJvmMultifileClassAnnotation
-import org.jetbrains.kotlin.light.classes.symbol.fields.FirLightField
-import org.jetbrains.kotlin.light.classes.symbol.modifierLists.FirLightClassModifierList
+import org.jetbrains.kotlin.light.classes.symbol.fields.SymbolLightField
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightClassModifierList
 import org.jetbrains.kotlin.light.classes.symbol.toPsiVisibilityForMember
 import org.jetbrains.kotlin.load.java.structure.LightClassOriginKind
 import org.jetbrains.kotlin.name.FqName
@@ -39,11 +39,11 @@ import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtFile

 context(KtAnalysisSession)
-class FirLightClassForFacade(
+class SymbolLightClassForFacade(
    manager: PsiManager,
    override val facadeClassFqName: FqName,
    override val files: Collection<KtFile>
-) : FirLightClassBase(manager), KtLightClassForFacade {
+) : SymbolLightClassBase(manager), KtLightClassForFacade {

    init {
        require(files.isNotEmpty())
@@ -71,14 +71,14 @@ class FirLightClassForFacade(

        val annotations = fileSymbols.flatMap {
            it.computeAnnotations(
-                this@FirLightClassForFacade,
+                this@SymbolLightClassForFacade,
                NullabilityType.Unknown,
                AnnotationUseSiteTarget.FILE,
                includeAnnotationsWithoutSite = false
            )
        }

-        FirLightClassModifierList(this@FirLightClassForFacade, modifiers, annotations)
+        SymbolLightClassModifierList(this@SymbolLightClassForFacade, modifiers, annotations)
    }

    override fun getModifierList(): PsiModifierList = _modifierList
@@ -111,7 +111,7 @@ class FirLightClassForFacade(

    private fun loadFieldsFromFile(
        fileScope: KtScope,
-        nameGenerator: FirLightField.FieldNameGenerator,
+        nameGenerator: SymbolLightField.FieldNameGenerator,
        result: MutableList<KtLightField>
    ) {
        for (propertySymbol in fileScope.getCallableSymbols()) {
@@ -147,7 +147,7 @@ class FirLightClassForFacade(

    private val _ownFields: List<KtLightField> by lazyPub {
        val result = mutableListOf<KtLightField>()
-        val nameGenerator = FirLightField.FieldNameGenerator()
+        val nameGenerator = SymbolLightField.FieldNameGenerator()
        for (fileSymbol in fileSymbols) {
            loadFieldsFromFile(fileSymbol.getFileScope(), nameGenerator, result)
        }
@@ -158,8 +158,8 @@ class FirLightClassForFacade(

    override fun getOwnMethods() = _ownMethods

-    override fun copy(): FirLightClassForFacade =
-        FirLightClassForFacade(manager, facadeClassFqName, files)
+    override fun copy(): SymbolLightClassForFacade =
+        SymbolLightClassForFacade(manager, facadeClassFqName, files)

    private val packageFqName: FqName =
        facadeClassFqName.parent()
@@ -230,7 +230,7 @@ class FirLightClassForFacade(
    override fun getNavigationElement() = firstFileInFacade

    override fun isEquivalentTo(another: PsiElement?): Boolean =
-        equals(another) || another is FirLightClassForFacade && another.qualifiedName == qualifiedName
+        equals(another) || another is SymbolLightClassForFacade && another.qualifiedName == qualifiedName

    override fun isInheritor(baseClass: PsiClass, checkDeep: Boolean): Boolean {
        return baseClass.qualifiedName == CommonClassNames.JAVA_LANG_OBJECT
@@ -247,7 +247,7 @@ class FirLightClassForFacade(
        arrayOf(PsiType.getJavaLangObject(manager, resolveScope))

    override fun equals(other: Any?): Boolean {
-        if (other !is FirLightClassForFacade) return false
+        if (other !is SymbolLightClassForFacade) return false
        if (this === other) return true

        if (this.hashCode() != other.hashCode()) return false
@@ -260,7 +260,7 @@ class FirLightClassForFacade(

    override fun hashCode() = facadeClassFqName.hashCode()

-    override fun toString() = "${FirLightClassForFacade::class.java.simpleName}:$facadeClassFqName"
+    override fun toString() = "${SymbolLightClassForFacade::class.java.simpleName}:$facadeClassFqName"

    override val originKind: LightClassOriginKind
        get() = LightClassOriginKind.SOURCE
@@ -10,29 +10,29 @@ import com.intellij.util.IncorrectOperationException
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.asJava.classes.lazyPub
-import org.jetbrains.kotlin.light.classes.symbol.modifierLists.FirLightClassModifierList
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightClassModifierList
 import org.jetbrains.kotlin.load.java.JvmAbi

 context(KtAnalysisSession)
-internal class FirLightClassForInterfaceDefaultImpls(
+internal class SymbolLightClassForInterfaceDefaultImpls(
    private val classOrObjectSymbol: KtNamedClassOrObjectSymbol,
-    private val containingClass: FirLightClassBase,
+    private val containingClass: SymbolLightClassBase,
    manager: PsiManager
-) : FirLightInterfaceClassSymbol(classOrObjectSymbol, manager) {
+) : SymbolLightInterfaceClass(classOrObjectSymbol, manager) {
    override fun getQualifiedName(): String? = containingClass.qualifiedName?.let { it + ".${JvmAbi.DEFAULT_IMPLS_CLASS_NAME}" }

    override fun getName() = JvmAbi.DEFAULT_IMPLS_CLASS_NAME
    override fun getParent() = containingClass

    override fun copy() =
-        FirLightClassForInterfaceDefaultImpls(classOrObjectSymbol, containingClass, manager)
+        SymbolLightClassForInterfaceDefaultImpls(classOrObjectSymbol, containingClass, manager)

    override fun getTypeParameterList(): PsiTypeParameterList? = null
    override fun getTypeParameters(): Array<PsiTypeParameter> = emptyArray()

    private val _modifierList: PsiModifierList? by lazyPub {
        val modifiers = setOf(PsiModifier.PUBLIC, PsiModifier.STATIC, PsiModifier.FINAL)
-        FirLightClassModifierList(this@FirLightClassForInterfaceDefaultImpls, modifiers, emptyList())
+        SymbolLightClassModifierList(this@SymbolLightClassForInterfaceDefaultImpls, modifiers, emptyList())
    }

    override fun getModifierList(): PsiModifierList? = _modifierList
@@ -17,10 +17,10 @@ import org.jetbrains.kotlin.asJava.elements.KtLightMethod
 import org.jetbrains.kotlin.resolve.deprecation.DeprecationLevelValue

 context(KtAnalysisSession)
-internal class FirLightInlineClass(
+internal class SymbolLightInlineClass(
    private val classOrObjectSymbol: KtNamedClassOrObjectSymbol,
    manager: PsiManager
-) : FirLightClassForSymbol(classOrObjectSymbol, manager) {
+) : SymbolLightClass(classOrObjectSymbol, manager) {

    init {
        require(classOrObjectSymbol.isInline)
@@ -61,6 +61,5 @@ internal class FirLightInlineClass(

    override fun getOwnFields(): List<KtLightField> = emptyList()

-    override fun copy(): FirLightInlineClass =
-        FirLightInlineClass(classOrObjectSymbol, manager)
+    override fun copy(): SymbolLightInlineClass = SymbolLightInlineClass(classOrObjectSymbol, manager)
 }
@@ -19,10 +19,10 @@ import org.jetbrains.kotlin.asJava.elements.KtLightField
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod

 context(KtAnalysisSession)
-internal open class FirLightInterfaceClassSymbol(
+internal open class SymbolLightInterfaceClass(
    private val classOrObjectSymbol: KtNamedClassOrObjectSymbol,
    manager: PsiManager
-) : FirLightInterfaceOrAnnotationClassSymbol(classOrObjectSymbol, manager) {
+) : SymbolLightInterfaceOrAnnotationClass(classOrObjectSymbol, manager) {

    init {
        require(classOrObjectSymbol.classKind == KtClassKind.INTERFACE)
@@ -52,14 +52,13 @@ internal open class FirLightInterfaceClassSymbol(
    override fun getOwnMethods(): List<PsiMethod> = _ownMethods

    override fun equals(other: Any?): Boolean =
-        other === this || (other is FirLightInterfaceClassSymbol && classOrObjectSymbol == other.classOrObjectSymbol)
+        other === this || (other is SymbolLightInterfaceClass && classOrObjectSymbol == other.classOrObjectSymbol)

    override fun hashCode(): Int = classOrObjectSymbol.hashCode()

    override fun isAnnotationType(): Boolean = false

-    override fun copy(): FirLightClassForClassOrObjectSymbol =
-        FirLightInterfaceClassSymbol(classOrObjectSymbol, manager)
+    override fun copy(): SymbolLightClassForClassOrObject = SymbolLightInterfaceClass(classOrObjectSymbol, manager)

    private val _extendsList: PsiReferenceList by lazyPub {
        createInheritanceList(forExtendsList = true, classOrObjectSymbol.superTypes)
@@ -16,14 +16,14 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.light.classes.symbol.NullabilityType
 import org.jetbrains.kotlin.light.classes.symbol.annotations.computeAnnotations
-import org.jetbrains.kotlin.light.classes.symbol.modifierLists.FirLightClassModifierList
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightClassModifierList
 import org.jetbrains.kotlin.light.classes.symbol.toPsiVisibilityForClass

 context(KtAnalysisSession)
-internal abstract class FirLightInterfaceOrAnnotationClassSymbol(
+internal abstract class SymbolLightInterfaceOrAnnotationClass(
    private val classOrObjectSymbol: KtNamedClassOrObjectSymbol,
    manager: PsiManager
-) : FirLightClassForClassOrObjectSymbol(classOrObjectSymbol, manager) {
+) : SymbolLightClassForClassOrObject(classOrObjectSymbol, manager) {

    init {
        require(
@@ -41,12 +41,12 @@ internal abstract class FirLightInterfaceOrAnnotationClassSymbol(
        }

        val annotations = classOrObjectSymbol.computeAnnotations(
-            parent = this@FirLightInterfaceOrAnnotationClassSymbol,
+            parent = this@SymbolLightInterfaceOrAnnotationClass,
            nullability = NullabilityType.Unknown,
            annotationUseSiteTarget = null,
        )

-        FirLightClassModifierList(this@FirLightInterfaceOrAnnotationClassSymbol, modifiers, annotations)
+        SymbolLightClassModifierList(this@SymbolLightInterfaceOrAnnotationClass, modifiers, annotations)
    }

    override fun getModifierList(): PsiModifierList? = _modifierList
@@ -34,13 +34,13 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.lexer.KtTokens.*
 import org.jetbrains.kotlin.light.classes.symbol.*
 import org.jetbrains.kotlin.light.classes.symbol.annotations.*
-import org.jetbrains.kotlin.light.classes.symbol.fields.FirLightField
-import org.jetbrains.kotlin.light.classes.symbol.fields.FirLightFieldForEnumEntry
-import org.jetbrains.kotlin.light.classes.symbol.fields.FirLightFieldForPropertySymbol
-import org.jetbrains.kotlin.light.classes.symbol.methods.FirLightAccessorMethodForSymbol
-import org.jetbrains.kotlin.light.classes.symbol.methods.FirLightConstructorForSymbol
-import org.jetbrains.kotlin.light.classes.symbol.methods.FirLightNoArgConstructor
-import org.jetbrains.kotlin.light.classes.symbol.methods.FirLightSimpleMethodForSymbol
+import org.jetbrains.kotlin.light.classes.symbol.fields.SymbolLightField
+import org.jetbrains.kotlin.light.classes.symbol.fields.SymbolLightFieldForEnumEntry
+import org.jetbrains.kotlin.light.classes.symbol.fields.SymbolLightFieldForProperty
+import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightAccessorMethod
+import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightConstructor
+import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightNoArgConstructor
+import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightSimpleMethod
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.psi.*
@@ -48,17 +48,17 @@ import org.jetbrains.kotlin.psi.psiUtil.containingClass
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKind
 import java.util.*

-internal fun getOrCreateFirLightClass(classOrObject: KtClassOrObject): KtLightClass? =
+internal fun getOrCreateSymbolLightClass(classOrObject: KtClassOrObject): KtLightClass? =
    CachedValuesManager.getCachedValue(classOrObject) {
        CachedValueProvider.Result
            .create(
-                createFirLightClassNoCache(classOrObject),
+                createSymbolLightClassNoCache(classOrObject),
                classOrObject.project.createProjectWideOutOfBlockModificationTracker()
            )
    }

@OptIn(KtAllowAnalysisOnEdt::class)
-internal fun createFirLightClassNoCache(classOrObject: KtClassOrObject): KtLightClass? = allowAnalysisOnEdt {
+internal fun createSymbolLightClassNoCache(classOrObject: KtClassOrObject): KtLightClass? = allowAnalysisOnEdt {

    val containingFile = classOrObject.containingFile
    if (containingFile is KtCodeFragment) {
@@ -86,7 +86,7 @@ internal fun createFirLightClassNoCache(classOrObject: KtClassOrObject): KtLight

        classOrObject.hasModifier(INLINE_KEYWORD) -> {
            analyzeForLightClasses(classOrObject) {
-                classOrObject.getNamedClassOrObjectSymbol()?.let { FirLightInlineClass(it, classOrObject.manager) }
+                classOrObject.getNamedClassOrObjectSymbol()?.let { SymbolLightInlineClass(it, classOrObject.manager) }
            }
        }

@@ -100,12 +100,12 @@ internal fun createFirLightClassNoCache(classOrObject: KtClassOrObject): KtLight


 context(KtAnalysisSession)
-internal fun KtClassOrObjectSymbol.createLightClassNoCache(manager: PsiManager): FirLightClassBase = when (this) {
-    is KtAnonymousObjectSymbol -> FirLightAnonymousClassForSymbol(this, manager)
+internal fun KtClassOrObjectSymbol.createLightClassNoCache(manager: PsiManager): SymbolLightClassBase = when (this) {
+    is KtAnonymousObjectSymbol -> SymbolLightAnonymousClassForSymbol(this, manager)
    is KtNamedClassOrObjectSymbol -> when (classKind) {
-        KtClassKind.INTERFACE -> FirLightInterfaceClassSymbol(this, manager)
-        KtClassKind.ANNOTATION_CLASS -> FirLightAnnotationClassSymbol(this, manager)
-        else -> FirLightClassForSymbol(this, manager)
+        KtClassKind.INTERFACE -> SymbolLightInterfaceClass(this, manager)
+        KtClassKind.ANNOTATION_CLASS -> SymbolLightAnnotationClassSymbol(this, manager)
+        else -> SymbolLightClass(this, manager)
    }
 }

@@ -113,20 +113,20 @@ context(KtAnalysisSession)
 private fun lightClassForEnumEntry(ktEnumEntry: KtEnumEntry): KtLightClass? {
    if (ktEnumEntry.body == null) return null

-    val firClass = ktEnumEntry
+    val symbolLightClass = ktEnumEntry
        .containingClass()
-        ?.let { getOrCreateFirLightClass(it) } as? FirLightClassForSymbol
+        ?.let { getOrCreateSymbolLightClass(it) } as? SymbolLightClass
        ?: return null

-    val targetField = firClass.ownFields
-        .firstOrNull { it is FirLightFieldForEnumEntry && it.kotlinOrigin == ktEnumEntry }
+    val targetField = symbolLightClass.ownFields
+        .firstOrNull { it is SymbolLightFieldForEnumEntry && it.kotlinOrigin == ktEnumEntry }
        ?: return null

-    return (targetField as? FirLightFieldForEnumEntry)?.initializingClass as? KtLightClass
+    return (targetField as? SymbolLightFieldForEnumEntry)?.initializingClass as? KtLightClass
 }

 context(KtAnalysisSession)
-internal fun FirLightClassBase.createConstructors(
+internal fun SymbolLightClassBase.createConstructors(
    declarations: Sequence<KtConstructorSymbol>,
    result: MutableList<KtLightMethod>
 ) {
@@ -138,7 +138,7 @@ internal fun FirLightClassBase.createConstructors(
    for (constructor in constructors) {
        if (constructor.isHiddenOrSynthetic()) continue
        result.add(
-            FirLightConstructorForSymbol(
+            SymbolLightConstructor(
                constructorSymbol = constructor,
                lightMemberOrigin = null,
                containingClass = this@createConstructors,
@@ -155,7 +155,7 @@ internal fun FirLightClassBase.createConstructors(
 }

 context(KtAnalysisSession)
-private fun FirLightClassBase.shouldGenerateNoArgOverload(
+private fun SymbolLightClassBase.shouldGenerateNoArgOverload(
    primaryConstructor: KtConstructorSymbol,
    constructors: Iterable<KtConstructorSymbol>,
 ): Boolean {
@@ -170,7 +170,7 @@ private fun FirLightClassBase.shouldGenerateNoArgOverload(
 }

 context(KtAnalysisSession)
-private fun FirLightClassBase.defaultConstructor(): KtLightMethod {
+private fun SymbolLightClassBase.defaultConstructor(): KtLightMethod {
    val classOrObject = kotlinOrigin
    val visibility = when {
        classOrObject is KtObjectDeclaration || classOrObject?.hasModifier(SEALED_KEYWORD) == true || isEnum -> PsiModifier.PRIVATE
@@ -181,11 +181,11 @@ private fun FirLightClassBase.defaultConstructor(): KtLightMethod {
 }

 context(KtAnalysisSession)
-private fun FirLightClassBase.noArgConstructor(
+private fun SymbolLightClassBase.noArgConstructor(
    visibility: String,
    methodIndex: Int,
 ): KtLightMethod {
-    return FirLightNoArgConstructor(
+    return SymbolLightNoArgConstructor(
        LightMemberOriginForDeclaration(
            originalElement = kotlinOrigin!!,
            originKind = JvmDeclarationOriginKind.OTHER,
@@ -198,7 +198,7 @@ private fun FirLightClassBase.noArgConstructor(
 }

 context(KtAnalysisSession)
-internal fun FirLightClassBase.createMethods(
+internal fun SymbolLightClassBase.createMethods(
    declarations: Sequence<KtCallableSymbol>,
    result: MutableList<KtLightMethod>,
    isTopLevel: Boolean = false,
@@ -216,7 +216,7 @@ internal fun FirLightClassBase.createMethods(

                var methodIndex = METHOD_INDEX_BASE
                result.add(
-                    FirLightSimpleMethodForSymbol(
+                    SymbolLightSimpleMethod(
                        functionSymbol = declaration,
                        lightMemberOrigin = null,
                        containingClass = this@createMethods,
@@ -236,7 +236,7 @@ internal fun FirLightClassBase.createMethods(
                        skipMask.set(i)

                        result.add(
-                            FirLightSimpleMethodForSymbol(
+                            SymbolLightSimpleMethod(
                                declaration, null, this@createMethods, methodIndex++, isTopLevel, skipMask.copy()
                            )
                        )
@@ -267,7 +267,7 @@ internal fun FirLightClassBase.createMethods(
 }

 context(KtAnalysisSession)
-internal fun FirLightClassBase.createPropertyAccessors(
+internal fun SymbolLightClassBase.createPropertyAccessors(
    result: MutableList<KtLightMethod>,
    declaration: KtPropertySymbol,
    isTopLevel: Boolean,
@@ -309,7 +309,7 @@ internal fun FirLightClassBase.createPropertyAccessors(
        }

        result.add(
-            FirLightAccessorMethodForSymbol(
+            SymbolLightAccessorMethod(
                propertyAccessorSymbol = getter,
                containingPropertySymbol = declaration,
                lightMemberOrigin = lightMemberOrigin,
@@ -333,7 +333,7 @@ internal fun FirLightClassBase.createPropertyAccessors(
            )
        }
        result.add(
-            FirLightAccessorMethodForSymbol(
+            SymbolLightAccessorMethod(
                propertyAccessorSymbol = setter,
                containingPropertySymbol = declaration,
                lightMemberOrigin = lightMemberOrigin,
@@ -346,9 +346,9 @@ internal fun FirLightClassBase.createPropertyAccessors(
 }

 context(KtAnalysisSession)
-internal fun FirLightClassBase.createField(
+internal fun SymbolLightClassBase.createField(
    declaration: KtPropertySymbol,
-    nameGenerator: FirLightField.FieldNameGenerator,
+    nameGenerator: SymbolLightField.FieldNameGenerator,
    isTopLevel: Boolean,
    forceStatic: Boolean,
    takePropertyVisibility: Boolean,
@@ -377,7 +377,7 @@ internal fun FirLightClassBase.createField(
    )

    result.add(
-        FirLightFieldForPropertySymbol(
+        SymbolLightFieldForProperty(
            propertySymbol = declaration,
            fieldName = fieldName,
            containingClass = this,
@@ -390,7 +390,7 @@ internal fun FirLightClassBase.createField(
 }

 context(KtAnalysisSession)
-internal fun FirLightClassBase.createInheritanceList(forExtendsList: Boolean, superTypes: List<KtType>): PsiReferenceList {
+internal fun SymbolLightClassBase.createInheritanceList(forExtendsList: Boolean, superTypes: List<KtType>): PsiReferenceList {

    val role = if (forExtendsList) PsiReferenceList.Role.EXTENDS_LIST else PsiReferenceList.Role.IMPLEMENTS_LIST

@@ -434,10 +434,10 @@ internal fun FirLightClassBase.createInheritanceList(forExtendsList: Boolean, su
 context(KtAnalysisSession)
 internal fun KtSymbolWithMembers.createInnerClasses(
    manager: PsiManager,
-    containingClass: FirLightClassBase,
+    containingClass: SymbolLightClassBase,
    classOrObject: KtClassOrObject?
-): List<FirLightClassBase> {
-    val result = ArrayList<FirLightClassBase>()
+): List<SymbolLightClassBase> {
+    val result = ArrayList<SymbolLightClassBase>()

    // workaround for ClassInnerStuffCache not supporting classes with null names, see KT-13927
    // inner classes with null names can't be searched for and can't be used from java anyway
@@ -456,7 +456,7 @@ internal fun KtSymbolWithMembers.createInnerClasses(
        classOrObject?.hasInterfaceDefaultImpls == true &&
        jvmDefaultMode != JvmDefaultMode.ALL_INCOMPATIBLE
    ) {
-        result.add(FirLightClassForInterfaceDefaultImpls(this, containingClass, manager))
+        result.add(SymbolLightClassForInterfaceDefaultImpls(this, containingClass, manager))
    }
    return result
 }
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.light.classes.symbol.codeReferences
 import com.intellij.psi.*
 import com.intellij.psi.scope.PsiScopeProcessor

-internal abstract class FirLightPsiJavaCodeReferenceElementBase(private val ktElement: PsiElement) :
+internal abstract class SymbolLightPsiJavaCodeReferenceElementBase(private val ktElement: PsiElement) :
    PsiElement by ktElement,
    PsiJavaCodeReferenceElement {

@@ -10,8 +10,8 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiReference
 import com.intellij.util.IncorrectOperationException

-internal class FirLightPsiJavaCodeReferenceElementWithNoReference(private val ktElement: PsiElement) :
-    FirLightPsiJavaCodeReferenceElementBase(ktElement),
+internal class SymbolLightPsiJavaCodeReferenceElementWithNoReference(private val ktElement: PsiElement) :
+    SymbolLightPsiJavaCodeReferenceElementBase(ktElement),
    PsiReference {

    override fun getElement(): PsiElement = ktElement
@@ -26,7 +26,7 @@ internal class FirLightPsiJavaCodeReferenceElementWithNoReference(private val kt

    @Throws(IncorrectOperationException::class)
    override fun bindToElement(element: PsiElement): PsiElement =
-        throw IncorrectOperationException("can't rename FirLightPsiJavaCodeReferenceElementWithNoReference")
+        throw IncorrectOperationException("can't rename SymbolLightPsiJavaCodeReferenceElementWithNoReference")

    override fun isReferenceTo(element: PsiElement): Boolean = false

@@ -8,8 +8,8 @@ package org.jetbrains.kotlin.light.classes.symbol.codeReferences
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiReference

-internal class FirLightPsiJavaCodeReferenceElementWithReference(private val ktElement: PsiElement, reference: PsiReference) :
-    FirLightPsiJavaCodeReferenceElementBase(ktElement),
+internal class SymbolLightPsiJavaCodeReferenceElementWithReference(private val ktElement: PsiElement, reference: PsiReference) :
+    SymbolLightPsiJavaCodeReferenceElementBase(ktElement),
    PsiReference by reference {

    override fun getElement(): PsiElement = ktElement
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtFile

-internal class KtLightClassForDecompiledFacade(
+internal class SymbolLightClassForDecompiledFacade(
    clsDelegate: PsiClass,
    clsParent: PsiElement,
    file: KtClsFile,
@@ -17,15 +17,15 @@ import org.jetbrains.kotlin.asJava.classes.KtLightClass
 import org.jetbrains.kotlin.asJava.classes.cannotModify
 import org.jetbrains.kotlin.asJava.elements.KtLightField
 import org.jetbrains.kotlin.idea.KotlinLanguage
-import org.jetbrains.kotlin.light.classes.symbol.FirLightMemberImpl
+import org.jetbrains.kotlin.light.classes.symbol.SymbolLightMemberBase
 import org.jetbrains.kotlin.light.classes.symbol.basicIsEquivalentTo
 import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import javax.swing.Icon

-internal abstract class FirLightField protected constructor(
+internal abstract class SymbolLightField protected constructor(
    private val containingClass: KtLightClass,
    lightMemberOrigin: LightMemberOrigin?,
-) : FirLightMemberImpl<PsiField>(lightMemberOrigin, containingClass), KtLightField {
+) : SymbolLightMemberBase<PsiField>(lightMemberOrigin, containingClass), KtLightField {
    override fun setInitializer(initializer: PsiExpression?) = cannotModify()

    override fun isEquivalentTo(another: PsiElement?): Boolean =
@@ -12,24 +12,24 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtEnumEntrySymbol
 import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin
 import org.jetbrains.kotlin.asJava.classes.cannotModify
 import org.jetbrains.kotlin.asJava.classes.lazyPub
-import org.jetbrains.kotlin.light.classes.symbol.FirLightIdentifier
-import org.jetbrains.kotlin.light.classes.symbol.classes.FirLightClassForEnumEntry
-import org.jetbrains.kotlin.light.classes.symbol.classes.FirLightClassForSymbol
-import org.jetbrains.kotlin.light.classes.symbol.modifierLists.FirLightMemberModifierList
+import org.jetbrains.kotlin.light.classes.symbol.SymbolLightIdentifier
+import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClass
+import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassForEnumEntry
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightMemberModifierList
 import org.jetbrains.kotlin.light.classes.symbol.nonExistentType
 import org.jetbrains.kotlin.psi.KtEnumEntry
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue

 context(KtAnalysisSession)
-internal class FirLightFieldForEnumEntry(
+internal class SymbolLightFieldForEnumEntry(
    private val enumEntrySymbol: KtEnumEntrySymbol,
-    containingClass: FirLightClassForSymbol,
+    containingClass: SymbolLightClass,
    override val lightMemberOrigin: LightMemberOrigin?
-) : FirLightField(containingClass, lightMemberOrigin), PsiEnumConstant {
+) : SymbolLightField(containingClass, lightMemberOrigin), PsiEnumConstant {

    private val _modifierList by lazyPub {
-        FirLightMemberModifierList(
-            containingDeclaration = this@FirLightFieldForEnumEntry,
+        SymbolLightMemberModifierList(
+            containingDeclaration = this@SymbolLightFieldForEnumEntry,
            modifiers = setOf(PsiModifier.STATIC, PsiModifier.FINAL, PsiModifier.PUBLIC),
            annotations = emptyList()
        )
@@ -46,9 +46,9 @@ internal class FirLightFieldForEnumEntry(

    private val _initializingClass: PsiEnumConstantInitializer? by lazyPub {
        hasBody.ifTrue {
-            FirLightClassForEnumEntry(
+            SymbolLightClassForEnumEntry(
                enumEntrySymbol = enumEntrySymbol,
-                enumConstant = this@FirLightFieldForEnumEntry,
+                enumConstant = this@SymbolLightFieldForEnumEntry,
                enumClass = containingClass,
                manager = manager
            )
@@ -71,7 +71,7 @@ internal class FirLightFieldForEnumEntry(
    override fun getName(): String = enumEntrySymbol.name.asString()

    private val _type: PsiType by lazyPub {
-        enumEntrySymbol.returnType.asPsiType(this@FirLightFieldForEnumEntry) ?: nonExistentType()
+        enumEntrySymbol.returnType.asPsiType(this@SymbolLightFieldForEnumEntry) ?: nonExistentType()
    }

    override fun getType(): PsiType = _type
@@ -80,7 +80,7 @@ internal class FirLightFieldForEnumEntry(
    override fun hashCode(): Int = enumEntrySymbol.hashCode()

    private val _identifier: PsiIdentifier by lazyPub {
-        FirLightIdentifier(this, enumEntrySymbol)
+        SymbolLightIdentifier(this, enumEntrySymbol)
    }

    override fun getNameIdentifier(): PsiIdentifier = _identifier
@@ -88,7 +88,5 @@ internal class FirLightFieldForEnumEntry(
    override fun isValid(): Boolean = super.isValid() && enumEntrySymbol.isValid()


-    override fun equals(other: Any?): Boolean =
-        other is FirLightFieldForEnumEntry &&
-                enumEntrySymbol == other.enumEntrySymbol
+    override fun equals(other: Any?): Boolean = other is SymbolLightFieldForEnumEntry && enumEntrySymbol == other.enumEntrySymbol
 }
@@ -13,21 +13,21 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
 import org.jetbrains.kotlin.asJava.classes.lazyPub
-import org.jetbrains.kotlin.light.classes.symbol.FirLightIdentifier
-import org.jetbrains.kotlin.light.classes.symbol.annotations.FirLightSimpleAnnotation
+import org.jetbrains.kotlin.light.classes.symbol.SymbolLightIdentifier
+import org.jetbrains.kotlin.light.classes.symbol.annotations.SymbolLightSimpleAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasDeprecatedAnnotation
-import org.jetbrains.kotlin.light.classes.symbol.modifierLists.FirLightMemberModifierList
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightMemberModifierList
 import org.jetbrains.kotlin.light.classes.symbol.nonExistentType
 import org.jetbrains.kotlin.light.classes.symbol.toPsiVisibilityForMember
 import org.jetbrains.kotlin.psi.KtDeclaration

 context(KtAnalysisSession)
-internal class FirLightFieldForObjectSymbol(
+internal class SymbolLightFieldForObject(
    private val objectSymbol: KtNamedClassOrObjectSymbol,
    containingClass: KtLightClass,
    private val name: String,
    lightMemberOrigin: LightMemberOrigin?,
-) : FirLightField(containingClass, lightMemberOrigin) {
+) : SymbolLightField(containingClass, lightMemberOrigin) {

    override val kotlinOrigin: KtDeclaration? = objectSymbol.psi as? KtDeclaration

@@ -35,8 +35,8 @@ internal class FirLightFieldForObjectSymbol(

    private val _modifierList: PsiModifierList by lazyPub {
        val modifiers = setOf(objectSymbol.toPsiVisibilityForMember(isTopLevel = false), PsiModifier.STATIC, PsiModifier.FINAL)
-        val notNullAnnotation = FirLightSimpleAnnotation(NotNull::class.java.name, this)
-        FirLightMemberModifierList(this, modifiers, listOf(notNullAnnotation))
+        val notNullAnnotation = SymbolLightSimpleAnnotation(NotNull::class.java.name, this)
+        SymbolLightMemberModifierList(this, modifiers, listOf(notNullAnnotation))
    }

    private val _isDeprecated: Boolean by lazyPub {
@@ -48,12 +48,12 @@ internal class FirLightFieldForObjectSymbol(
    override fun getModifierList(): PsiModifierList? = _modifierList

    private val _type: PsiType by lazyPub {
-        objectSymbol.buildSelfClassType().asPsiType(this@FirLightFieldForObjectSymbol)
+        objectSymbol.buildSelfClassType().asPsiType(this@SymbolLightFieldForObject)
            ?: nonExistentType()
    }

    private val _identifier: PsiIdentifier by lazyPub {
-        FirLightIdentifier(this, objectSymbol)
+        SymbolLightIdentifier(this, objectSymbol)
    }

    override fun getNameIdentifier(): PsiIdentifier = _identifier
@@ -65,7 +65,7 @@ internal class FirLightFieldForObjectSymbol(

    override fun equals(other: Any?): Boolean =
        this === other ||
-                (other is FirLightFieldForObjectSymbol &&
+                (other is SymbolLightFieldForObject &&
                        kotlinOrigin == other.kotlinOrigin &&
                        objectSymbol == other.objectSymbol)

@@ -20,23 +20,23 @@ import org.jetbrains.kotlin.light.classes.symbol.*
 import org.jetbrains.kotlin.light.classes.symbol.annotations.computeAnnotations
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasDeprecatedAnnotation
-import org.jetbrains.kotlin.light.classes.symbol.classes.FirLightClassBase
-import org.jetbrains.kotlin.light.classes.symbol.modifierLists.FirLightMemberModifierList
+import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassBase
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightMemberModifierList
 import org.jetbrains.kotlin.name.JvmNames.TRANSIENT_ANNOTATION_CLASS_ID
 import org.jetbrains.kotlin.name.JvmNames.VOLATILE_ANNOTATION_CLASS_ID
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtProperty

 context(KtAnalysisSession)
-internal class FirLightFieldForPropertySymbol(
+internal class SymbolLightFieldForProperty(
    private val propertySymbol: KtPropertySymbol,
    private val fieldName: String,
-    containingClass: FirLightClassBase,
+    containingClass: SymbolLightClassBase,
    lightMemberOrigin: LightMemberOrigin?,
    isTopLevel: Boolean,
    forceStatic: Boolean,
    takePropertyVisibility: Boolean
-) : FirLightField(containingClass, lightMemberOrigin) {
+) : SymbolLightField(containingClass, lightMemberOrigin) {

    override val kotlinOrigin: KtDeclaration? = propertySymbol.psi as? KtDeclaration

@@ -45,11 +45,11 @@ internal class FirLightFieldForPropertySymbol(
        when {
            isDelegated ->
                (kotlinOrigin as? KtProperty)?.delegateExpression?.let {
-                    it.getKtType()?.asPsiType(this@FirLightFieldForPropertySymbol, KtTypeMappingMode.RETURN_TYPE)
+                    it.getKtType()?.asPsiType(this@SymbolLightFieldForProperty, KtTypeMappingMode.RETURN_TYPE)
                }

            else -> {
-                propertySymbol.returnType.asPsiType(this@FirLightFieldForPropertySymbol, KtTypeMappingMode.RETURN_TYPE)
+                propertySymbol.returnType.asPsiType(this@SymbolLightFieldForProperty, KtTypeMappingMode.RETURN_TYPE)
            }
        } ?: nonExistentType()
    }
@@ -61,7 +61,7 @@ internal class FirLightFieldForPropertySymbol(
    override fun isDeprecated(): Boolean = _isDeprecated

    private val _identifier: PsiIdentifier by lazyPub {
-        FirLightIdentifier(this, propertySymbol)
+        SymbolLightIdentifier(this, propertySymbol)
    }

    override fun getNameIdentifier(): PsiIdentifier = _identifier
@@ -110,7 +110,7 @@ internal class FirLightFieldForPropertySymbol(
            annotationUseSiteTarget = AnnotationUseSiteTarget.FIELD,
        )

-        FirLightMemberModifierList(this, modifiers, annotations)
+        SymbolLightMemberModifierList(this, modifiers, annotations)
    }

    override fun getModifierList(): PsiModifierList = _modifierList
@@ -127,7 +127,7 @@ internal class FirLightFieldForPropertySymbol(

    override fun equals(other: Any?): Boolean =
        this === other ||
-                (other is FirLightFieldForPropertySymbol &&
+                (other is SymbolLightFieldForProperty &&
                        kotlinOrigin == other.kotlinOrigin &&
                        propertySymbol == other.propertySymbol)

@@ -20,10 +20,10 @@ import org.jetbrains.kotlin.light.classes.symbol.annotations.computeAnnotations
 import org.jetbrains.kotlin.light.classes.symbol.annotations.getJvmNameFromAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasDeprecatedAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasJvmStaticAnnotation
-import org.jetbrains.kotlin.light.classes.symbol.classes.FirLightClassBase
-import org.jetbrains.kotlin.light.classes.symbol.modifierLists.FirLightMemberModifierList
-import org.jetbrains.kotlin.light.classes.symbol.parameters.FirLightParameterList
-import org.jetbrains.kotlin.light.classes.symbol.parameters.FirLightSetterParameterForSymbol
+import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassBase
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightMemberModifierList
+import org.jetbrains.kotlin.light.classes.symbol.parameters.SymbolLightParameterList
+import org.jetbrains.kotlin.light.classes.symbol.parameters.SymbolLightSetterParameter
 import org.jetbrains.kotlin.load.java.JvmAbi.getterName
 import org.jetbrains.kotlin.load.java.JvmAbi.setterName
 import org.jetbrains.kotlin.psi.KtDeclaration
@@ -31,14 +31,14 @@ import org.jetbrains.kotlin.psi.KtParameter
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue

 context(KtAnalysisSession)
-internal class FirLightAccessorMethodForSymbol(
+internal class SymbolLightAccessorMethod(
    private val propertyAccessorSymbol: KtPropertyAccessorSymbol,
    private val containingPropertySymbol: KtPropertySymbol,
    lightMemberOrigin: LightMemberOrigin?,
-    containingClass: FirLightClassBase,
+    containingClass: SymbolLightClassBase,
    private val isTopLevel: Boolean,
    private val suppressStatic: Boolean = false,
-) : FirLightMethod(
+) : SymbolLightMethodBase(
    lightMemberOrigin,
    containingClass,
    if (propertyAccessorSymbol is KtPropertyGetterSymbol) METHOD_INDEX_FOR_GETTER else METHOD_INDEX_FOR_SETTER
@@ -73,7 +73,7 @@ internal class FirLightAccessorMethodForSymbol(
            if (propertyAccessorSymbol is KtPropertyGetterSymbol) AnnotationUseSiteTarget.PROPERTY_GETTER
            else AnnotationUseSiteTarget.PROPERTY_SETTER

-    //TODO Fix it when KtFirConstructorValueParameterSymbol be ready
+    //TODO Fix it when SymbolConstructorValueParameter be ready
    private val isParameter: Boolean get() = containingPropertySymbol.psi.let { it == null || it is KtParameter }

    private fun computeAnnotations(isPrivate: Boolean): List<PsiAnnotation> {
@@ -135,7 +135,7 @@ internal class FirLightAccessorMethodForSymbol(
    private val _modifierList: PsiModifierList by lazyPub {
        val modifiers = computeModifiers()
        val annotations = computeAnnotations(modifiers.contains(PsiModifier.PRIVATE))
-        FirLightMemberModifierList(this, modifiers, annotations)
+        SymbolLightMemberModifierList(this, modifiers, annotations)
    }

    override fun getModifierList(): PsiModifierList = _modifierList
@@ -149,7 +149,7 @@ internal class FirLightAccessorMethodForSymbol(
    override fun isDeprecated(): Boolean = _isDeprecated

    private val _identifier: PsiIdentifier by lazyPub {
-        FirLightIdentifier(this, containingPropertySymbol)
+        SymbolLightIdentifier(this, containingPropertySymbol)
    }

    override fun getNameIdentifier(): PsiIdentifier = _identifier
@@ -157,7 +157,7 @@ internal class FirLightAccessorMethodForSymbol(
    private val _returnedType: PsiType by lazyPub {
        if (!isGetter) return@lazyPub PsiType.VOID
        containingPropertySymbol.returnType.asPsiType(
-            this@FirLightAccessorMethodForSymbol,
+            this@SymbolLightAccessorMethod,
            KtTypeMappingMode.RETURN_TYPE,
            containingClass.isAnnotationType
        ) ?: nonExistentType()
@@ -167,7 +167,7 @@ internal class FirLightAccessorMethodForSymbol(

    override fun equals(other: Any?): Boolean =
        this === other ||
-                (other is FirLightAccessorMethodForSymbol &&
+                (other is SymbolLightAccessorMethod &&
                        isGetter == other.isGetter &&
                        kotlinOrigin == other.kotlinOrigin &&
                        propertyAccessorSymbol == other.propertyAccessorSymbol)
@@ -176,12 +176,12 @@ internal class FirLightAccessorMethodForSymbol(


    private val _parametersList by lazyPub {
-        FirLightParameterList(this, containingPropertySymbol) { builder ->
+        SymbolLightParameterList(this, containingPropertySymbol) { builder ->
            val propertyParameter = (propertyAccessorSymbol as? KtPropertySetterSymbol)?.parameter
            if (propertyParameter != null) {
                builder.addParameter(
-                    FirLightSetterParameterForSymbol(
-                        containingPropertySymbol, propertyParameter, this@FirLightAccessorMethodForSymbol
+                    SymbolLightSetterParameter(
+                        containingPropertySymbol, propertyParameter, this@SymbolLightAccessorMethod
                    )
                )
            }
@@ -14,18 +14,18 @@ import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.light.classes.symbol.NullabilityType
 import org.jetbrains.kotlin.light.classes.symbol.annotations.computeAnnotations
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasDeprecatedAnnotation
-import org.jetbrains.kotlin.light.classes.symbol.classes.FirLightClassBase
-import org.jetbrains.kotlin.light.classes.symbol.classes.FirLightClassForEnumEntry
-import org.jetbrains.kotlin.light.classes.symbol.modifierLists.FirLightMemberModifierList
+import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassBase
+import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassForEnumEntry
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightMemberModifierList
 import org.jetbrains.kotlin.light.classes.symbol.toPsiVisibilityForMember

 context(KtAnalysisSession)
-internal class FirLightConstructorForSymbol(
+internal class SymbolLightConstructor(
    private val constructorSymbol: KtConstructorSymbol,
    lightMemberOrigin: LightMemberOrigin?,
-    containingClass: FirLightClassBase,
+    containingClass: SymbolLightClassBase,
    methodIndex: Int,
-) : FirLightMethodForSymbol(constructorSymbol, lightMemberOrigin, containingClass, methodIndex) {
+) : SymbolLightMethod(constructorSymbol, lightMemberOrigin, containingClass, methodIndex) {

    private val _name: String? = containingClass.name

@@ -56,14 +56,14 @@ internal class FirLightConstructorForSymbol(
        // On the other hand, FE 1.0 doesn't add anything; then ULC adds default ctor w/ package local visibility.
        // Technically, an enum entry should not be instantiated anywhere else, and thus FIR's modeling makes sense.
        // But, to be backward compatible, we manually force the visibility of enum entry ctor to be package private.
-        if (containingClass is FirLightClassForEnumEntry)
+        if (containingClass is SymbolLightClassForEnumEntry)
            setOf(PsiModifier.PACKAGE_LOCAL)
        else
            setOf(constructorSymbol.toPsiVisibilityForMember(isTopLevel = false))
    }

    private val _modifierList: PsiModifierList by lazyPub {
-        FirLightMemberModifierList(this, _modifiers, _annotations)
+        SymbolLightMemberModifierList(this, _modifiers, _annotations)
    }

    override fun getModifierList(): PsiModifierList = _modifierList
@@ -72,7 +72,7 @@ internal class FirLightConstructorForSymbol(

    override fun equals(other: Any?): Boolean =
        this === other ||
-                (other is FirLightConstructorForSymbol &&
+                (other is SymbolLightConstructor &&
                        kotlinOrigin == other.kotlinOrigin &&
                        constructorSymbol == other.constructorSymbol)

@@ -13,22 +13,22 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionLikeSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
 import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin
 import org.jetbrains.kotlin.asJava.classes.lazyPub
-import org.jetbrains.kotlin.light.classes.symbol.FirLightIdentifier
-import org.jetbrains.kotlin.light.classes.symbol.classes.FirLightClassBase
-import org.jetbrains.kotlin.light.classes.symbol.parameters.FirLightParameterForSymbol
-import org.jetbrains.kotlin.light.classes.symbol.parameters.FirLightParameterList
-import org.jetbrains.kotlin.light.classes.symbol.parameters.FirLightSuspendContinuationParameter
+import org.jetbrains.kotlin.light.classes.symbol.SymbolLightIdentifier
+import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassBase
+import org.jetbrains.kotlin.light.classes.symbol.parameters.SymbolLightParameter
+import org.jetbrains.kotlin.light.classes.symbol.parameters.SymbolLightParameterList
+import org.jetbrains.kotlin.light.classes.symbol.parameters.SymbolLightSuspendContinuationParameter
 import org.jetbrains.kotlin.psi.KtDeclaration
 import java.util.*

 context(KtAnalysisSession)
-internal abstract class FirLightMethodForSymbol(
+internal abstract class SymbolLightMethod(
    private val functionSymbol: KtFunctionLikeSymbol,
    lightMemberOrigin: LightMemberOrigin?,
-    containingClass: FirLightClassBase,
+    containingClass: SymbolLightClassBase,
    methodIndex: Int,
    argumentsSkipMask: BitSet? = null
-) : FirLightMethod(
+) : SymbolLightMethodBase(
    lightMemberOrigin,
    containingClass,
    methodIndex
@@ -38,23 +38,23 @@ internal abstract class FirLightMethodForSymbol(
    override fun isVarArgs(): Boolean = _isVarArgs

    private val _parametersList by lazyPub {
-        FirLightParameterList(this, functionSymbol) { builder ->
+        SymbolLightParameterList(this, functionSymbol) { builder ->
            functionSymbol.valueParameters.mapIndexed { index, parameter ->
                val needToSkip = argumentsSkipMask?.get(index) == true
                if (!needToSkip) {
                    builder.addParameter(
-                        FirLightParameterForSymbol(
+                        SymbolLightParameter(
                            parameterSymbol = parameter,
-                            containingMethod = this@FirLightMethodForSymbol
+                            containingMethod = this@SymbolLightMethod
                        )
                    )
                }
            }
            if ((functionSymbol as? KtFunctionSymbol)?.isSuspend == true) {
                builder.addParameter(
-                    FirLightSuspendContinuationParameter(
+                    SymbolLightSuspendContinuationParameter(
                        functionSymbol = functionSymbol,
-                        containingMethod = this@FirLightMethodForSymbol
+                        containingMethod = this@SymbolLightMethod
                    )
                )
            }
@@ -62,7 +62,7 @@ internal abstract class FirLightMethodForSymbol(
    }

    private val _identifier: PsiIdentifier by lazyPub {
-        FirLightIdentifier(this, functionSymbol)
+        SymbolLightIdentifier(this, functionSymbol)
    }

    override fun getNameIdentifier(): PsiIdentifier = _identifier
@@ -25,19 +25,19 @@ import org.jetbrains.kotlin.asJava.elements.KtLightMethod
 import org.jetbrains.kotlin.asJava.mangleInternalName
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
-import org.jetbrains.kotlin.light.classes.symbol.FirLightMemberImpl
+import org.jetbrains.kotlin.light.classes.symbol.SymbolLightMemberBase
 import org.jetbrains.kotlin.light.classes.symbol.annotations.getJvmNameFromAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasPublishedApiAnnotation
-import org.jetbrains.kotlin.light.classes.symbol.classes.FirLightClassBase
+import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassBase
 import org.jetbrains.kotlin.light.classes.symbol.tryGetEffectiveVisibility
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue

 context(KtAnalysisSession)
-internal abstract class FirLightMethod(
+internal abstract class SymbolLightMethodBase(
    lightMemberOrigin: LightMemberOrigin?,
    containingClass: KtLightClass,
    private val methodIndex: Int
-) : FirLightMemberImpl<PsiMethod>(lightMemberOrigin, containingClass), KtLightMethod {
+) : SymbolLightMemberBase<PsiMethod>(lightMemberOrigin, containingClass), KtLightMethod {

    override fun getBody(): PsiCodeBlock? = null

@@ -92,7 +92,7 @@ internal abstract class FirLightMethod(

    protected fun <T> T.computeJvmMethodName(
        defaultName: String,
-        containingClass: FirLightClassBase,
+        containingClass: SymbolLightClassBase,
        annotationUseSiteTarget: AnnotationUseSiteTarget? = null
    ): String where T : KtAnnotatedSymbol, T : KtSymbolWithVisibility, T : KtCallableSymbol {
        getJvmNameFromAnnotation(annotationUseSiteTarget)?.let { return it }
@@ -9,18 +9,18 @@ import com.intellij.psi.*
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin
 import org.jetbrains.kotlin.asJava.classes.lazyPub
-import org.jetbrains.kotlin.light.classes.symbol.FirLightIdentifier
-import org.jetbrains.kotlin.light.classes.symbol.classes.FirLightClassBase
-import org.jetbrains.kotlin.light.classes.symbol.modifierLists.FirLightMemberModifierList
-import org.jetbrains.kotlin.light.classes.symbol.parameters.FirLightParameterList
+import org.jetbrains.kotlin.light.classes.symbol.SymbolLightIdentifier
+import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassBase
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightMemberModifierList
+import org.jetbrains.kotlin.light.classes.symbol.parameters.SymbolLightParameterList

 context(KtAnalysisSession)
-internal class FirLightNoArgConstructor(
+internal class SymbolLightNoArgConstructor(
    lightMemberOrigin: LightMemberOrigin?,
-    containingClass: FirLightClassBase,
+    containingClass: SymbolLightClassBase,
    visibility: String,
    methodIndex: Int,
-) : FirLightMethod(lightMemberOrigin, containingClass, methodIndex) {
+) : SymbolLightMethodBase(lightMemberOrigin, containingClass, methodIndex) {
    private val _name: String? = containingClass.name

    override fun getName(): String = _name ?: ""
@@ -32,7 +32,7 @@ internal class FirLightNoArgConstructor(
    override fun getTypeParameters(): Array<PsiTypeParameter> = PsiTypeParameter.EMPTY_ARRAY

    private val _identifier: PsiIdentifier by lazyPub {
-        FirLightIdentifier(this, firSymbol = null)
+        SymbolLightIdentifier(this, ktSymbol = null)
    }

    override fun getNameIdentifier(): PsiIdentifier = _identifier
@@ -44,13 +44,13 @@ internal class FirLightNoArgConstructor(
    }

    private val _modifierList: PsiModifierList by lazyPub {
-        FirLightMemberModifierList(this, _modifiers, emptyList())
+        SymbolLightMemberModifierList(this, _modifiers, emptyList())
    }

    override fun getModifierList(): PsiModifierList = _modifierList

    private val _parameterList: PsiParameterList by lazyPub {
-        FirLightParameterList(this, callableSymbol = null) {}
+        SymbolLightParameterList(this, callableSymbol = null) {}
    }

    override fun getParameterList(): PsiParameterList = _parameterList
@@ -59,7 +59,7 @@ internal class FirLightNoArgConstructor(

    override fun equals(other: Any?): Boolean =
        this === other ||
-                (other is FirLightNoArgConstructor &&
+                (other is SymbolLightNoArgConstructor &&
                        kotlinOrigin == other.kotlinOrigin &&
                        containingClass == other.containingClass)

@@ -15,23 +15,24 @@ import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.light.classes.symbol.*
 import org.jetbrains.kotlin.light.classes.symbol.annotations.*
-import org.jetbrains.kotlin.light.classes.symbol.classes.FirLightClassBase
-import org.jetbrains.kotlin.light.classes.symbol.modifierLists.FirLightMemberModifierList
+import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassBase
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightMemberModifierList
+import org.jetbrains.kotlin.light.classes.symbol.parameters.SymbolLightTypeParameterList
 import org.jetbrains.kotlin.name.JvmNames.STRICTFP_ANNOTATION_CLASS_ID
 import org.jetbrains.kotlin.name.JvmNames.SYNCHRONIZED_ANNOTATION_CLASS_ID
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue
 import java.util.*

 context(KtAnalysisSession)
-internal class FirLightSimpleMethodForSymbol(
+internal class SymbolLightSimpleMethod(
    private val functionSymbol: KtFunctionSymbol,
    lightMemberOrigin: LightMemberOrigin?,
-    containingClass: FirLightClassBase,
+    containingClass: SymbolLightClassBase,
    methodIndex: Int,
    private val isTopLevel: Boolean,
    argumentsSkipMask: BitSet? = null,
    private val suppressStatic: Boolean = false
-) : FirLightMethodForSymbol(
+) : SymbolLightMethod(
    functionSymbol = functionSymbol,
    lightMemberOrigin = lightMemberOrigin,
    containingClass = containingClass,
@@ -47,7 +48,7 @@ internal class FirLightSimpleMethodForSymbol(

    private val _typeParameterList: PsiTypeParameterList? by lazyPub {
        hasTypeParameters().ifTrue {
-            FirLightTypeParameterListForSymbol(
+            SymbolLightTypeParameterList(
                owner = this,
                symbolWithTypeParameterList = functionSymbol,
            )
@@ -131,7 +132,7 @@ internal class FirLightSimpleMethodForSymbol(
    private val _modifierList: PsiModifierList by lazyPub {
        val modifiers = computeModifiers()
        val annotations = computeAnnotations(modifiers.contains(PsiModifier.PRIVATE))
-        FirLightMemberModifierList(this, modifiers, annotations)
+        SymbolLightMemberModifierList(this, modifiers, annotations)
    }

    override fun getModifierList(): PsiModifierList = _modifierList
@@ -155,7 +156,7 @@ internal class FirLightSimpleMethodForSymbol(
                functionSymbol.returnType
        }
        ktType.asPsiType(
-            this@FirLightSimpleMethodForSymbol,
+            this@SymbolLightSimpleMethod,
            KtTypeMappingMode.RETURN_TYPE,
            containingClass.isAnnotationType
        ) ?: nonExistentType()
@@ -164,7 +165,7 @@ internal class FirLightSimpleMethodForSymbol(
    override fun getReturnType(): PsiType = _returnedType

    override fun equals(other: Any?): Boolean =
-        this === other || (other is FirLightSimpleMethodForSymbol && functionSymbol == other.functionSymbol)
+        this === other || (other is SymbolLightSimpleMethod && functionSymbol == other.functionSymbol)

    override fun hashCode(): Int = functionSymbol.hashCode()

@@ -13,11 +13,11 @@ import org.jetbrains.kotlin.asJava.elements.KtLightElementBase
 import org.jetbrains.kotlin.light.classes.symbol.invalidAccess
 import org.jetbrains.kotlin.psi.KtModifierListOwner

-internal class FirLightClassModifierList<T : KtLightElement<KtModifierListOwner, PsiModifierListOwner>>(
+internal class SymbolLightClassModifierList<T : KtLightElement<KtModifierListOwner, PsiModifierListOwner>>(
    containingDeclaration: T,
    private val modifiers: Set<String>,
    private val annotations: List<PsiAnnotation>
-) : FirLightModifierList<T>(containingDeclaration) {
+) : SymbolLightModifierList<T>(containingDeclaration) {
    init {
        annotations.forEach {
            (it as? KtLightElementBase)?.parent = this
@@ -11,14 +11,14 @@ import org.jetbrains.kotlin.asJava.elements.KtLightAbstractAnnotation
 import org.jetbrains.kotlin.asJava.elements.KtLightElementBase
 import org.jetbrains.kotlin.asJava.elements.KtLightMember
 import org.jetbrains.kotlin.light.classes.symbol.invalidAccess
-import org.jetbrains.kotlin.light.classes.symbol.methods.FirLightMethod
+import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightMethodBase
 import org.jetbrains.kotlin.psi.psiUtil.hasBody

-internal class FirLightMemberModifierList<T : KtLightMember<*>>(
+internal class SymbolLightMemberModifierList<T : KtLightMember<*>>(
    containingDeclaration: T,
    private val modifiers: Set<String>,
    private val annotations: List<PsiAnnotation>
-) : FirLightModifierList<T>(containingDeclaration) {
+) : SymbolLightModifierList<T>(containingDeclaration) {
    init {
        annotations.forEach {
            (it as? KtLightElementBase)?.parent = this
@@ -38,7 +38,7 @@ internal class FirLightMemberModifierList<T : KtLightMember<*>>(
    }

    private fun isImplementationInInterface(): Boolean {
-        return owner.containingClass.isInterface && owner is FirLightMethod && owner.kotlinOrigin?.hasBody() == true
+        return owner.containingClass.isInterface && owner is SymbolLightMethodBase && owner.kotlinOrigin?.hasBody() == true
    }

    override fun hasExplicitModifier(name: String): Boolean {
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.asJava.elements.KtLightElementBase
 import org.jetbrains.kotlin.psi.KtModifierList
 import org.jetbrains.kotlin.psi.KtModifierListOwner

-internal abstract class FirLightModifierList<out T : KtLightElement<KtModifierListOwner, PsiModifierListOwner>>(
+internal abstract class SymbolLightModifierList<out T : KtLightElement<KtModifierListOwner, PsiModifierListOwner>>(
    protected val owner: T
 ) : KtLightElementBase(owner), PsiModifierList, KtLightElement<KtModifierList, PsiModifierListOwner> {

@@ -37,7 +37,7 @@ internal abstract class FirLightModifierList<out T : KtLightElement<KtModifierLi
    override fun findAnnotation(qualifiedName: String): PsiAnnotation? = null //TODO()

    override fun isEquivalentTo(another: PsiElement?) =
-        another is FirLightModifierList<*> && owner == another.owner
+        another is SymbolLightModifierList<*> && owner == another.owner

    override fun isWritable() = false

@@ -14,15 +14,15 @@ import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.light.classes.symbol.NullabilityType
 import org.jetbrains.kotlin.light.classes.symbol.annotations.computeAnnotations
-import org.jetbrains.kotlin.light.classes.symbol.methods.FirLightMethod
-import org.jetbrains.kotlin.light.classes.symbol.modifierLists.FirLightClassModifierList
+import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightMethodBase
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightClassModifierList
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue

 context(KtAnalysisSession)
-internal class FirLightParameterForSymbol(
+internal class SymbolLightParameter(
    private val parameterSymbol: KtValueParameterSymbol,
-    containingMethod: FirLightMethod
-) : FirLightParameterBaseForSymbol(parameterSymbol, containingMethod) {
+    containingMethod: SymbolLightMethodBase
+) : SymbolLightParameterCommon(parameterSymbol, containingMethod) {

    private val isConstructorParameterSymbol = containingMethod.isConstructor

@@ -44,14 +44,14 @@ internal class FirLightParameterForSymbol(

    override fun getModifierList(): PsiModifierList = _modifierList
    private val _modifierList: PsiModifierList by lazyPub {
-        FirLightClassModifierList(this, emptySet(), _annotations)
+        SymbolLightClassModifierList(this, emptySet(), _annotations)
    }

    override fun isVarArgs() = parameterSymbol.isVararg

    override fun equals(other: Any?): Boolean =
        this === other ||
-                (other is FirLightParameterForSymbol && parameterSymbol == other.parameterSymbol)
+                (other is SymbolLightParameter && parameterSymbol == other.parameterSymbol)

    override fun hashCode(): Int = kotlinOrigin.hashCode()

@@ -13,10 +13,10 @@ import com.intellij.util.IncorrectOperationException
 import org.jetbrains.kotlin.asJava.elements.*
 import org.jetbrains.kotlin.light.classes.symbol.basicIsEquivalentTo
 import org.jetbrains.kotlin.light.classes.symbol.invalidAccess
-import org.jetbrains.kotlin.light.classes.symbol.methods.FirLightMethod
+import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightMethodBase
 import org.jetbrains.kotlin.psi.KtParameter

-internal abstract class FirLightParameter(containingDeclaration: FirLightMethod) : PsiVariable, NavigationItem,
+internal abstract class SymbolLightParameterBase(containingDeclaration: SymbolLightMethodBase) : PsiVariable, NavigationItem,
    KtLightElement<KtParameter, PsiParameter>, KtLightParameter, KtLightElementBase(containingDeclaration) {

    override val givenAnnotations: List<KtLightAbstractAnnotation>
@@ -49,7 +49,7 @@ internal abstract class FirLightParameter(containingDeclaration: FirLightMethod)
        }
    }

-    override fun toString(): String = "Fir Light Parameter $name"
+    override fun toString(): String = "${this::class.simpleName}:$name"

    override fun isEquivalentTo(another: PsiElement?): Boolean =
        basicIsEquivalentTo(this, another as? PsiParameter)
@@ -10,18 +10,18 @@ import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
 import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode
 import org.jetbrains.kotlin.asJava.classes.lazyPub
-import org.jetbrains.kotlin.light.classes.symbol.FirLightIdentifier
 import org.jetbrains.kotlin.light.classes.symbol.NullabilityType
+import org.jetbrains.kotlin.light.classes.symbol.SymbolLightIdentifier
 import org.jetbrains.kotlin.light.classes.symbol.getTypeNullability
-import org.jetbrains.kotlin.light.classes.symbol.methods.FirLightMethod
+import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightMethodBase
 import org.jetbrains.kotlin.light.classes.symbol.nonExistentType
 import org.jetbrains.kotlin.psi.KtParameter

 context(KtAnalysisSession)
-internal abstract class FirLightParameterBaseForSymbol(
+internal abstract class SymbolLightParameterCommon(
    private val parameterSymbol: KtValueParameterSymbol,
-    private val containingMethod: FirLightMethod
-) : FirLightParameter(containingMethod) {
+    private val containingMethod: SymbolLightMethodBase
+) : SymbolLightParameterBase(containingMethod) {
    private val _name: String = parameterSymbol.name.asString()
    override fun getName(): String = _name

@@ -33,7 +33,7 @@ internal abstract class FirLightParameterBaseForSymbol(
    abstract override fun getModifierList(): PsiModifierList

    private val _identifier: PsiIdentifier by lazyPub {
-        FirLightIdentifier(this, parameterSymbol)
+        SymbolLightIdentifier(this, parameterSymbol)
    }

    protected val nullabilityType: NullabilityType
@@ -56,7 +56,7 @@ internal abstract class FirLightParameterBaseForSymbol(
                // TODO: methods with declaration site wildcards?
                else -> KtTypeMappingMode.VALUE_PARAMETER
            }
-            ktType.asPsiType(this@FirLightParameterBaseForSymbol, typeMappingMode)
+            ktType.asPsiType(this@SymbolLightParameterCommon, typeMappingMode)
        } ?: nonExistentType()
        if (parameterSymbol.isVararg) {
            PsiEllipsisType(convertedType, convertedType.annotationProvider)
@@ -18,32 +18,32 @@ import org.jetbrains.kotlin.analysis.api.symbols.markers.KtNamedSymbol
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.codegen.AsmUtil
-import org.jetbrains.kotlin.light.classes.symbol.annotations.FirLightAnnotationForAnnotationCall
-import org.jetbrains.kotlin.light.classes.symbol.methods.FirLightMethod
-import org.jetbrains.kotlin.light.classes.symbol.modifierLists.FirLightClassModifierList
+import org.jetbrains.kotlin.light.classes.symbol.annotations.SymbolLightAnnotationForAnnotationCall
+import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightMethodBase
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightClassModifierList
 import org.jetbrains.kotlin.light.classes.symbol.nonExistentType
 import org.jetbrains.kotlin.psi.KtParameter

 context(KtAnalysisSession)
-internal class FirLightParameterForReceiver private constructor(
+internal class SymbolLightParameterForReceiver private constructor(
    private val receiverType: KtType,
    private val context: KtSymbol,
    methodName: String,
-    method: FirLightMethod
-) : FirLightParameter(method) {
+    method: SymbolLightMethodBase
+) : SymbolLightParameterBase(method) {

    companion object {
        context (KtAnalysisSession)
        fun tryGet(
            callableSymbol: KtCallableSymbol,
-            method: FirLightMethod
-        ): FirLightParameterForReceiver? {
+            method: SymbolLightMethodBase
+        ): SymbolLightParameterForReceiver? {
            if (callableSymbol !is KtNamedSymbol) return null

            if (!callableSymbol.isExtension) return null
            val extensionTypeAndAnnotations = callableSymbol.receiverType ?: return null

-            return FirLightParameterForReceiver(
+            return SymbolLightParameterForReceiver(
                receiverType = extensionTypeAndAnnotations,
                context = callableSymbol,
                methodName = callableSymbol.name.asString(),
@@ -67,24 +67,24 @@ internal class FirLightParameterForReceiver private constructor(

    private val _annotations: List<PsiAnnotation> by lazyPub {
        receiverType.annotations.map {
-            FirLightAnnotationForAnnotationCall(it, this)
+            SymbolLightAnnotationForAnnotationCall(it, this)
        }
    }

    override fun getModifierList(): PsiModifierList = _modifierList
    private val _modifierList: PsiModifierList by lazyPub {
-        FirLightClassModifierList(this, emptySet(), _annotations)
+        SymbolLightClassModifierList(this, emptySet(), _annotations)
    }

    private val _type: PsiType by lazyPub {
-        receiverType.asPsiType(this@FirLightParameterForReceiver) ?: nonExistentType()
+        receiverType.asPsiType(this@SymbolLightParameterForReceiver) ?: nonExistentType()
    }

    override fun getType(): PsiType = _type

    override fun equals(other: Any?): Boolean =
        this === other ||
-                (other is FirLightParameterForReceiver &&
+                (other is SymbolLightParameterForReceiver &&
                        receiverType == other.receiverType)

    override fun hashCode(): Int = kotlinOrigin.hashCode()
@@ -13,17 +13,17 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.KtLightElement
 import org.jetbrains.kotlin.asJava.elements.KtLightElementBase
-import org.jetbrains.kotlin.light.classes.symbol.methods.FirLightMethod
+import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightMethodBase
 import org.jetbrains.kotlin.psi.KtFunction
 import org.jetbrains.kotlin.psi.KtParameterList

 context(KtAnalysisSession)
-internal class FirLightParameterList(
-    private val parent: FirLightMethod,
+internal class SymbolLightParameterList(
+    private val parent: SymbolLightMethodBase,
    private val callableSymbol: KtCallableSymbol?,
    parameterPopulator: (LightParameterListBuilder) -> Unit,
 ) : KtLightElement<KtParameterList, PsiParameterList>,
-    // With this, a parent chain is properly built: from FirLightParameter through FirLightParameterList to FirLightMethod
+    // With this, a parent chain is properly built: from SymbolLightParameter through SymbolLightParameterList to SymbolLightMethod
    KtLightElementBase(parent),
    // NB: we can't use delegation here, which will conflict getTextRange from KtLightElementBase
    PsiParameterList {
@@ -35,7 +35,7 @@ internal class FirLightParameterList(
        val builder = LightParameterListBuilder(manager, language)

        callableSymbol?.let {
-            FirLightParameterForReceiver.tryGet(it, parent)?.let { receiver ->
+            SymbolLightParameterForReceiver.tryGet(it, parent)?.let { receiver ->
                builder.addParameter(receiver)
            }
        }
@@ -15,15 +15,15 @@ import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.light.classes.symbol.NullabilityType
 import org.jetbrains.kotlin.light.classes.symbol.annotations.computeAnnotations
-import org.jetbrains.kotlin.light.classes.symbol.methods.FirLightMethod
-import org.jetbrains.kotlin.light.classes.symbol.modifierLists.FirLightClassModifierList
+import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightMethodBase
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightClassModifierList

 context(KtAnalysisSession)
-internal class FirLightSetterParameterForSymbol(
+internal class SymbolLightSetterParameter(
    private val containingPropertySymbol: KtPropertySymbol,
    private val parameterSymbol: KtValueParameterSymbol,
-    containingMethod: FirLightMethod
-) : FirLightParameterBaseForSymbol(parameterSymbol, containingMethod) {
+    containingMethod: SymbolLightMethodBase
+) : SymbolLightParameterCommon(parameterSymbol, containingMethod) {

    private val _annotations: List<PsiAnnotation> by lazyPub {
        val annotationsFromSetter = parameterSymbol.computeAnnotations(
@@ -44,14 +44,14 @@ internal class FirLightSetterParameterForSymbol(

    override fun getModifierList(): PsiModifierList = _modifierList
    private val _modifierList: PsiModifierList by lazyPub {
-        FirLightClassModifierList(this, emptySet(), _annotations)
+        SymbolLightClassModifierList(this, emptySet(), _annotations)
    }

    override fun isVarArgs() = false

    override fun equals(other: Any?): Boolean =
        this === other ||
-                (other is FirLightSetterParameterForSymbol && parameterSymbol == other.parameterSymbol)
+                (other is SymbolLightSetterParameter && parameterSymbol == other.parameterSymbol)

    override fun hashCode(): Int = kotlinOrigin.hashCode()

@@ -16,25 +16,25 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.isPrivateOrPrivateToThis
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.codegen.coroutines.SUSPEND_FUNCTION_COMPLETION_PARAMETER_NAME
-import org.jetbrains.kotlin.light.classes.symbol.FirLightIdentifier
-import org.jetbrains.kotlin.light.classes.symbol.annotations.FirLightSimpleAnnotation
-import org.jetbrains.kotlin.light.classes.symbol.methods.FirLightMethod
-import org.jetbrains.kotlin.light.classes.symbol.modifierLists.FirLightClassModifierList
+import org.jetbrains.kotlin.light.classes.symbol.SymbolLightIdentifier
+import org.jetbrains.kotlin.light.classes.symbol.annotations.SymbolLightSimpleAnnotation
+import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightMethodBase
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightClassModifierList
 import org.jetbrains.kotlin.light.classes.symbol.nonExistentType
 import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.psi.KtParameter

 context(KtAnalysisSession)
-internal class FirLightSuspendContinuationParameter(
+internal class SymbolLightSuspendContinuationParameter(
    private val functionSymbol: KtFunctionSymbol,
-    private val containingMethod: FirLightMethod,
-) : FirLightParameter(containingMethod) {
+    private val containingMethod: SymbolLightMethodBase,
+) : SymbolLightParameterBase(containingMethod) {
    override fun getName(): String = SUSPEND_FUNCTION_COMPLETION_PARAMETER_NAME

    override fun getNameIdentifier(): PsiIdentifier = _identifier

    private val _identifier: PsiIdentifier by lazyPub {
-        FirLightIdentifier(this, functionSymbol)
+        SymbolLightIdentifier(this, functionSymbol)
    }

    override fun getType(): PsiType = _type
@@ -53,9 +53,9 @@ internal class FirLightSuspendContinuationParameter(
        val annotations =
            if (functionSymbol.visibility.isPrivateOrPrivateToThis()) emptyList() else
                listOf(
-                    FirLightSimpleAnnotation(NotNull::class.java.name, this@FirLightSuspendContinuationParameter)
+                    SymbolLightSimpleAnnotation(NotNull::class.java.name, this@SymbolLightSuspendContinuationParameter)
                )
-        FirLightClassModifierList(this, emptySet(), annotations)
+        SymbolLightClassModifierList(this, emptySet(), annotations)
    }

    override fun hasModifierProperty(p0: String): Boolean = false
@@ -64,7 +64,7 @@ internal class FirLightSuspendContinuationParameter(

    override fun equals(other: Any?): Boolean =
        this === other ||
-                (other is FirLightSuspendContinuationParameter && functionSymbol == other.functionSymbol)
+                (other is SymbolLightSuspendContinuationParameter && functionSymbol == other.functionSymbol)

    override fun hashCode(): Int = functionSymbol.hashCode() * 31 + containingMethod.hashCode()

@@ -24,7 +24,6 @@ import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.KtLightAbstractAnnotation
 import org.jetbrains.kotlin.asJava.elements.KtLightDeclaration
 import org.jetbrains.kotlin.idea.KotlinLanguage
-import org.jetbrains.kotlin.light.classes.symbol.FirLightTypeParameterListForSymbol
 import org.jetbrains.kotlin.light.classes.symbol.basicIsEquivalentTo
 import org.jetbrains.kotlin.light.classes.symbol.invalidAccess
 import org.jetbrains.kotlin.light.classes.symbol.mapSuperType
@@ -33,8 +32,8 @@ import org.jetbrains.kotlin.psi.KtTypeParameter
 import org.jetbrains.kotlin.psi.psiUtil.startOffset

 context(KtAnalysisSession)
-internal class FirLightTypeParameter(
-    private val parent: FirLightTypeParameterListForSymbol,
+internal class SymbolLightTypeParameter(
+    private val parent: SymbolLightTypeParameterList,
    private val index: Int,
    private val typeParameterSymbol: KtTypeParameterSymbol
 ) : LightElement(parent.manager, KotlinLanguage.INSTANCE), PsiTypeParameter,
@@ -45,7 +44,7 @@ internal class FirLightTypeParameter(
    override val kotlinOrigin: KtTypeParameter? = typeParameterSymbol.psi as? KtTypeParameter

    override fun copy(): PsiElement =
-        FirLightTypeParameter(parent, index, typeParameterSymbol)
+        SymbolLightTypeParameter(parent, index, typeParameterSymbol)

    override fun accept(visitor: PsiElementVisitor) {
        if (visitor is JavaElementVisitor) {
@@ -72,7 +71,7 @@ internal class FirLightTypeParameter(
                }
            }
            .mapNotNull {
-                mapSuperType(it, this@FirLightTypeParameter, kotlinCollectionAsIs = true)
+                mapSuperType(it, this@SymbolLightTypeParameter, kotlinCollectionAsIs = true)
            }
            .forEach { listBuilder.addReference(it) }

@@ -142,7 +141,7 @@ internal class FirLightTypeParameter(
    override fun getIndex(): Int = index
    override fun getApplicableAnnotations(): Array<PsiAnnotation> = PsiAnnotation.EMPTY_ARRAY //TODO

-    override fun toString(): String = "FirLightTypeParameter:$name"
+    override fun toString(): String = "SymbolLightTypeParameter:$name"

    override fun getNavigationElement(): PsiElement =
        kotlinOrigin ?: parent.navigationElement
@@ -154,7 +153,7 @@ internal class FirLightTypeParameter(

    override fun equals(other: Any?): Boolean =
        this === other ||
-                (other is FirLightTypeParameter && index == other.index && typeParameterSymbol == other.typeParameterSymbol)
+                (other is SymbolLightTypeParameter && index == other.index && typeParameterSymbol == other.typeParameterSymbol)

    override fun hashCode(): Int = typeParameterSymbol.hashCode() + index

@@ -3,7 +3,7 @@
 * 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.light.classes.symbol
+package org.jetbrains.kotlin.light.classes.symbol.parameters

 import com.intellij.psi.*
 import com.intellij.psi.impl.light.LightElement
@@ -12,10 +12,10 @@ import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithTypeParameters
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.idea.KotlinLanguage
-import org.jetbrains.kotlin.light.classes.symbol.parameters.FirLightTypeParameter
+import org.jetbrains.kotlin.light.classes.symbol.basicIsEquivalentTo

 context(KtAnalysisSession)
-internal class FirLightTypeParameterListForSymbol(
+internal class SymbolLightTypeParameterList(
    internal val owner: PsiTypeParameterListOwner,
    private val symbolWithTypeParameterList: KtSymbolWithTypeParameters,
 ) : LightElement(owner.manager, KotlinLanguage.INSTANCE), PsiTypeParameterList {
@@ -39,8 +39,8 @@ internal class FirLightTypeParameterListForSymbol(

    private val _typeParameters: Array<PsiTypeParameter> by lazyPub {
        symbolWithTypeParameterList.typeParameters.mapIndexed { index, parameter ->
-            FirLightTypeParameter(
-                parent = this@FirLightTypeParameterListForSymbol,
+            SymbolLightTypeParameter(
+                parent = this@SymbolLightTypeParameterList,
                index = index,
                typeParameterSymbol = parameter
            )
@@ -52,11 +52,11 @@ internal class FirLightTypeParameterListForSymbol(
    override fun getTypeParameterIndex(typeParameter: PsiTypeParameter?): Int =
        _typeParameters.indexOf(typeParameter)

-    override fun toString(): String = "FirLightTypeParameterList"
+    override fun toString(): String = "SymbolLightTypeParameterList"

    override fun equals(other: Any?): Boolean =
        this === other ||
-                (other is FirLightTypeParameterListForSymbol && symbolWithTypeParameterList == other.symbolWithTypeParameterList)
+                (other is SymbolLightTypeParameterList && symbolWithTypeParameterList == other.symbolWithTypeParameterList)

    override fun hashCode(): Int = symbolWithTypeParameterList.hashCode()

@@ -25,16 +25,16 @@ import org.jetbrains.kotlin.asJava.elements.psiType
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.light.classes.symbol.annotations.FirLightSimpleAnnotation
-import org.jetbrains.kotlin.light.classes.symbol.annotations.FirPsiArrayInitializerMemberValue
-import org.jetbrains.kotlin.light.classes.symbol.annotations.FirPsiExpression
-import org.jetbrains.kotlin.light.classes.symbol.annotations.FirPsiLiteral
+import org.jetbrains.kotlin.light.classes.symbol.annotations.SymbolLightSimpleAnnotation
+import org.jetbrains.kotlin.light.classes.symbol.annotations.SymbolPsiArrayInitializerMemberValue
+import org.jetbrains.kotlin.light.classes.symbol.annotations.SymbolPsiExpression
+import org.jetbrains.kotlin.light.classes.symbol.annotations.SymbolPsiLiteral
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.SpecialNames
 import java.util.*

 internal fun <L : Any> L.invalidAccess(): Nothing =
-    error("Cls delegate shouldn't be accessed for fir light classes! Qualified name: ${javaClass.name}")
+    error("Cls delegate shouldn't be accessed for symbol light classes! Qualified name: ${javaClass.name}")


 internal fun KtAnalysisSession.mapSuperType(
@@ -200,12 +200,12 @@ private fun escapeString(str: String): String = buildString {
 internal fun KtAnnotationValue.toAnnotationMemberValue(parent: PsiElement): PsiAnnotationMemberValue? {
    return when (this) {
        is KtArrayAnnotationValue ->
-            FirPsiArrayInitializerMemberValue(sourcePsi, parent) { arrayLiteralParent ->
+            SymbolPsiArrayInitializerMemberValue(sourcePsi, parent) { arrayLiteralParent ->
                values.mapNotNull { element -> element.toAnnotationMemberValue(arrayLiteralParent) }
            }

        is KtAnnotationApplicationValue ->
-            FirLightSimpleAnnotation(
+            SymbolLightSimpleAnnotation(
                annotationValue.classId?.relativeClassName?.asString(),
                parent,
                annotationValue.arguments,
@@ -215,8 +215,8 @@ internal fun KtAnnotationValue.toAnnotationMemberValue(parent: PsiElement): PsiA
        is KtConstantAnnotationValue -> {
            this.constantValue.createPsiLiteral(parent)?.let {
                when (it) {
-                    is PsiLiteral -> FirPsiLiteral(sourcePsi, parent, it)
-                    else -> FirPsiExpression(sourcePsi, parent, it)
+                    is PsiLiteral -> SymbolPsiLiteral(sourcePsi, parent, it)
+                    else -> SymbolPsiExpression(sourcePsi, parent, it)
                }
            }
        }
@@ -224,7 +224,7 @@ internal fun KtAnnotationValue.toAnnotationMemberValue(parent: PsiElement): PsiA
        is KtEnumEntryAnnotationValue -> {
            val fqName = this.callableId?.asSingleFqName()?.asString() ?: return null
            val psiExpression = PsiElementFactory.getInstance(parent.project).createExpressionFromText(fqName, parent)
-            FirPsiExpression(sourcePsi, parent, psiExpression)
+            SymbolPsiExpression(sourcePsi, parent, psiExpression)
        }

        KtUnsupportedAnnotationValue -> null
@@ -10,8 +10,8 @@ import com.intellij.psi.*
 import junit.framework.TestCase
 import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator
 import org.jetbrains.kotlin.asJava.LightClassTestCommon
-import org.jetbrains.kotlin.light.classes.symbol.modifierLists.FirLightClassModifierList
-import org.jetbrains.kotlin.light.classes.symbol.modifierLists.FirLightMemberModifierList
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightClassModifierList
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightMemberModifierList
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
@@ -106,11 +106,11 @@ abstract class AbstractSymbolLightClassesAnnotationOwnerTest(
            when (lastDeclaration) {
                is PsiClass,
                is PsiParameter ->
-                    TestCase.assertTrue(owner is FirLightClassModifierList<*>)
+                    TestCase.assertTrue(owner is SymbolLightClassModifierList<*>)

                is PsiField,
                is PsiMethod ->
-                    TestCase.assertTrue(owner is FirLightMemberModifierList<*>)
+                    TestCase.assertTrue(owner is SymbolLightMemberModifierList<*>)

                else ->
                    throw IllegalStateException("Unexpected annotation owner kind: ${lastDeclaration::class.java}")