Rewrite scripting related API to PsiFile instead of VirtualFile

There were several places where we converted virtualFile to PsiFile. This operation need a read access and may throw ProcessCanceledException,
so we want to minimize its usages in IDE

plugins/scripting/scripting-compiler-impl/src/org/jetbrains/kotlin/scripting/definitions/ScriptDependenciesProvider.kt

@@ -9,24 +9,29 @@ import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiFile
+import com.intellij.psi.PsiManager
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.scripting.resolve.ScriptCompilationConfigurationResult
 import kotlin.script.experimental.api.valueOrNull
 import kotlin.script.experimental.dependencies.ScriptDependencies
 
-interface ScriptDependenciesProvider {
+open class ScriptDependenciesProvider constructor(
+    protected val project: Project
+) {
 
     @Deprecated("Migrating to configuration refinement", level = DeprecationLevel.ERROR)
-    fun getScriptDependencies(file: VirtualFile): ScriptDependencies? =
-        getScriptConfigurationResult(file)?.valueOrNull()?.legacyDependencies
+    fun getScriptDependencies(file: VirtualFile): ScriptDependencies? {
+        val ktFile = PsiManager.getInstance(project).findFile(file) as? KtFile ?: return null
+        return getScriptConfigurationResult(ktFile)?.valueOrNull()?.legacyDependencies
+    }
 
     @Deprecated("Migrating to configuration refinement", level = DeprecationLevel.ERROR)
-    fun getScriptDependencies(file: PsiFile): ScriptDependencies? =
-        getScriptConfigurationResult(file.virtualFile ?: file.originalFile.virtualFile)?.valueOrNull()?.legacyDependencies
+    fun getScriptDependencies(file: PsiFile): ScriptDependencies? {
+        if (file !is KtFile) return null
+        return getScriptConfigurationResult(file)?.valueOrNull()?.legacyDependencies
+    }
 
-    fun getScriptConfigurationResult(file: VirtualFile): ScriptCompilationConfigurationResult? = null
-
-    fun getScriptConfigurationResult(file: PsiFile): ScriptCompilationConfigurationResult? =
-        getScriptConfigurationResult(file.virtualFile ?: file.originalFile.virtualFile)
+    open fun getScriptConfigurationResult(file: KtFile): ScriptCompilationConfigurationResult? = null
 
     companion object {
         fun getInstance(project: Project): ScriptDependenciesProvider? =

plugins/scripting/scripting-compiler-impl/src/org/jetbrains/kotlin/scripting/definitions/definitions.kt

@@ -25,18 +25,20 @@ inline fun <T> runReadAction(crossinline runnable: () -> T): T {
 fun PsiFile.findScriptDefinition(): ScriptDefinition? {
     // Do not use psiFile.script, see comments in findScriptDefinition
     if (this !is KtFile/* || this.script == null*/) return null
-    val file = virtualFile ?: originalFile.virtualFile ?: return null
-    if (file.isNonScript()) return null
 
-    return findScriptDefinitionByFilePath(project, File(file.path))
+    val virtualFile = this.virtualFile ?: this.originalFile.virtualFile ?: return null
+    if (virtualFile.isNonScript()) return null
+
+    return findScriptDefinitionByFilePath(project, File(virtualFile.path))
 }
 
+@Deprecated("Use PsiFile.findScriptDefinition() instead")
 fun VirtualFile.findScriptDefinition(project: Project): ScriptDefinition? {
     if (!isValid || isNonScript()) return null
+
     // Do not use psiFile.script here because this method can be called during indexes access
     // and accessing stubs may cause deadlock
     // TODO: measure performance effect and if necessary consider detecting indexing here or using separate logic for non-IDE operations to speed up filtering
-
     if (runReadAction { PsiManager.getInstance(project).findFile(this) as? KtFile }/*?.script*/ == null) return null
 
     return findScriptDefinitionByFilePath(project, File(path))

plugins/scripting/scripting-compiler-impl/src/org/jetbrains/kotlin/scripting/definitions/dynamicConfigurations.kt

@@ -5,8 +5,6 @@
 
 package org.jetbrains.kotlin.scripting.definitions
 
-import com.intellij.openapi.project.Project
-import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.scripting.resolve.ScriptCompilationConfigurationResult
@@ -27,16 +25,6 @@ fun PsiFile.findScriptCompilationConfiguration(): ScriptCompilationConfiguration
         ?: findScriptDefinition()?.compilationConfiguration
 }
 
-fun VirtualFile.findScriptCompilationConfiguration(project: Project): ScriptCompilationConfiguration? {
-    if (!isValid || isNonScript()) return null
-    // see comments in findScriptDefinition
-    // we do not need expensive check as in findScriptDefinition here, since it is assumed that this function is called only for known scripts
-
-    val provider = ScriptDependenciesProvider.getInstance(project)
-    return provider?.getScriptConfigurationResult(this)?.valueOrError()?.configuration
-        ?: findScriptDefinition(project)?.compilationConfiguration
-}
-
 private fun ScriptCompilationConfigurationResult.valueOrError() = valueOr { failure ->
     val singleCause = failure.reports.singleOrNull { it.severity == ScriptDiagnostic.Severity.ERROR }
     if (singleCause != null)

plugins/scripting/scripting-compiler-impl/src/org/jetbrains/kotlin/scripting/extensions/ScriptExtraImportsProviderExtension.kt

@@ -29,7 +29,9 @@ class ScriptExtraImportsProviderExtension : ExtraImportsProviderExtension {
 
     override fun getExtraImports(ktFile: KtFile): Collection<KtImportInfo> =
         ktFile.takeIf { it.isScript() }?.let { file ->
-            val refinedConfiguration = ScriptDependenciesProvider.getInstance(file.project)?.getScriptConfigurationResult(file.originalFile)?.valueOrNull()
+            val refinedConfiguration = ScriptDependenciesProvider.getInstance(file.project)
+                ?.getScriptConfigurationResult(file.originalFile as KtFile)
+                ?.valueOrNull()
             refinedConfiguration?.defaultImports?.map {
                 ScriptExtraImportImpl(
                     ImportPath.fromString(it)

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/definitions/CliScriptDependenciesProvider.kt

@@ -8,38 +8,37 @@ package org.jetbrains.kotlin.scripting.compiler.plugin.definitions
 import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.vfs.VirtualFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.scripting.definitions.ScriptDependenciesProvider
 import org.jetbrains.kotlin.scripting.definitions.findScriptDefinition
+import org.jetbrains.kotlin.scripting.resolve.KtFileScriptSource
 import org.jetbrains.kotlin.scripting.resolve.ScriptCompilationConfigurationResult
 import org.jetbrains.kotlin.scripting.resolve.ScriptReportSink
-import org.jetbrains.kotlin.scripting.resolve.VirtualFileScriptSource
 import org.jetbrains.kotlin.scripting.resolve.refineScriptCompilationConfiguration
 import java.io.File
 import java.util.concurrent.locks.ReentrantReadWriteLock
 import kotlin.concurrent.read
 import kotlin.concurrent.write
 import kotlin.script.experimental.api.ResultWithDiagnostics
-import kotlin.script.experimental.jvm.compat.mapToLegacyReports
 
-class CliScriptDependenciesProvider(private val project: Project) : ScriptDependenciesProvider {
+class CliScriptDependenciesProvider(project: Project) : ScriptDependenciesProvider(project) {
     private val cacheLock = ReentrantReadWriteLock()
     private val cache = hashMapOf<String, ScriptCompilationConfigurationResult?>()
 
-    override fun getScriptConfigurationResult(file: VirtualFile): ScriptCompilationConfigurationResult? = cacheLock.read {
+    override fun getScriptConfigurationResult(file: KtFile): ScriptCompilationConfigurationResult? = cacheLock.read {
         calculateRefinedConfiguration(file)
     }
 
-    private fun calculateRefinedConfiguration(file: VirtualFile): ScriptCompilationConfigurationResult? {
-        val path = file.path
+    private fun calculateRefinedConfiguration(file: KtFile): ScriptCompilationConfigurationResult? {
+        val path = file.virtualFilePath
         val cached = cache[path]
         return if (cached != null) cached
         else {
-            val scriptDef = file.findScriptDefinition(project)
+            val scriptDef = file.findScriptDefinition()
             if (scriptDef != null) {
-                val result = refineScriptCompilationConfiguration(VirtualFileScriptSource(file), scriptDef, project)
+                val result = refineScriptCompilationConfiguration(KtFileScriptSource(file), scriptDef, project)
 
-                ServiceManager.getService(project, ScriptReportSink::class.java)?.attachReports(file, result.reports)
+                ServiceManager.getService(project, ScriptReportSink::class.java)?.attachReports(file.virtualFile, result.reports)
 
                 if (result is ResultWithDiagnostics.Success) {
                     log.info("[kts] new cached deps for $path: ${result.value.dependenciesClassPath.joinToString(File.pathSeparator)}")