[ULC] avoid resolve from KtUltraLightClassModifierList.hasModifierProperty in most cases

^KT-55445 Fixed

compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassImpl.kt

@@ -10,7 +10,6 @@ import com.intellij.psi.impl.InheritanceImplUtil
 import com.intellij.psi.scope.PsiScopeProcessor
 import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
 import org.jetbrains.kotlin.asJava.elements.FakeFileForLightClass
-import org.jetbrains.kotlin.asJava.elements.KtLightModifierListDescriptorBased
 import org.jetbrains.kotlin.asJava.hasInterfaceDefaultImpls
 import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
@@ -22,17 +21,8 @@ import org.jetbrains.kotlin.psi.KtClassBody
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 
-private class KtLightClassModifierList(containingClass: KtLightClassForSourceDeclaration, computeModifiers: () -> Set<String>) :
-    KtLightModifierListDescriptorBased<KtLightClassForSourceDeclaration>(containingClass) {
-
-    private val modifiers by lazyPub { computeModifiers() }
-
-    override fun hasModifierProperty(name: String): Boolean =
-        if (name != PsiModifier.FINAL) name in modifiers else owner.isFinal(PsiModifier.FINAL in modifiers)
-}
-
 // light class for top level or (inner/nested of top level) source declarations
-abstract class KtLightClassImpl constructor(
+abstract class KtLightClassImpl(
     classOrObject: KtClassOrObject,
     jvmDefaultMode: JvmDefaultMode,
 ) : KtLightClassForSourceDeclaration(classOrObject, jvmDefaultMode) {
@@ -43,18 +33,13 @@ abstract class KtLightClassImpl constructor(
 
     override fun isDeprecated(): Boolean = _deprecated
 
-
-    private val _modifierList: PsiModifierList by lazyPub { KtLightClassModifierList(this) { computeModifiers() } }
-
-    override fun getModifierList(): PsiModifierList? = _modifierList
-
-    override fun computeModifiers(): Set<String> {
+    protected open fun computeModifiersByPsi(): Set<String> {
         val psiModifiers = hashSetOf<String>()
 
-        // PUBLIC, PROTECTED, PRIVATE, ABSTRACT, FINAL
+        // PUBLIC, PROTECTED, PRIVATE
         //noinspection unchecked
 
-        for (tokenAndModifier in jetTokenToPsiModifier) {
+        for (tokenAndModifier in ktTokenToPsiModifier) {
             if (classOrObject.hasModifier(tokenAndModifier.first)) {
                 psiModifiers.add(tokenAndModifier.second)
             }
@@ -68,29 +53,12 @@ abstract class KtLightClassImpl constructor(
             psiModifiers.add(PsiModifier.PUBLIC)
         }
 
-        // ABSTRACT | FINAL
-        when {
-            isAbstract() || isSealed() -> {
-                psiModifiers.add(PsiModifier.ABSTRACT)
-            }
-
-            isEnum -> {
-                // Enum class should not be `final`, since its enum entries extend it.
-                // It could be either `abstract` w/o ctor, or empty modality w/ private ctor.
-            }
-
-            !(classOrObject.hasModifier(KtTokens.OPEN_KEYWORD)) -> {
-                val descriptor = lazy { getDescriptor() }
-                var modifier = PsiModifier.FINAL
-                project.applyCompilerPlugins {
-                    modifier = it.interceptModalityBuilding(kotlinOrigin, descriptor, modifier)
-                }
-                if (modifier == PsiModifier.FINAL) {
-                    psiModifiers.add(PsiModifier.FINAL)
-                }
-            }
+        // ABSTRACT
+        if (isAbstract() || isSealed()) {
+            psiModifiers.add(PsiModifier.ABSTRACT)
         }
 
+        // STATIC
         if (!classOrObject.isTopLevel() && !classOrObject.hasModifier(KtTokens.INNER_KEYWORD)) {
             psiModifiers.add(PsiModifier.STATIC)
         }
@@ -98,6 +66,23 @@ abstract class KtLightClassImpl constructor(
         return psiModifiers
     }
 
+    protected open fun computeIsFinal(): Boolean = when {
+        classOrObject.hasModifier(KtTokens.FINAL_KEYWORD) -> true
+        isAbstract() || isSealed() -> false
+        isEnum -> false
+        !classOrObject.hasModifier(KtTokens.OPEN_KEYWORD) -> {
+            val descriptor = lazy { getDescriptor() }
+            var modifier = PsiModifier.FINAL
+            project.applyCompilerPlugins {
+                modifier = it.interceptModalityBuilding(kotlinOrigin, descriptor, modifier)
+            }
+
+            modifier == PsiModifier.FINAL
+        }
+
+        else -> false
+    }
+
     private fun isAbstract(): Boolean = classOrObject.hasModifier(KtTokens.ABSTRACT_KEYWORD) || isInterface
 
     private fun isSealed(): Boolean = classOrObject.hasModifier(KtTokens.SEALED_KEYWORD)
@@ -221,11 +206,10 @@ abstract class KtLightClassImpl constructor(
             return false
         }
 
-        private val jetTokenToPsiModifier = listOf(
+        private val ktTokenToPsiModifier = listOf(
             KtTokens.PUBLIC_KEYWORD to PsiModifier.PUBLIC,
             KtTokens.INTERNAL_KEYWORD to PsiModifier.PUBLIC,
             KtTokens.PROTECTED_KEYWORD to PsiModifier.PROTECTED,
-            KtTokens.FINAL_KEYWORD to PsiModifier.FINAL,
         )
     }
 }

compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtUltraLightClassForInterfaceDefaultImpls.kt

@@ -44,7 +44,8 @@ class KtUltraLightClassForInterfaceDefaultImpls(classOrObject: KtClassOrObject,
 
     override fun getTypeParameterList(): PsiTypeParameterList? = null
     override fun getTypeParameters(): Array<PsiTypeParameter> = emptyArray()
-    override fun computeModifiers(): Set<String> = publicStaticFinal
+    override fun computeModifiersByPsi(): Set<String> = publicStaticFinal
+    override fun computeIsFinal(): Boolean = true
 
     override fun getOwnFields(): List<KtLightField> = emptyList()
     override fun isInterface(): Boolean = false

compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/ultraLightClass.kt

@@ -56,24 +56,22 @@ open class KtUltraLightClass(classOrObject: KtClassOrObject, internal val suppor
     private class KtUltraLightClassModifierList(
         private val containingClass: KtLightClassForSourceDeclaration,
         support: KtUltraLightSupport,
-        private val computeModifiers: () -> Set<String>
+        private val lazyModifiers: Lazy<Set<String>>,
+        private val lazyIsFinal: Lazy<Boolean>,
     ) : KtUltraLightModifierList<KtLightClassForSourceDeclaration>(containingClass, support) {
-        private val modifiers by lazyPub { computeModifiers() }
-
         override fun hasModifierProperty(name: String): Boolean =
-            if (name != PsiModifier.FINAL) name in modifiers else owner.isFinal(PsiModifier.FINAL in modifiers)
+            if (name != PsiModifier.FINAL) name in lazyModifiers.value else owner.isFinal(lazyIsFinal.value)
 
-        override fun copy(): PsiElement = KtUltraLightClassModifierList(containingClass, support, computeModifiers)
+        override fun copy(): PsiElement = KtUltraLightClassModifierList(containingClass, support, lazyModifiers, lazyIsFinal)
     }
 
-
     private val membersBuilder by lazyPub {
         UltraLightMembersCreator(
             this,
             isNamedObject(),
             classOrObject.hasModifier(SEALED_KEYWORD),
             mangleInternalFunctions = true,
-            support = support
+            support = support,
         )
     }
 
@@ -82,7 +80,12 @@ open class KtUltraLightClass(classOrObject: KtClassOrObject, internal val suppor
     override fun isFinal(isFinalByPsi: Boolean) = isFinalByPsi
 
     private val _modifierList: PsiModifierList? by lazyPub {
-        KtUltraLightClassModifierList(this, support) { computeModifiers() }
+        KtUltraLightClassModifierList(
+            containingClass = this,
+            support = support,
+            lazyModifiers = lazyPub { computeModifiersByPsi() },
+            lazyIsFinal = lazyPub { computeIsFinal() },
+        )
     }
 
     override fun getModifierList(): PsiModifierList? = _modifierList