Fix propagation of dependency resolution failure reports during script compilation

libraries/scripting/common/src/kotlin/script/experimental/api/scriptCompilation.kt

@@ -274,13 +274,15 @@ fun ScriptCompilationConfiguration.refineOnAnnotations(
     val foundAnnotationNames = collectedData[ScriptCollectedData.foundAnnotations]?.mapTo(HashSet()) { it.annotationClass.java.name }
     if (foundAnnotationNames.isNullOrEmpty()) return this.asSuccess()
 
-    val refinedConfig = this[ScriptCompilationConfiguration.refineConfigurationOnAnnotations]
+    val thisResult: ResultWithDiagnostics<ScriptCompilationConfiguration> = this.asSuccess()
-        ?.fold(this) { config, (annotations, handler) ->
+    return this[ScriptCompilationConfiguration.refineConfigurationOnAnnotations]
+        ?.fold(thisResult) { config, (annotations, handler) ->
+            config.onSuccess {
                 // checking that the collected data contains expected annotations
-            if (annotations.none { foundAnnotationNames.contains(it.typeName) }) config
+                if (annotations.none { foundAnnotationNames.contains(it.typeName) }) it.asSuccess()
-            else handler.invoke(ScriptConfigurationRefinementContext(script, config, collectedData)).valueOr { return it }
+                else handler.invoke(ScriptConfigurationRefinementContext(script, it, collectedData))
             }
-    return (refinedConfig ?: this).asSuccess()
+        } ?: thisResult
 }
 
 fun ScriptCompilationConfiguration.refineBeforeCompiling(

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/dependencies/ScriptsCompilationDependencies.kt

@@ -13,6 +13,8 @@ import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.scripting.definitions.ScriptDependenciesProvider
 import java.io.File
+import kotlin.script.experimental.api.ResultWithDiagnostics
+import kotlin.script.experimental.api.asSuccess
 import kotlin.script.experimental.host.FileBasedScriptSource
 
 data class ScriptsCompilationDependencies(
@@ -22,7 +24,7 @@ data class ScriptsCompilationDependencies(
 ) {
     data class SourceDependencies(
         val scriptFile: KtFile,
-        val sourceDependencies: List<KtFile>
+        val sourceDependencies: ResultWithDiagnostics<List<KtFile>>
     )
 }
 
@@ -42,11 +44,15 @@ fun collectScriptsCompilationDependencies(
         while (true) {
             val newRemainingSources = ArrayList<KtFile>()
             for (source in remainingSources) {
-                val refinedConfiguration = importsProvider.getScriptConfiguration(source)
+                when (val refinedConfiguration = importsProvider.getScriptConfigurationResult(source)) {
-                if (refinedConfiguration != null) {
+                    null -> {}
-                    collectedClassPath.addAll(refinedConfiguration.dependenciesClassPath)
+                    is ResultWithDiagnostics.Failure -> {
+                        collectedSourceDependencies.add(ScriptsCompilationDependencies.SourceDependencies(source, refinedConfiguration))
+                    }
+                    is ResultWithDiagnostics.Success -> {
+                        collectedClassPath.addAll(refinedConfiguration.value.dependenciesClassPath)
 
-                    val sourceDependenciesRoots = refinedConfiguration.importedScripts.mapNotNull {
+                        val sourceDependenciesRoots = refinedConfiguration.value.importedScripts.mapNotNull {
                             // TODO: support any kind of ScriptSource.
                             val path = (it as? FileBasedScriptSource)?.file?.path ?: return@mapNotNull null
                             KotlinSourceRoot(path, false)
@@ -61,7 +67,7 @@ fun collectScriptsCompilationDependencies(
                             collectedSourceDependencies.add(
                                 ScriptsCompilationDependencies.SourceDependencies(
                                     source,
-                                sourceDependencies
+                                    sourceDependencies.asSuccess(refinedConfiguration.reports)
                                 )
                             )
 
@@ -74,6 +80,7 @@ fun collectScriptsCompilationDependencies(
                         }
                     }
                 }
+            }
             if (newRemainingSources.isEmpty()) break
             else {
                 remainingSources = newRemainingSources

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

@@ -103,6 +103,12 @@ class KJvmReplCompilerImpl(val hostConfiguration: ScriptingHostConfiguration) :
                 messageCollector
             )
 
+            val firstFailure = sourceDependencies.firstOrNull { it.sourceDependencies is ResultWithDiagnostics.Failure }
+                ?.let { it.sourceDependencies as ResultWithDiagnostics.Failure }
+
+            if (firstFailure != null)
+                return firstFailure
+
             if (history.isEmpty()) {
                 val updatedConfiguration = ScriptDependenciesProvider.getInstance(context.environment.project)
                     ?.getScriptConfiguration(snippetKtFile)?.configuration
@@ -165,7 +171,7 @@ class KJvmReplCompilerImpl(val hostConfiguration: ScriptingHostConfiguration) :
                         ?: context.baseScriptCompilationConfiguration
                 }
 
-            ResultWithDiagnostics.Success(compiledScript, messageCollector.diagnostics)
+            compiledScript.asSuccess(messageCollector.diagnostics)
         }
 }
 

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

@@ -119,7 +119,7 @@ internal fun makeCompiledScript(
 
         val containingKtFile = script.containingKtFile
         val otherScripts: List<KJvmCompiledScript<*>> =
-            sourceDependencies.find { it.scriptFile == containingKtFile }?.sourceDependencies?.mapNotNull { sourceFile ->
+            sourceDependencies.find { it.scriptFile == containingKtFile }?.sourceDependencies?.valueOrThrow()?.mapNotNull { sourceFile ->
                 sourceFile.declarations.firstIsInstanceOrNull<KtScript>()?.let {
                     KJvmCompiledScript<Any>(
                         containingKtFile.virtualFile?.path,