Remove redundant direct usages of the ScriptDefinition in compiler

plus some refactoring around definition extraction

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java

@@ -84,6 +84,8 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
 
     private final SyntheticResolveExtension syntheticResolveExtension;
 
+    private Project project;
+
     @Inject
     public void setAnnotationResolve(AnnotationResolver annotationResolver) {
         this.annotationResolver = annotationResolver;
@@ -190,6 +192,8 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
         danglingAnnotations = storageManager.createMemoizedFunction(file -> createAnnotations(file, file.getDanglingAnnotations()));
 
         syntheticResolveExtension = SyntheticResolveExtension.Companion.getInstance(project);
+
+        this.project = project;
     }
 
     private LazyAnnotations createAnnotations(KtFile file, List<KtAnnotationEntry> annotationEntries) {
@@ -451,6 +455,11 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
         return platformDiagnosticSuppressor;
     }
 
+    @NotNull
+    public Project getProject() {
+        return project;
+    }
+
     @Override
     public void assertValid() {
         module.assertValid();

compiler/psi/src/org/jetbrains/kotlin/psi/KtScript.java

@@ -20,23 +20,14 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.name.FqName;
+import org.jetbrains.kotlin.name.Name;
+import org.jetbrains.kotlin.name.NameUtils;
 import org.jetbrains.kotlin.psi.stubs.KotlinScriptStub;
 import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
-import org.jetbrains.kotlin.script.KotlinScriptDefinition;
-import org.jetbrains.kotlin.script.ScriptDefinitionProvider;
 
 import java.util.List;
 
 public class KtScript extends KtNamedDeclarationStub<KotlinScriptStub> implements KtDeclarationContainer {
-    public KotlinScriptDefinition getKotlinScriptDefinition() {
-        ScriptDefinitionProvider definitionsProvider = ScriptDefinitionProvider.Companion.getInstance(getProject());
-        if (definitionsProvider == null) {
-            throw new IllegalStateException("Unable to use KtScript: ScriptDefinitionProvider is not configured.");
-        }
-        KotlinScriptDefinition definition = definitionsProvider.findScriptDefinition(getContainingKtFile().getName());
-        return definition != null ? definition : definitionsProvider.getDefaultScriptDefinition();
-    }
-
     public KtScript(@NotNull ASTNode node) {
         super(node);
     }
@@ -53,7 +44,8 @@ public class KtScript extends KtNamedDeclarationStub<KotlinScriptStub> implement
             return stub.getFqName();
         }
         KtFile containingKtFile = getContainingKtFile();
-        return containingKtFile.getPackageFqName().child(getKotlinScriptDefinition().getScriptName(this));
+        Name fileBasedName = NameUtils.getScriptNameForFile(containingKtFile.getName());
+        return containingKtFile.getPackageFqName().child(fileBasedName);
     }
 
     @Override

compiler/psi/src/org/jetbrains/kotlin/script/KotlinScriptDefinitionProvider.kt

@@ -39,39 +39,37 @@ interface ScriptDefinitionProvider {
     }
 }
 
-fun findScriptDefinition(psiFile: PsiFile): KotlinScriptDefinition? {
-    val virtualFile = psiFile.virtualFile ?: psiFile.originalFile.virtualFile ?: return null
-    return findScriptDefinition(virtualFile, psiFile.project)
+fun PsiFile.scriptDefinition(): KotlinScriptDefinition? {
+    if (this !is KtFile || this.script == null) return null
+    val file = virtualFile ?: originalFile.virtualFile ?: return null
+    if (file.isNonScript()) return null
+
+    return scriptDefinitionByFileName(project, file.name)
 }
 
 fun findScriptDefinition(file: VirtualFile, project: Project): KotlinScriptDefinition? {
-    if (file.isDirectory ||
-        file.extension == KotlinFileType.EXTENSION ||
-        file.extension == JavaClassFileType.INSTANCE.defaultExtension ||
-        !isKotlinFileType(file)
-    ) {
-        return null
-    }
+    if (file.isNonScript()) return null
+    if ((PsiManager.getInstance(project).findFile(file) as? KtFile)?.script == null) return null
 
+    return scriptDefinitionByFileName(project, file.name)
+}
+
+fun scriptDefinitionByFileName(project: Project, fileName: String): KotlinScriptDefinition {
     val scriptDefinitionProvider = ScriptDefinitionProvider.getInstance(project) ?: return null
-    val psiFile = PsiManager.getInstance(project).findFile(file)
-    if (psiFile != null) {
-        if (psiFile !is KtFile) return null
+        ?: throw IllegalStateException("Unable to get script definition: ScriptDefinitionProvider is not configured.")
 
-        // Do not use psiFile.script here because this method can be called during indexes access
-        // and accessing stubs may cause deadlock
-        // If script definition cannot be find, default script definition is used
-        // because all KtFile-s with KotlinFileType and non-kts extensions are parsed as scripts
-        val definition = scriptDefinitionProvider.findScriptDefinition(file.name)
-        return definition ?: scriptDefinitionProvider.getDefaultScriptDefinition()
-    }
-
-    return scriptDefinitionProvider.findScriptDefinition(file.name)
+    return scriptDefinitionProvider.findScriptDefinition(fileName) ?: scriptDefinitionProvider.getDefaultScriptDefinition()
 }
 
-private fun isKotlinFileType(file: VirtualFile): Boolean {
+private fun VirtualFile.isNonScript(): Boolean =
+    isDirectory ||
+            extension == KotlinFileType.EXTENSION ||
+            extension == JavaClassFileType.INSTANCE.defaultExtension ||
+            !this.isKotlinFileType()
+
+private fun VirtualFile.isKotlinFileType(): Boolean {
     val typeRegistry = FileTypeRegistry.getInstance()
-    return typeRegistry.getFileTypeByFile(file) == KotlinFileType.INSTANCE ||
-            typeRegistry.getFileTypeByFileName(file.name) == KotlinFileType.INSTANCE
+    return typeRegistry.getFileTypeByFile(this) == KotlinFileType.INSTANCE ||
+            typeRegistry.getFileTypeByFileName(name) == KotlinFileType.INSTANCE
 }