[SLC] support non-psi classes

^KT-54051

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/symbols/pointers/KtPsiBasedSymbolPointer.kt

@@ -97,36 +97,15 @@ public class KtPsiBasedSymbolPointer<S : KtSymbol> private constructor(
 public fun KtElement.symbolPointer(): KtSymbolPointer<KtSymbol> = KtPsiBasedSymbolPointer(this, KtSymbol::class)
 public inline fun <reified S : KtSymbol> KtElement.symbolPointerOfType(): KtSymbolPointer<S> = KtPsiBasedSymbolPointer(this, S::class)
 
-public fun KtFile.symbolPointer(): KtSymbolPointer<KtFileSymbol> = KtPsiBasedSymbolPointer(this, KtFileSymbol::class)
+public fun KtFile.symbolPointer(): KtSymbolPointer<KtFileSymbol> = symbolPointerOfType()
-public fun KtParameter.symbolPointer(): KtSymbolPointer<KtVariableLikeSymbol> = KtPsiBasedSymbolPointer(this, KtVariableLikeSymbol::class)
+public fun KtParameter.symbolPointer(): KtSymbolPointer<KtVariableLikeSymbol> = symbolPointerOfType()
-public fun KtTypeAlias.symbolPointer(): KtSymbolPointer<KtTypeAliasSymbol> = KtPsiBasedSymbolPointer(this, KtTypeAliasSymbol::class)
+public fun KtTypeAlias.symbolPointer(): KtSymbolPointer<KtTypeAliasSymbol> = symbolPointerOfType()
-public fun KtEnumEntry.symbolPointer(): KtSymbolPointer<KtEnumEntrySymbol> = KtPsiBasedSymbolPointer(this, KtEnumEntrySymbol::class)
+public fun KtEnumEntry.symbolPointer(): KtSymbolPointer<KtEnumEntrySymbol> = symbolPointerOfType()
-public fun KtProperty.symbolPointer(): KtSymbolPointer<KtVariableSymbol> = KtPsiBasedSymbolPointer(this, KtVariableSymbol::class)
+public fun KtProperty.symbolPointer(): KtSymbolPointer<KtVariableSymbol> = symbolPointerOfType()
-
+public fun KtNamedFunction.symbolPointer(): KtSymbolPointer<KtFunctionLikeSymbol> = symbolPointerOfType()
-public fun KtNamedFunction.symbolPointer(): KtSymbolPointer<KtFunctionLikeSymbol> {
+public fun KtConstructor<*>.symbolPointer(): KtSymbolPointer<KtConstructorSymbol> = symbolPointerOfType()
-    return KtPsiBasedSymbolPointer(this, KtFunctionLikeSymbol::class)
+public fun KtTypeParameter.symbolPointer(): KtSymbolPointer<KtTypeParameterSymbol> = symbolPointerOfType()
-}
+public fun KtFunctionLiteral.symbolPointer(): KtSymbolPointer<KtAnonymousFunctionSymbol> = symbolPointerOfType()
-
+public fun KtObjectLiteralExpression.symbolPointer(): KtSymbolPointer<KtAnonymousObjectSymbol> = symbolPointerOfType()
-public fun KtConstructor<*>.symbolPointer(): KtSymbolPointer<KtConstructorSymbol> {
+public fun KtPropertyAccessor.symbolPointer(): KtSymbolPointer<KtPropertyAccessorSymbol> = symbolPointerOfType()
-    return KtPsiBasedSymbolPointer(this, KtConstructorSymbol::class)
+public fun KtClassOrObject.symbolPointer(): KtSymbolPointer<KtClassOrObjectSymbol> = symbolPointerOfType()
-}
-
-public fun KtTypeParameter.symbolPointer(): KtSymbolPointer<KtTypeParameterSymbol> {
-    return KtPsiBasedSymbolPointer(this, KtTypeParameterSymbol::class)
-}
-
-public fun KtFunctionLiteral.symbolPointer(): KtSymbolPointer<KtAnonymousFunctionSymbol> {
-    return KtPsiBasedSymbolPointer(this, KtAnonymousFunctionSymbol::class)
-}
-
-public fun KtObjectLiteralExpression.symbolPointer(): KtSymbolPointer<KtAnonymousObjectSymbol> {
-    return KtPsiBasedSymbolPointer(this, KtAnonymousObjectSymbol::class)
-}
-
-public fun KtClassOrObject.symbolPointer(): KtSymbolPointer<KtClassOrObjectSymbol> {
-    return KtPsiBasedSymbolPointer(this, KtClassOrObjectSymbol::class)
-}
-
-public fun KtPropertyAccessor.symbolPointer(): KtSymbolPointer<KtPropertyAccessorSymbol> {
-    return KtPsiBasedSymbolPointer(this, KtPropertyAccessorSymbol::class)
-}

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/SymbolLightAnnotationClass.kt

@@ -5,24 +5,53 @@
 
 package org.jetbrains.kotlin.light.classes.symbol.classes
 
+import com.intellij.psi.PsiManager
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.PsiReferenceList
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.symbols.KtClassKind
 import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.isPrivateOrPrivateToThis
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
+import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.psi.KtClassOrObject
 
-internal class SymbolLightAnnotationClass(
+internal class SymbolLightAnnotationClass : SymbolLightInterfaceOrAnnotationClass {
-    classOrObject: KtClassOrObject,
+    constructor(
-    ktModule: KtModule,
+        ktAnalysisSession: KtAnalysisSession,
-) : SymbolLightInterfaceOrAnnotationClass(classOrObject, ktModule) {
+        ktModule: KtModule,
-    init {
+        classOrObjectSymbol: KtNamedClassOrObjectSymbol,
-        require(isAnnotation)
+        manager: PsiManager
+    ) : super(
+        ktAnalysisSession = ktAnalysisSession,
+        ktModule = ktModule,
+        classOrObjectSymbol = classOrObjectSymbol,
+        manager = manager,
+    ) {
+        require(classOrObjectSymbol.classKind == KtClassKind.ANNOTATION_CLASS)
     }
 
+    constructor(classOrObject: KtClassOrObject, ktModule: KtModule) : super(classOrObject, ktModule) {
+        require(classOrObject is KtClass && classOrObject.isAnnotation())
+    }
+
+    private constructor(
+        classOrObjectDeclaration: KtClassOrObject?,
+        classOrObjectSymbolPointer: KtSymbolPointer<KtNamedClassOrObjectSymbol>,
+        ktModule: KtModule,
+        manager: PsiManager,
+    ) : super(
+        classOrObjectDeclaration = classOrObjectDeclaration,
+        classOrObjectSymbolPointer = classOrObjectSymbolPointer,
+        ktModule = ktModule,
+        manager = manager,
+    )
+
     override fun isAnnotationType(): Boolean = true
 
     private val _ownMethods: List<KtLightMethod> by lazyPub {
@@ -41,5 +70,6 @@ internal class SymbolLightAnnotationClass(
 
     override fun getExtendsList(): PsiReferenceList? = null
 
-    override fun copy(): SymbolLightClassForClassOrObject = SymbolLightAnnotationClass(classOrObject, ktModule)
+    override fun copy(): SymbolLightAnnotationClass =
+        SymbolLightAnnotationClass(classOrObjectDeclaration, classOrObjectSymbolPointer, ktModule, manager)
 }

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/SymbolLightAnonymousClass.kt

@@ -6,7 +6,10 @@
 package org.jetbrains.kotlin.light.classes.symbol.classes
 
 import com.intellij.psi.*
+import org.jetbrains.kotlin.analysis.api.symbols.KtAnonymousObjectSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.symbolPointerOfType
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.asJava.classes.getParentForLocalDeclaration
 import org.jetbrains.kotlin.asJava.classes.lazyPub
@@ -17,8 +20,23 @@ import org.jetbrains.kotlin.light.classes.symbol.annotations.hasJvmFieldAnnotati
 import org.jetbrains.kotlin.light.classes.symbol.fields.SymbolLightField
 import org.jetbrains.kotlin.psi.KtClassOrObject
 
-internal class SymbolLightAnonymousClass(classOrObject: KtClassOrObject, ktModule: KtModule) :
+internal class SymbolLightAnonymousClass : SymbolLightClassForClassOrObject<KtAnonymousObjectSymbol>, PsiAnonymousClass {
-    SymbolLightClassForClassOrObject(classOrObject, ktModule), PsiAnonymousClass {
+    constructor(
+        anonymousObjectDeclaration: KtClassOrObject,
+        ktModule: KtModule,
+    ) : this(
+        classOrObjectDeclaration = anonymousObjectDeclaration,
+        classOrObjectSymbolPointer = anonymousObjectDeclaration.symbolPointerOfType(),
+        ktModule = ktModule,
+        manager = anonymousObjectDeclaration.manager,
+    )
+
+    private constructor(
+        classOrObjectDeclaration: KtClassOrObject?,
+        classOrObjectSymbolPointer: KtSymbolPointer<KtAnonymousObjectSymbol>,
+        ktModule: KtModule,
+        manager: PsiManager,
+    ) : super(classOrObjectDeclaration, classOrObjectSymbolPointer, ktModule, manager)
 
     private val _baseClassType: PsiClassType by lazyPub {
         extendsListTypes.firstOrNull()
@@ -43,8 +61,8 @@ internal class SymbolLightAnonymousClass(classOrObject: KtClassOrObject, ktModul
         }
     }
 
-    override fun getExtendsList(): PsiReferenceList = _extendsList
+    override fun getExtendsList(): PsiReferenceList? = _extendsList
-    override fun getImplementsList(): PsiReferenceList = _implementsList
+    override fun getImplementsList(): PsiReferenceList? = _implementsList
 
     override fun getOwnFields(): List<KtLightField> = _ownFields
     override fun getOwnMethods(): List<PsiMethod> = _ownMethods
@@ -74,7 +92,7 @@ internal class SymbolLightAnonymousClass(classOrObject: KtClassOrObject, ktModul
                         isTopLevel = false,
                         forceStatic = false,
                         takePropertyVisibility = propertySymbol.hasJvmFieldAnnotation(),
-                        result
+                        result,
                     )
                 }
 
@@ -82,7 +100,7 @@ internal class SymbolLightAnonymousClass(classOrObject: KtClassOrObject, ktModul
         }
     }
 
-    override fun getParent(): PsiElement? = kotlinOrigin.let(::getParentForLocalDeclaration)
+    override fun getParent(): PsiElement? = kotlinOrigin?.let(::getParentForLocalDeclaration)
     override fun getArgumentList(): PsiExpressionList? = null
     override fun isInQualifiedNew(): Boolean = false
     override fun getName(): String? = null
@@ -93,5 +111,5 @@ internal class SymbolLightAnonymousClass(classOrObject: KtClassOrObject, ktModul
     override fun getTypeParameters(): Array<PsiTypeParameter> = PsiTypeParameter.EMPTY_ARRAY
     override fun getTypeParameterList(): PsiTypeParameterList? = null
     override fun getQualifiedName(): String? = null
-    override fun copy() = SymbolLightAnonymousClass(classOrObject, ktModule)
+    override fun copy() = SymbolLightAnonymousClass(classOrObjectDeclaration, classOrObjectSymbolPointer, ktModule, manager)
 }

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/SymbolLightClass.kt

@@ -5,13 +5,12 @@
 
 package org.jetbrains.kotlin.light.classes.symbol.classes
 
-import com.intellij.psi.PsiMethod
+import com.intellij.psi.*
-import com.intellij.psi.PsiModifier
-import com.intellij.psi.PsiModifierList
-import com.intellij.psi.PsiReferenceList
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithMembers
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.symbolPointerOfType
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.asJava.builder.LightMemberOriginForDeclaration
 import org.jetbrains.kotlin.asJava.classes.METHOD_INDEX_BASE
@@ -36,7 +35,10 @@ import org.jetbrains.kotlin.light.classes.symbol.toPsiVisibilityForClass
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.StandardClassIds
-import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtEnumEntry
 import org.jetbrains.kotlin.resolve.DataClassResolver
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKind
 import org.jetbrains.kotlin.util.OperatorNameConventions.EQUALS
@@ -44,15 +46,48 @@ import org.jetbrains.kotlin.util.OperatorNameConventions.TO_STRING
 import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.kotlin.utils.addToStdlib.applyIf
 
-internal open class SymbolLightClass(classOrObject: KtClassOrObject, ktModule: KtModule) :
+internal open class SymbolLightClass : SymbolLightClassForNamedClassOrObject {
-    SymbolLightClassForClassOrObject(classOrObject, ktModule) {
+    constructor(
-    init {
+        ktAnalysisSession: KtAnalysisSession,
+        ktModule: KtModule,
+        classOrObjectSymbol: KtNamedClassOrObjectSymbol,
+        manager: PsiManager
+    ) : super(
+        ktAnalysisSession = ktAnalysisSession,
+        ktModule = ktModule,
+        classOrObjectSymbol = classOrObjectSymbol,
+        manager = manager,
+    ) {
+        require(classOrObjectSymbol.classKind != KtClassKind.INTERFACE && classOrObjectSymbol.classKind != KtClassKind.ANNOTATION_CLASS)
+    }
+
+    constructor(
+        classOrObject: KtClassOrObject,
+        ktModule: KtModule,
+    ) : this(
+        classOrObjectDeclaration = classOrObject,
+        classOrObjectSymbolPointer = classOrObject.symbolPointerOfType(),
+        ktModule = ktModule,
+        manager = classOrObject.manager,
+    ) {
         require(classOrObject !is KtClass || !classOrObject.isInterface() && !classOrObject.isAnnotation())
     }
 
+    protected constructor(
+        classOrObjectDeclaration: KtClassOrObject?,
+        classOrObjectSymbolPointer: KtSymbolPointer<KtNamedClassOrObjectSymbol>,
+        ktModule: KtModule,
+        manager: PsiManager,
+    ) : super(
+        classOrObjectDeclaration = classOrObjectDeclaration,
+        classOrObjectSymbolPointer = classOrObjectSymbolPointer,
+        ktModule = ktModule,
+        manager = manager,
+    )
+
     private val _modifierList: PsiModifierList? by lazy {
         val lazyModifiers = lazy {
-            withNamedClassOrObjectSymbol { classOrObjectSymbol ->
+            withClassOrObjectSymbol { classOrObjectSymbol ->
                 buildSet {
                     add(classOrObjectSymbol.toPsiVisibilityForClass(isNested = !isTopLevel))
                     addIfNotNull(classOrObjectSymbol.computeSimpleModality())
@@ -64,7 +99,7 @@ internal open class SymbolLightClass(classOrObject: KtClassOrObject, ktModule: K
         }
 
         val lazyAnnotations = lazyPub {
-            withNamedClassOrObjectSymbol { classOrObjectSymbol ->
+            withClassOrObjectSymbol { classOrObjectSymbol ->
                 classOrObjectSymbol.computeAnnotations(
                     parent = this@SymbolLightClass,
                     nullability = NullabilityType.Unknown,
@@ -95,7 +130,7 @@ internal open class SymbolLightClass(classOrObject: KtClassOrObject, ktModule: K
     }
 
     private val _ownMethods: List<KtLightMethod> by lazyPub {
-        withNamedClassOrObjectSymbol { classOrObjectSymbol ->
+        withClassOrObjectSymbol { classOrObjectSymbol ->
             val result = mutableListOf<KtLightMethod>()
 
             val declaredMemberScope = classOrObjectSymbol.getDeclaredMemberScope()
@@ -138,12 +173,16 @@ internal open class SymbolLightClass(classOrObject: KtClassOrObject, ktModule: K
 
         fun createMethodFromAny(ktFunctionSymbol: KtFunctionSymbol) {
             // Similar to `copy`, synthetic members from `Any` should refer to `data` class as origin, not the function in `Any`.
-            val lightMemberOrigin = LightMemberOriginForDeclaration(classOrObject, JvmDeclarationOriginKind.OTHER)
+            val lightMemberOrigin = classOrObjectDeclaration?.let { LightMemberOriginForDeclaration(it, JvmDeclarationOriginKind.OTHER) }
             result.add(
                 SymbolLightSimpleMethod(
                     ktAnalysisSession = this@ktAnalysisSession,
-                    ktFunctionSymbol, lightMemberOrigin, this, METHOD_INDEX_BASE, false,
+                    ktFunctionSymbol,
-                    suppressStatic = false
+                    lightMemberOrigin,
+                    this,
+                    METHOD_INDEX_BASE,
+                    false,
+                    suppressStatic = false,
                 )
             )
         }
@@ -189,8 +228,8 @@ internal open class SymbolLightClass(classOrObject: KtClassOrObject, ktModule: K
     context(ktAnalysisSession@KtAnalysisSession)
     private fun addDelegatesToInterfaceMethods(result: MutableList<KtLightMethod>, classOrObjectSymbol: KtNamedClassOrObjectSymbol) {
         fun createDelegateMethod(ktFunctionSymbol: KtFunctionSymbol) {
-            val kotlinOrigin = ktFunctionSymbol.psiSafe<KtDeclaration>() ?: classOrObject
+            val kotlinOrigin = ktFunctionSymbol.psiSafe<KtDeclaration>() ?: classOrObjectDeclaration
-            val lightMemberOrigin = LightMemberOriginForDeclaration(kotlinOrigin, JvmDeclarationOriginKind.DELEGATION)
+            val lightMemberOrigin = kotlinOrigin?.let { LightMemberOriginForDeclaration(it, JvmDeclarationOriginKind.DELEGATION) }
             result.add(
                 SymbolLightSimpleMethod(
                     ktAnalysisSession = this@ktAnalysisSession,
@@ -213,18 +252,18 @@ internal open class SymbolLightClass(classOrObject: KtClassOrObject, ktModule: K
     }
 
     private val _ownFields: List<KtLightField> by lazyPub {
-        withNamedClassOrObjectSymbol { classOrObjectSymbol ->
+        withClassOrObjectSymbol { classOrObjectSymbol ->
             val result = mutableListOf<KtLightField>()
 
             // First, add static fields: companion object and fields from companion object
-            addCompanionObjectFieldIfNeeded(result)
+            addCompanionObjectFieldIfNeeded(result, classOrObjectSymbol)
-            addFieldsFromCompanionIfNeeded(result)
+            addFieldsFromCompanionIfNeeded(result, classOrObjectSymbol)
 
             // Then, add instance fields: properties from parameters, and then member properties
             addPropertyBackingFields(result, classOrObjectSymbol)
 
             // Next, add INSTANCE field if non-local named object
-            addInstanceFieldIfNeeded(result)
+            addInstanceFieldIfNeeded(result, classOrObjectSymbol)
 
             // Last, add fields for enum entries
             addFieldsForEnumEntries(result, classOrObjectSymbol)
@@ -271,40 +310,41 @@ internal open class SymbolLightClass(classOrObject: KtClassOrObject, ktModule: K
         propertyGroups[false]?.forEach(::addPropertyBackingField)
     }
 
-    private fun addInstanceFieldIfNeeded(result: MutableList<KtLightField>) {
+    context(ktAnalysisSession@KtAnalysisSession)
-        if (isNamedObject && !isLocal) {
+    private fun addInstanceFieldIfNeeded(result: MutableList<KtLightField>, namedClassOrObjectSymbol: KtNamedClassOrObjectSymbol) {
-            result.add(
+        if (!isNamedObject || isLocal) return
-                SymbolLightFieldForObject(
+
-                    objectDeclaration = classOrObject as KtObjectDeclaration,
+        result.add(
-                    containingClass = this@SymbolLightClass,
+            SymbolLightFieldForObject(
-                    name = JvmAbi.INSTANCE_FIELD,
+                ktAnalysisSession = this@ktAnalysisSession,
-                    lightMemberOrigin = null
+                objectSymbol = namedClassOrObjectSymbol,
-                )
+                containingClass = this,
+                name = JvmAbi.INSTANCE_FIELD,
+                lightMemberOrigin = null,
             )
-        }
+        )
     }
 
-    context(KtAnalysisSession)
+    context(ktAnalysisSession@KtAnalysisSession)
     private fun addFieldsForEnumEntries(result: MutableList<KtLightField>, classOrObjectSymbol: KtNamedClassOrObjectSymbol) {
-        if (isEnum) {
+        if (!isEnum) return
-            classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols()
+
-                .filterIsInstance<KtEnumEntrySymbol>()
+        classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols()
-                .mapNotNullTo(result) {
+            .filterIsInstance<KtEnumEntrySymbol>()
-                    val enumEntry = it.psiSafe<KtEnumEntry>()
+            .mapNotNullTo(result) {
-                    val name = enumEntry?.name ?: return@mapNotNullTo null
+                val enumEntry = it.psiSafe<KtEnumEntry>()
-                    SymbolLightFieldForEnumEntry(
+                val name = enumEntry?.name ?: return@mapNotNullTo null
-                        enumEntry = enumEntry,
+                SymbolLightFieldForEnumEntry(
-                        enumEntryName = name,
+                    enumEntry = enumEntry,
-                        containingClass = this@SymbolLightClass,
+                    enumEntryName = name,
-                        lightMemberOrigin = null,
+                    containingClass = this@SymbolLightClass,
-                    )
+                )
-                }
+            }
-        }
     }
 
     override fun isInterface(): Boolean = false
 
     override fun isAnnotationType(): Boolean = false
 
-    override fun copy(): SymbolLightClass = SymbolLightClass(classOrObject, ktModule)
+    override fun copy(): SymbolLightClass = SymbolLightClass(classOrObjectDeclaration, classOrObjectSymbolPointer, ktModule, manager)
 }

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/SymbolLightClassForClassOrObject.kt

@@ -8,30 +8,24 @@ package org.jetbrains.kotlin.light.classes.symbol.classes
 import com.intellij.psi.*
 import com.intellij.psi.impl.InheritanceImplUtil
 import com.intellij.psi.impl.PsiClassImplUtil
+import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.search.SearchScope
 import com.intellij.psi.stubs.IStubElementType
 import com.intellij.psi.stubs.StubElement
 import org.jetbrains.annotations.NonNls
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.symbols.*
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
-import org.jetbrains.kotlin.analysis.api.symbols.pointers.symbolPointer
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 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.KtLightIdentifier
-import org.jetbrains.kotlin.asJava.elements.KtLightMethod
 import org.jetbrains.kotlin.asJava.toLightClass
-import org.jetbrains.kotlin.light.classes.symbol.analyzeForLightClasses
+import org.jetbrains.kotlin.light.classes.symbol.*
 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.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.light.classes.symbol.withSymbol
 import org.jetbrains.kotlin.load.java.structure.LightClassOriginKind
 import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.psi.KtClassBody
@@ -39,32 +33,76 @@ import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtObjectDeclaration
 import org.jetbrains.kotlin.psi.debugText.getDebugText
 import org.jetbrains.kotlin.psi.stubs.KotlinClassOrObjectStub
-import org.jetbrains.kotlin.utils.addToStdlib.applyIf
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue
-import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
-abstract class SymbolLightClassForClassOrObject(protected val classOrObject: KtClassOrObject, ktModule: KtModule) :
+abstract class SymbolLightClassForClassOrObject<SType : KtClassOrObjectSymbol> protected constructor(
-    SymbolLightClassBase(ktModule, classOrObject.manager),
+    internal val classOrObjectDeclaration: KtClassOrObject?,
+    internal val classOrObjectSymbolPointer: KtSymbolPointer<SType>,
+    ktModule: KtModule,
+    manager: PsiManager,
+) : SymbolLightClassBase(ktModule, manager),
     StubBasedPsiElement<KotlinClassOrObjectStub<out KtClassOrObject>> {
-    private val classOrObjectSymbolPointer: KtSymbolPointer<KtClassOrObjectSymbol> = classOrObject.symbolPointer()
+    constructor(
+        ktAnalysisSession: KtAnalysisSession,
+        ktModule: KtModule,
+        classOrObjectSymbol: SType,
+        manager: PsiManager,
+    ) : this(
+        classOrObjectDeclaration = classOrObjectSymbol.sourcePsiSafe(),
+        classOrObjectSymbolPointer = with(ktAnalysisSession) {
+            @Suppress("UNCHECKED_CAST")
+            classOrObjectSymbol.createPointer() as KtSymbolPointer<SType>
+        },
+        ktModule = ktModule,
+        manager = manager,
+    )
 
-    protected fun <T> withClassOrObjectSymbol(action: KtAnalysisSession.(KtClassOrObjectSymbol) -> T): T {
+    override val kotlinOrigin: KtClassOrObject? get() = classOrObjectDeclaration
-        return classOrObjectSymbolPointer.withSymbol(ktModule, action)
+
+    protected fun <T> withClassOrObjectSymbol(action: KtAnalysisSession.(SType) -> T): T =
+        classOrObjectSymbolPointer.withSymbol(ktModule, action)
+
+    override val isTopLevel: Boolean by lazy {
+        classOrObjectDeclaration?.isTopLevel() ?: withClassOrObjectSymbol { it.symbolKind == KtSymbolKind.TOP_LEVEL }
     }
 
-    protected fun <T> withNamedClassOrObjectSymbol(action: KtAnalysisSession.(KtNamedClassOrObjectSymbol) -> T): T =
+    internal val isCompanionObject: Boolean by lazy {
-        analyzeForLightClasses(ktModule) {
+        classOrObjectDeclaration?.let { it is KtObjectDeclaration && it.isCompanion() } ?: withClassOrObjectSymbol {
-            action(requireNotNull(classOrObject.getNamedClassOrObjectSymbol()))
+            it.classKind == KtClassKind.COMPANION_OBJECT
         }
+    }
 
-    override val isTopLevel: Boolean get() = classOrObject.isTopLevel()
+    internal val isLocal: Boolean by lazy {
-    internal val isCompanionObject: Boolean get() = classOrObject is KtObjectDeclaration && classOrObject.isCompanion()
+        classOrObjectDeclaration?.isLocal ?: withClassOrObjectSymbol { it.symbolKind == KtSymbolKind.LOCAL }
-    internal val isLocal: Boolean get() = classOrObject.isLocal
+    }
-    internal val isNamedObject: Boolean get() = classOrObject is KtObjectDeclaration && !classOrObject.isCompanion()
+
-    internal val isObject: Boolean get() = classOrObject is KtObjectDeclaration
+    internal val isNamedObject: Boolean by lazy {
-    internal val isInterface: Boolean get() = classOrObject is KtClass && classOrObject.isInterface()
+        classOrObjectDeclaration?.let { it is KtObjectDeclaration && !it.isCompanion() } ?: withClassOrObjectSymbol {
-    internal val isAnnotation: Boolean get() = classOrObject is KtClass && classOrObject.isAnnotation()
+            it.classKind == KtClassKind.OBJECT
-    internal val isEnum: Boolean get() = classOrObject is KtClass && classOrObject.isEnum()
+        }
+    }
+
+    internal val isObject: Boolean by lazy {
+        classOrObjectDeclaration?.let { it is KtObjectDeclaration } ?: withClassOrObjectSymbol { it.classKind.isObject }
+    }
+
+    internal val isInterface: Boolean by lazy {
+        classOrObjectDeclaration?.let { it is KtClass && it.isInterface() } ?: withClassOrObjectSymbol {
+            it.classKind == KtClassKind.INTERFACE
+        }
+    }
+
+    internal val isAnnotation: Boolean by lazy {
+        classOrObjectDeclaration?.let { it is KtClass && it.isAnnotation() } ?: withClassOrObjectSymbol {
+            it.classKind == KtClassKind.ANNOTATION_CLASS
+        }
+    }
+
+    internal val isEnum: Boolean by lazy {
+        classOrObjectDeclaration?.let { it is KtClass && it.isEnum() } ?: withClassOrObjectSymbol {
+            it.classKind == KtClassKind.ENUM_CLASS
+        }
+    }
 
     private val _isDeprecated: Boolean by lazy {
         withClassOrObjectSymbol { it.hasDeprecatedAnnotation() }
@@ -77,7 +115,7 @@ abstract class SymbolLightClassForClassOrObject(protected val classOrObject: KtC
     abstract override fun getOwnMethods(): List<PsiMethod>
 
     private val _identifier: PsiIdentifier by lazy {
-        KtLightIdentifier(this, classOrObject)
+        KtLightIdentifier(this, classOrObjectDeclaration)
     }
 
     override fun getNameIdentifier(): PsiIdentifier? = _identifier
@@ -91,96 +129,29 @@ abstract class SymbolLightClassForClassOrObject(protected val classOrObject: KtC
                 owner = this,
                 symbolWithTypeParameterPointer = classOrObjectSymbolPointer,
                 ktModule = ktModule,
-                ktDeclaration = classOrObject,
+                ktDeclaration = classOrObjectDeclaration,
             )
         }
     }
 
-    override fun hasTypeParameters(): Boolean = classOrObject.typeParameters.isNotEmpty()
+    override fun hasTypeParameters(): Boolean = hasTypeParameters(ktModule, classOrObjectDeclaration, classOrObjectSymbolPointer)
 
     override fun getTypeParameterList(): PsiTypeParameterList? = _typeParameterList
     override fun getTypeParameters(): Array<PsiTypeParameter> = _typeParameterList?.typeParameters ?: PsiTypeParameter.EMPTY_ARRAY
 
     private val _ownInnerClasses: List<SymbolLightClassBase> by lazyPub {
         withClassOrObjectSymbol {
-            it.createInnerClasses(this@SymbolLightClassForClassOrObject, classOrObject)
+            it.createInnerClasses(manager, this@SymbolLightClassForClassOrObject, classOrObjectDeclaration)
         }
     }
 
     override fun getOwnInnerClasses(): List<PsiClass> = _ownInnerClasses
 
-    override fun getTextOffset(): Int = classOrObject.textOffset
+    override fun getTextOffset(): Int = classOrObjectDeclaration?.textOffset ?: -1
-    override fun getStartOffsetInParent(): Int = classOrObject.startOffsetInParent
+    override fun getStartOffsetInParent(): Int = classOrObjectDeclaration?.startOffsetInParent ?: -1
     override fun isWritable() = false
-    override val kotlinOrigin: KtClassOrObject = classOrObject
 
-    protected fun addMethodsFromCompanionIfNeeded(
+    override fun getNavigationElement(): PsiElement = classOrObjectDeclaration ?: this
-        result: MutableList<KtLightMethod>,
-    ): Unit = withNamedClassOrObjectSymbol { classOrObjectSymbol ->
-        classOrObjectSymbol.companionObject?.run {
-            val methods = getDeclaredMemberScope().getCallableSymbols()
-                .filterIsInstance<KtFunctionSymbol>()
-                .filter { it.hasJvmStaticAnnotation() }
-
-            createMethods(methods, result)
-
-            val properties = getDeclaredMemberScope().getCallableSymbols().filterIsInstance<KtPropertySymbol>()
-            properties.forEach { property ->
-                createPropertyAccessors(
-                    result,
-                    property,
-                    isTopLevel = false,
-                    onlyJvmStatic = true
-                )
-            }
-        }
-    }
-
-    protected fun addCompanionObjectFieldIfNeeded(result: MutableList<KtLightField>) {
-        classOrObject.companionObjects.forEach {
-            result.add(
-                SymbolLightFieldForObject(
-                    objectDeclaration = it,
-                    containingClass = this@SymbolLightClassForClassOrObject,
-                    name = it.name ?: return@forEach,
-                    lightMemberOrigin = null,
-                )
-            )
-        }
-    }
-
-    protected fun addFieldsFromCompanionIfNeeded(
-        result: MutableList<KtLightField>,
-    ): Unit = withNamedClassOrObjectSymbol { classOrObjectSymbol ->
-        classOrObjectSymbol.companionObject
-            ?.getDeclaredMemberScope()
-            ?.getCallableSymbols()
-            ?.filterIsInstance<KtPropertySymbol>()
-            ?.applyIf(isInterface) {
-                filter { it.isConstOrJvmField }
-            }
-            ?.mapTo(result) {
-                SymbolLightFieldForProperty(
-                    ktAnalysisSession = this,
-                    propertySymbol = it,
-                    fieldName = it.name.asString(),
-                    containingClass = this@SymbolLightClassForClassOrObject,
-                    lightMemberOrigin = null,
-                    isTopLevel = false,
-                    forceStatic = true,
-                    takePropertyVisibility = it.isConstOrJvmField,
-                )
-            }
-
-    }
-
-    private val KtPropertySymbol.isConstOrJvmField: Boolean
-        get() = isConst || hasJvmFieldAnnotation()
-
-    private val KtPropertySymbol.isConst: Boolean
-        get() = (this as? KtKotlinPropertySymbol)?.isConst == true
-
-    override fun getNavigationElement(): PsiElement = classOrObject
 
     override fun isEquivalentTo(another: PsiElement?): Boolean =
         basicIsEquivalentTo(this, another) ||
@@ -188,13 +159,21 @@ abstract class SymbolLightClassForClassOrObject(protected val classOrObject: KtC
 
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
+        if (other !is SymbolLightClassForClassOrObject<*> || other.ktModule != ktModule || other.manager != manager) return false
+        if (classOrObjectDeclaration != null) {
+            return other.classOrObjectDeclaration == classOrObjectDeclaration
+        }
 
-        return other?.safeAs<SymbolLightClassForClassOrObject>()?.classOrObject == classOrObject
+        return other.classOrObjectDeclaration == null && compareSymbolPointers(
+            ktModule,
+            classOrObjectSymbolPointer,
+            other.classOrObjectSymbolPointer,
+        )
     }
 
-    override fun hashCode(): Int = classOrObject.hashCode()
+    override fun hashCode(): Int = classOrObjectDeclaration.hashCode()
 
-    override fun getName(): String? = classOrObject.name
+    override fun getName(): String? = classOrObjectDeclaration?.name
 
     override fun hasModifierProperty(@NonNls name: String): Boolean = modifierList?.hasModifierProperty(name) ?: false
 
@@ -202,17 +181,17 @@ abstract class SymbolLightClassForClassOrObject(protected val classOrObject: KtC
     override fun isAnnotationType(): Boolean = isAnnotation
     override fun isEnum(): Boolean = isEnum
 
-    override fun isValid(): Boolean = classOrObject.isValid
+    override fun isValid(): Boolean = classOrObjectDeclaration?.isValid ?: classOrObjectSymbolPointer.isValid(ktModule)
 
-    override fun toString() = "${this::class.java.simpleName}:${classOrObject.getDebugText()}"
+    override fun toString() = "${this::class.java.simpleName}:${classOrObjectDeclaration?.getDebugText()}"
 
-    override fun getUseScope(): SearchScope = classOrObject.useScope
+    override fun getUseScope(): SearchScope = classOrObjectDeclaration?.useScope ?: GlobalSearchScope.projectScope(project)
-    override fun getElementType(): IStubElementType<out StubElement<*>, *>? = classOrObject.elementType
+    override fun getElementType(): IStubElementType<out StubElement<*>, *>? = classOrObjectDeclaration?.elementType
-    override fun getStub(): KotlinClassOrObjectStub<out KtClassOrObject>? = classOrObject.stub
+    override fun getStub(): KotlinClassOrObjectStub<out KtClassOrObject>? = classOrObjectDeclaration?.stub
 
     override val originKind: LightClassOriginKind get() = LightClassOriginKind.SOURCE
 
-    override fun getQualifiedName() = classOrObject.fqName?.asString()
+    override fun getQualifiedName(): String? = classOrObjectDeclaration?.fqName?.asString()
 
     override fun getInterfaces(): Array<PsiClass> = PsiClassImplUtil.getInterfaces(this)
     override fun getSuperClass(): PsiClass? = PsiClassImplUtil.getSuperClass(this)
@@ -220,7 +199,7 @@ abstract class SymbolLightClassForClassOrObject(protected val classOrObject: KtC
     override fun getSuperTypes(): Array<PsiClassType> = PsiClassImplUtil.getSuperTypes(this)
 
     override fun getContainingClass(): PsiClass? {
-        val containingBody = classOrObject.parent as? KtClassBody
+        val containingBody = classOrObjectDeclaration?.parent as? KtClassBody
         val containingClass = containingBody?.parent as? KtClassOrObject
         containingClass?.let { return it.toLightClass() }
         return null
@@ -228,7 +207,7 @@ abstract class SymbolLightClassForClassOrObject(protected val classOrObject: KtC
 
     override fun getParent(): PsiElement? {
         if (isLocal) {
-            return classOrObject.let(::getParentForLocalDeclaration)
+            return classOrObjectDeclaration?.let(::getParentForLocalDeclaration)
         }
 
         return containingClass ?: containingFile
@@ -239,5 +218,5 @@ abstract class SymbolLightClassForClassOrObject(protected val classOrObject: KtC
     override fun isInheritorDeep(baseClass: PsiClass?, classToByPass: PsiClass?): Boolean =
         baseClass?.let { InheritanceImplUtil.isInheritorDeep(this, it, classToByPass) } ?: false
 
-    abstract override fun copy(): SymbolLightClassForClassOrObject
+    abstract override fun copy(): SymbolLightClassForClassOrObject<*>
 }

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/SymbolLightClassForEnumEntry.kt

@@ -6,6 +6,8 @@
 package org.jetbrains.kotlin.light.classes.symbol.classes
 
 import com.intellij.psi.*
+import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.symbolPointer
 import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.asJava.classes.KotlinSuperTypeListBuilder
@@ -20,7 +22,12 @@ internal class SymbolLightClassForEnumEntry(
     private val enumConstant: SymbolLightFieldForEnumEntry,
     private val enumClass: SymbolLightClass,
     ktModule: KtModule,
-) : SymbolLightClass(enumConstant.kotlinOrigin, ktModule), PsiEnumConstantInitializer {
+) : SymbolLightClass(
+    enumConstant.kotlinOrigin,
+    symbolPointer<KtNamedClassOrObjectSymbol> { null },
+    ktModule,
+    enumClass.manager,
+), PsiEnumConstantInitializer {
     override fun getBaseClassType(): PsiClassType = enumConstant.type as PsiClassType //???TODO
 
     override fun getBaseClassReference(): PsiJavaCodeReferenceElement =
@@ -63,7 +70,7 @@ internal class SymbolLightClassForEnumEntry(
         } ?: return@lazyPub null
 
         KotlinSuperTypeListBuilder(
-            kotlinOrigin = enumClass.kotlinOrigin.getSuperTypeList(),
+            kotlinOrigin = enumClass.kotlinOrigin?.getSuperTypeList(),
             manager = manager,
             language = language,
             role = PsiReferenceList.Role.EXTENDS_LIST

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/SymbolLightClassForInterfaceDefaultImpls.kt

@@ -11,7 +11,12 @@ import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightClassM
 import org.jetbrains.kotlin.load.java.JvmAbi
 
 internal class SymbolLightClassForInterfaceDefaultImpls(private val containingClass: SymbolLightInterfaceClass) :
-    SymbolLightInterfaceClass(containingClass.kotlinOrigin, containingClass.ktModule) {
+    SymbolLightInterfaceClass(
+        containingClass.classOrObjectDeclaration,
+        containingClass.classOrObjectSymbolPointer,
+        containingClass.ktModule,
+        containingClass.manager,
+    ) {
     override fun getQualifiedName(): String? = containingClass.qualifiedName?.let { it + ".${JvmAbi.DEFAULT_IMPLS_CLASS_NAME}" }
 
     override fun getName() = JvmAbi.DEFAULT_IMPLS_CLASS_NAME
@@ -19,6 +24,11 @@ internal class SymbolLightClassForInterfaceDefaultImpls(private val containingCl
 
     override fun copy() = SymbolLightClassForInterfaceDefaultImpls(containingClass)
 
+    override fun equals(other: Any?): Boolean = this === other ||
+            other is SymbolLightClassForInterfaceDefaultImpls && other.containingClass == containingClass
+
+    override fun hashCode(): Int = containingClass.hashCode()
+
     override fun getTypeParameterList(): PsiTypeParameterList? = null
     override fun getTypeParameters(): Array<PsiTypeParameter> = emptyArray()
 

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/SymbolLightClassForNamedClassOrObject.kt

@@ -0,0 +1,122 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * 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.classes
+
+import com.intellij.psi.PsiManager
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtKotlinPropertySymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.project.structure.KtModule
+import org.jetbrains.kotlin.asJava.elements.KtLightField
+import org.jetbrains.kotlin.asJava.elements.KtLightMethod
+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.SymbolLightFieldForObject
+import org.jetbrains.kotlin.light.classes.symbol.fields.SymbolLightFieldForProperty
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.utils.addToStdlib.applyIf
+
+abstract class SymbolLightClassForNamedClassOrObject : SymbolLightClassForClassOrObject<KtNamedClassOrObjectSymbol> {
+    constructor(
+        ktAnalysisSession: KtAnalysisSession,
+        ktModule: KtModule,
+        classOrObjectSymbol: KtNamedClassOrObjectSymbol,
+        manager: PsiManager
+    ) : super(
+        ktAnalysisSession = ktAnalysisSession,
+        ktModule = ktModule,
+        classOrObjectSymbol = classOrObjectSymbol,
+        manager = manager,
+    )
+
+    protected constructor(
+        classOrObjectDeclaration: KtClassOrObject?,
+        classOrObjectSymbolPointer: KtSymbolPointer<KtNamedClassOrObjectSymbol>,
+        ktModule: KtModule,
+        manager: PsiManager,
+    ) : super(
+        classOrObjectDeclaration = classOrObjectDeclaration,
+        classOrObjectSymbolPointer = classOrObjectSymbolPointer,
+        ktModule = ktModule,
+        manager = manager
+    )
+
+    protected fun addMethodsFromCompanionIfNeeded(
+        result: MutableList<KtLightMethod>,
+    ): Unit = withClassOrObjectSymbol { classOrObjectSymbol ->
+        classOrObjectSymbol.companionObject?.run {
+            val methods = getDeclaredMemberScope().getCallableSymbols()
+                .filterIsInstance<KtFunctionSymbol>()
+                .filter { it.hasJvmStaticAnnotation() }
+
+            createMethods(methods, result)
+
+            val properties = getDeclaredMemberScope().getCallableSymbols().filterIsInstance<KtPropertySymbol>()
+            properties.forEach { property ->
+                createPropertyAccessors(
+                    result,
+                    property,
+                    isTopLevel = false,
+                    onlyJvmStatic = true
+                )
+            }
+        }
+    }
+
+    private val KtPropertySymbol.isConstOrJvmField: Boolean
+        get() = isConst || hasJvmFieldAnnotation()
+
+    private val KtPropertySymbol.isConst: Boolean
+        get() = (this as? KtKotlinPropertySymbol)?.isConst == true
+
+    context(ktAnalysisSession@KtAnalysisSession)
+    protected fun addFieldsFromCompanionIfNeeded(
+        result: MutableList<KtLightField>,
+        classOrObjectSymbol: KtNamedClassOrObjectSymbol,
+    ) {
+        classOrObjectSymbol.companionObject
+            ?.getDeclaredMemberScope()
+            ?.getCallableSymbols()
+            ?.filterIsInstance<KtPropertySymbol>()
+            ?.applyIf(isInterface) {
+                filter { it.isConstOrJvmField }
+            }
+            ?.mapTo(result) {
+                SymbolLightFieldForProperty(
+                    ktAnalysisSession = this@ktAnalysisSession,
+                    propertySymbol = it,
+                    fieldName = it.name.asString(),
+                    containingClass = this,
+                    lightMemberOrigin = null,
+                    isTopLevel = false,
+                    forceStatic = true,
+                    takePropertyVisibility = it.isConstOrJvmField,
+                )
+            }
+    }
+
+    context(ktAnalysisSession@KtAnalysisSession)
+    protected fun addCompanionObjectFieldIfNeeded(result: MutableList<KtLightField>, classOrObjectSymbol: KtNamedClassOrObjectSymbol) {
+        val companionObjectSymbols: List<KtNamedClassOrObjectSymbol>? = classOrObjectDeclaration?.companionObjects?.mapNotNull {
+            it.getNamedClassOrObjectSymbol()
+        } ?: classOrObjectSymbol.companionObject?.let(::listOf)
+
+        companionObjectSymbols?.forEach {
+            result.add(
+                SymbolLightFieldForObject(
+                    ktAnalysisSession = this@ktAnalysisSession,
+                    objectSymbol = it,
+                    containingClass = this,
+                    name = it.name.asString(),
+                    lightMemberOrigin = null,
+                )
+            )
+        }
+    }
+}

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/SymbolLightInlineClass.kt

@@ -5,9 +5,13 @@
 
 package org.jetbrains.kotlin.light.classes.symbol.classes
 
+import com.intellij.psi.PsiManager
 import com.intellij.psi.PsiMethod
 import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.symbolPointerOfType
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.KtLightField
@@ -16,11 +20,31 @@ import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.resolve.deprecation.DeprecationLevelValue
 
-internal class SymbolLightInlineClass(classOrObject: KtClassOrObject, ktModule: KtModule) : SymbolLightClass(classOrObject, ktModule) {
+internal class SymbolLightInlineClass : SymbolLightClass {
-    init {
+    constructor(
+        classOrObject: KtClassOrObject,
+        ktModule: KtModule,
+    ) : this(
+        classOrObjectDeclaration = classOrObject,
+        classOrObjectSymbolPointer = classOrObject.symbolPointerOfType(),
+        ktModule = ktModule,
+        manager = classOrObject.manager,
+    ) {
         require(classOrObject.hasModifier(KtTokens.INLINE_KEYWORD))
     }
 
+    private constructor(
+        classOrObjectDeclaration: KtClassOrObject?,
+        classOrObjectSymbolPointer: KtSymbolPointer<KtNamedClassOrObjectSymbol>,
+        ktModule: KtModule,
+        manager: PsiManager,
+    ) : super(
+        classOrObjectDeclaration = classOrObjectDeclaration,
+        classOrObjectSymbolPointer = classOrObjectSymbolPointer,
+        ktModule = ktModule,
+        manager = manager,
+    )
+
     private val _ownMethods: List<KtLightMethod> by lazyPub {
         withClassOrObjectSymbol { classOrObjectSymbol ->
             val result = mutableListOf<KtLightMethod>()
@@ -59,7 +83,7 @@ internal class SymbolLightInlineClass(classOrObject: KtClassOrObject, ktModule:
     }
 
     private val _ownFields: List<KtLightField> by lazyPub {
-        withNamedClassOrObjectSymbol { classOrObjectSymbol ->
+        withClassOrObjectSymbol { classOrObjectSymbol ->
             mutableListOf<KtLightField>().apply {
                 addPropertyBackingFields(this, classOrObjectSymbol)
             }
@@ -70,5 +94,6 @@ internal class SymbolLightInlineClass(classOrObject: KtClassOrObject, ktModule:
 
     override fun getOwnFields(): List<KtLightField> = _ownFields
 
-    override fun copy(): SymbolLightInlineClass = SymbolLightInlineClass(classOrObject, ktModule)
+    override fun copy(): SymbolLightInlineClass =
+        SymbolLightInlineClass(classOrObjectDeclaration, classOrObjectSymbolPointer, ktModule, manager)
 }

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/SymbolLightInterfaceClass.kt

@@ -5,23 +5,52 @@
 
 package org.jetbrains.kotlin.light.classes.symbol.classes
 
+import com.intellij.psi.PsiManager
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.PsiReferenceList
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.symbols.KtClassKind
 import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.isPrivateOrPrivateToThis
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
+import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.psi.KtClassOrObject
 
-internal open class SymbolLightInterfaceClass(
+internal open class SymbolLightInterfaceClass : SymbolLightInterfaceOrAnnotationClass {
-    classOrObject: KtClassOrObject,
+    constructor(
-    ktModule: KtModule,
+        ktAnalysisSession: KtAnalysisSession,
-) : SymbolLightInterfaceOrAnnotationClass(classOrObject, ktModule) {
+        ktModule: KtModule,
-    init {
+        classOrObjectSymbol: KtNamedClassOrObjectSymbol,
-        require(isInterface)
+        manager: PsiManager
+    ) : super(
+        ktAnalysisSession = ktAnalysisSession,
+        ktModule = ktModule,
+        classOrObjectSymbol = classOrObjectSymbol,
+        manager = manager,
+    ) {
+        require(classOrObjectSymbol.classKind == KtClassKind.INTERFACE)
     }
 
+    constructor(classOrObject: KtClassOrObject, ktModule: KtModule) : super(classOrObject, ktModule) {
+        require(classOrObject is KtClass && classOrObject.isInterface())
+    }
+
+    protected constructor(
+        classOrObjectDeclaration: KtClassOrObject?,
+        classOrObjectSymbolPointer: KtSymbolPointer<KtNamedClassOrObjectSymbol>,
+        ktModule: KtModule,
+        manager: PsiManager,
+    ) : super(
+        classOrObjectDeclaration = classOrObjectDeclaration,
+        classOrObjectSymbolPointer = classOrObjectSymbolPointer,
+        ktModule = ktModule,
+        manager = manager,
+    )
+
     private val _ownMethods: List<KtLightMethod> by lazyPub {
         withClassOrObjectSymbol { classOrObjectSymbol ->
             val result = mutableListOf<KtLightMethod>()
@@ -38,7 +67,8 @@ internal open class SymbolLightInterfaceClass(
 
     override fun getOwnMethods(): List<PsiMethod> = _ownMethods
 
-    override fun copy(): SymbolLightClassForClassOrObject = SymbolLightInterfaceClass(classOrObject, ktModule)
+    override fun copy(): SymbolLightInterfaceClass =
+        SymbolLightInterfaceClass(classOrObjectDeclaration, classOrObjectSymbolPointer, ktModule, manager)
 
     private val _extendsList: PsiReferenceList by lazyPub {
         withClassOrObjectSymbol { classOrObjectSymbol ->

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/SymbolLightInterfaceOrAnnotationClass.kt

@@ -5,9 +5,15 @@
 
 package org.jetbrains.kotlin.light.classes.symbol.classes
 
+import com.intellij.psi.PsiManager
 import com.intellij.psi.PsiModifier
 import com.intellij.psi.PsiModifierList
 import com.intellij.psi.PsiReferenceList
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.symbols.KtClassKind
+import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.symbolPointerOfType
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.KtLightField
@@ -15,18 +21,52 @@ 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.SymbolLightClassModifierList
 import org.jetbrains.kotlin.light.classes.symbol.toPsiVisibilityForClass
+import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.psi.KtClassOrObject
 
-internal abstract class SymbolLightInterfaceOrAnnotationClass(classOrObject: KtClassOrObject, ktModule: KtModule) :
+internal abstract class SymbolLightInterfaceOrAnnotationClass : SymbolLightClassForNamedClassOrObject {
-    SymbolLightClassForClassOrObject(classOrObject, ktModule) {
+    constructor(
-
+        ktAnalysisSession: KtAnalysisSession,
-    init {
+        ktModule: KtModule,
-        require(isInterface || isAnnotation)
+        classOrObjectSymbol: KtNamedClassOrObjectSymbol,
+        manager: PsiManager
+    ) : super(
+        ktAnalysisSession = ktAnalysisSession,
+        ktModule = ktModule,
+        classOrObjectSymbol = classOrObjectSymbol,
+        manager = manager,
+    ) {
+        val classKind = classOrObjectSymbol.classKind
+        require(classKind == KtClassKind.INTERFACE || classKind == KtClassKind.ANNOTATION_CLASS)
     }
 
+    constructor(
+        classOrObject: KtClassOrObject,
+        ktModule: KtModule,
+    ) : this(
+        classOrObjectDeclaration = classOrObject,
+        classOrObjectSymbolPointer = classOrObject.symbolPointerOfType(),
+        ktModule = ktModule,
+        manager = classOrObject.manager,
+    ) {
+        require(classOrObject is KtClass && (classOrObject.isInterface() || classOrObject.isAnnotation()))
+    }
+
+    protected constructor(
+        classOrObjectDeclaration: KtClassOrObject?,
+        classOrObjectSymbolPointer: KtSymbolPointer<KtNamedClassOrObjectSymbol>,
+        ktModule: KtModule,
+        manager: PsiManager,
+    ) : super(
+        classOrObjectDeclaration = classOrObjectDeclaration,
+        classOrObjectSymbolPointer = classOrObjectSymbolPointer,
+        ktModule = ktModule,
+        manager = manager,
+    )
+
     private val _modifierList: PsiModifierList? by lazy {
         val lazyModifiers = lazy {
-            withNamedClassOrObjectSymbol { classOrObjectSymbol ->
+            withClassOrObjectSymbol { classOrObjectSymbol ->
                 buildSet {
                     add(classOrObjectSymbol.toPsiVisibilityForClass(isNested = !isTopLevel))
                     add(PsiModifier.ABSTRACT)
@@ -38,7 +78,7 @@ internal abstract class SymbolLightInterfaceOrAnnotationClass(classOrObject: KtC
         }
 
         val lazyAnnotations = lazyPub {
-            withNamedClassOrObjectSymbol { classOrObjectSymbol ->
+            withClassOrObjectSymbol { classOrObjectSymbol ->
                 classOrObjectSymbol.computeAnnotations(
                     parent = this@SymbolLightInterfaceOrAnnotationClass,
                     nullability = NullabilityType.Unknown,
@@ -56,9 +96,11 @@ internal abstract class SymbolLightInterfaceOrAnnotationClass(classOrObject: KtC
     override fun getModifierList(): PsiModifierList? = _modifierList
 
     private val _ownFields: List<KtLightField> by lazyPub {
-        mutableListOf<KtLightField>().also {
+        withClassOrObjectSymbol { classOrObjectSymbol ->
-            addCompanionObjectFieldIfNeeded(it)
+            buildList {
-            addFieldsFromCompanionIfNeeded(it)
+                addCompanionObjectFieldIfNeeded(this, classOrObjectSymbol)
+                addFieldsFromCompanionIfNeeded(this, classOrObjectSymbol)
+            }
         }
     }
 

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/symbolLightClassUtils.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.light.classes.symbol.classes
 
+import com.intellij.psi.PsiManager
 import com.intellij.psi.PsiModifier
 import com.intellij.psi.PsiReferenceList
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
@@ -50,16 +51,44 @@ import java.util.*
 internal fun createSymbolLightClassNoCache(classOrObject: KtClassOrObject, ktModule: KtModule): KtLightClass? = when {
     classOrObject.isObjectLiteral() -> SymbolLightAnonymousClass(classOrObject, ktModule)
     classOrObject is KtEnumEntry -> lightClassForEnumEntry(classOrObject)
-    classOrObject.hasModifier(INLINE_KEYWORD) -> SymbolLightInlineClass(classOrObject, ktModule)
     else -> createLightClassNoCache(classOrObject, ktModule)
 }
 
 internal fun createLightClassNoCache(ktClassOrObject: KtClassOrObject, ktModule: KtModule): SymbolLightClassBase = when {
+    ktClassOrObject.hasModifier(INLINE_KEYWORD) -> SymbolLightInlineClass(ktClassOrObject, ktModule)
     ktClassOrObject is KtClass && ktClassOrObject.isAnnotation() -> SymbolLightAnnotationClass(ktClassOrObject, ktModule)
     ktClassOrObject is KtClass && ktClassOrObject.isInterface() -> SymbolLightInterfaceClass(ktClassOrObject, ktModule)
     else -> SymbolLightClass(ktClassOrObject, ktModule)
 }
 
+context(ktAnalysisSession@KtAnalysisSession)
+internal fun createLightClassNoCache(
+    ktClassOrObjectSymbol: KtNamedClassOrObjectSymbol,
+    ktModule: KtModule,
+    manager: PsiManager,
+): SymbolLightClassBase = when (ktClassOrObjectSymbol.classKind) {
+    KtClassKind.INTERFACE -> SymbolLightInterfaceClass(
+        ktAnalysisSession = this@ktAnalysisSession,
+        ktModule = ktModule,
+        classOrObjectSymbol = ktClassOrObjectSymbol,
+        manager = manager,
+    )
+
+    KtClassKind.ANNOTATION_CLASS -> SymbolLightAnnotationClass(
+        ktAnalysisSession = this@ktAnalysisSession,
+        ktModule = ktModule,
+        classOrObjectSymbol = ktClassOrObjectSymbol,
+        manager = manager,
+    )
+
+    else -> SymbolLightClass(
+        ktAnalysisSession = this@ktAnalysisSession,
+        ktModule = ktModule,
+        classOrObjectSymbol = ktClassOrObjectSymbol,
+        manager = manager,
+    )
+}
+
 private fun lightClassForEnumEntry(ktEnumEntry: KtEnumEntry): KtLightClass? {
     if (ktEnumEntry.body == null) return null
 
@@ -72,7 +101,7 @@ private fun lightClassForEnumEntry(ktEnumEntry: KtEnumEntry): KtLightClass? {
 }
 
 context(ktAnalysisSession@KtAnalysisSession)
-internal fun SymbolLightClassForClassOrObject.createConstructors(
+internal fun SymbolLightClassForClassOrObject<*>.createConstructors(
     declarations: Sequence<KtConstructorSymbol>,
     result: MutableList<KtLightMethod>,
 ) {
@@ -129,26 +158,28 @@ private fun SymbolLightClassBase.shouldGenerateNoArgOverload(
             !primaryConstructor.hasJvmOverloadsAnnotation()
 }
 
-private fun SymbolLightClassForClassOrObject.defaultConstructor(): KtLightMethod {
+private fun SymbolLightClassForClassOrObject<*>.defaultConstructor(): KtLightMethod {
     val classOrObject = kotlinOrigin
     val visibility = when {
-        classOrObject is KtObjectDeclaration || isEnum -> PsiModifier.PRIVATE
+        isObject || isEnum -> PsiModifier.PRIVATE
-        classOrObject.hasModifier(SEALED_KEYWORD) -> PsiModifier.PROTECTED
+        classOrObject?.hasModifier(SEALED_KEYWORD) == true -> PsiModifier.PROTECTED
-        classOrObject is KtEnumEntry -> PsiModifier.PACKAGE_LOCAL
+        this is SymbolLightClassForEnumEntry -> PsiModifier.PACKAGE_LOCAL
         else -> PsiModifier.PUBLIC
     }
 
     return noArgConstructor(visibility, METHOD_INDEX_FOR_DEFAULT_CTOR)
 }
 
-private fun SymbolLightClassForClassOrObject.noArgConstructor(
+private fun SymbolLightClassForClassOrObject<*>.noArgConstructor(
     visibility: String,
     methodIndex: Int,
 ): KtLightMethod = SymbolLightNoArgConstructor(
-    LightMemberOriginForDeclaration(
+    kotlinOrigin?.let {
-        originalElement = kotlinOrigin,
+        LightMemberOriginForDeclaration(
-        originKind = JvmDeclarationOriginKind.OTHER,
+            originalElement = it,
-    ),
+            originKind = JvmDeclarationOriginKind.OTHER,
+        )
+    },
     this,
     visibility,
     methodIndex,
@@ -350,14 +381,17 @@ internal fun SymbolLightClassBase.createField(
 }
 
 context(KtAnalysisSession)
-internal fun SymbolLightClassForClassOrObject.createInheritanceList(forExtendsList: Boolean, superTypes: List<KtType>): PsiReferenceList {
+internal fun SymbolLightClassForClassOrObject<*>.createInheritanceList(
+    forExtendsList: Boolean,
+    superTypes: List<KtType>,
+): PsiReferenceList {
     val role = if (forExtendsList) PsiReferenceList.Role.EXTENDS_LIST else PsiReferenceList.Role.IMPLEMENTS_LIST
 
     val listBuilder = KotlinSuperTypeListBuilder(
-        kotlinOrigin = kotlinOrigin.getSuperTypeList(),
+        kotlinOrigin = kotlinOrigin?.getSuperTypeList(),
         manager = manager,
         language = language,
-        role = role
+        role = role,
     )
 
     fun KtType.needToAddTypeIntoList(): Boolean {
@@ -404,8 +438,9 @@ internal fun SymbolLightClassForClassOrObject.createInheritanceList(forExtendsLi
 
 context(KtAnalysisSession)
 internal fun KtSymbolWithMembers.createInnerClasses(
+    manager: PsiManager,
     containingClass: SymbolLightClassBase,
-    classOrObject: KtClassOrObject
+    classOrObject: KtClassOrObject?
 ): List<SymbolLightClassBase> {
     val result = ArrayList<SymbolLightClassBase>()
 
@@ -414,16 +449,23 @@ internal fun KtSymbolWithMembers.createInnerClasses(
     // we can't prohibit creating light classes with null names either since they can contain members
 
     getDeclaredMemberScope().getClassifierSymbols().filterIsInstance<KtNamedClassOrObjectSymbol>().mapTo(result) {
-        createLightClassNoCache(it.psi(), ktModule = containingClass.ktModule)
+        val classOrObjectDeclaration = it.psiSafe<KtClassOrObject>()
+        if (classOrObjectDeclaration != null) {
+            createLightClassNoCache(classOrObjectDeclaration, containingClass.ktModule)
+        } else {
+            createLightClassNoCache(it, ktModule = containingClass.ktModule, manager)
+        }
     }
 
-    val jvmDefaultMode =
+    val jvmDefaultMode = classOrObject
-        classOrObject.getKtModuleOfTypeSafe<KtSourceModule>()?.languageVersionSettings?.getFlag(JvmAnalysisFlags.jvmDefaultMode)
+        ?.getKtModuleOfTypeSafe<KtSourceModule>()
-            ?: JvmDefaultMode.DEFAULT
+        ?.languageVersionSettings
+        ?.getFlag(JvmAnalysisFlags.jvmDefaultMode)
+        ?: JvmDefaultMode.DEFAULT
 
-    if (classOrObject.hasInterfaceDefaultImpls &&
+    if (containingClass is SymbolLightInterfaceClass &&
-        jvmDefaultMode != JvmDefaultMode.ALL_INCOMPATIBLE &&
+        classOrObject?.hasInterfaceDefaultImpls == true &&
-        containingClass is SymbolLightInterfaceClass
+        jvmDefaultMode != JvmDefaultMode.ALL_INCOMPATIBLE
     ) {
         result.add(SymbolLightClassForInterfaceDefaultImpls(containingClass))
     }

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/SymbolLightFieldForEnumEntry.kt

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.light.classes.symbol.fields
 import com.intellij.psi.*
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 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.descriptors.annotations.AnnotationUseSiteTarget
@@ -26,8 +25,7 @@ internal class SymbolLightFieldForEnumEntry(
     private val enumEntry: KtEnumEntry,
     private val enumEntryName: String,
     containingClass: SymbolLightClass,
-    override val lightMemberOrigin: LightMemberOrigin?,
+) : SymbolLightField(containingClass = containingClass, lightMemberOrigin = null), PsiEnumConstant {
-) : SymbolLightField(containingClass, lightMemberOrigin), PsiEnumConstant {
     internal fun <T> withEnumEntrySymbol(action: KtAnalysisSession.(KtEnumEntrySymbol) -> T): T = analyzeForLightClasses(ktModule) {
         action(enumEntry.getEnumEntrySymbol())
     }

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/SymbolLightFieldForObject.kt

@@ -12,29 +12,40 @@ import com.intellij.psi.PsiType
 import org.jetbrains.annotations.NotNull
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.sourcePsiSafe
 import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin
 import org.jetbrains.kotlin.asJava.classes.lazyPub
-import org.jetbrains.kotlin.light.classes.symbol.analyzeForLightClasses
+import org.jetbrains.kotlin.light.classes.symbol.*
 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.classes.SymbolLightClassForClassOrObject
 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.KtObjectDeclaration
 
-internal class SymbolLightFieldForObject(
+internal class SymbolLightFieldForObject private constructor(
-    private val objectDeclaration: KtObjectDeclaration,
+    containingClass: SymbolLightClassForClassOrObject<*>,
-    containingClass: SymbolLightClassForClassOrObject,
     private val name: String,
     lightMemberOrigin: LightMemberOrigin?,
+    private val objectSymbolPointer: KtSymbolPointer<KtNamedClassOrObjectSymbol>,
+    override val kotlinOrigin: KtObjectDeclaration?,
 ) : SymbolLightField(containingClass, lightMemberOrigin) {
-    private fun <T> withObjectDeclarationSymbol(action: KtAnalysisSession.(KtNamedClassOrObjectSymbol) -> T): T =
+    internal constructor(
-        analyzeForLightClasses(ktModule) {
+        ktAnalysisSession: KtAnalysisSession,
-            action(requireNotNull(objectDeclaration.getNamedClassOrObjectSymbol()))
+        objectSymbol: KtNamedClassOrObjectSymbol,
-        }
+        name: String,
+        lightMemberOrigin: LightMemberOrigin?,
+        containingClass: SymbolLightClassForClassOrObject<*>,
+    ) : this(
+        containingClass = containingClass,
+        name = name,
+        lightMemberOrigin = lightMemberOrigin,
+        kotlinOrigin = objectSymbol.sourcePsiSafe(),
+        objectSymbolPointer = with(ktAnalysisSession) { objectSymbol.createPointer() },
+    )
 
-    override val kotlinOrigin: KtObjectDeclaration = objectDeclaration
+    private fun <T> withObjectDeclarationSymbol(action: KtAnalysisSession.(KtNamedClassOrObjectSymbol) -> T): T =
+        objectSymbolPointer.withSymbol(ktModule, action)
 
     override fun getName(): String = name
 
@@ -73,10 +84,19 @@ internal class SymbolLightFieldForObject(
 
     override fun getInitializer(): PsiExpression? = null //TODO
 
-    override fun equals(other: Any?): Boolean =
+    override fun equals(other: Any?): Boolean {
-        this === other || other is SymbolLightFieldForObject && objectDeclaration == other.objectDeclaration
+        if (this === other) return true
+        if (other !is SymbolLightFieldForObject || other.ktModule != ktModule) return false
+        if (kotlinOrigin != null) {
+            return other.kotlinOrigin == kotlinOrigin
+        }
 
-    override fun hashCode(): Int = objectDeclaration.hashCode()
+        return other.kotlinOrigin == null &&
+                other.containingClass == containingClass &&
+                compareSymbolPointers(ktModule, other.objectSymbolPointer, objectSymbolPointer)
+    }
 
-    override fun isValid(): Boolean = objectDeclaration.isValid
+    override fun hashCode(): Int = kotlinOrigin.hashCode()
+
+    override fun isValid(): Boolean = kotlinOrigin?.isValid ?: objectSymbolPointer.isValid(ktModule)
 }

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/SymbolLightNoArgConstructor.kt

@@ -13,8 +13,8 @@ import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightMember
 import org.jetbrains.kotlin.light.classes.symbol.parameters.SymbolLightParameterList
 
 internal class SymbolLightNoArgConstructor(
-    lightMemberOrigin: LightMemberOrigin,
+    lightMemberOrigin: LightMemberOrigin?,
-    containingClass: SymbolLightClassForClassOrObject,
+    containingClass: SymbolLightClassForClassOrObject<*>,
     private val visibility: String,
     methodIndex: Int,
 ) : SymbolLightMethodBase(lightMemberOrigin, containingClass, methodIndex) {