diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt index 149d2892054..22714b2399c 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt @@ -22,7 +22,6 @@ import com.intellij.codeInsight.InferredAnnotationsManager import com.intellij.codeInsight.runner.JavaMainMethodProvider import com.intellij.core.* import com.intellij.ide.highlighter.JavaFileType -import com.intellij.ide.plugins.PluginManagerCore import com.intellij.lang.MetaLanguage import com.intellij.lang.java.JavaParserDefinition import com.intellij.openapi.Disposable @@ -241,16 +240,11 @@ class KotlinCoreEnvironment private constructor( } sourceFiles += createKtFiles(project) - sourceFiles.sortBy { it.virtualFile.path } if (scriptDefinitionProvider != null) { - ScriptDependenciesProvider.getInstance(project).let { importsProvider -> - configuration.addJvmClasspathRoots( - sourceFiles.mapNotNull(importsProvider::getScriptDependencies) - .flatMap { it.classpath } - .distinctBy { it.absolutePath }) - } + sourceFiles += collectRequiredSourcesFromDependencies(configuration, project, sourceFiles) } + sourceFiles.sortBy { it.virtualFile.path } val jdkHome = configuration.get(JVMConfigurationKeys.JDK_HOME) val jrtFileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.JRT_PROTOCOL) @@ -427,61 +421,13 @@ class KotlinCoreEnvironment private constructor( fun getSourceFiles(): List = sourceFiles - private fun createKtFiles(project: Project): List { - val sourceRoots = getSourceRootsCheckingForDuplicates() + private fun createKtFiles(project: Project): List = + createSourceFilesFromSourceRoots(configuration, project, getSourceRootsCheckingForDuplicates()) - val localFileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL) - val psiManager = PsiManager.getInstance(project) - - val processedFiles = hashSetOf() - val result = mutableListOf() - - val virtualFileCreator = PreprocessedFileCreator(project) - - for ((sourceRootPath, isCommon) in sourceRoots) { - val vFile = localFileSystem.findFileByPath(sourceRootPath) - if (vFile == null) { - val message = "Source file or directory not found: $sourceRootPath" - - val buildFilePath = configuration.get(JVMConfigurationKeys.MODULE_XML_FILE) - if (buildFilePath != null && Logger.isInitialized()) { - LOG.warn("$message\n\nbuild file path: $buildFilePath\ncontent:\n${buildFilePath.readText()}") - } - - report(ERROR, message) - continue - } - - if (!vFile.isDirectory && vFile.fileType != KotlinFileType.INSTANCE) { - report(ERROR, "Source entry is not a Kotlin file: $sourceRootPath") - continue - } - - for (file in File(sourceRootPath).walkTopDown()) { - if (!file.isFile) continue - - val virtualFile = localFileSystem.findFileByPath(file.absolutePath)?.let(virtualFileCreator::create) - if (virtualFile != null && processedFiles.add(virtualFile)) { - val psiFile = psiManager.findFile(virtualFile) - if (psiFile is KtFile) { - result.add(psiFile) - if (isCommon) { - psiFile.isCommonSource = true - } - } - } - } - } - - return result - } - - private fun report(severity: CompilerMessageSeverity, message: String) { - configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY).report(severity, message) - } + internal fun report(severity: CompilerMessageSeverity, message: String) = report(configuration, severity, message) companion object { - private val LOG = Logger.getInstance(KotlinCoreEnvironment::class.java) + internal val LOG = Logger.getInstance(KotlinCoreEnvironment::class.java) private val APPLICATION_LOCK = Object() private var ourApplicationEnvironment: JavaCoreApplicationEnvironment? = null @@ -701,3 +647,85 @@ class KotlinCoreEnvironment private constructor( } } } + +private fun report(configuration: CompilerConfiguration, severity: CompilerMessageSeverity, message: String) { + configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY).report(severity, message) +} + +private fun createSourceFilesFromSourceRoots( + configuration: CompilerConfiguration, + project: Project, + sourceRoots: List +): MutableList { + val localFileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL) + val psiManager = PsiManager.getInstance(project) + + val processedFiles = hashSetOf() + val result = mutableListOf() + + val virtualFileCreator = PreprocessedFileCreator(project) + + for ((sourceRootPath, isCommon) in sourceRoots) { + val vFile = localFileSystem.findFileByPath(sourceRootPath) + if (vFile == null) { + val message = "Source file or directory not found: $sourceRootPath" + + val buildFilePath = configuration.get(JVMConfigurationKeys.MODULE_XML_FILE) + if (buildFilePath != null && Logger.isInitialized()) { + KotlinCoreEnvironment.LOG.warn("$message\n\nbuild file path: $buildFilePath\ncontent:\n${buildFilePath.readText()}") + } + + report(configuration, ERROR, message) + continue + } + + if (!vFile.isDirectory && vFile.fileType != KotlinFileType.INSTANCE) { + report(configuration, ERROR, "Source entry is not a Kotlin file: $sourceRootPath") + continue + } + + for (file in File(sourceRootPath).walkTopDown()) { + if (!file.isFile) continue + + val virtualFile = localFileSystem.findFileByPath(file.absolutePath)?.let(virtualFileCreator::create) + if (virtualFile != null && processedFiles.add(virtualFile)) { + val psiFile = psiManager.findFile(virtualFile) + if (psiFile is KtFile) { + result.add(psiFile) + if (isCommon) { + psiFile.isCommonSource = true + } + } + } + } + } + + return result +} + +fun collectRequiredSourcesFromDependencies( + configuration: CompilerConfiguration, + project: Project, + initialSources: Iterable +): List { + val collectedSources = ArrayList() + val importsProvider = ScriptDependenciesProvider.getInstance(project) + var remainingSources = initialSources.sortedBy { it.virtualFile.path } + val knownSourcePaths = HashSet() + while (true) { + val dependencies = remainingSources.mapNotNull(importsProvider::getScriptDependencies) + configuration.addJvmClasspathRoots(dependencies.flatMap { it.classpath }.distinctBy { it.absolutePath }) + val addedSourceRoots = dependencies.flatMap { it.scripts.map { KotlinSourceRoot(it.path, false) } } + val addedSources = createSourceFilesFromSourceRoots(configuration, project, addedSourceRoots) + val newSources = if (addedSources.isEmpty()) emptyList() else { + remainingSources.forEach { knownSourcePaths.add(it.virtualFile.path) } + addedSources.filterNot { knownSourcePaths.contains(it.virtualFile.path) } + } + if (newSources.isEmpty()) break + else { + collectedSources += newSources + remainingSources = newSources + } + } + return collectedSources +} diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt index aeabc058d29..a49eba3b1e7 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt @@ -267,7 +267,7 @@ object KotlinToJVMBytecodeCompiler { } } - internal fun compileAndExecuteScript(environment: KotlinCoreEnvironment, scriptArgs: List): ExitCode { + fun compileAndExecuteScript(environment: KotlinCoreEnvironment, scriptArgs: List): ExitCode { val scriptClass = compileScript(environment) ?: return ExitCode.COMPILATION_ERROR try { diff --git a/compiler/testData/script/hello.kts b/compiler/testData/script/hello.kts new file mode 100644 index 00000000000..dce07af0106 --- /dev/null +++ b/compiler/testData/script/hello.kts @@ -0,0 +1,2 @@ + +print("Hello from basic script!") \ No newline at end of file diff --git a/compiler/testData/script/hello.req1.kts b/compiler/testData/script/hello.req1.kts new file mode 100644 index 00000000000..56859ed15ae --- /dev/null +++ b/compiler/testData/script/hello.req1.kts @@ -0,0 +1,4 @@ + +@file:Import("hello_req.kt") + +print("Hello from ${RequiredFromHello().name}!") \ No newline at end of file diff --git a/compiler/testData/script/hello_args.kts b/compiler/testData/script/hello_args.kts new file mode 100644 index 00000000000..8397b0be807 --- /dev/null +++ b/compiler/testData/script/hello_args.kts @@ -0,0 +1,2 @@ + +print("Hello, ${args[0]}!") \ No newline at end of file diff --git a/compiler/testData/script/hello_req.kt b/compiler/testData/script/hello_req.kt new file mode 100644 index 00000000000..b71765c5e42 --- /dev/null +++ b/compiler/testData/script/hello_req.kt @@ -0,0 +1,5 @@ + +class RequiredFromHello { + + val name = "required" +} diff --git a/compiler/tests/org/jetbrains/kotlin/scripts/ScriptCliCompilationTest.kt b/compiler/tests/org/jetbrains/kotlin/scripts/ScriptCliCompilationTest.kt new file mode 100644 index 00000000000..c25d1d25831 --- /dev/null +++ b/compiler/tests/org/jetbrains/kotlin/scripts/ScriptCliCompilationTest.kt @@ -0,0 +1,148 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.scripts + +import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY +import org.jetbrains.kotlin.cli.common.ExitCode +import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoot +import org.jetbrains.kotlin.cli.common.messages.MessageCollector +import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles +import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment +import org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler +import org.jetbrains.kotlin.config.JVMConfigurationKeys +import org.jetbrains.kotlin.daemon.TestMessageCollector +import org.jetbrains.kotlin.script.KotlinScriptDefinition +import org.jetbrains.kotlin.scripting.compiler.plugin.KotlinScriptDefinitionAdapterFromNewAPI +import org.jetbrains.kotlin.test.ConfigurationKind +import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.TestJdkKind +import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase +import org.jetbrains.kotlin.utils.PathUtil +import org.junit.Assert +import org.junit.Test +import java.io.File +import kotlin.reflect.KClass +import kotlin.script.experimental.annotations.KotlinScript +import kotlin.script.experimental.api.* +import kotlin.script.experimental.host.FileScriptSource +import kotlin.script.experimental.host.ScriptingHostConfiguration +import kotlin.script.experimental.host.configurationDependencies +import kotlin.script.experimental.host.createCompilationConfigurationFromTemplate +import kotlin.script.experimental.jvm.JvmDependency +import kotlin.script.experimental.jvm.defaultJvmScriptingHostConfiguration +import kotlin.script.experimental.jvm.dependenciesFromCurrentContext +import kotlin.script.experimental.jvm.jvm + +private const val testDataPath = "compiler/testData/script/" + +class ScriptCliCompilationTest : KtUsefulTestCase() { + + @Test + fun testPrerequisites() { + Assert.assertTrue(thisClasspath.isNotEmpty()) + } + + @Test + fun testSimpleScript() { + val out = checkRun("hello.kts") + Assert.assertEquals("Hello from basic script!", out) + } + + @Test + fun testSimpleScriptWithArgs() { + val out = checkRun("hello_args.kts", listOf("kotlin")) + Assert.assertEquals("Hello, kotlin!", out) + } + + @Test + fun testScriptWithRequire() { + val out = checkRun("hello.req1.kts", scriptDef = TestScriptWithRequire::class) + Assert.assertEquals("Hello from required!", out) + } + + + private val thisClasspath = listOf(PathUtil.getResourcePathForClass(ScriptCliCompilationTest::class.java)) + + private fun runCompiler( + script: File, + args: List = emptyList(), + scriptDef: KClass<*>? = null, + classpath: List = emptyList() + ): Pair { + + val collector = TestMessageCollector() + + val configuration = KotlinTestUtils.newConfiguration(ConfigurationKind.NO_KOTLIN_REFLECT, TestJdkKind.FULL_JDK).apply { + put(MESSAGE_COLLECTOR_KEY, collector) + addKotlinSourceRoot(script.path) + if (scriptDef != null) { + val hostConfiguration = ScriptingHostConfiguration(defaultJvmScriptingHostConfiguration) { + configurationDependencies(JvmDependency(classpath)) + } + val scriptDefinition = KotlinScriptDefinitionAdapterFromNewAPI( + createCompilationConfigurationFromTemplate( + KotlinType(scriptDef), + hostConfiguration, KotlinScriptDefinition::class + ), + hostConfiguration + ) + add(JVMConfigurationKeys.SCRIPT_DEFINITIONS, scriptDefinition) + } + } + + val environment = KotlinCoreEnvironment.createForTests(testRootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES) + + return KotlinToJVMBytecodeCompiler.compileAndExecuteScript(environment, args) to collector + } + + private fun checkRun( + scriptFileName: String, + args: List = emptyList(), + scriptDef: KClass<*>? = null, + classpath: List = emptyList() + ): String = + captureOut { + val res = runCompiler(File(testDataPath, scriptFileName), args, scriptDef, classpath) + val resMessage = lazy { + "Compilation results:\n" + res.second.toString() + } + Assert.assertEquals(resMessage.value, ExitCode.OK, res.first) + Assert.assertFalse(resMessage.value, res.second.hasErrors()) + } +} + +@KotlinScript( + fileExtension = "req1.kts", + compilationConfiguration = TestScriptWithRequireConfiguration::class +) +abstract class TestScriptWithRequire + +object TestScriptWithRequireConfiguration : ScriptCompilationConfiguration( + { + defaultImports(Import::class) + jvm { + dependenciesFromCurrentContext(wholeClasspath = true) + } + refineConfiguration { + onAnnotations(Import::class) { context: ScriptConfigurationRefinementContext -> + val sources = context.collectedData?.get(ScriptCollectedData.foundAnnotations) + ?.flatMap { + (it as? Import)?.sources?.map { sourceName -> FileScriptSource(File(testDataPath, sourceName)) } ?: emptyList() + } + ?.takeIf { it.isNotEmpty() } + ?: return@onAnnotations context.compilationConfiguration.asSuccess() + ScriptCompilationConfiguration(context.compilationConfiguration) { + importScripts.append(sources) + }.asSuccess() + } + } + } +) + +@Target(AnnotationTarget.FILE) +@Repeatable +@Retention(AnnotationRetention.SOURCE) +annotation class Import(vararg val sources: String) diff --git a/libraries/scripting/common/src/kotlin/script/experimental/api/scriptCompilation.kt b/libraries/scripting/common/src/kotlin/script/experimental/api/scriptCompilation.kt index 7e77aad4fb7..18c96a3c8bf 100644 --- a/libraries/scripting/common/src/kotlin/script/experimental/api/scriptCompilation.kt +++ b/libraries/scripting/common/src/kotlin/script/experimental/api/scriptCompilation.kt @@ -77,6 +77,11 @@ val ScriptCompilationConfigurationKeys.providedProperties by PropertiesCollectio */ val ScriptCompilationConfigurationKeys.defaultImports by PropertiesCollection.key>() +/** + * The list of script sources that should be compiled along with the script and imported into it + */ +val ScriptCompilationConfigurationKeys.importScripts by PropertiesCollection.key>() + /** * The list of script dependencies - platform specific */ diff --git a/libraries/scripting/jvm-host/build.gradle.kts b/libraries/scripting/jvm-host/build.gradle.kts index 851de4badec..c046196ca5c 100644 --- a/libraries/scripting/jvm-host/build.gradle.kts +++ b/libraries/scripting/jvm-host/build.gradle.kts @@ -15,6 +15,7 @@ dependencies { compileOnly(project(":compiler:cli")) compileOnly(intellijCoreDep()) runtime(projectRuntimeJar(":kotlin-compiler")) + testCompile(projectTests(":compiler:tests-common")) testCompile(commonDep("junit")) } @@ -27,3 +28,6 @@ standardPublicJars() publish() +projectTest { + workingDir = rootDir +} diff --git a/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/KJvmCompilerImpl.kt b/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/KJvmCompilerImpl.kt index 9e0755dc9d8..fc15c833ada 100644 --- a/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/KJvmCompilerImpl.kt +++ b/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/KJvmCompilerImpl.kt @@ -16,15 +16,13 @@ import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity import org.jetbrains.kotlin.cli.common.messages.MessageCollector -import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles -import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment -import org.jetbrains.kotlin.cli.jvm.compiler.NoScopeRecordCliBindingTrace -import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM +import org.jetbrains.kotlin.cli.jvm.compiler.* import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot import org.jetbrains.kotlin.cli.jvm.config.JvmModulePathRoot import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots import org.jetbrains.kotlin.cli.jvm.modules.CoreJrtFileSystem import org.jetbrains.kotlin.codegen.ClassBuilderFactories +import org.jetbrains.kotlin.codegen.CompilationErrorHandler import org.jetbrains.kotlin.codegen.KotlinCodegenFacade import org.jetbrains.kotlin.codegen.state.GenerationState import org.jetbrains.kotlin.config.* @@ -133,7 +131,9 @@ class KJvmCompilerImpl(val hostConfiguration: ScriptingHostConfiguration) : KJvm val psiFile: KtFile = psiFileFactory.trySetupPsiForFile(virtualFile, KotlinLanguage.INSTANCE, true, false) as KtFile? ?: return failure("Unable to make PSI file from script".asErrorDiagnostics()) - val sourceFiles = listOf(psiFile) + val sourceFiles = arrayListOf(psiFile).also { + it.addAll(collectRequiredSourcesFromDependencies(kotlinCompilerConfiguration, environment.project, it)) + } analyzerWithCompilerReport.analyzeAndReport(sourceFiles) { val project = environment.project @@ -158,13 +158,7 @@ class KJvmCompilerImpl(val hostConfiguration: ScriptingHostConfiguration) : KJvm sourceFiles, kotlinCompilerConfiguration ).build() - generationState.beforeCompile() - KotlinCodegenFacade.generatePackage( - generationState, - psiFile.script!!.containingKtFile.packageFqName, - setOf(psiFile.script!!.containingKtFile), - org.jetbrains.kotlin.codegen.CompilationErrorHandler.THROW_EXCEPTION - ) + KotlinCodegenFacade.compileCorrectFiles(generationState, CompilationErrorHandler.THROW_EXCEPTION) val res = KJvmCompiledScript(updatedConfiguration, generationState, scriptFileName.capitalize()) diff --git a/libraries/scripting/jvm-host/test/kotlin/script/experimental/jvmhost/test/ScriptingHostTest.kt b/libraries/scripting/jvm-host/test/kotlin/script/experimental/jvmhost/test/ScriptingHostTest.kt index 9ee7184dd6d..1d19eb67a3d 100644 --- a/libraries/scripting/jvm-host/test/kotlin/script/experimental/jvmhost/test/ScriptingHostTest.kt +++ b/libraries/scripting/jvm-host/test/kotlin/script/experimental/jvmhost/test/ScriptingHostTest.kt @@ -5,6 +5,7 @@ package kotlin.script.experimental.jvmhost.test +import junit.framework.TestCase import kotlinx.coroutines.runBlocking import org.junit.Assert import org.junit.Test @@ -21,7 +22,11 @@ import kotlin.script.experimental.jvmhost.impl.CompiledScriptClassLoader import kotlin.script.experimental.jvmhost.impl.KJvmCompiledScript import kotlin.script.templates.standard.SimpleScriptTemplate -class ScriptingHostTest { +class ScriptingHostTest : TestCase() { + + companion object { + const val TEST_DATA_DIR = "libraries/scripting/jvm-host/testData" + } @Test fun testSimpleUsage() { @@ -32,6 +37,19 @@ class ScriptingHostTest { Assert.assertEquals(greeting, output) } + @Test + fun testSimpleRequire() { + val greeting = "Hello from required!" + val script = "val subj = RequiredClass().value\nprintln(\"Hello from \$subj!\")" + val compilationConfiguration = createJvmCompilationConfigurationFromTemplate { + importScripts(File(TEST_DATA_DIR, "importTest/requiredSrc.kt").toScriptSource()) + } + val output = captureOut { + BasicJvmScriptingHost().eval(script.toScriptSource(), compilationConfiguration, null).throwOnFailure() + } + Assert.assertEquals(greeting, output) + } + @Test fun testMemoryCache() { val script = "val x = 1\nprintln(\"x = \$x\")" diff --git a/libraries/scripting/jvm-host/testData/importTest/requiredSrc.kt b/libraries/scripting/jvm-host/testData/importTest/requiredSrc.kt new file mode 100644 index 00000000000..1a74af5767b --- /dev/null +++ b/libraries/scripting/jvm-host/testData/importTest/requiredSrc.kt @@ -0,0 +1,5 @@ + +class RequiredClass { + + val value = "required" +} \ No newline at end of file diff --git a/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/impl/BridgeDependenciesResolver.kt b/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/impl/BridgeDependenciesResolver.kt index cd256927407..b07189950d1 100644 --- a/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/impl/BridgeDependenciesResolver.kt +++ b/libraries/scripting/jvm/src/kotlin/script/experimental/jvm/impl/BridgeDependenciesResolver.kt @@ -44,11 +44,13 @@ class BridgeDependenciesResolver( val defaultImports = scriptCompilationConfiguration[ScriptCompilationConfiguration.defaultImports]?.toList() ?: emptyList() - fun ScriptCompilationConfiguration.toDependencies(classpath: List): ScriptDependencies = ScriptDependencies( - classpath = classpath, - sources = this[ScriptCompilationConfiguration.ide.dependenciesSources].toClassPathOrEmpty(), - imports = defaultImports - ) + fun ScriptCompilationConfiguration.toDependencies(classpath: List): ScriptDependencies = + ScriptDependencies( + classpath = classpath, + sources = this[ScriptCompilationConfiguration.ide.dependenciesSources].toClassPathOrEmpty(), + imports = defaultImports, + scripts = this[ScriptCompilationConfiguration.importScripts].toFilesOrEmpty() + ) val refineResults = scriptCompilationConfiguration.refineWith( scriptCompilationConfiguration[ScriptCompilationConfiguration.refineConfigurationOnAnnotations]?.handler, @@ -76,11 +78,8 @@ class BridgeDependenciesResolver( } return DependenciesResolver.ResolveResult.Success( - ScriptDependencies( - classpath = newClasspath, // TODO: maybe it should return only increment from the initial config - sources = refinedConfiguration[ScriptCompilationConfiguration.ide.dependenciesSources].toClassPathOrEmpty(), - imports = defaultImports - ), + // TODO: consider returning only increment from the initial config + refinedConfiguration.toDependencies(newClasspath), diagnostics ) } catch (e: Throwable) {