JVM: remove obsolete code for reporting JVM backend diagnostics

The last remaining usages from diagnostic tests were removed in previous
commits.

compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt

@@ -39,7 +39,6 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtScript
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.BindingTraceFilter
 import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
 import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
@@ -67,7 +66,6 @@ class GenerationState private constructor(
     moduleName: String?,
     val outDirectory: File?,
     private val onIndependentPartCompilationEnd: GenerationStateEventCallback,
-    wantsDiagnostics: Boolean,
     val jvmBackendClassResolver: JvmBackendClassResolver,
     val isIrBackend: Boolean,
     val ignoreErrors: Boolean,
@@ -117,10 +115,6 @@ class GenerationState private constructor(
         fun onIndependentPartCompilationEnd(v: GenerationStateEventCallback) =
             apply { onIndependentPartCompilationEnd = v }
 
-        private var wantsDiagnostics: Boolean = true
-        fun wantsDiagnostics(v: Boolean) =
-            apply { wantsDiagnostics = v }
-
         private var jvmBackendClassResolver: JvmBackendClassResolver = JvmBackendClassResolverForModuleWithDependencies(module)
         fun jvmBackendClassResolver(v: JvmBackendClassResolver) =
             apply { jvmBackendClassResolver = v }
@@ -149,7 +143,7 @@ class GenerationState private constructor(
             GenerationState(
                 project, builderFactory, module, bindingContext, configuration,
                 generateDeclaredClassFilter, targetId,
-                moduleName, outDirectory, onIndependentPartCompilationEnd, wantsDiagnostics,
+                moduleName, outDirectory, onIndependentPartCompilationEnd,
                 jvmBackendClassResolver, isIrBackend, ignoreErrors,
                 diagnosticReporter ?: DiagnosticReporterFactory.createReporter(),
                 isIncrementalCompilation
@@ -237,10 +231,7 @@ class GenerationState private constructor(
 
     val moduleName: String = moduleName ?: JvmCodegenUtil.getModuleName(module)
     val classBuilderMode: ClassBuilderMode = builderFactory.classBuilderMode
-    val bindingTrace: BindingTrace = DelegatingBindingTrace(
+    val bindingTrace: BindingTrace = DelegatingBindingTrace(originalFrontendBindingContext, "trace in GenerationState")
-        originalFrontendBindingContext, "trace in GenerationState",
-        filter = if (wantsDiagnostics) BindingTraceFilter.ACCEPT_ALL else BindingTraceFilter.NO_DIAGNOSTICS
-    )
     val bindingContext: BindingContext = bindingTrace.bindingContext
     val mainFunctionDetector = MainFunctionDetector(originalFrontendBindingContext, languageVersionSettings)
     val typeMapper: KotlinTypeMapper = KotlinTypeMapper(

compiler/cli/cli-base/src/org/jetbrains/kotlin/cli/jvm/compiler/CliLightClassGenerationSupport.kt

@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.asJava.classes.KtUltraLightSupport
 import org.jetbrains.kotlin.asJava.classes.cleanFromAnonymousTypes
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.classes.tryGetPredefinedName
-import org.jetbrains.kotlin.cli.jvm.compiler.builder.LightClassConstructionContext
 import org.jetbrains.kotlin.codegen.ClassBuilderMode
 import org.jetbrains.kotlin.codegen.JvmCodegenUtil
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
@@ -89,14 +88,6 @@ class CliLightClassGenerationSupport(
         return ultraLightSupport
     }
 
-    val context: LightClassConstructionContext
-        get() = LightClassConstructionContext(
-            traceHolder.bindingContext,
-            traceHolder.module,
-            traceHolder.languageVersionSettings,
-            traceHolder.jvmTarget,
-        )
-
     override fun resolveToDescriptor(declaration: KtDeclaration): DeclarationDescriptor? {
         return traceHolder.bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, declaration)
     }

compiler/cli/cli-base/src/org/jetbrains/kotlin/cli/jvm/compiler/builder/KotlinLightClassBuilderFactory.kt

@@ -1,26 +0,0 @@
-/*
- * Copyright 2010-2023 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.
- */
-
-package org.jetbrains.kotlin.cli.jvm.compiler.builder
-
-import org.jetbrains.kotlin.codegen.AbstractClassBuilder
-import org.jetbrains.kotlin.codegen.ClassBuilder
-import org.jetbrains.kotlin.codegen.ClassBuilderFactory
-import org.jetbrains.kotlin.codegen.ClassBuilderMode
-import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
-import org.jetbrains.org.objectweb.asm.ClassVisitor
-import org.jetbrains.org.objectweb.asm.ClassWriter
-
-object KotlinLightClassBuilderFactory : ClassBuilderFactory {
-    override fun getClassBuilderMode(): ClassBuilderMode = ClassBuilderMode.LIGHT_CLASSES
-    override fun newClassBuilder(origin: JvmDeclarationOrigin): ClassBuilder =
-        object : AbstractClassBuilder() {
-            override fun getVisitor(): ClassVisitor = ClassWriter(0)
-        }
-
-    override fun asText(builder: ClassBuilder) = throw UnsupportedOperationException("asText is not implemented")
-    override fun asBytes(builder: ClassBuilder) = throw UnsupportedOperationException("asBytes is not implemented")
-    override fun close() {}
-}

compiler/cli/cli-base/src/org/jetbrains/kotlin/cli/jvm/compiler/builder/LightClassBuilder.kt

@@ -1,69 +0,0 @@
-/*
- * Copyright 2010-2023 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.
- */
-
-package org.jetbrains.kotlin.cli.jvm.compiler.builder
-
-import com.intellij.openapi.diagnostic.Logger
-import com.intellij.openapi.progress.ProcessCanceledException
-import com.intellij.openapi.util.SystemInfo
-import com.intellij.openapi.vfs.VirtualFile
-import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
-import org.jetbrains.kotlin.config.languageVersionSettings
-import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
-
-data class CodeGenerationResult(val bindingContext: BindingContext, val diagnostics: Diagnostics)
-
-fun extraJvmDiagnosticsFromBackend(
-    packageFqName: FqName,
-    files: Collection<KtFile>,
-    generateClassFilter: GenerationState.GenerateClassFilter,
-    context: LightClassConstructionContext,
-    generate: (state: GenerationState, files: Collection<KtFile>) -> Unit,
-): CodeGenerationResult {
-    val project = files.first().project
-
-    try {
-        val state = GenerationState.Builder(
-            project,
-            KotlinLightClassBuilderFactory,
-            context.module,
-            context.bindingContext,
-            context.languageVersionSettings?.let {
-                CompilerConfiguration().apply {
-                    languageVersionSettings = it
-                    put(JVMConfigurationKeys.JVM_TARGET, context.jvmTarget)
-                    isReadOnly = true
-                }
-            } ?: CompilerConfiguration.EMPTY,
-        ).generateDeclaredClassFilter(generateClassFilter).wantsDiagnostics(false).build()
-        state.beforeCompile()
-        state.oldBEInitTrace(files)
-
-        generate(state, files)
-
-        return CodeGenerationResult(context.bindingContext, state.collectedExtraJvmDiagnostics)
-    } catch (e: ProcessCanceledException) {
-        throw e
-    } catch (e: RuntimeException) {
-        logErrorWithOSInfo(e, packageFqName, files.firstOrNull()?.virtualFile)
-        throw e
-    }
-}
-
-private fun logErrorWithOSInfo(cause: Throwable?, fqName: FqName, virtualFile: VirtualFile?) {
-    val path = virtualFile?.path ?: "<null>"
-    LOG.error(
-        "Could not generate LightClass for $fqName declared in $path\n" +
-                "System: ${SystemInfo.OS_NAME} ${SystemInfo.OS_VERSION} Java Runtime: ${SystemInfo.JAVA_RUNTIME_VERSION}",
-        cause,
-    )
-}
-
-private val LOG = Logger.getInstance(CodeGenerationResult::class.java)

compiler/cli/cli-base/src/org/jetbrains/kotlin/cli/jvm/compiler/builder/LightClassConstructionContext.kt

@@ -1,18 +0,0 @@
-/*
- * Copyright 2010-2023 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.
- */
-
-package org.jetbrains.kotlin.cli.jvm.compiler.builder
-
-import org.jetbrains.kotlin.config.JvmTarget
-import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.resolve.BindingContext
-
-open class LightClassConstructionContext(
-    val bindingContext: BindingContext,
-    val module: ModuleDescriptor,
-    val languageVersionSettings: LanguageVersionSettings?,
-    val jvmTarget: JvmTarget,
-)

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

@@ -1,94 +0,0 @@
-/*
- * 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.
- */
-
-package org.jetbrains.kotlin.cli.jvm.compiler
-
-import com.intellij.openapi.util.Key
-import com.intellij.psi.search.GlobalSearchScope
-import com.intellij.psi.util.CachedValue
-import com.intellij.psi.util.CachedValueProvider
-import com.intellij.psi.util.CachedValuesManager
-import org.jetbrains.kotlin.analyzer.KotlinModificationTrackerService
-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.shouldNotBeVisibleAsLightClass
-import org.jetbrains.kotlin.cli.jvm.compiler.builder.extraJvmDiagnosticsFromBackend
-import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
-import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName
-import org.jetbrains.kotlin.psi.KtClassOrObject
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
-
-private val JAVA_API_STUB = Key.create<CachedValue<Diagnostics>>("JAVA_API_STUB")
-
-object CliExtraDiagnosticsProvider {
-    fun forClassOrObject(kclass: KtClassOrObject): Diagnostics {
-        if (kclass.shouldNotBeVisibleAsLightClass()) {
-            return Diagnostics.EMPTY
-        }
-
-        return getLightClassCachedValue(kclass).value
-    }
-
-    fun forFacade(file: KtFile): Diagnostics = CachedValuesManager.getCachedValue(file) {
-        CachedValueProvider.Result.create(
-            calculateForFacade(file),
-            KotlinModificationTrackerService.getInstance(file.project).outOfBlockModificationTracker,
-        )
-    }
-
-    private fun calculateForFacade(file: KtFile): Diagnostics {
-        val project = file.project
-        val facadeFqName = file.javaFileFacadeFqName
-        val facadeCollection = KotlinAsJavaSupport.getInstance(project)
-            .findFilesForFacade(facadeFqName, GlobalSearchScope.allScope(project))
-            .ifEmpty { return Diagnostics.EMPTY }
-
-        val context = (LightClassGenerationSupport.getInstance(project) as CliLightClassGenerationSupport).context
-        val (_, diagnostics) = extraJvmDiagnosticsFromBackend(
-            facadeFqName.parent(),
-            facadeCollection,
-            ClassFilterForFacade,
-            context,
-        ) generate@{ state, files ->
-            val representativeFile = files.first()
-            val fileClassInfo = JvmFileClassUtil.getFileClassInfoNoResolve(representativeFile)
-            if (!fileClassInfo.withJvmMultifileClass) {
-                val codegen = state.factory.forPackage(representativeFile.packageFqName, files)
-                codegen.generate()
-                state.factory.done()
-                return@generate
-            }
-
-            val codegen = state.factory.forMultifileClass(facadeFqName, files)
-            codegen.generate()
-            state.factory.done()
-        }
-
-        return diagnostics
-    }
-}
-
-private fun getLightClassCachedValue(classOrObject: KtClassOrObject): CachedValue<Diagnostics> {
-    val outerClassValue = getOutermostClassOrObject(classOrObject).getUserData(JAVA_API_STUB)
-    outerClassValue?.let {
-        // stub computed for outer class can be used for inner/nested
-        return it
-    }
-
-    return computeLightClassCachedValue(classOrObject)
-}
-
-private fun computeLightClassCachedValue(classOrObject: KtClassOrObject): CachedValue<Diagnostics> {
-    val value = classOrObject.getUserData(JAVA_API_STUB) ?: run {
-        val manager = CachedValuesManager.getManager(classOrObject.project)
-        val cachedValue = manager.createCachedValue(LightClassDataProviderForClassOrObject(classOrObject))
-
-        classOrObject.putUserDataIfAbsent(JAVA_API_STUB, cachedValue)
-    }
-
-    return value
-}

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

@@ -1,112 +0,0 @@
-/*
- * 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.
- */
-
-package org.jetbrains.kotlin.cli.jvm.compiler
-
-import com.intellij.psi.PsiFile
-import com.intellij.psi.util.CachedValueProvider
-import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.kotlin.analyzer.KotlinModificationTrackerService
-import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
-import org.jetbrains.kotlin.asJava.classes.getOutermostClassOrObject
-import org.jetbrains.kotlin.asJava.classes.safeIsLocal
-import org.jetbrains.kotlin.cli.jvm.compiler.builder.extraJvmDiagnosticsFromBackend
-import org.jetbrains.kotlin.codegen.MemberCodegen
-import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
-import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.psi.psiUtil.isAncestor
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
-import org.jetbrains.org.objectweb.asm.Type
-
-internal class LightClassDataProviderForClassOrObject(
-    private val classOrObject: KtClassOrObject
-) : CachedValueProvider<Diagnostics> {
-    private fun computeLightClassData(): Diagnostics {
-        val file = classOrObject.containingKtFile
-        val packageFqName = file.packageFqName
-        val cliSupport = LightClassGenerationSupport.getInstance(classOrObject.project) as CliLightClassGenerationSupport
-
-        //force resolve companion for light class generation
-        cliSupport.traceHolder.bindingContext.get(BindingContext.CLASS, classOrObject)?.companionObjectDescriptor
-
-        val (bindingContext, diagnostics) = extraJvmDiagnosticsFromBackend(
-            packageFqName,
-            listOf(file),
-            ClassFilterForClassOrObject(classOrObject),
-            cliSupport.context,
-        ) { state, files ->
-            val packageCodegen = state.factory.forPackage(packageFqName, files)
-            val packagePartType = Type.getObjectType(JvmFileClassUtil.getFileClassInternalName(file))
-            val context = state.rootContext.intoPackagePart(packageCodegen.packageFragment, packagePartType, file)
-            MemberCodegen.genClassOrObject(context, getOutermostClassOrObject(classOrObject), state, null)
-            state.factory.done()
-        }
-
-        return diagnostics.takeIf { bindingContext.get(BindingContext.CLASS, classOrObject) != null } ?: Diagnostics.EMPTY
-    }
-
-    override fun compute(): CachedValueProvider.Result<Diagnostics> {
-        val trackerService = KotlinModificationTrackerService.getInstance(classOrObject.project)
-        return CachedValueProvider.Result.create(
-            computeLightClassData(),
-            if (classOrObject.safeIsLocal()) trackerService.modificationTracker else trackerService.outOfBlockModificationTracker
-        )
-    }
-
-    override fun toString(): String = this::class.java.name + " for " + classOrObject.name
-}
-
-private class ClassFilterForClassOrObject(private val classOrObject: KtClassOrObject) : GenerationState.GenerateClassFilter() {
-
-    override fun shouldGeneratePackagePart(ktFile: KtFile) = true
-    override fun shouldAnnotateClass(processingClassOrObject: KtClassOrObject) = shouldGenerateClass(processingClassOrObject)
-
-    override fun shouldGenerateClassMembers(processingClassOrObject: KtClassOrObject): Boolean {
-        if (classOrObject === processingClassOrObject) return true
-
-        // process all children
-        if (classOrObject.isAncestor(processingClassOrObject, true)) {
-            return true
-        }
-
-        // Local classes should be process by CodegenAnnotatingVisitor to
-        // decide what class they should be placed in.
-        //
-        // Example:
-        // class A
-        // fun foo() {
-        //     trait Z: A {}
-        //     fun bar() {
-        //         class <caret>O2: Z {}
-        //     }
-        // }
-        // TODO: current method will process local classes in irrelevant declarations, it should be fixed.
-        // We generate all enclosing classes
-
-        if (classOrObject.safeIsLocal() && processingClassOrObject.safeIsLocal()) {
-            val commonParent = PsiTreeUtil.findCommonParent(classOrObject, processingClassOrObject)
-            return commonParent != null && commonParent !is PsiFile
-        }
-
-        return false
-    }
-
-    override fun shouldGenerateClass(processingClassOrObject: KtClassOrObject)
-    // generate outer classes but not their members
-            = shouldGenerateClassMembers(processingClassOrObject) || processingClassOrObject.isAncestor(classOrObject, true)
-
-    override fun shouldGenerateScript(script: KtScript) = PsiTreeUtil.isAncestor(script, classOrObject, false)
-    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

@@ -6,62 +6,15 @@
 package org.jetbrains.kotlin.cli.jvm.compiler
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.asJava.classes.getOutermostClassOrObject
-import org.jetbrains.kotlin.asJava.classes.safeIsScript
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory
 import org.jetbrains.kotlin.diagnostics.Errors.*
-import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.KtPropertyAccessor
 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.*
 
-fun getJvmSignatureDiagnostics(element: PsiElement, otherDiagnostics: Diagnostics): Diagnostics? {
-    fun getDiagnosticsForClass(ktClassOrObject: KtClassOrObject): Diagnostics {
-        val outermostClass = getOutermostClassOrObject(ktClassOrObject)
-        return CliExtraDiagnosticsProvider.forClassOrObject(outermostClass)
-    }
-
-    fun doGetDiagnostics(): Diagnostics? {
-        if ((element.containingFile as? KtFile)?.safeIsScript() == true) return null
-
-        var parent = element.parent
-        if (element is KtPropertyAccessor) {
-            parent = parent?.parent
-        }
-        if (element is KtParameter && element.hasValOrVar()) {
-            // property declared in constructor
-            val parentClass = (parent?.parent?.parent as? KtClass)
-            if (parentClass != null) {
-                return getDiagnosticsForClass(parentClass)
-            }
-        }
-        if (element is KtClassOrObject) {
-            return getDiagnosticsForClass(element)
-        }
-
-        when (parent) {
-            is KtFile -> {
-                return CliExtraDiagnosticsProvider.forFacade(parent)
-            }
-
-            is KtClassBody -> {
-                val parentsParent = parent.getParent()
-
-                if (parentsParent is KtClassOrObject) {
-                    return getDiagnosticsForClass(parentsParent)
-                }
-            }
-        }
-        return null
-    }
-
-    val result = doGetDiagnostics() ?: return null
-
-    return FilteredJvmDiagnostics(result, otherDiagnostics)
-}
-
 class FilteredJvmDiagnostics(val jvmDiagnostics: Diagnostics, val otherDiagnostics: Diagnostics) : Diagnostics by jvmDiagnostics {
     companion object {
         private val higherPriorityDiagnosticFactories =

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

@@ -25,7 +25,10 @@ import com.intellij.util.containers.ContainerUtil
 import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
 import org.jetbrains.kotlin.asJava.UltraLightClassModifierExtension
 import org.jetbrains.kotlin.asJava.builder.LightMemberOriginForDeclaration
-import org.jetbrains.kotlin.asJava.elements.*
+import org.jetbrains.kotlin.asJava.elements.KotlinLightTypeParameterListBuilder
+import org.jetbrains.kotlin.asJava.elements.KtLightAnnotationForSourceEntry
+import org.jetbrains.kotlin.asJava.elements.KtLightMethod
+import org.jetbrains.kotlin.asJava.elements.psiType
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.codegen.DescriptorAsmUtil
@@ -476,12 +479,6 @@ inline fun <T> runReadAction(crossinline runnable: () -> T): T {
 @Suppress("NOTHING_TO_INLINE")
 inline fun KtClassOrObject.safeIsLocal(): Boolean = runReadAction { this.isLocal }
 
-@Suppress("NOTHING_TO_INLINE")
-inline fun KtFile.safeIsScript() = runReadAction { this.isScript() }
-
-@Suppress("NOTHING_TO_INLINE")
-inline fun KtFile.safeScript() = runReadAction { this.script }
-
 internal fun KtUltraLightSupport.findAnnotation(owner: KtAnnotated, fqName: FqName): Pair<KtAnnotationEntry, AnnotationDescriptor>? {
 
     val candidates = owner.annotationEntries