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 oldClasspath =
+                scriptCompilationConfiguration[ScriptCompilationConfiguration.dependencies]
+                    ?.flatMap { (it as JvmDependency).classpath } ?: emptyList()
+
+            val defaultImports = scriptCompilationConfiguration[ScriptCompilationConfiguration.defaultImports]?.toList() ?: emptyList()
+
             val refineFn = scriptCompilationConfiguration[ScriptCompilationConfiguration.refineConfigurationOnAnnotations]?.handler
-            val refinedConfiguration =
+                ?: return DependenciesResolver.ResolveResult.Success(
-                if (refineFn == null) null
+                    ScriptDependencies(classpath = oldClasspath, imports = defaultImports),
-                else {
+                    diagnostics
-                    val res = refineFn(
+                )
+
+            val refineResults = refineFn(
                 ScriptConfigurationRefinementContext(scriptContents.toScriptSource(), scriptCompilationConfiguration, processedScriptData)
             )
-                    when (res) {
+            val refinedConfiguration = when (refineResults) {
                 is ResultWithDiagnostics.Failure ->
-                            return@resolveAsync DependenciesResolver.ResolveResult.Failure(res.reports.mapScriptReportsToDiagnostics())
+                    return DependenciesResolver.ResolveResult.Failure(refineResults.reports.mapScriptReportsToDiagnostics())
                 is ResultWithDiagnostics.Success -> {
-                            diagnostics.addAll(res.reports.mapScriptReportsToDiagnostics())
+                    diagnostics.addAll(refineResults.reports.mapScriptReportsToDiagnostics())
-                            res.value
+                    refineResults.value
-                        }
                 }
             }
 
-            val newClasspath = refinedConfiguration?.get(ScriptCompilationConfiguration.dependencies)
+            val newClasspath = refinedConfiguration[ScriptCompilationConfiguration.dependencies]
-                ?.flatMap { (it as JvmDependency).classpath } ?: emptyList()
-            if (newClasspath.isNotEmpty()) {
-                val oldClasspath =
-                    scriptCompilationConfiguration[ScriptCompilationConfiguration.dependencies]
                 ?.flatMap { (it as JvmDependency).classpath } ?: emptyList()
             if (newClasspath != oldClasspath) {
                 onClasspathUpdated(newClasspath)
             }
-            }
+
-            DependenciesResolver.ResolveResult.Success(
+            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")
             )
         }