Fix bridge resolver behaviour on static dependencies

libraries/scripting/jvm/src/kotlin/script/experimental/jvm/impl/BridgeDependenciesResolver.kt

@@ -30,7 +30,7 @@ class BridgeDependenciesResolver(
         }
 
     override suspend fun resolveAsync(scriptContents: ScriptContents, environment: Environment): DependenciesResolver.ResolveResult {
-        return try {
+        try {
 
             val diagnostics = arrayListOf<ScriptReport>()
             val processedScriptData = ScriptCollectedData(
@@ -39,42 +39,45 @@ class BridgeDependenciesResolver(
                 )
             )
 
-            val refineFn = scriptCompilationConfiguration[ScriptCompilationConfiguration.refineConfigurationOnAnnotations]?.handler
+            val oldClasspath =
-            val refinedConfiguration =
+                scriptCompilationConfiguration[ScriptCompilationConfiguration.dependencies]
-                if (refineFn == null) null
+                    ?.flatMap { (it as JvmDependency).classpath } ?: emptyList()
-                else {
-                    val res = refineFn(
-                        ScriptConfigurationRefinementContext(scriptContents.toScriptSource(), scriptCompilationConfiguration, processedScriptData)
-                    )
-                    when (res) {
-                        is ResultWithDiagnostics.Failure ->
-                            return@resolveAsync DependenciesResolver.ResolveResult.Failure(res.reports.mapScriptReportsToDiagnostics())
-                        is ResultWithDiagnostics.Success -> {
-                            diagnostics.addAll(res.reports.mapScriptReportsToDiagnostics())
-                            res.value
-                        }
-                    }
-                }
 
-            val newClasspath = refinedConfiguration?.get(ScriptCompilationConfiguration.dependencies)
+            val defaultImports = scriptCompilationConfiguration[ScriptCompilationConfiguration.defaultImports]?.toList() ?: emptyList()
-                ?.flatMap { (it as JvmDependency).classpath } ?: emptyList()
+
-            if (newClasspath.isNotEmpty()) {
+            val refineFn = scriptCompilationConfiguration[ScriptCompilationConfiguration.refineConfigurationOnAnnotations]?.handler
-                val oldClasspath =
+                ?: return DependenciesResolver.ResolveResult.Success(
-                    scriptCompilationConfiguration[ScriptCompilationConfiguration.dependencies]
+                    ScriptDependencies(classpath = oldClasspath, imports = defaultImports),
-                        ?.flatMap { (it as JvmDependency).classpath } ?: emptyList()
+                    diagnostics
-                if (newClasspath != oldClasspath) {
+                )
-                    onClasspathUpdated(newClasspath)
+
+            val refineResults = refineFn(
+                ScriptConfigurationRefinementContext(scriptContents.toScriptSource(), scriptCompilationConfiguration, processedScriptData)
+            )
+            val refinedConfiguration = when (refineResults) {
+                is ResultWithDiagnostics.Failure ->
+                    return DependenciesResolver.ResolveResult.Failure(refineResults.reports.mapScriptReportsToDiagnostics())
+                is ResultWithDiagnostics.Success -> {
+                    diagnostics.addAll(refineResults.reports.mapScriptReportsToDiagnostics())
+                    refineResults.value
                 }
             }
-            DependenciesResolver.ResolveResult.Success(
+
+            val newClasspath = refinedConfiguration[ScriptCompilationConfiguration.dependencies]
+                ?.flatMap { (it as JvmDependency).classpath } ?: emptyList()
+            if (newClasspath != oldClasspath) {
+                onClasspathUpdated(newClasspath)
+            }
+
+            return DependenciesResolver.ResolveResult.Success(
                 ScriptDependencies(
                     classpath = newClasspath, // TODO: maybe it should return only increment from the initial config
-                    imports = scriptCompilationConfiguration[ScriptCompilationConfiguration.defaultImports]?.toList() ?: emptyList()
+                    imports = defaultImports
                 ),
                 diagnostics
             )
         } catch (e: Throwable) {
-            DependenciesResolver.ResolveResult.Failure(
+            return DependenciesResolver.ResolveResult.Failure(
                 ScriptReport(e.message ?: "unknown error $e")
             )
         }