[light classes] drop old light classes and backend: iteration #11

drop redundant builder for scripts

^KT-48773

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliExtraDiagnosticsProvider.kt

@@ -12,8 +12,6 @@ import com.intellij.psi.util.CachedValuesManager
 import org.jetbrains.kotlin.asJava.KotlinAsJavaSupport
 import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
 import org.jetbrains.kotlin.asJava.classes.getOutermostClassOrObject
-import org.jetbrains.kotlin.asJava.classes.safeIsLocal
-import org.jetbrains.kotlin.asJava.classes.safeScript
 import org.jetbrains.kotlin.asJava.classes.shouldNotBeVisibleAsLightClass
 import org.jetbrains.kotlin.cli.jvm.compiler.builder.InvalidLightClassDataHolder
 import org.jetbrains.kotlin.cli.jvm.compiler.builder.LightClassDataHolder
@@ -21,11 +19,9 @@ import org.jetbrains.kotlin.cli.jvm.compiler.builder.buildLightClass
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.psi.KtScript
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
 import org.jetbrains.kotlin.utils.addToStdlib.cast
 
-private val JAVA_API_STUB_FOR_SCRIPT = Key.create<CachedValue<LightClassDataHolder.ForScript>>("JAVA_API_STUB_FOR_SCRIPT")
 private val JAVA_API_STUB = Key.create<CachedValue<LightClassDataHolder.ForClass>>("JAVA_API_STUB")
 private val JAVA_API_STUB_LOCK = Key.create<Any>("JAVA_API_STUB_LOCK")
 
@@ -37,12 +33,7 @@ object CliExtraDiagnosticsProvider {
             return Diagnostics.EMPTY
         }
 
-        val containingScript = kclass.containingKtFile.safeScript()
-        val lightClassDataHolder = when {
-            !kclass.safeIsLocal() && containingScript != null -> getLightClassCachedValue(containingScript).value
-            else -> getLightClassCachedValue(kclass).value
-        }
-
+        val lightClassDataHolder = getLightClassCachedValue(kclass).value
         return if (lightClassDataHolder is InvalidLightClassDataHolder) {
             Diagnostics.EMPTY
         } else {
@@ -77,15 +68,6 @@ object CliExtraDiagnosticsProvider {
     }
 }
 
-private fun getLightClassCachedValue(script: KtScript): CachedValue<LightClassDataHolder.ForScript> {
-    return script.getUserData(JAVA_API_STUB_FOR_SCRIPT) ?: createCachedValueForScript(script).also {
-        script.putUserData(JAVA_API_STUB_FOR_SCRIPT, it)
-    }
-}
-
-private fun createCachedValueForScript(script: KtScript): CachedValue<LightClassDataHolder.ForScript> =
-    CachedValuesManager.getManager(script.project).createCachedValue(LightClassDataProviderForScript(script), false)
-
 private fun getLightClassCachedValue(classOrObject: KtClassOrObject): CachedValue<LightClassDataHolder.ForClass> {
     val outerClassValue = getOutermostClassOrObject(classOrObject).getUserData(JAVA_API_STUB)
     outerClassValue?.let {

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/LightClassDataProvider.kt

@@ -99,53 +99,10 @@ private class ClassFilterForClassOrObject(private val classOrObject: KtClassOrOb
     override fun shouldGenerateCodeFragment(script: KtCodeFragment) = false
 }
 
-internal class LightClassDataProviderForScript(private val script: KtScript) : CachedValueProvider<LightClassDataHolder.ForScript> {
-    private fun computeLightClassData(): LightClassDataHolder.ForScript {
-        return LightClassGenerationSupport.getInstance(script.project)
-            .cast<CliLightClassGenerationSupport>()
-            .createDataHolderForScript { constructionContext ->
-                buildLightClass(
-                    script.fqName.parent(),
-                    listOf(script.containingKtFile),
-                    ClassFilterForScript(script),
-                    constructionContext
-                ) generate@{ state, files ->
-                    val scriptFile = files.first()
-                    val codegen = state.factory.forPackage(scriptFile.packageFqName, files)
-                    codegen.generate()
-                    state.factory.done()
-                }
-            }
-    }
-
-    override fun compute(): CachedValueProvider.Result<LightClassDataHolder.ForScript> =
-        CachedValueProvider.Result.create(
-            computeLightClassData(),
-            KotlinModificationTrackerService.getInstance(script.project).outOfBlockModificationTracker
-        )
-
-    override fun toString(): String = this::class.java.name + " for ${script.fqName}"
-}
-
-private class ClassFilterForScript(val script: KtScript) : GenerationState.GenerateClassFilter() {
-    override fun shouldAnnotateClass(processingClassOrObject: KtClassOrObject): Boolean =
-        shouldGenerateClass(processingClassOrObject)
-
-    override fun shouldGenerateClass(processingClassOrObject: KtClassOrObject): Boolean =
-        processingClassOrObject.isAncestor(script, true)
-
-    override fun shouldGenerateClassMembers(processingClassOrObject: KtClassOrObject): Boolean = true
-
-    override fun shouldGeneratePackagePart(ktFile: KtFile): Boolean = script.containingKtFile === ktFile
-
-    override fun shouldGenerateScript(script: KtScript): Boolean = this.script === script
-    override fun shouldGenerateCodeFragment(script: KtCodeFragment) = false
-}
-
 internal object ClassFilterForFacade : GenerationState.GenerateClassFilter() {
     override fun shouldAnnotateClass(processingClassOrObject: KtClassOrObject) = shouldGenerateClass(processingClassOrObject)
     override fun shouldGenerateClass(processingClassOrObject: KtClassOrObject) = KtPsiUtil.isLocal(processingClassOrObject)
     override fun shouldGeneratePackagePart(ktFile: KtFile) = true
     override fun shouldGenerateScript(script: KtScript) = false
     override fun shouldGenerateCodeFragment(script: KtCodeFragment) = false
-}
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/duplicateJvmSignatureUtil.kt

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ConflictingJvmDeclarationsData
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.*
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKind.*
+import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 fun getJvmSignatureDiagnostics(element: PsiElement, otherDiagnostics: Diagnostics, moduleScope: GlobalSearchScope): Diagnostics? {
     fun getDiagnosticsForClass(ktClassOrObject: KtClassOrObject): Diagnostics {
@@ -25,8 +26,7 @@ fun getJvmSignatureDiagnostics(element: PsiElement, otherDiagnostics: Diagnostic
     }
 
     fun doGetDiagnostics(): Diagnostics? {
-        //TODO: enable this diagnostic when light classes for scripts are ready
-        if ((element.containingFile as? KtFile)?.safeIsScript() == true) return null
+        if (element.containingFile.safeAs<KtFile>()?.safeIsScript() == true) return null
 
         var parent = element.parent
         if (element is KtPropertyAccessor) {