[lc] KotlinAsJavaSupportBase: implement getLightClass

add more caching

^KT-50241

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

@@ -45,29 +45,23 @@ abstract class LightClassGenerationSupport {
         )
     }
 
-    fun createUltraLightClass(element: KtClassOrObject): KtUltraLightClass? {
-        if (element.shouldNotBeVisibleAsLightClass()) {
-            return null
+    fun createUltraLightClass(element: KtClassOrObject): KtUltraLightClass = getUltraLightClassSupport(element).let { support ->
+        if (support.languageVersionSettings.getFlag(AnalysisFlags.eagerResolveOfLightClasses)) {
+            val descriptor = resolveToDescriptor(element)
+            (descriptor as? LazyClassDescriptor)?.forceResolveAllContents()
         }
 
-        return getUltraLightClassSupport(element).let { support ->
-            if (support.languageVersionSettings.getFlag(AnalysisFlags.eagerResolveOfLightClasses)) {
-                val descriptor = resolveToDescriptor(element)
-                (descriptor as? LazyClassDescriptor)?.forceResolveAllContents()
-            }
+        when {
+            element is KtObjectDeclaration && element.isObjectLiteral() ->
+                KtUltraLightClassForAnonymousDeclaration(element, support)
 
-            when {
-                element is KtObjectDeclaration && element.isObjectLiteral() ->
-                    KtUltraLightClassForAnonymousDeclaration(element, support)
+            element.safeIsLocal() ->
+                KtUltraLightClassForLocalDeclaration(element, support)
 
-                element.safeIsLocal() ->
-                    KtUltraLightClassForLocalDeclaration(element, support)
+            (element.hasModifier(KtTokens.INLINE_KEYWORD)) ->
+                KtUltraLightInlineClass(element, support)
 
-                (element.hasModifier(KtTokens.INLINE_KEYWORD)) ->
-                    KtUltraLightInlineClass(element, support)
-
-                else -> KtUltraLightClass(element, support)
-            }
+            else -> KtUltraLightClass(element, support)
         }
     }
 

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

@@ -9,19 +9,10 @@ import com.intellij.psi.util.CachedValueProvider
 import com.intellij.psi.util.CachedValuesManager
 import org.jetbrains.kotlin.analyzer.KotlinModificationTrackerService
 import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
-import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtCodeFragment
 import org.jetbrains.kotlin.psi.KtScript
 
 class KotlinK1LightClassFactory : KotlinLightClassFactory {
-    override fun createClass(classOrObject: KtClassOrObject): KtLightClassForSourceDeclaration? =
-        CachedValuesManager.getCachedValue(classOrObject) {
-            CachedValueProvider.Result.create(
-                createClassNoCache(classOrObject),
-                KotlinModificationTrackerService.getInstance(classOrObject.project).outOfBlockModificationTracker,
-            )
-        }
-
     override fun createScript(script: KtScript): KtLightClassForScript? = CachedValuesManager.getCachedValue(script) {
         CachedValueProvider.Result.create(
             createScriptNoCache(script),
@@ -39,19 +30,5 @@ class KotlinK1LightClassFactory : KotlinLightClassFactory {
 
             return LightClassGenerationSupport.getInstance(script.project).createUltraLightClassForScript(script)
         }
-
-        fun createClassNoCache(classOrObject: KtClassOrObject): KtLightClassForSourceDeclaration? {
-            val containingFile = classOrObject.containingFile
-            if (containingFile is KtCodeFragment) {
-                // Avoid building light classes for code fragments
-                return null
-            }
-
-            if (classOrObject.shouldNotBeVisibleAsLightClass()) {
-                return null
-            }
-
-            return LightClassGenerationSupport.getInstance(classOrObject.project).createUltraLightClass(classOrObject)
-        }
     }
 }

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

@@ -12,6 +12,7 @@ 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
 import org.jetbrains.kotlin.config.JvmDefaultMode
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
@@ -133,7 +134,7 @@ abstract class KtLightClassImpl constructor(
     private val _containingFile: PsiFile by lazyPub {
         object : FakeFileForLightClass(
             classOrObject.containingKtFile,
-            { if (classOrObject.isTopLevel()) this else KotlinLightClassFactory.createClass(getOutermostClassOrObject(classOrObject))!! },
+            { if (classOrObject.isTopLevel()) this else getOutermostClassOrObject(classOrObject).toLightClass()!! },
         ) {
             override fun findReferenceAt(offset: Int) = ktFile.findReferenceAt(offset)
 
@@ -167,9 +168,7 @@ abstract class KtLightClassImpl constructor(
             // inner classes with null names can't be searched for and can't be used from java anyway
             // we can't prohibit creating light classes with null names either since they can contain members
             .filter { it.name != null }
-            .mapNotNullTo(result) {
-                KotlinLightClassFactory.createClass(it)
-            }
+            .mapNotNullTo(result, KtClassOrObject::toLightClass)
 
         if (classOrObject.hasInterfaceDefaultImpls && jvmDefaultMode != JvmDefaultMode.ALL_INCOMPATIBLE) {
             result.add(createClassForInterfaceDefaultImpls())
@@ -185,11 +184,10 @@ abstract class KtLightClassImpl constructor(
 
         val containingClassOrObject = (classOrObject.parent as? KtClassBody)?.parent as? KtClassOrObject
         if (containingClassOrObject != null) {
-            return KotlinLightClassFactory.createClass(containingClassOrObject)
+            return containingClassOrObject.toLightClass()
         }
 
-        // TODO: should return null
-        return super.getContainingClass()
+        return null
     }
 
     companion object {

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

@@ -14,6 +14,7 @@ import com.intellij.util.IncorrectOperationException
 import org.jetbrains.annotations.NotNull
 import org.jetbrains.kotlin.asJava.elements.KtLightField
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
+import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.codegen.AsmUtil
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.load.java.JvmAbi
@@ -59,7 +60,7 @@ class KtUltraLightClassForInterfaceDefaultImpls(classOrObject: KtClassOrObject,
     override fun setName(name: String): PsiElement =
         throw IncorrectOperationException("Impossible to rename ${JvmAbi.DEFAULT_IMPLS_CLASS_NAME}")
 
-    override fun getContainingClass(): KtLightClassForSourceDeclaration? = KotlinLightClassFactory.createClass(classOrObject)
+    override fun getContainingClass(): KtLightClass? = classOrObject.toLightClass()
 
     override fun getOwnInnerClasses() = emptyList<PsiClass>()
     override fun getOwnMethods(): List<KtLightMethod> = _ownMethods.value

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

@@ -11,6 +11,7 @@ import com.intellij.psi.impl.light.LightModifierList
 import com.intellij.psi.impl.light.LightParameterListBuilder
 import com.intellij.util.IncorrectOperationException
 import org.jetbrains.kotlin.asJava.elements.*
+import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.psi.KtClassOrObject
@@ -22,7 +23,7 @@ class KtUltraLightClassForRepeatableAnnotationContainer(classOrObject: KtClassOr
     override fun getParent() = containingClass
     override fun getTypeParameterList(): PsiTypeParameterList? = null
     override fun getTypeParameters(): Array<PsiTypeParameter> = emptyArray()
-    override fun getContainingClass(): KtLightClassForSourceDeclaration? = KotlinLightClassFactory.createClass(classOrObject)
+    override fun getContainingClass(): KtLightClass? = classOrObject.toLightClass()
     override fun getScope(): PsiElement? = containingClass
     override fun getOwnInnerClasses() = emptyList<PsiClass>()
     override fun getOwnFields(): List<KtLightField> = emptyList()

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

@@ -18,6 +18,7 @@ import com.intellij.psi.util.CachedValuesManager
 import org.jetbrains.kotlin.asJava.elements.KtLightField
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
 import org.jetbrains.kotlin.asJava.elements.KtUltraLightModifierList
+import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.backend.common.CodegenUtil
 import org.jetbrains.kotlin.backend.common.DataClassMethodGenerator
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
@@ -484,7 +485,7 @@ open class KtUltraLightClass(classOrObject: KtClassOrObject, internal val suppor
 
         val containingBody = classOrObject.parent as? KtClassBody
         val containingClass = containingBody?.parent as? KtClassOrObject
-        containingClass?.let { return KotlinLightClassFactory.createClass(it) }
+        containingClass?.let { return it.toLightClass() }
 
         val containingBlock = classOrObject.parent as? KtBlockExpression
         val containingScript = containingBlock?.parent as? KtScript

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

@@ -15,6 +15,7 @@ import com.intellij.psi.util.CachedValuesManager
 import org.jetbrains.kotlin.analyzer.KotlinModificationTrackerService
 import org.jetbrains.kotlin.asJava.elements.KtLightField
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
+import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.psi.KtProperty
@@ -136,6 +137,6 @@ class KtUltraLightClassForScript(
             // inner classes with null names can't be searched for and can't be used from java anyway
             // we can't prohibit creating light classes with null names either since they can contain members
             .filter { it.name != null }
-            .mapNotNull { KotlinLightClassFactory.createClass(it) }
+            .mapNotNull(KtClassOrObject::toLightClass)
     }
 }