Use scripting cache earlier in the pipeline:

before initializing compiler and processing callbacks

libraries/scripting/jvm-host-test/test/kotlin/script/experimental/jvmhost/test/CachingTest.kt

@@ -127,7 +127,7 @@ class CachingTest : TestCase() {
         Assert.assertEquals(1, cache.storedScripts)
         Assert.assertEquals(0, cache.retrievedScripts)
 
-        val cachedScript = cache.get(script.toScriptSource(), compiledScript!!.compilationConfiguration)
+        val cachedScript = cache.get(script.toScriptSource(), scriptCompilationConfiguration)
         Assert.assertNotNull(cachedScript)
         Assert.assertEquals(1, cache.retrievedScripts)
 

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

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.scripting.compiler.plugin.impl
 import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
+import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.compiler.NoScopeRecordCliBindingTrace
 import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
@@ -36,16 +37,17 @@ class ScriptJvmCompilerIsolated(val hostConfiguration: ScriptingHostConfiguratio
         scriptCompilationConfiguration: ScriptCompilationConfiguration
     ): ResultWithDiagnostics<CompiledScript<*>> =
         withMessageCollectorAndDisposable(script = script) { messageCollector, disposable ->
+            withScriptCompilationCache(script, scriptCompilationConfiguration, messageCollector) {
+                val initialConfiguration = scriptCompilationConfiguration.refineBeforeParsing(script).valueOr {
+                    return@withScriptCompilationCache it
+                }
 
-            val initialConfiguration = scriptCompilationConfiguration.refineBeforeParsing(script).valueOr {
+                val context = createIsolatedCompilationContext(
-                return it
+                    initialConfiguration, hostConfiguration, messageCollector, disposable
+                )
+
+                compileImpl(script, context, messageCollector)
             }
-
-            val context = createIsolatedCompilationContext(
-                initialConfiguration, hostConfiguration, messageCollector, disposable
-            )
-
-            compileImpl(script, context, messageCollector)
         }
 }
 
@@ -57,22 +59,41 @@ class ScriptJvmCompilerFromEnvironment(val environment: KotlinCoreEnvironment) :
     ): ResultWithDiagnostics<CompiledScript<*>> {
         val parentMessageCollector = environment.configuration[CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY]
         return withMessageCollector(script = script, parentMessageCollector = parentMessageCollector) { messageCollector ->
+            withScriptCompilationCache(script, scriptCompilationConfiguration, messageCollector) {
 
-            val initialConfiguration = scriptCompilationConfiguration.refineBeforeParsing(script).valueOr {
+                val initialConfiguration = scriptCompilationConfiguration.refineBeforeParsing(script).valueOr {
-                return it
+                    return@withScriptCompilationCache it
+                }
+
+                val context = createCompilationContextFromEnvironment(initialConfiguration, environment, messageCollector)
+
+                try {
+                    environment.configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector)
+
+                    compileImpl(script, context, messageCollector)
+                } finally {
+                    if (parentMessageCollector != null)
+                        environment.configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, parentMessageCollector)
+                }
             }
+        }
+    }
+}
 
-            val context = createCompilationContextFromEnvironment(initialConfiguration, environment, messageCollector)
+private fun withScriptCompilationCache(
+    script: SourceCode,
+    scriptCompilationConfiguration: ScriptCompilationConfiguration,
+    messageCollector: ScriptDiagnosticsMessageCollector,
+    body: () -> ResultWithDiagnostics<CompiledScript<*>>
+): ResultWithDiagnostics<CompiledScript<*>> {
+    val cache = scriptCompilationConfiguration[ScriptCompilationConfiguration.hostConfiguration]?.get(ScriptingHostConfiguration.jvm.compilationCache)
 
-            try {
+    val cached = cache?.get(script, scriptCompilationConfiguration)
-                environment.configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector)
 
-                compileImpl(script, context, messageCollector)
+    return if (cached != null) cached.asSuccess(messageCollector.diagnostics)
-
+    else body().also {
-            } finally {
+        if (cache != null && it is ResultWithDiagnostics.Success) {
-                if (parentMessageCollector != null)
+            cache.store(it.value, script, scriptCompilationConfiguration)
-                    environment.configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, parentMessageCollector)
-            }
         }
     }
 }
@@ -117,18 +138,7 @@ private fun compileImpl(
             }
     }
 
-    val refinedConfiguration = getScriptConfiguration(mainKtFile)
+    return doCompile(context, script, sourceFiles, sourceDependencies, messageCollector, getScriptConfiguration)
-
-    val cache = refinedConfiguration[ScriptCompilationConfiguration.hostConfiguration]?.get(ScriptingHostConfiguration.jvm.compilationCache)
-
-    val cached = cache?.get(script, refinedConfiguration)
-
-    return cached?.asSuccess(messageCollector.diagnostics)
-        ?: doCompile(context, script, sourceFiles, sourceDependencies, messageCollector, getScriptConfiguration).also {
-            if (cache != null && it is ResultWithDiagnostics.Success) {
-                cache.store(it.value, script, refinedConfiguration)
-            }
-        }
 }
 
 internal fun registerPackageFragmentProvidersIfNeeded(