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

This reverts commit 9d81a4abea.

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

@@ -12,6 +12,8 @@ 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
@@ -19,9 +21,11 @@ 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")
 
@@ -33,7 +37,12 @@ object CliExtraDiagnosticsProvider {
             return Diagnostics.EMPTY
         }
 
-        val lightClassDataHolder = getLightClassCachedValue(kclass).value
+        val containingScript = kclass.containingKtFile.safeScript()
+        val lightClassDataHolder = when {
+            !kclass.safeIsLocal() && containingScript != null -> getLightClassCachedValue(containingScript).value
+            else -> getLightClassCachedValue(kclass).value
+        }
+
         return if (lightClassDataHolder is InvalidLightClassDataHolder) {
             Diagnostics.EMPTY
         } else {
@@ -68,6 +77,15 @@ 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,6 +99,49 @@ 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)

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

@@ -17,7 +17,6 @@ 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 {
@@ -26,7 +25,8 @@ fun getJvmSignatureDiagnostics(element: PsiElement, otherDiagnostics: Diagnostic
     }
 
     fun doGetDiagnostics(): Diagnostics? {
-        if (element.containingFile.safeAs<KtFile>()?.safeIsScript() == true) return null
+        //TODO: enable this diagnostic when light classes for scripts are ready
+        if ((element.containingFile as? KtFile)?.safeIsScript() == true) return null
 
         var parent = element.parent
         if (element is KtPropertyAccessor) {