[SLC] SymbolLightClassForEnumEntry: improve implementation

^KT-54051
^KT-50241

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

@@ -11,6 +11,7 @@ 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.project.structure.KtModule
 import org.jetbrains.kotlin.asJava.builder.LightMemberOriginForDeclaration
 import org.jetbrains.kotlin.asJava.classes.METHOD_INDEX_BASE
@@ -229,8 +230,8 @@ internal open class SymbolLightClass(classOrObject: KtClassOrObject, ktModule: K
     }
 
     context(KtAnalysisSession)
-    protected fun addPropertyBackingFields(result: MutableList<KtLightField>, classOrObjectSymbol: KtNamedClassOrObjectSymbol) {
+    protected fun addPropertyBackingFields(result: MutableList<KtLightField>, symbolWithMembers: KtSymbolWithMembers) {
-        val propertySymbols = classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols()
+        val propertySymbols = symbolWithMembers.getDeclaredMemberScope().getCallableSymbols()
             .filterIsInstance<KtPropertySymbol>()
             .applyIf(isCompanionObject) {
                 // All fields for companion object of classes are generated to the containing class

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

@@ -6,25 +6,21 @@
 package org.jetbrains.kotlin.light.classes.symbol.classes
 
 import com.intellij.psi.*
-import com.intellij.psi.impl.PsiClassImplUtil
 import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.asJava.classes.KotlinSuperTypeListBuilder
 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.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
 
 internal class SymbolLightClassForEnumEntry(
     private val enumConstant: SymbolLightFieldForEnumEntry,
     private val enumClass: SymbolLightClass,
     ktModule: KtModule,
-) : SymbolLightClassBase(ktModule, enumConstant.manager), PsiEnumConstantInitializer {
+) : SymbolLightClass(enumConstant.kotlinOrigin, ktModule), PsiEnumConstantInitializer {
-    override fun getName(): String = enumConstant.name
-
     override fun getBaseClassType(): PsiClassType = enumConstant.type as PsiClassType //???TODO
 
     override fun getBaseClassReference(): PsiJavaCodeReferenceElement =
@@ -36,44 +32,29 @@ internal class SymbolLightClassForEnumEntry(
 
     override fun isInQualifiedNew(): Boolean = false
 
-    override fun equals(other: Any?): Boolean =
+    override fun copy() = SymbolLightClassForEnumEntry(enumConstant, enumClass, ktModule)
-        this === other || other is SymbolLightClassForEnumEntry && this.enumConstant == other.enumConstant
-
-    override fun hashCode(): Int = enumConstant.hashCode()
-
-    override fun copy(): PsiElement = SymbolLightClassForEnumEntry(enumConstant, enumClass, ktModule)
 
     override fun toString(): String = "SymbolLightClassForEnumEntry:$name"
 
-    override fun getNameIdentifier(): PsiIdentifier? = null //TODO
-
     private val _modifierList: PsiModifierList by lazyPub {
         SymbolLightClassModifierList(
             containingDeclaration = this,
-            lazyModifiers = lazyOf(setOf(PsiModifier.PUBLIC, PsiModifier.STATIC, PsiModifier.FINAL)),
+            lazyModifiers = lazyOf(setOf(PsiModifier.STATIC, PsiModifier.FINAL)),
             lazyAnnotations = lazyOf(emptyList())
         )
     }
 
     override fun getModifierList(): PsiModifierList = _modifierList
 
-    override fun hasModifierProperty(name: String): Boolean =
+    override fun hasModifierProperty(name: String): Boolean = name == PsiModifier.STATIC || name == PsiModifier.FINAL
-        name == PsiModifier.PUBLIC || name == PsiModifier.STATIC || name == PsiModifier.FINAL
 
     override fun getContainingClass(): PsiClass = enumClass
 
-    override fun isDeprecated(): Boolean = false
-
     override fun getTypeParameters(): Array<PsiTypeParameter> = emptyArray()
-
     override fun getTypeParameterList(): PsiTypeParameterList? = null
 
     override fun getQualifiedName(): String = "${enumConstant.containingClass.qualifiedName}.${enumConstant.name}"
 
-    override fun isInterface(): Boolean = false
-
-    override fun isAnnotationType(): Boolean = false
-
     override fun isEnum(): Boolean = false
 
     private val _extendsList: PsiReferenceList? by lazyPub {
@@ -92,41 +73,44 @@ internal class SymbolLightClassForEnumEntry(
     }
 
     override fun getExtendsList(): PsiReferenceList? = _extendsList
-
     override fun getImplementsList(): PsiReferenceList? = null
-
     override fun getSuperClass(): PsiClass = enumClass
-
     override fun getInterfaces(): Array<PsiClass> = PsiClass.EMPTY_ARRAY
-
     override fun getSupers(): Array<PsiClass> = arrayOf(enumClass)
 
-    override fun getSuperTypes(): Array<PsiClassType> = PsiClassImplUtil.getSuperTypes(this)
-
     override fun getParent(): PsiElement? = containingClass
 
     override fun getScope(): PsiElement? = parent
 
-    override fun isInheritor(baseClass: PsiClass, checkDeep: Boolean): Boolean = false //TODO
+    private val _ownFields: List<KtLightField> by lazyPub {
+        enumConstant.withEnumEntrySymbol { enumEntrySymbol ->
+            val result = mutableListOf<KtLightField>()
 
-    override fun isInheritorDeep(baseClass: PsiClass?, classToByPass: PsiClass?): Boolean = false //TODO
+            // Then, add instance fields: properties from parameters, and then member properties
+            addPropertyBackingFields(result, enumEntrySymbol)
 
-    override val kotlinOrigin: KtClassOrObject = enumConstant.kotlinOrigin
+            result
-
+        }
-    override val originKind: LightClassOriginKind = LightClassOriginKind.SOURCE
-
-    override fun getOwnFields(): MutableList<PsiField> = mutableListOf()
-
-    override fun getOwnMethods(): MutableList<KtLightMethod> = enumConstant.withEnumEntrySymbol { enumEntrySymbol ->
-        val result = mutableListOf<KtLightMethod>()
-        val declaredMemberScope = enumEntrySymbol.getDeclaredMemberScope()
-
-        createMethods(declaredMemberScope.getCallableSymbols(), result)
-        createConstructors(declaredMemberScope.getConstructors(), result)
-        result
     }
 
-    override fun getOwnInnerClasses(): MutableList<PsiClass> = mutableListOf()
+    override fun getOwnFields(): List<KtLightField> = _ownFields
 
-    override fun isValid(): Boolean = enumConstant.isValid
+    private val _ownMethods: List<KtLightMethod> by lazyPub {
+        enumConstant.withEnumEntrySymbol { enumEntrySymbol ->
+            val result = mutableListOf<KtLightMethod>()
+
+            val declaredMemberScope = enumEntrySymbol.getDeclaredMemberScope()
+            val visibleDeclarations = declaredMemberScope.getCallableSymbols()
+
+            val suppressStatic = isCompanionObject
+            createMethods(visibleDeclarations, result, suppressStatic = suppressStatic)
+
+            createConstructors(declaredMemberScope.getConstructors(), result)
+
+            result
+        }
+    }
+
+    override fun getOwnMethods(): List<KtLightMethod> = _ownMethods
+    override fun getOwnInnerClasses(): MutableList<PsiClass> = mutableListOf()
 }

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesTestBase.kt

@@ -13,7 +13,12 @@ import org.jetbrains.kotlin.analysis.test.framework.services.libraries.CompiledL
 import org.jetbrains.kotlin.analysis.test.framework.services.libraries.CompilerExecutor
 import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator
 import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
+import org.jetbrains.kotlin.asJava.toLightClass
+import org.jetbrains.kotlin.asJava.unwrapped
 import org.jetbrains.kotlin.light.classes.symbol.base.service.NullabilityAnnotationSourceProvider
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtEnumEntry
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.directives.ConfigurationDirectives
@@ -25,6 +30,7 @@ import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
 import org.jetbrains.kotlin.test.services.service
 import org.jetbrains.kotlin.test.utils.FirIdenticalCheckerHelper
+import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import java.io.File
 import java.nio.file.Path
 import kotlin.io.path.exists
@@ -110,9 +116,24 @@ abstract class AbstractSymbolLightClassesTestBase(
     }
 
     protected fun findLightClass(fqname: String, project: Project): PsiClass? {
-        return JavaElementFinder
+        val searchScope = GlobalSearchScope.allScope(project)
-            .getInstance(project)
+        JavaElementFinder.getInstance(project).findClass(fqname, searchScope)?.let { return it }
-            .findClass(fqname, GlobalSearchScope.allScope(project))
+
+        val fqName = FqName(fqname)
+        val parentFqName = fqName.parent().takeUnless(FqName::isRoot) ?: return null
+        val enumClass = JavaElementFinder.getInstance(project).findClass(parentFqName.asString(), searchScope) ?: return null
+        val kotlinEnumClass = enumClass.unwrapped?.safeAs<KtClass>()?.takeIf(KtClass::isEnum) ?: return null
+
+        val enumEntryName = fqName.shortName().asString()
+        enumClass.findInnerClassByName(enumEntryName, false)?.let { return it }
+
+        return kotlinEnumClass.declarations.firstNotNullOfOrNull {
+            if (it is KtEnumEntry && it.name == enumEntryName) {
+                it
+            } else {
+                null
+            }
+        }?.toLightClass()
     }
 
     private fun removeDuplicatedFirJava(testServices: TestServices) {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesForLibraryTestGenerated.java

@@ -120,6 +120,12 @@ public class SymbolLightClassesForLibraryTestGenerated extends AbstractSymbolLig
         runTest("compiler/testData/asJava/lightClasses/DollarsInNameNoPackage.kt");
     }
 
+    @Test
+    @TestMetadata("EnumEntry.kt")
+    public void testEnumEntry() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/EnumEntry.kt");
+    }
+
     @Test
     @TestMetadata("ExtendingInterfaceWithDefaultImpls.kt")
     public void testExtendingInterfaceWithDefaultImpls() throws Exception {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesParentingForLibraryTestGenerated.java

@@ -120,6 +120,12 @@ public class SymbolLightClassesParentingForLibraryTestGenerated extends Abstract
         runTest("compiler/testData/asJava/lightClasses/DollarsInNameNoPackage.kt");
     }
 
+    @Test
+    @TestMetadata("EnumEntry.kt")
+    public void testEnumEntry() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/EnumEntry.kt");
+    }
+
     @Test
     @TestMetadata("ExtendingInterfaceWithDefaultImpls.kt")
     public void testExtendingInterfaceWithDefaultImpls() throws Exception {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesForSourceTestGenerated.java

@@ -120,6 +120,12 @@ public class SymbolLightClassesForSourceTestGenerated extends AbstractSymbolLigh
         runTest("compiler/testData/asJava/lightClasses/DollarsInNameNoPackage.kt");
     }
 
+    @Test
+    @TestMetadata("EnumEntry.kt")
+    public void testEnumEntry() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/EnumEntry.kt");
+    }
+
     @Test
     @TestMetadata("ExtendingInterfaceWithDefaultImpls.kt")
     public void testExtendingInterfaceWithDefaultImpls() throws Exception {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesParentingForSourceTestGenerated.java

@@ -120,6 +120,12 @@ public class SymbolLightClassesParentingForSourceTestGenerated extends AbstractS
         runTest("compiler/testData/asJava/lightClasses/DollarsInNameNoPackage.kt");
     }
 
+    @Test
+    @TestMetadata("EnumEntry.kt")
+    public void testEnumEntry() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/EnumEntry.kt");
+    }
+
     @Test
     @TestMetadata("ExtendingInterfaceWithDefaultImpls.kt")
     public void testExtendingInterfaceWithDefaultImpls() throws Exception {

compiler/testData/asJava/lightClasses/EnumEntry.fir.java

@@ -0,0 +1,17 @@
+static final class FirstEntry /* p.KotlinEnum.FirstEntry*/ extends p.KotlinEnum {
+  private final int firstEntryProp = 4 /* initializer type: int */;
+
+  private int variable = 1 /* initializer type: int */;
+
+   FirstEntry();//  .ctor()
+
+  @java.lang.Override()
+  public void abstractFun();//  abstractFun()
+
+  public final int getFirstEntryProp();//  getFirstEntryProp()
+
+  public final int getVariable();//  getVariable()
+
+  public final void firstEntryFun();//  firstEntryFun()
+
+}

compiler/testData/asJava/lightClasses/EnumEntry.java

@@ -0,0 +1,16 @@
+public static final class FirstEntry /* p.KotlinEnum.FirstEntry*/ extends p.KotlinEnum {
+  private final int firstEntryProp;
+
+  private int variable;
+
+   FirstEntry();//  .ctor()
+
+  public final int getFirstEntryProp();//  getFirstEntryProp()
+
+  public final int getVariable();//  getVariable()
+
+  public final void firstEntryFun();//  firstEntryFun()
+
+  public void abstractFun();//  abstractFun()
+
+}

compiler/testData/asJava/lightClasses/EnumEntry.kt

@@ -0,0 +1,28 @@
+// p.KotlinEnum.FirstEntry
+
+package p
+
+enum class KotlinEnum {
+    FirstEntry {
+        fun firstEntryFun() = Unit
+        val firstEntryProp = 4
+        var variable: Int = 1
+            get() = 2
+            private set
+
+        override fun abstractFun() {
+            TODO("Not yet implemented")
+        }
+    },
+
+    SecondEntry {
+        fun secondEntryFun() = 3
+        val secondEntryProp = 2
+
+        override fun abstractFun() {
+            TODO("Not yet implemented")
+        }
+    };
+
+    abstract fun abstractFun()
+}

compiler/testData/asJava/lightClasses/EnumEntry.lib.java

@@ -0,0 +1,16 @@
+static final class FirstEntry /* p.KotlinEnum.FirstEntry*/ extends p.KotlinEnum {
+  private final int firstEntryProp;
+
+  private int variable;
+
+   FirstEntry();//  .ctor()
+
+  public final int getFirstEntryProp();//  getFirstEntryProp()
+
+  public final int getVariable();//  getVariable()
+
+  public final void firstEntryFun();//  firstEntryFun()
+
+  public void abstractFun();//  abstractFun()
+
+}

compiler/tests-common/tests/org/jetbrains/kotlin/asJava/AbstractCompilerLightClassTest.kt

@@ -1,17 +1,6 @@
 /*
- * Copyright 2010-2017 JetBrains s.r.o.
+ * 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.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
  */
 
 package org.jetbrains.kotlin.asJava
@@ -22,7 +11,11 @@ import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
 import org.jetbrains.kotlin.checkers.KotlinMultiFileTestWithJava
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.test.*
+import org.jetbrains.kotlin.psi.KtEnumEntry
+import org.jetbrains.kotlin.test.Directives
+import org.jetbrains.kotlin.test.InTextDirectivesUtils
+import org.jetbrains.kotlin.test.KotlinBaseTest
+import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.util.KotlinFrontEndException
 import org.junit.Assert
 import java.io.File
@@ -63,14 +56,17 @@ abstract class AbstractCompilerLightClassTest : KotlinMultiFileTestWithJava<Kotl
                 KotlinTestUtils.resolveAllKotlinFiles(environment)
             }
 
-            val lightCLassForScript = KotlinAsJavaSupport
+            val searchScope = GlobalSearchScope.allScope(environment.project)
-                .getInstance(environment.project)
+            val kotlinAsJavaSupport = KotlinAsJavaSupport.getInstance(environment.project)
-                .getScriptClasses(FqName(fqname), GlobalSearchScope.allScope(environment.project))
+            val lightClassForScript = kotlinAsJavaSupport
+                .getScriptClasses(FqName(fqname), searchScope)
                 .firstOrNull()
 
-            return lightCLassForScript ?: JavaElementFinder
+            return lightClassForScript
-                .getInstance(environment.project)
+                ?: JavaElementFinder.getInstance(environment.project).findClass(fqname, searchScope)
-                .findClass(fqname, GlobalSearchScope.allScope(environment.project))
+                ?: kotlinAsJavaSupport.findClassOrObjectDeclarations(FqName(fqname), searchScope).firstOrNull {
+                    it is KtEnumEntry // JavaElementFinder will ignore enum entry
+                }?.toLightClass()
         }
 
         private fun assertException(shouldOccur: Boolean, klass: Class<out Throwable>, f: () -> Unit) {

compiler/tests-gen/org/jetbrains/kotlin/asJava/CompilerLightClassTestGenerated.java

@@ -109,6 +109,11 @@ public class CompilerLightClassTestGenerated extends AbstractCompilerLightClassT
         runTest("compiler/testData/asJava/lightClasses/DollarsInNameNoPackage.kt");
     }
 
+    @TestMetadata("EnumEntry.kt")
+    public void testEnumEntry() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/EnumEntry.kt");
+    }
+
     @TestMetadata("ExtendingInterfaceWithDefaultImpls.kt")
     public void testExtendingInterfaceWithDefaultImpls() throws Exception {
         runTest("compiler/testData/asJava/lightClasses/ExtendingInterfaceWithDefaultImpls.kt");