Build: Fix deprecated Gradle configurations usages

for migration to Gradle 7+ #KTI-559

analysis/analysis-api-fir/build.gradle.kts

@@ -5,29 +5,29 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:psi"))
+    api(project(":compiler:psi"))
-    compile(project(":compiler:fir:fir2ir"))
+    api(project(":compiler:fir:fir2ir"))
-    compile(project(":compiler:ir.tree"))
+    api(project(":compiler:ir.tree"))
-    compile(project(":compiler:fir:resolve"))
+    api(project(":compiler:fir:resolve"))
-    compile(project(":compiler:fir:checkers"))
+    api(project(":compiler:fir:checkers"))
-    compile(project(":compiler:fir:checkers:checkers.jvm"))
+    api(project(":compiler:fir:checkers:checkers.jvm"))
-    compile(project(":compiler:fir:java"))
+    api(project(":compiler:fir:java"))
-    compile(project(":analysis:low-level-api-fir"))
+    api(project(":analysis:low-level-api-fir"))
-    compile(project(":analysis:analysis-api"))
+    api(project(":analysis:analysis-api"))
-    compile(project(":compiler:light-classes"))
+    api(project(":compiler:light-classes"))
-    compile(intellijCoreDep())
+    api(intellijCoreDep())
     implementation(project(":analysis:analysis-api-providers"))
 
-    testCompile(projectTests(":analysis:low-level-api-fir"))
+    testApi(projectTests(":analysis:low-level-api-fir"))
-    testCompile(projectTests(":compiler:tests-common"))
+    testApi(projectTests(":compiler:tests-common"))
-    testCompile(projectTests(":compiler:test-infrastructure-utils"))
+    testApi(projectTests(":compiler:test-infrastructure-utils"))
-    testCompile(projectTests(":compiler:test-infrastructure"))
+    testApi(projectTests(":compiler:test-infrastructure"))
-    testCompile(projectTests(":compiler:tests-common-new"))
+    testApi(projectTests(":compiler:tests-common-new"))
-    testCompile(projectTests(":compiler:fir:analysis-tests:legacy-fir-tests"))
+    testApi(projectTests(":compiler:fir:analysis-tests:legacy-fir-tests"))
-    testCompile(project(":kotlin-test:kotlin-test-junit"))
+    testApi(project(":kotlin-test:kotlin-test-junit"))
-    testCompile(toolsJar())
+    testApi(toolsJar())
     testApiJUnit5()
-    testRuntime(project(":analysis:symbol-light-classes"))
+    testRuntimeOnly(project(":analysis:symbol-light-classes"))
 
     testRuntimeOnly(intellijDep()) {
         includeJars(

analysis/analysis-api/build.gradle.kts

@@ -17,7 +17,7 @@ dependencies {
     compileOnly(project(":analysis:low-level-api-fir"))
     implementation(project(":analysis:analysis-api-providers"))
 
-    compile(intellijCoreDep()) { includeJars("intellij-core", "guava", rootProject = rootProject) }
+    api(intellijCoreDep()) { includeJars("intellij-core", "guava", rootProject = rootProject) }
 }
 
 kotlin {

analysis/low-level-api-fir/build.gradle.kts

@@ -4,35 +4,35 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:psi"))
+    api(project(":compiler:psi"))
     implementation(project(":analysis:project-structure"))
-    compile(project(":compiler:fir:fir2ir"))
+    api(project(":compiler:fir:fir2ir"))
-    compile(project(":compiler:fir:fir2ir:jvm-backend"))
+    api(project(":compiler:fir:fir2ir:jvm-backend"))
-    compile(project(":compiler:ir.serialization.common"))
+    api(project(":compiler:ir.serialization.common"))
-    compile(project(":compiler:fir:resolve"))
+    api(project(":compiler:fir:resolve"))
-    compile(project(":compiler:fir:checkers"))
+    api(project(":compiler:fir:checkers"))
-    compile(project(":compiler:fir:checkers:checkers.jvm"))
+    api(project(":compiler:fir:checkers:checkers.jvm"))
-    compile(project(":compiler:fir:java"))
+    api(project(":compiler:fir:java"))
-    compile(project(":compiler:backend.common.jvm"))
+    api(project(":compiler:backend.common.jvm"))
-    testCompile(project(":analysis:analysis-api-fir"))
+    testApi(project(":analysis:analysis-api-fir"))
     implementation(project(":compiler:ir.psi2ir"))
     implementation(project(":compiler:fir:entrypoint"))
     implementation(project(":analysis:analysis-api-providers"))
 
-    compile(intellijCoreDep()) { includeJars("intellij-core", "guava", rootProject = rootProject) }
+    api(intellijCoreDep()) { includeJars("intellij-core", "guava", rootProject = rootProject) }
 
 
-    testCompile(projectTests(":compiler:test-infrastructure-utils"))
+    testApi(projectTests(":compiler:test-infrastructure-utils"))
-    testCompile(projectTests(":compiler:test-infrastructure"))
+    testApi(projectTests(":compiler:test-infrastructure"))
-    testCompile(projectTests(":compiler:tests-common-new"))
+    testApi(projectTests(":compiler:tests-common-new"))
 
     testImplementation("org.opentest4j:opentest4j:1.2.0")
-    testCompile(toolsJar())
+    testApi(toolsJar())
-    testCompile(projectTests(":compiler:tests-common"))
+    testApi(projectTests(":compiler:tests-common"))
-    testCompile(projectTests(":compiler:fir:analysis-tests:legacy-fir-tests"))
+    testApi(projectTests(":compiler:fir:analysis-tests:legacy-fir-tests"))
-    testCompile(project(":kotlin-test:kotlin-test-junit"))
+    testApi(project(":kotlin-test:kotlin-test-junit"))
     testApiJUnit5()
-    testCompile(project(":kotlin-reflect"))
+    testApi(project(":kotlin-reflect"))
     testImplementation(project(":analysis:symbol-light-classes"))
 
     testRuntimeOnly(intellijDep()) {

ant/build.gradle.kts

@@ -6,9 +6,9 @@ plugins {
 }
 
 dependencies {
-    compile(commonDep("org.apache.ant", "ant"))
+    api(commonDep("org.apache.ant", "ant"))
-    compile(project(":kotlin-preloader"))
+    api(project(":kotlin-preloader"))
-    compile(kotlinStdlib())
+    api(kotlinStdlib())
 }
 
 sourceSets {

benchmarks/build.gradle.kts

@@ -9,15 +9,15 @@ plugins {
 }
 
 dependencies {
-    compile(kotlinStdlib())
+    api(kotlinStdlib())
-    compile(project(":compiler:frontend"))
+    api(project(":compiler:frontend"))
-    compile(projectTests(":compiler:tests-common"))
+    api(projectTests(":compiler:tests-common"))
-    compile(project(":compiler:cli"))
+    api(project(":compiler:cli"))
-    compile(intellijCoreDep()) { includeJars("intellij-core") }
+    api(intellijCoreDep()) { includeJars("intellij-core") }
-    compile(jpsStandalone()) { includeJars("jps-model") }
+    api(jpsStandalone()) { includeJars("jps-model") }
-    compile(intellijPluginDep("java"))
+    api(intellijPluginDep("java"))
-    compile(intellijDep()) { includeIntellijCoreJarDependencies(project) }
+    api(intellijDep()) { includeIntellijCoreJarDependencies(project) }
-    compile("org.jetbrains.kotlinx:kotlinx-benchmark-runtime:$benchmarks_version")
+    api("org.jetbrains.kotlinx:kotlinx-benchmark-runtime:$benchmarks_version")
 }
 
 sourceSets {

build-common/build.gradle.kts

@@ -19,11 +19,11 @@ dependencies {
     compileOnly(project(":kotlin-reflect-api"))
 
     testCompileOnly(project(":compiler:cli-common"))
-    testCompile(projectTests(":compiler:tests-common"))
+    testApi(projectTests(":compiler:tests-common"))
-    testCompile(commonDep("junit:junit"))
+    testApi(commonDep("junit:junit"))
-    testCompile(protobufFull())
+    testApi(protobufFull())
-    testCompile(kotlinStdlib())
+    testApi(kotlinStdlib())
-    testRuntime(project(":kotlin-reflect"))
+    testImplementation(project(":kotlin-reflect"))
 }
 
 sourceSets {

buildSrc/src/main/kotlin/artifacts.kt

@@ -33,7 +33,7 @@ import plugins.mainPublicationName
 private const val MAGIC_DO_NOT_CHANGE_TEST_JAR_TASK_NAME = "testJar"
 
 fun Project.testsJar(body: Jar.() -> Unit = {}): Jar {
-    val testsJarCfg = configurations.getOrCreate("tests-jar").extendsFrom(configurations["testCompile"])
+    val testsJarCfg = configurations.getOrCreate("tests-jar").extendsFrom(configurations["testApi"])
 
     return task<Jar>(MAGIC_DO_NOT_CHANGE_TEST_JAR_TASK_NAME) {
         dependsOn("testClasses")

buildSrc/src/main/kotlin/dependencies.kt

@@ -142,14 +142,14 @@ fun DependencyHandler.jpsLikeJarDependency(
         JpsDepScope.COMPILE -> {
             if (exported) {
                 add("api", dependencyNotation, dependencyConfiguration)
-                add("testCompile", dependencyNotation, dependencyConfiguration)
+                add("testApi", dependencyNotation, dependencyConfiguration)
             } else {
                 add("implementation", dependencyNotation, dependencyConfiguration)
             }
         }
         JpsDepScope.TEST -> {
             if (exported) {
-                add("testCompile", dependencyNotation, dependencyConfiguration)
+                add("testApi", dependencyNotation, dependencyConfiguration)
             } else {
                 add("testImplementation", dependencyNotation, dependencyConfiguration)
             }
@@ -160,7 +160,7 @@ fun DependencyHandler.jpsLikeJarDependency(
         JpsDepScope.PROVIDED -> {
             if (exported) {
                 add("compileOnlyApi", dependencyNotation, dependencyConfiguration)
-                add("testCompile", dependencyNotation, dependencyConfiguration)
+                add("testApi", dependencyNotation, dependencyConfiguration)
             } else {
                 add("compileOnly", dependencyNotation, dependencyConfiguration)
                 add("testImplementation", dependencyNotation, dependencyConfiguration)

buildSrc/src/main/kotlin/instrument.kt

@@ -140,7 +140,7 @@ abstract class IntelliJInstrumentCodeTask : ConventionTask() {
 
     // Instrumentation needs to have access to sources of forms for inclusion
     private val depSourceDirectorySets by lazy {
-        project.configurations["compile"].dependencies.withType(ProjectDependency::class.java)
+        project.configurations["api"].dependencies.withType(ProjectDependency::class.java)
             .map { p -> p.dependencyProject.mainSourceSet.allSource.sourceDirectories }
     }
 

compiler/android-tests/build.gradle.kts

@@ -6,37 +6,37 @@ plugins {
 }
 
 dependencies {
-    testCompile(project(":core:descriptors"))
+    testApi(project(":core:descriptors"))
-    testCompile(project(":core:descriptors.jvm"))
+    testApi(project(":core:descriptors.jvm"))
-    testCompile(project(":compiler:util"))
+    testApi(project(":compiler:util"))
-    testCompile(project(":compiler:cli"))
+    testApi(project(":compiler:cli"))
-    testCompile(project(":compiler:frontend"))
+    testApi(project(":compiler:frontend"))
-    testCompile(project(":compiler:backend"))
+    testApi(project(":compiler:backend"))
-    testCompile(project(":compiler:incremental-compilation-impl"))
+    testApi(project(":compiler:incremental-compilation-impl"))
-    testCompile(project(":compiler:frontend.java"))
+    testApi(project(":compiler:frontend.java"))
 
-    testCompile(kotlinStdlib())
+    testApi(kotlinStdlib())
-    testCompile(project(":kotlin-reflect"))
+    testApi(project(":kotlin-reflect"))
-    testCompile(projectTests(":compiler:tests-common"))
+    testApi(projectTests(":compiler:tests-common"))
-    testCompile(commonDep("junit:junit"))
+    testApi(commonDep("junit:junit"))
     testApi(projectTests(":compiler:test-infrastructure"))
     testApi(projectTests(":compiler:test-infrastructure-utils"))
     testApi(projectTests(":compiler:tests-compiler-utils"))
     testApi(projectTests(":compiler:tests-common-new"))
 
-    testCompile(commonDep("junit:junit"))
+    testApi(commonDep("junit:junit"))
 
-    testCompile(intellijDep()) { includeJars("util", "idea", "idea_rt", rootProject = rootProject) }
+    testApi(intellijDep()) { includeJars("util", "idea", "idea_rt", rootProject = rootProject) }
-    testCompile(intellijDep()) { includeJars("groovy", rootProject = rootProject) }
+    testApi(intellijDep()) { includeJars("groovy", rootProject = rootProject) }
 
-    testCompile(intellijPluginDep("java")) { includeJars("jps-builders") }
+    testApi(intellijPluginDep("java")) { includeJars("jps-builders") }
-    testCompile(jpsStandalone()) { includeJars("jps-model") }
+    testApi(jpsStandalone()) { includeJars("jps-model") }
-    testCompile(jpsBuildTest())
+    testApi(jpsBuildTest())
 
-    testRuntimeOnly(compile(intellijCoreDep()) { includeJars("intellij-core") })
+    testRuntimeOnly(intellijCoreDep()) { includeJars("intellij-core") }
-    testRuntimeOnly(compile(intellijDep()) { includeJars("jna", rootProject = rootProject) })
+    testRuntimeOnly(intellijDep()) { includeJars("jna", rootProject = rootProject) }
 
-    testCompile("org.junit.platform:junit-platform-launcher:${commonVer("org.junit.platform", "")}")
+    testApi("org.junit.platform:junit-platform-launcher:${commonVer("org.junit.platform", "")}")
 }
 
 sourceSets {

compiler/backend-common/build.gradle.kts

@@ -5,9 +5,9 @@ plugins {
 }
 
 dependencies {
-    compile(project(":core:descriptors"))
+    api(project(":core:descriptors"))
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":compiler:frontend"))
+    api(project(":compiler:frontend"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 }
 

compiler/backend/build.gradle.kts

@@ -4,12 +4,12 @@ plugins {
 }
 
 dependencies {
-    compile(project(":kotlin-annotations-jvm"))
+    api(project(":kotlin-annotations-jvm"))
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":compiler:backend-common"))
+    api(project(":compiler:backend-common"))
-    compile(project(":compiler:frontend"))
+    api(project(":compiler:frontend"))
-    compile(project(":compiler:frontend.java"))
+    api(project(":compiler:frontend.java"))
-    compile(project(":compiler:serialization"))
+    api(project(":compiler:serialization"))
     api(project(":compiler:backend.common.jvm"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core", "asm-all", "guava", rootProject = rootProject) }
     compileOnly(intellijDep()) { includeJars("trove4j", rootProject = rootProject) }

compiler/build.gradle.kts

@@ -12,26 +12,26 @@ val otherCompilerModules = compilerModules.filter { it != path }
 val antLauncherJar by configurations.creating
 
 dependencies {
-    testRuntime(intellijDep()) // Should come before compiler, because of "progarded" stuff needed for tests
+    testImplementation(intellijDep()) // Should come before compiler, because of "progarded" stuff needed for tests
 
-    testCompile(project(":kotlin-script-runtime"))
+    testApi(project(":kotlin-script-runtime"))
-    testCompile(project(":kotlin-test:kotlin-test-jvm"))
+    testApi(project(":kotlin-test:kotlin-test-jvm"))
     
-    testCompile(kotlinStdlib())
+    testApi(kotlinStdlib())
 
-    testCompile(commonDep("junit:junit"))
+    testApi(commonDep("junit:junit"))
     testCompileOnly(project(":kotlin-test:kotlin-test-jvm"))
     testCompileOnly(project(":kotlin-test:kotlin-test-junit"))
-    testCompile(projectTests(":compiler:tests-common"))
+    testApi(projectTests(":compiler:tests-common"))
-    testCompile(projectTests(":compiler:fir:raw-fir:psi2fir"))
+    testApi(projectTests(":compiler:fir:raw-fir:psi2fir"))
-    testCompile(projectTests(":compiler:fir:raw-fir:light-tree2fir"))
+    testApi(projectTests(":compiler:fir:raw-fir:light-tree2fir"))
-    testCompile(projectTests(":compiler:fir:fir2ir"))
+    testApi(projectTests(":compiler:fir:fir2ir"))
-    testCompile(projectTests(":compiler:fir:analysis-tests:legacy-fir-tests"))
+    testApi(projectTests(":compiler:fir:analysis-tests:legacy-fir-tests"))
-    testCompile(projectTests(":generators:test-generator"))
+    testApi(projectTests(":generators:test-generator"))
-    testCompile(project(":compiler:ir.ir2cfg"))
+    testApi(project(":compiler:ir.ir2cfg"))
-    testCompile(project(":compiler:ir.tree")) // used for deepCopyWithSymbols call that is removed by proguard from the compiler TODO: make it more straightforward
+    testApi(project(":compiler:ir.tree")) // used for deepCopyWithSymbols call that is removed by proguard from the compiler TODO: make it more straightforward
-    testCompile(project(":kotlin-scripting-compiler"))
+    testApi(project(":kotlin-scripting-compiler"))
-    testCompile(project(":kotlin-script-util"))
+    testApi(project(":kotlin-script-util"))
     testCompileOnly(project(":kotlin-reflect-api"))
     otherCompilerModules.forEach {
         testCompileOnly(project(it))
@@ -41,8 +41,8 @@ dependencies {
 
     testRuntimeOnly(intellijPluginDep("java"))
 
-    testRuntime(project(":kotlin-reflect"))
+    testImplementation(project(":kotlin-reflect"))
-    testRuntime(toolsJar())
+    testImplementation(toolsJar())
 
     antLauncherJar(commonDep("org.apache.ant", "ant"))
     antLauncherJar(toolsJar())

compiler/cli/build.gradle.kts

@@ -4,35 +4,35 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":compiler:cli-common"))
+    api(project(":compiler:cli-common"))
-    compile(project(":compiler:frontend"))
+    api(project(":compiler:frontend"))
-    compile(project(":compiler:frontend.java"))
+    api(project(":compiler:frontend.java"))
-    compile(project(":compiler:frontend:cfg"))
+    api(project(":compiler:frontend:cfg"))
-    compile(project(":compiler:backend-common"))
+    api(project(":compiler:backend-common"))
-    compile(project(":compiler:backend"))
+    api(project(":compiler:backend"))
-    compile(project(":compiler:backend.jvm"))
+    api(project(":compiler:backend.jvm"))
     implementation(project(":compiler:backend.jvm.lower"))
     implementation(project(":compiler:backend.jvm.entrypoint"))
-    compile(project(":compiler:ir.backend.common"))
+    api(project(":compiler:ir.backend.common"))
-    compile(project(":compiler:light-classes"))
+    api(project(":compiler:light-classes"))
-    compile(project(":compiler:serialization"))
+    api(project(":compiler:serialization"))
-    compile(project(":compiler:plugin-api"))
+    api(project(":compiler:plugin-api"))
-    compile(project(":compiler:javac-wrapper"))
+    api(project(":compiler:javac-wrapper"))
-    compile(project(":js:js.translator"))
+    api(project(":js:js.translator"))
-    compile(project(":native:frontend.native"))
+    api(project(":native:frontend.native"))
-    compile(commonDep("org.fusesource.jansi", "jansi"))
+    api(commonDep("org.fusesource.jansi", "jansi"))
-    compile(commonDep("org.jline", "jline"))
+    api(commonDep("org.jline", "jline"))
-    compile(project(":compiler:fir:raw-fir:psi2fir"))
+    api(project(":compiler:fir:raw-fir:psi2fir"))
-    compile(project(":compiler:fir:resolve"))
+    api(project(":compiler:fir:resolve"))
-    compile(project(":compiler:fir:java"))
+    api(project(":compiler:fir:java"))
     implementation(project(":compiler:fir:entrypoint"))
-    compile(project(":compiler:fir:fir2ir"))
+    api(project(":compiler:fir:fir2ir"))
-    compile(project(":compiler:fir:fir2ir:jvm-backend"))
+    api(project(":compiler:fir:fir2ir:jvm-backend"))
-    compile(project(":compiler:fir:checkers"))
+    api(project(":compiler:fir:checkers"))
-    compile(project(":compiler:fir:checkers:checkers.jvm"))
+    api(project(":compiler:fir:checkers:checkers.jvm"))
-    compile(project(":kotlin-util-klib"))
+    api(project(":kotlin-util-klib"))
-    compile(project(":kotlin-util-io"))
+    api(project(":kotlin-util-io"))
 
     // TODO: as soon as cli-jvm is extracted out of this module, move this dependency there
     compileOnly(project(":compiler:ir.tree.impl"))
@@ -41,10 +41,10 @@ dependencies {
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     compileOnly(intellijDep()) { includeIntellijCoreJarDependencies(project) }
 
-    testCompile(project(":compiler:backend"))
+    testApi(project(":compiler:backend"))
-    testCompile(project(":compiler:cli"))
+    testApi(project(":compiler:cli"))
-    testCompile(projectTests(":compiler:tests-common"))
+    testApi(projectTests(":compiler:tests-common"))
-    testCompile(commonDep("junit:junit"))
+    testApi(commonDep("junit:junit"))
 }
 
 sourceSets {

compiler/cli/cli-common/build.gradle.kts

@@ -4,11 +4,11 @@ plugins {
 }
 
 dependencies {
-    compile(project(":core:util.runtime"))
+    api(project(":core:util.runtime"))
-    compile(project(":compiler:config"))
+    api(project(":compiler:config"))
-    compile(project(":compiler:config.jvm"))
+    api(project(":compiler:config.jvm"))
-    compile(project(":js:js.config"))
+    api(project(":js:js.config"))
-    compile(project(":native:kotlin-native-utils"))
+    api(project(":native:kotlin-native-utils"))
     compileOnly(project(":kotlin-reflect-api"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     compileOnly(intellijDep()) { includeIntellijCoreJarDependencies(project) }

compiler/cli/cli-js/build.gradle.kts

@@ -4,20 +4,20 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":compiler:cli-common"))
+    api(project(":compiler:cli-common"))
-    compile(project(":compiler:cli"))
+    api(project(":compiler:cli"))
-    compile(project(":compiler:frontend"))
+    api(project(":compiler:frontend"))
-    compile(project(":compiler:backend-common"))
+    api(project(":compiler:backend-common"))
-    compile(project(":compiler:ir.backend.common"))
+    api(project(":compiler:ir.backend.common"))
-    compile(project(":compiler:ir.serialization.js"))
+    api(project(":compiler:ir.serialization.js"))
-    compile(project(":compiler:ir.tree.impl"))
+    api(project(":compiler:ir.tree.impl"))
-    compile(project(":compiler:backend.js"))
+    api(project(":compiler:backend.js"))
-    compile(project(":compiler:backend.wasm"))
+    api(project(":compiler:backend.wasm"))
-    compile(project(":js:js.translator"))
+    api(project(":js:js.translator"))
-    compile(project(":js:js.serializer"))
+    api(project(":js:js.serializer"))
-    compile(project(":js:js.dce"))
+    api(project(":js:js.dce"))
-    compile(project(":js:js.sourcemap"))
+    api(project(":js:js.sourcemap"))
 
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 }

compiler/cli/cli-runner/build.gradle.kts

@@ -7,7 +7,7 @@ plugins {
 }
 
 dependencies {
-    compile(kotlinStdlib())
+    api(kotlinStdlib())
 }
 
 sourceSets {

compiler/compiler-runner/build.gradle.kts

@@ -6,17 +6,17 @@ plugins {
 }
 
 dependencies {
-    compile(project(":kotlin-build-common"))
+    api(project(":kotlin-build-common"))
     compileOnly(project(":compiler:cli-common"))
     compileOnly(project(":kotlin-preloader"))
     compileOnly(project(":compiler:frontend.java"))
     compileOnly(project(":daemon-common"))
     compileOnly(project(":daemon-common-new"))
-    compile(projectRuntimeJar(":kotlin-daemon-client"))
+    api(projectRuntimeJar(":kotlin-daemon-client"))
     compileOnly(project(":compiler:util"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     runtimeOnly(projectRuntimeJar(":kotlin-compiler-embeddable"))
-    compile(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) { isTransitive = false }
+    api(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) { isTransitive = false }
 }
 
 sourceSets {

compiler/container/build.gradle.kts

@@ -4,17 +4,17 @@ plugins {
 }
 
 dependencies {
-    compile(project(":core:util.runtime"))
+    api(project(":core:util.runtime"))
-    compile(commonDep("javax.inject"))
+    api(commonDep("javax.inject"))
     compileOnly(kotlinStdlib())
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-    testCompile(kotlinStdlib())
+    testApi(kotlinStdlib())
     testCompileOnly("org.jetbrains:annotations:13.0")
-    testCompile(project(":kotlin-test:kotlin-test-jvm"))
+    testApi(project(":kotlin-test:kotlin-test-jvm"))
-    testCompile(project(":kotlin-test:kotlin-test-junit"))
+    testApi(project(":kotlin-test:kotlin-test-junit"))
-    testCompile(commonDep("junit:junit"))
+    testApi(commonDep("junit:junit"))
     testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-    testRuntime(intellijDep()) { includeJars("trove4j", "util") }
+    testRuntimeOnly(intellijDep()) { includeJars("trove4j", "util") }
 }
 
 sourceSets {

compiler/daemon/build.gradle.kts

@@ -8,8 +8,8 @@ plugins {
 val ktorExcludesForDaemon : List<Pair<String, String>> by rootProject.extra
 
 dependencies {
-    compile(commonDep("org.fusesource.jansi", "jansi"))
+    api(commonDep("org.fusesource.jansi", "jansi"))
-    compile(commonDep("org.jline", "jline"))
+    api(commonDep("org.jline", "jline"))
 
     compileOnly(project(":compiler:cli"))
     compileOnly(project(":compiler:cli-js"))

compiler/daemon/daemon-client-new/build.gradle.kts

@@ -37,10 +37,10 @@ dependencies {
     nativePlatformVariants.forEach {
         embedded(commonDep("net.rubygrapefruit", "native-platform", "-$it"))
     }
-    compile(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) {
+    api(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) {
         isTransitive = false
     }
-    compile(commonDep("io.ktor", "ktor-network")) {
+    api(commonDep("io.ktor", "ktor-network")) {
         ktorExcludesForDaemon.forEach { (group, module) ->
             exclude(group = group, module = module)
         }

compiler/daemon/daemon-common-new/build.gradle.kts

@@ -8,13 +8,13 @@ val ktorExcludesForDaemon: List<Pair<String, String>> by rootProject.extra
 
 dependencies {
     compileOnly(project(":daemon-common"))
-    compile(kotlinStdlib())
+    api(kotlinStdlib())
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     compileOnly(intellijDep()) { includeIntellijCoreJarDependencies(project) }
-    compile(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) {
+    api(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) {
         isTransitive = false
     }
-    compile(commonDep("io.ktor", "ktor-network")) {
+    api(commonDep("io.ktor", "ktor-network")) {
         ktorExcludesForDaemon.forEach { (group, module) ->
             exclude(group = group, module = module)
         }

compiler/daemon/daemon-common/build.gradle.kts

@@ -4,13 +4,13 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:cli-common"))
+    api(project(":compiler:cli-common"))
-    compile(project(":kotlin-build-common"))
+    api(project(":kotlin-build-common"))
-    compile(kotlinStdlib())
+    api(kotlinStdlib())
     compileOnly(project(":js:js.config"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     compileOnly(intellijDep()) { includeIntellijCoreJarDependencies(project) }
-    compile(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) {
+    api(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) {
         isTransitive = false
     }
 }

compiler/daemon/daemon-tests/build.gradle.kts

@@ -9,23 +9,23 @@ plugins {
 val ktorExcludesForDaemon: List<Pair<String, String>> by rootProject.extra
 
 dependencies {
-    testCompile(project(":kotlin-test:kotlin-test-jvm"))
+    testApi(project(":kotlin-test:kotlin-test-jvm"))
-    testCompile(kotlinStdlib())
+    testApi(kotlinStdlib())
-    testCompile(commonDep("junit:junit"))
+    testApi(commonDep("junit:junit"))
     testCompileOnly(project(":kotlin-test:kotlin-test-jvm"))
     testCompileOnly(project(":kotlin-test:kotlin-test-junit"))
-    testCompile(projectRuntimeJar(":kotlin-daemon-client"))
+    testApi(projectRuntimeJar(":kotlin-daemon-client"))
-    testCompile(projectRuntimeJar(":kotlin-daemon-client-new"))
+    testApi(projectRuntimeJar(":kotlin-daemon-client-new"))
     testCompileOnly(project(":kotlin-daemon"))
-    testCompile(projectTests(":compiler:tests-common"))
+    testApi(projectTests(":compiler:tests-common"))
-    testCompile(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) { isTransitive = false }
+    testApi(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) { isTransitive = false }
-    testCompile(commonDep("io.ktor", "ktor-network")) {
+    testApi(commonDep("io.ktor", "ktor-network")) {
         ktorExcludesForDaemon.forEach { (group, module) ->
             exclude(group = group, module = module)
         }
     }
-    testRuntime(project(":kotlin-daemon"))
+    testImplementation(project(":kotlin-daemon"))
-    testRuntime(intellijCoreDep()) { includeJars("intellij-core") }
+    testImplementation(intellijCoreDep()) { includeJars("intellij-core") }
 }
 
 sourceSets {

compiler/fir/raw-fir/light-tree2fir/build.gradle.kts

@@ -122,5 +122,5 @@ val jmhExec by tasks.registering(JavaExec::class) {
     workingDir = rootDir
     systemProperty("idea.home.path", project.intellijRootDir().absolutePath)
     systemProperty("idea.max.intellisense.filesize", 5000 * 1024)
-    configurations.plusAssign(project.configurations["compile"])
+    configurations.plusAssign(project.configurations["api"])
 }

compiler/frontend.common/build.gradle.kts

@@ -4,8 +4,8 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:config"))
+    api(project(":compiler:config"))
-    compile(project(":compiler:container"))
+    api(project(":compiler:container"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 }
 

compiler/frontend.java/build.gradle.kts

@@ -4,12 +4,12 @@ plugins {
 }
 
 dependencies {
-    compile(project(":core:descriptors"))
+    api(project(":core:descriptors"))
-    compile(project(":core:descriptors.jvm"))
+    api(project(":core:descriptors.jvm"))
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":compiler:config.jvm"))
+    api(project(":compiler:config.jvm"))
-    compile("javax.annotation:jsr250-api:1.0")
+    api("javax.annotation:jsr250-api:1.0")
-    compile(project(":compiler:frontend"))
+    api(project(":compiler:frontend"))
     api(project(":compiler:resolution.common.jvm"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     compileOnly(intellijDep()) { includeJars("asm-all", "trove4j", "guava", rootProject = rootProject) }

compiler/frontend/build.gradle.kts

@@ -4,18 +4,18 @@ plugins {
 }
 
 dependencies {
-    compile(project(":kotlin-annotations-jvm"))
+    api(project(":kotlin-annotations-jvm"))
-    compile(project(":core:descriptors"))
+    api(project(":core:descriptors"))
-    compile(project(":core:deserialization"))
+    api(project(":core:deserialization"))
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":compiler:config"))
+    api(project(":compiler:config"))
-    compile(project(":compiler:container"))
+    api(project(":compiler:container"))
-    compile(project(":compiler:resolution"))
+    api(project(":compiler:resolution"))
-    compile(project(":compiler:psi"))
+    api(project(":compiler:psi"))
-    compile(project(":compiler:frontend.common"))
+    api(project(":compiler:frontend.common"))
-    compile(project(":compiler:frontend.common-psi"))
+    api(project(":compiler:frontend.common-psi"))
-    compile(project(":kotlin-script-runtime"))
+    api(project(":kotlin-script-runtime"))
-    compile(commonDep("io.javaslang","javaslang"))
+    api(commonDep("io.javaslang","javaslang"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     compileOnly(intellijDep()) { includeJars("trove4j", "guava", rootProject = rootProject) }
 }

compiler/frontend/cfg/build.gradle.kts

@@ -4,7 +4,7 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:frontend"))
+    api(project(":compiler:frontend"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     compileOnly(intellijDep()) { includeJars("guava", rootProject = rootProject) }
 }

compiler/incremental-compilation-impl/build.gradle.kts

@@ -5,28 +5,28 @@ plugins {
 }
 
 dependencies {
-    compile(project(":core:descriptors"))
+    api(project(":core:descriptors"))
-    compile(project(":core:descriptors.jvm"))
+    api(project(":core:descriptors.jvm"))
-    compile(project(":core:deserialization"))
+    api(project(":core:deserialization"))
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":compiler:frontend"))
+    api(project(":compiler:frontend"))
-    compile(project(":compiler:frontend.java"))
+    api(project(":compiler:frontend.java"))
-    compile(project(":compiler:cli"))
+    api(project(":compiler:cli"))
-    compile(project(":compiler:cli-js"))
+    api(project(":compiler:cli-js"))
-    compile(project(":kotlin-build-common"))
+    api(project(":kotlin-build-common"))
-    compile(project(":daemon-common"))
+    api(project(":daemon-common"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 
-    testCompile(commonDep("junit:junit"))
+    testApi(commonDep("junit:junit"))
-    testCompile(project(":kotlin-test:kotlin-test-junit"))
+    testApi(project(":kotlin-test:kotlin-test-junit"))
-    testCompile(kotlinStdlib())
+    testApi(kotlinStdlib())
-    testCompile(projectTests(":kotlin-build-common"))
+    testApi(projectTests(":kotlin-build-common"))
-    testCompile(projectTests(":compiler:tests-common"))
+    testApi(projectTests(":compiler:tests-common"))
-    testCompile(intellijCoreDep()) { includeJars("intellij-core") }
+    testApi(intellijCoreDep()) { includeJars("intellij-core") }
-    testCompile(intellijDep()) { includeJars("log4j", "jdom") }
+    testApi(intellijDep()) { includeJars("log4j", "jdom") }
-    testRuntime(project(":kotlin-reflect"))
+    testRuntimeOnly(project(":kotlin-reflect"))
-    testRuntime(project(":core:descriptors.runtime"))
+    testRuntimeOnly(project(":core:descriptors.runtime"))
-    testRuntime(intellijDep()) { includeJars("lz4-java", "jna", rootProject = rootProject) }
+    testRuntimeOnly(intellijDep()) { includeJars("lz4-java", "jna", rootProject = rootProject) }
 }
 
 sourceSets {

compiler/ir/backend.common/build.gradle.kts

@@ -4,11 +4,11 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":compiler:frontend"))
+    api(project(":compiler:frontend"))
-    compile(project(":compiler:backend-common"))
+    api(project(":compiler:backend-common"))
-    compile(project(":compiler:ir.tree"))
+    api(project(":compiler:ir.tree"))
-    compile(project(":compiler:ir.interpreter"))
+    api(project(":compiler:ir.interpreter"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 }
 

compiler/ir/backend.js/build.gradle.kts

@@ -4,17 +4,17 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":compiler:frontend"))
+    api(project(":compiler:frontend"))
-    compile(project(":compiler:backend-common"))
+    api(project(":compiler:backend-common"))
-    compile(project(":compiler:ir.tree"))
+    api(project(":compiler:ir.tree"))
-    compile(project(":compiler:ir.backend.common"))
+    api(project(":compiler:ir.backend.common"))
-    compile(project(":compiler:ir.serialization.common"))
+    api(project(":compiler:ir.serialization.common"))
-    compile(project(":compiler:ir.serialization.js"))
+    api(project(":compiler:ir.serialization.js"))
-    compile(project(":compiler:ir.tree.persistent"))
+    api(project(":compiler:ir.tree.persistent"))
-    compile(project(":js:js.ast"))
+    api(project(":js:js.ast"))
-    compile(project(":js:js.frontend"))
+    api(project(":js:js.frontend"))
-    compile(project(":js:js.sourcemap"))
+    api(project(":js:js.sourcemap"))
 
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 }

compiler/ir/backend.jvm/build.gradle.kts

@@ -4,10 +4,10 @@ plugins {
 }
 
 dependencies {
-    compile(project(":kotlin-annotations-jvm"))
+    api(project(":kotlin-annotations-jvm"))
-    compile(project(":compiler:backend"))
+    api(project(":compiler:backend"))
-    compile(project(":compiler:ir.tree"))
+    api(project(":compiler:ir.tree"))
-    compile(project(":compiler:ir.backend.common"))
+    api(project(":compiler:ir.backend.common"))
     api(project(":compiler:backend.common.jvm"))
     compileOnly(project(":compiler:ir.tree.impl"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core", "asm-all", "guava", rootProject = rootProject) }

compiler/ir/backend.wasm/build.gradle.kts

@@ -4,17 +4,17 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":compiler:frontend"))
+    api(project(":compiler:frontend"))
-    compile(project(":compiler:backend-common"))
+    api(project(":compiler:backend-common"))
-    compile(project(":compiler:ir.tree"))
+    api(project(":compiler:ir.tree"))
-    compile(project(":compiler:ir.backend.common"))
+    api(project(":compiler:ir.backend.common"))
-    compile(project(":compiler:ir.serialization.common"))
+    api(project(":compiler:ir.serialization.common"))
-    compile(project(":compiler:ir.serialization.js"))
+    api(project(":compiler:ir.serialization.js"))
-    compile(project(":js:js.ast"))
+    api(project(":js:js.ast"))
-    compile(project(":js:js.frontend"))
+    api(project(":js:js.frontend"))
-    compile(project(":compiler:backend.js"))
+    api(project(":compiler:backend.js"))
-    compile(project(":wasm:wasm.ir"))
+    api(project(":wasm:wasm.ir"))
 
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 }

compiler/ir/ir.ir2cfg/build.gradle.kts

@@ -5,9 +5,9 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":compiler:frontend"))
+    api(project(":compiler:frontend"))
-    compile(project(":compiler:ir.tree"))
+    api(project(":compiler:ir.tree"))
 }
 
 sourceSets {

compiler/ir/ir.psi2ir/build.gradle.kts

@@ -4,10 +4,10 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":compiler:frontend"))
+    api(project(":compiler:frontend"))
-    compile(project(":compiler:backend-common"))
+    api(project(":compiler:backend-common"))
-    compile(project(":compiler:ir.tree"))
+    api(project(":compiler:ir.tree"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 }
 

compiler/ir/ir.tree.impl/build.gradle.kts

@@ -4,7 +4,7 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:ir.tree"))
+    api(project(":compiler:ir.tree"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 }
 

compiler/ir/serialization.common/build.gradle.kts

@@ -4,11 +4,11 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:ir.tree"))
+    api(project(":compiler:ir.tree"))
-    compile(project(":compiler:serialization"))
+    api(project(":compiler:serialization"))
-    compile(project(":kotlin-util-klib"))
+    api(project(":kotlin-util-klib"))
-    compile(project(":kotlin-util-klib-metadata"))
+    api(project(":kotlin-util-klib-metadata"))
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
     implementation(project(":compiler:psi"))
     compileOnly(project(":kotlin-reflect-api"))
 

compiler/ir/serialization.js/build.gradle.kts

@@ -7,8 +7,9 @@ dependencies {
     api(project(":compiler:ir.psi2ir"))
     api(project(":compiler:ir.serialization.common"))
     api(project(":js:js.frontend"))
+    api(project(":compiler:ir.tree.persistent"))
+
     implementation(project(":compiler:ir.backend.common"))
-    compile(project(":compiler:ir.tree.persistent"))
     compileOnly(project(":kotlin-reflect-api"))
 
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }

compiler/ir/serialization.jvm/build.gradle.kts

@@ -4,12 +4,12 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:ir.tree"))
+    api(project(":compiler:ir.tree"))
-    compile(project(":compiler:ir.serialization.common"))
+    api(project(":compiler:ir.serialization.common"))
-    compile(project(":core:descriptors.jvm"))
+    api(project(":core:descriptors.jvm"))
-    compile(project(":core:metadata.jvm"))
+    api(project(":core:metadata.jvm"))
     implementation(project(":core:deserialization.common.jvm"))
-    compile(project(":compiler:frontend.java"))
+    api(project(":compiler:frontend.java"))
 }
 
 sourceSets {

compiler/javac-wrapper/build.gradle.kts

@@ -4,8 +4,8 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":compiler:frontend.java"))
+    api(project(":compiler:frontend.java"))
 
     compileOnly(toolsJarApi())
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }

compiler/light-classes/build.gradle.kts

@@ -5,10 +5,10 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":compiler:backend"))
+    api(project(":compiler:backend"))
-    compile(project(":compiler:frontend"))
+    api(project(":compiler:frontend"))
-    compile(project(":compiler:frontend.java"))
+    api(project(":compiler:frontend.java"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 
     compileOnly(intellijDep()) { includeJars("platform-core-ui", "platform-util-ui") }

compiler/plugin-api/build.gradle.kts

@@ -5,8 +5,8 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":compiler:frontend"))
+    api(project(":compiler:frontend"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 }
 

compiler/psi/build.gradle.kts

@@ -10,13 +10,10 @@ repositories {
 val jflexPath by configurations.creating
 
 dependencies {
-    val compile by configurations
+    api(project(":core:compiler.common"))
-    val compileOnly by configurations
+    api(project(":compiler:util"))
-
+    api(project(":compiler:frontend.common"))
-    compile(project(":core:compiler.common"))
+    api(project(":kotlin-script-runtime"))
-    compile(project(":compiler:util"))
-    compile(project(":compiler:frontend.common"))
-    compile(project(":kotlin-script-runtime"))
 
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     compileOnly(intellijDep()) { includeJars("guava", "trove4j", rootProject = rootProject) }

compiler/resolution/build.gradle.kts

@@ -4,8 +4,8 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":core:descriptors"))
+    api(project(":core:descriptors"))
     api(project(":compiler:resolution.common"))
     compileOnly(intellijDep()) { includeJars("trove4j") }
 }

compiler/serialization/build.gradle.kts

@@ -4,8 +4,8 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:resolution"))
+    api(project(":compiler:resolution"))
-    compile(project(":core:deserialization"))
+    api(project(":core:deserialization"))
     api(project(":compiler:util"))
 
     compileOnly(intellijCoreDep()) { includeJars("intellij-core", rootProject = rootProject) }

compiler/tests-against-klib/build.gradle.kts

@@ -7,8 +7,8 @@ plugins {
 }
 
 dependencies {
-    compile(kotlinStdlib())
+    api(kotlinStdlib())
-    testCompile(projectTests(":generators:test-generator"))
+    testApi(projectTests(":generators:test-generator"))
     testApi(projectTests(":compiler:tests-common"))
 
     testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") }

compiler/tests-common-jvm6/build.gradle.kts

@@ -6,8 +6,8 @@ plugins {
 project.updateJvmTarget("1.6")
 
 dependencies {
-    compile(kotlinStdlib())
+    api(kotlinStdlib())
-    testCompile(project(":kotlin-test:kotlin-test-jvm"))
+    testApi(project(":kotlin-test:kotlin-test-jvm"))
 }
 
 sourceSets {

compiler/tests-common/build.gradle.kts

@@ -5,59 +5,59 @@ plugins {
 }
 
 dependencies {
-    testCompile(kotlinStdlib("jdk8"))
+    testApi(kotlinStdlib("jdk8"))
-    testCompile(project(":kotlin-scripting-compiler"))
+    testApi(project(":kotlin-scripting-compiler"))
-    testCompile(project(":core:descriptors"))
+    testApi(project(":core:descriptors"))
-    testCompile(project(":core:descriptors.jvm"))
+    testApi(project(":core:descriptors.jvm"))
-    testCompile(project(":core:deserialization"))
+    testApi(project(":core:deserialization"))
-    testCompile(project(":compiler:util"))
+    testApi(project(":compiler:util"))
-    testCompile(project(":compiler:tests-mutes"))
+    testApi(project(":compiler:tests-mutes"))
-    testCompile(project(":compiler:backend"))
+    testApi(project(":compiler:backend"))
-    testCompile(project(":compiler:ir.tree.impl"))
+    testApi(project(":compiler:ir.tree.impl"))
-    testCompile(project(":compiler:fir:tree"))
+    testApi(project(":compiler:fir:tree"))
-    testCompile(project(":compiler:fir:raw-fir:psi2fir"))
+    testApi(project(":compiler:fir:raw-fir:psi2fir"))
-    testCompile(project(":compiler:fir:raw-fir:light-tree2fir"))
+    testApi(project(":compiler:fir:raw-fir:light-tree2fir"))
-    testCompile(project(":compiler:fir:fir2ir"))
+    testApi(project(":compiler:fir:fir2ir"))
-    testCompile(project(":compiler:fir:fir2ir:jvm-backend"))
+    testApi(project(":compiler:fir:fir2ir:jvm-backend"))
-    testCompile(project(":compiler:fir:fir-serialization"))
+    testApi(project(":compiler:fir:fir-serialization"))
-    testCompile(project(":compiler:fir:fir-deserialization"))
+    testApi(project(":compiler:fir:fir-deserialization"))
-    testCompile(project(":compiler:fir:cones"))
+    testApi(project(":compiler:fir:cones"))
-    testCompile(project(":compiler:fir:resolve"))
+    testApi(project(":compiler:fir:resolve"))
-    testCompile(project(":compiler:fir:checkers"))
+    testApi(project(":compiler:fir:checkers"))
-    testCompile(project(":compiler:fir:checkers:checkers.jvm"))
+    testApi(project(":compiler:fir:checkers:checkers.jvm"))
-    testCompile(project(":compiler:fir:java"))
+    testApi(project(":compiler:fir:java"))
-    testCompile(project(":compiler:fir:entrypoint"))
+    testApi(project(":compiler:fir:entrypoint"))
-    testCompile(project(":compiler:ir.ir2cfg"))
+    testApi(project(":compiler:ir.ir2cfg"))
-    testCompile(project(":compiler:frontend"))
+    testApi(project(":compiler:frontend"))
-    testCompile(project(":compiler:frontend.java"))
+    testApi(project(":compiler:frontend.java"))
-    testCompile(project(":compiler:util"))
+    testApi(project(":compiler:util"))
-    testCompile(project(":compiler:cli-common"))
+    testApi(project(":compiler:cli-common"))
-    testCompile(project(":compiler:cli"))
+    testApi(project(":compiler:cli"))
-    testCompile(project(":compiler:cli-js"))
+    testApi(project(":compiler:cli-js"))
-    testCompile(project(":compiler:light-classes"))
+    testApi(project(":compiler:light-classes"))
-    testCompile(project(":compiler:serialization"))
+    testApi(project(":compiler:serialization"))
-    testCompile(project(":kotlin-preloader"))
+    testApi(project(":kotlin-preloader"))
-    testCompile(project(":compiler:cli-common"))
+    testApi(project(":compiler:cli-common"))
-    testCompile(project(":daemon-common"))
+    testApi(project(":daemon-common"))
-    testCompile(project(":daemon-common-new"))
+    testApi(project(":daemon-common-new"))
-    testCompile(project(":js:js.serializer"))
+    testApi(project(":js:js.serializer"))
-    testCompile(project(":js:js.frontend"))
+    testApi(project(":js:js.frontend"))
-    testCompile(project(":js:js.translator"))
+    testApi(project(":js:js.translator"))
-    testCompile(project(":native:frontend.native"))
+    testApi(project(":native:frontend.native"))
     testCompileOnly(project(":plugins:android-extensions-compiler"))
     testApi(projectTests(":generators:test-generator"))
-    testCompile(projectTests(":compiler:tests-compiler-utils"))
+    testApi(projectTests(":compiler:tests-compiler-utils"))
-    testCompile(project(":kotlin-test:kotlin-test-jvm"))
+    testApi(project(":kotlin-test:kotlin-test-jvm"))
-    testCompile(projectTests(":compiler:tests-common-jvm6"))
+    testApi(projectTests(":compiler:tests-common-jvm6"))
-    testCompile(project(":kotlin-scripting-compiler-impl"))
+    testApi(project(":kotlin-scripting-compiler-impl"))
-    testCompile(projectTests(":compiler:test-infrastructure-utils"))
+    testApi(projectTests(":compiler:test-infrastructure-utils"))
-    testCompile(commonDep("junit:junit"))
+    testApi(commonDep("junit:junit"))
-    testCompile(commonDep("com.android.tools:r8"))
+    testApi(commonDep("com.android.tools:r8"))
     testCompileOnly(project(":kotlin-reflect-api"))
     testCompileOnly(toolsJar())
     testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-    testCompile(intellijDep()) { includeJars("intellij-deps-fastutil-8.4.1-4") }
+    testApi(intellijDep()) { includeJars("intellij-deps-fastutil-8.4.1-4") }
-    testCompile(intellijDep()) {
+    testApi(intellijDep()) {
         includeJars(
             "guava",
             "trove4j",

compiler/tests-compiler-utils/build.gradle.kts

@@ -5,31 +5,31 @@ plugins {
 }
 
 dependencies {
-    testCompile(kotlinStdlib("jdk8"))
+    testApi(kotlinStdlib("jdk8"))
-    testCompile(project(":kotlin-scripting-compiler"))
+    testApi(project(":kotlin-scripting-compiler"))
-    testCompile(project(":core:descriptors"))
+    testApi(project(":core:descriptors"))
-    testCompile(project(":core:descriptors.jvm"))
+    testApi(project(":core:descriptors.jvm"))
-    testCompile(project(":core:deserialization"))
+    testApi(project(":core:deserialization"))
-    testCompile(project(":compiler:util"))
+    testApi(project(":compiler:util"))
-    testCompile(project(":compiler:tests-mutes"))
+    testApi(project(":compiler:tests-mutes"))
-    testCompile(project(":compiler:backend"))
+    testApi(project(":compiler:backend"))
-    testCompile(project(":compiler:ir.ir2cfg"))
+    testApi(project(":compiler:ir.ir2cfg"))
-    testCompile(project(":compiler:frontend"))
+    testApi(project(":compiler:frontend"))
-    testCompile(project(":compiler:frontend.java"))
+    testApi(project(":compiler:frontend.java"))
-    testCompile(project(":compiler:util"))
+    testApi(project(":compiler:util"))
-    testCompile(project(":compiler:psi"))
+    testApi(project(":compiler:psi"))
-    testCompile(project(":compiler:cli-common"))
+    testApi(project(":compiler:cli-common"))
-    testCompile(project(":compiler:cli"))
+    testApi(project(":compiler:cli"))
-    testCompile(project(":compiler:cli-js"))
+    testApi(project(":compiler:cli-js"))
-    testCompile(project(":compiler:serialization"))
+    testApi(project(":compiler:serialization"))
-    testCompile(project(":compiler:fir:entrypoint"))
+    testApi(project(":compiler:fir:entrypoint"))
-    testCompile(project(":compiler:backend.jvm.entrypoint"))
+    testApi(project(":compiler:backend.jvm.entrypoint"))
-    testCompile(projectTests(":compiler:test-infrastructure-utils"))
+    testApi(projectTests(":compiler:test-infrastructure-utils"))
-    testCompile(project(":kotlin-preloader"))
+    testApi(project(":kotlin-preloader"))
-    testCompile(commonDep("com.android.tools:r8"))
+    testApi(commonDep("com.android.tools:r8"))
     testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 
-    testCompile(intellijDep()) {
+    testApi(intellijDep()) {
         includeJars(
             "jps-model",
             "extensions",

compiler/tests-different-jdk/build.gradle.kts

@@ -6,17 +6,17 @@ plugins {
 val testJvm6ServerRuntime by configurations.creating
 
 dependencies {
-    testCompile(projectTests(":compiler"))
+    testApi(projectTests(":compiler"))
     testApi(projectTests(":compiler:test-infrastructure"))
     testApi(projectTests(":compiler:test-infrastructure-utils"))
     testApi(projectTests(":compiler:tests-compiler-utils"))
-    testCompile(projectTests(":compiler:tests-common-new"))
+    testApi(projectTests(":compiler:tests-common-new"))
 
     testApiJUnit5(vintageEngine = true, runner = true, suiteApi = true)
 
     testImplementation(intellijCoreDep()) { includeJars("intellij-core") }
-    testRuntime(project(":kotlin-reflect"))
+    testRuntimeOnly(project(":kotlin-reflect"))
-    testRuntime(intellijDep())
+    testRuntimeOnly(intellijDep())
     testJvm6ServerRuntime(projectTests(":compiler:tests-common-jvm6"))
 }
 

compiler/tests-java8/build.gradle.kts

@@ -6,13 +6,13 @@ plugins {
 }
 
 dependencies {
-    testCompile(project(":kotlin-scripting-compiler"))
+    testApi(project(":kotlin-scripting-compiler"))
-    testCompile(projectTests(":compiler:tests-common"))
+    testApi(projectTests(":compiler:tests-common"))
     testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-    testCompile(projectTests(":generators:test-generator"))
+    testApi(projectTests(":generators:test-generator"))
-    testRuntime(project(":kotlin-reflect"))
+    testRuntimeOnly(project(":kotlin-reflect"))
     testRuntimeOnly(toolsJar())
-    testRuntime(intellijDep())
+    testRuntimeOnly(intellijDep())
     testRuntimeOnly(intellijPluginDep("java"))
     if (isIdeaActive) testRuntimeOnly(files("${rootProject.projectDir}/dist/kotlinc/lib/kotlin-reflect.jar"))
 }

compiler/tests-spec/build.gradle.kts

@@ -4,21 +4,21 @@ plugins {
 }
 
 dependencies {
-    testCompile(projectTests(":compiler"))
+    testApi(projectTests(":compiler"))
     testImplementation(projectTests(":compiler:test-infrastructure"))
     testImplementation(projectTests(":compiler:tests-common-new"))
 
-    testCompile(intellijDep()) {
+    testApi(intellijDep()) {
         includeJars("groovy", "groovy-xml", rootProject = rootProject)
     }
-    testCompile(intellijDep()) {
+    testApi(intellijDep()) {
         includeJars("gson", rootProject = rootProject)
     }
     testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     testRuntimeOnly(intellijPluginDep("java"))
-    compile("org.jsoup:jsoup:1.14.2")
+    api("org.jsoup:jsoup:1.14.2")
     if (isIdeaActive) testRuntimeOnly(files("${rootProject.projectDir}/dist/kotlinc/lib/kotlin-reflect.jar"))
-    testRuntime(project(":kotlin-reflect"))
+    testRuntimeOnly(project(":kotlin-reflect"))
 
     testApiJUnit5(vintageEngine = true)
 }

compiler/util-klib-metadata/build.gradle.kts

@@ -11,9 +11,9 @@ dependencies {
     compileOnly(project(":core:deserialization"))
     compileOnly(project(":compiler:serialization"))
 
-    compile(kotlinStdlib())
+    api(kotlinStdlib())
-    compile(project(":kotlin-util-io"))
+    api(project(":kotlin-util-io"))
-    compile(project(":kotlin-util-klib"))
+    api(project(":kotlin-util-klib"))
 }
 
 sourceSets {

compiler/util-klib/build.gradle.kts

@@ -6,8 +6,8 @@ plugins {
 description = "Common klib reader and writer"
 
 dependencies {
-    compile(kotlinStdlib())
+    api(kotlinStdlib())
-    compile(project(":kotlin-util-io"))
+    api(project(":kotlin-util-io"))
     testImplementation(commonDep("junit:junit"))
 }
 

compiler/visualizer/build.gradle.kts

@@ -20,7 +20,7 @@ dependencies {
     testImplementation(projectTests(":generators:test-generator"))
 
     testRuntimeOnly(intellijDep()) { includeJars("intellij-deps-fastutil-8.4.1-4") }
-    testRuntimeOnly(compile(intellijDep()) { includeJars("jna", rootProject = rootProject) })
+    testRuntimeOnly(intellijDep()) { includeJars("jna", rootProject = rootProject) }
 }
 
 val generationRoot = projectDir.resolve("tests-gen")

compiler/visualizer/common/build.gradle.kts

@@ -4,7 +4,7 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:frontend"))
+    api(project(":compiler:frontend"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 }
 

compiler/visualizer/render-fir/build.gradle.kts

@@ -4,9 +4,9 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:fir:raw-fir:psi2fir"))
+    api(project(":compiler:fir:raw-fir:psi2fir"))
-    compile(project(":compiler:fir:resolve"))
+    api(project(":compiler:fir:resolve"))
-    compile(project(":compiler:visualizer:common"))
+    api(project(":compiler:visualizer:common"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 }
 

compiler/visualizer/render-psi/build.gradle.kts

@@ -4,8 +4,8 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:visualizer:common"))
+    api(project(":compiler:visualizer:common"))
-    compile(intellijCoreDep()) { includeJars("intellij-core") }
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 }
 
 sourceSets {

core/compiler.common/build.gradle.kts

@@ -6,9 +6,9 @@ plugins {
 project.configureJvmToolchain(JdkMajorVersion.JDK_1_6)
 
 dependencies {
-    compile(project(":core:util.runtime"))
+    api(project(":core:util.runtime"))
-    compile(kotlinStdlib())
+    api(kotlinStdlib())
-    compile(project(":kotlin-annotations-jvm"))
+    api(project(":kotlin-annotations-jvm"))
 }
 
 sourceSets {

core/descriptors.jvm/build.gradle.kts

@@ -6,13 +6,13 @@ plugins {
 project.configureJvmToolchain(JdkMajorVersion.JDK_1_6)
 
 dependencies {
-    compile(project(":kotlin-annotations-jvm"))
+    api(project(":kotlin-annotations-jvm"))
-    compile(project(":core:descriptors"))
+    api(project(":core:descriptors"))
-    compile(project(":core:deserialization"))
+    api(project(":core:deserialization"))
     api(project(":core:compiler.common.jvm"))
     api(project(":core:deserialization.common.jvm"))
-    compile(project(":core:util.runtime"))
+    api(project(":core:util.runtime"))
-    compile(commonDep("javax.inject"))
+    api(commonDep("javax.inject"))
 }
 
 sourceSets {

core/descriptors.runtime/build.gradle.kts

@@ -22,8 +22,8 @@ dependencies {
     compileOnly(project(":core:descriptors"))
     compileOnly(project(":core:descriptors.jvm"))
 
-    testCompile(projectTests(":compiler:tests-common"))
+    testApi(projectTests(":compiler:tests-common"))
-    testCompile(projectTests(":generators:test-generator"))
+    testApi(projectTests(":generators:test-generator"))
 
     testRuntimeOnly(intellijCoreDep()) { includeJars("intellij-core") }
     testRuntimeOnly(intellijDep()) { includeJars("platform-concurrency") }

core/descriptors/build.gradle.kts

@@ -6,10 +6,10 @@ plugins {
 project.configureJvmToolchain(JdkMajorVersion.JDK_1_6)
 
 dependencies {
-    compile(project(":core:compiler.common"))
+    api(project(":core:compiler.common"))
-    compile(project(":core:util.runtime"))
+    api(project(":core:util.runtime"))
-    compile(kotlinStdlib())
+    api(kotlinStdlib())
-    compile(project(":kotlin-annotations-jvm"))
+    api(project(":kotlin-annotations-jvm"))
 }
 
 sourceSets {

core/deserialization/build.gradle.kts

@@ -6,11 +6,11 @@ plugins {
 project.configureJvmToolchain(JdkMajorVersion.JDK_1_6)
 
 dependencies {
-    compile(project(":core:metadata"))
+    api(project(":core:metadata"))
     api(project(":core:deserialization.common"))
-    compile(project(":core:util.runtime"))
+    api(project(":core:util.runtime"))
-    compile(project(":core:descriptors"))
+    api(project(":core:descriptors"))
-    compile(commonDep("javax.inject"))
+    api(commonDep("javax.inject"))
 }
 
 sourceSets {

core/metadata/build.gradle.kts

@@ -6,8 +6,8 @@ plugins {
 project.configureJvmToolchain(JdkMajorVersion.JDK_1_6)
 
 dependencies {
-    compile(protobufLite())
+    api(protobufLite())
-    compile(kotlinStdlib())
+    api(kotlinStdlib())
 }
 
 sourceSets {

generators/analysis-api-generator/build.gradle.kts

@@ -9,14 +9,14 @@ sourceSets {
 }
 
 dependencies {
-    compile(kotlinStdlib("jdk8"))
+    api(kotlinStdlib("jdk8"))
 
-    testCompile(projectTests(":generators:test-generator"))
+    testApi(projectTests(":generators:test-generator"))
-    testCompile(projectTests(":compiler:tests-common"))
+    testApi(projectTests(":compiler:tests-common"))
-    testCompile(projectTests(":compiler:tests-spec"))
+    testApi(projectTests(":compiler:tests-spec"))
-    testCompile(projectTests("::analysis:low-level-api-fir"))
+    testApi(projectTests("::analysis:low-level-api-fir"))
-    testCompile(projectTests(":analysis:analysis-api-fir"))
+    testApi(projectTests(":analysis:analysis-api-fir"))
-    testCompile(intellijCoreDep()) { includeJars("intellij-core", "guava", rootProject = rootProject) }
+    testApi(intellijCoreDep()) { includeJars("intellij-core", "guava", rootProject = rootProject) }
     testApiJUnit5()
 }
 

generators/build.gradle.kts

@@ -30,8 +30,8 @@ val (wasmSourceSet, wasmApi) = extraSourceSet("wasm")
 
 dependencies {
     // for GeneratorsFileUtil
-    compile(kotlinStdlib("jdk8"))
+    api(kotlinStdlib("jdk8"))
-    compile(intellijDep()) { includeJars("util") }
+    api(intellijDep()) { includeJars("util") }
 
     builtinsApi("org.jetbrains.kotlin:kotlin-stdlib:$bootstrapKotlinVersion") { isTransitive = false }
     evaluateApi(project(":core:deserialization"))
@@ -43,33 +43,33 @@ dependencies {
     protobufApi(kotlinStdlib())
     protobufCompareApi(projectTests(":kotlin-build-common"))
 
-    testCompile(builtinsSourceSet.output)
+    testApi(builtinsSourceSet.output)
-    testCompile(evaluateSourceSet.output)
+    testApi(evaluateSourceSet.output)
-    testCompile(interpreterSourceSet.output)
+    testApi(interpreterSourceSet.output)
-    testCompile(protobufSourceSet.output)
+    testApi(protobufSourceSet.output)
-    testCompile(protobufCompareSourceSet.output)
+    testApi(protobufCompareSourceSet.output)
 
-    testCompile(projectTests(":compiler:cli"))
+    testApi(projectTests(":compiler:cli"))
-    testCompile(projectTests(":compiler:incremental-compilation-impl"))
+    testApi(projectTests(":compiler:incremental-compilation-impl"))
-    testCompile(projectTests(":plugins:jvm-abi-gen"))
+    testApi(projectTests(":plugins:jvm-abi-gen"))
-    testCompile(projectTests(":plugins:android-extensions-compiler"))
+    testApi(projectTests(":plugins:android-extensions-compiler"))
-    testCompile(projectTests(":plugins:parcelize:parcelize-compiler"))
+    testApi(projectTests(":plugins:parcelize:parcelize-compiler"))
-    testCompile(projectTests(":kotlin-annotation-processing"))
+    testApi(projectTests(":kotlin-annotation-processing"))
-    testCompile(projectTests(":kotlin-annotation-processing-cli"))
+    testApi(projectTests(":kotlin-annotation-processing-cli"))
-    testCompile(projectTests(":kotlin-allopen-compiler-plugin"))
+    testApi(projectTests(":kotlin-allopen-compiler-plugin"))
-    testCompile(projectTests(":kotlin-noarg-compiler-plugin"))
+    testApi(projectTests(":kotlin-noarg-compiler-plugin"))
-    testCompile(projectTests(":plugins:lombok:lombok-compiler-plugin"))
+    testApi(projectTests(":plugins:lombok:lombok-compiler-plugin"))
-    testCompile(projectTests(":kotlin-sam-with-receiver-compiler-plugin"))
+    testApi(projectTests(":kotlin-sam-with-receiver-compiler-plugin"))
-    testCompile(projectTests(":kotlinx-serialization-compiler-plugin"))
+    testApi(projectTests(":kotlinx-serialization-compiler-plugin"))
-    testCompile(projectTests(":plugins:fir:fir-plugin-prototype"))
+    testApi(projectTests(":plugins:fir:fir-plugin-prototype"))
-    testCompile(projectTests(":generators:test-generator"))
+    testApi(projectTests(":generators:test-generator"))
     testCompileOnly(project(":kotlin-reflect-api"))
-    testRuntime(intellijDep()) { includeJars("idea_rt") }
+    testImplementation(intellijDep()) { includeJars("idea_rt") }
-    testRuntime(project(":kotlin-reflect"))
+    testImplementation(project(":kotlin-reflect"))
 
     if (Ide.IJ()) {
         testCompileOnly(jpsBuildTest())
-        testCompile(jpsBuildTest())
+        testApi(jpsBuildTest())
     }
 }
 

generators/test-generator/build.gradle.kts

@@ -5,12 +5,12 @@ plugins {
 }
 
 dependencies {
-    testCompile(intellijDep()) { includeJars("util") }
+    testApi(intellijDep()) { includeJars("util") }
-    testCompile(project(":core:util.runtime"))
+    testApi(project(":core:util.runtime"))
     testApi(projectTests(":compiler:test-infrastructure-utils"))
-    testCompile(kotlinStdlib())
+    testApi(kotlinStdlib())
-    testCompile(commonDep("junit:junit"))
+    testApi(commonDep("junit:junit"))
-    testCompile(project(":generators"))
+    testApi(project(":generators"))
 }
 
 sourceSets {

js/js.ast/build.gradle.kts

@@ -4,7 +4,7 @@ plugins {
 }
 
 dependencies {
-    compile(project(":core:descriptors"))
+    api(project(":core:descriptors"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     compileOnly(intellijDep()) { includeJars("trove4j") }
 }

js/js.dce/build.gradle.kts

@@ -5,9 +5,9 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":js:js.ast"))
+    api(project(":js:js.ast"))
-    compile(project(":js:js.translator"))
+    api(project(":js:js.translator"))
     compileOnly(project(":js:js.sourcemap"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     compileOnly(intellijDep()) { includeJars("guava", rootProject = rootProject) }

js/js.engines/build.gradle.kts

@@ -5,10 +5,10 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":js:js.ast"))
+    api(project(":js:js.ast"))
-    compile(project(":js:js.translator"))
+    api(project(":js:js.translator"))
-    compile(intellijCoreDep()) { includeJars("intellij-core") }
+    api(intellijCoreDep()) { includeJars("intellij-core") }
 }
 
 sourceSets {

js/js.frontend/build.gradle.kts

@@ -4,12 +4,12 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":compiler:frontend"))
+    api(project(":compiler:frontend"))
-    compile(project(":js:js.ast"))
+    api(project(":js:js.ast"))
-    compile(project(":js:js.parser"))
+    api(project(":js:js.parser"))
-    compile(project(":js:js.serializer"))
+    api(project(":js:js.serializer"))
-    compile(project(":js:js.config"))
+    api(project(":js:js.config"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     compileOnly(intellijDep()) { includeJars("guava", rootProject = rootProject) }
 }

js/js.parser/build.gradle.kts

@@ -5,7 +5,7 @@ plugins {
 
 dependencies {
     api(kotlinStdlib())
-    compile(project(":js:js.ast"))
+    api(project(":js:js.ast"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 }
 

js/js.serializer/build.gradle.kts

@@ -4,11 +4,11 @@ plugins {
 }
 
 dependencies {
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":compiler:frontend"))
+    api(project(":compiler:frontend"))
-    compile(project(":compiler:serialization"))
+    api(project(":compiler:serialization"))
-    compile(project(":js:js.ast"))
+    api(project(":js:js.ast"))
-    compile(project(":js:js.config"))
+    api(project(":js:js.config"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 }
 

js/js.tests/build.gradle.kts

@@ -27,45 +27,45 @@ val testJsRuntime by configurations.creating {
 }
 
 dependencies {
-    testRuntime(intellijDep())
+    testRuntimeOnly(intellijDep())
 
-    testCompile(protobufFull())
+    testApi(protobufFull())
-    testCompile(projectTests(":compiler:tests-common"))
+    testApi(projectTests(":compiler:tests-common"))
     testCompileOnly(project(":compiler:frontend"))
     testCompileOnly(project(":compiler:cli"))
     testCompileOnly(project(":compiler:cli-js"))
     testCompileOnly(project(":compiler:util"))
     testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     testCompileOnly(intellijDep()) { includeJars("idea", "idea_rt", "util") }
-    testCompile(project(":compiler:backend.js"))
+    testApi(project(":compiler:backend.js"))
-    testCompile(project(":compiler:backend.wasm"))
+    testApi(project(":compiler:backend.wasm"))
-    testCompile(project(":js:js.translator"))
+    testApi(project(":js:js.translator"))
-    testCompile(project(":js:js.serializer"))
+    testApi(project(":js:js.serializer"))
-    testCompile(project(":js:js.dce"))
+    testApi(project(":js:js.dce"))
-    testCompile(project(":js:js.engines"))
+    testApi(project(":js:js.engines"))
-    testCompile(project(":compiler:incremental-compilation-impl"))
+    testApi(project(":compiler:incremental-compilation-impl"))
-    testCompile(commonDep("junit:junit"))
+    testApi(commonDep("junit:junit"))
-    testCompile(projectTests(":kotlin-build-common"))
+    testApi(projectTests(":kotlin-build-common"))
-    testCompile(projectTests(":generators:test-generator"))
+    testApi(projectTests(":generators:test-generator"))
 
-    testCompile(intellijCoreDep()) { includeJars("intellij-core") }
+    testApi(intellijCoreDep()) { includeJars("intellij-core") }
-    testCompile(project(":compiler:frontend"))
+    testApi(project(":compiler:frontend"))
-    testCompile(project(":compiler:cli"))
+    testApi(project(":compiler:cli"))
-    testCompile(project(":compiler:util"))
+    testApi(project(":compiler:util"))
 
-    testRuntime(project(":kotlin-reflect"))
+    testRuntimeOnly(project(":kotlin-reflect"))
 
-    testRuntime(intellijDep()) { includeJars("trove4j", "guava", "jdom", rootProject = rootProject) }
+    testRuntimeOnly(intellijDep()) { includeJars("trove4j", "guava", "jdom", rootProject = rootProject) }
 
-    testRuntime(kotlinStdlib())
+    testRuntimeOnly(kotlinStdlib())
     testJsRuntime(kotlinStdlib("js"))
     if (!kotlinBuildProperties.isInJpsBuildIdeaSync) {
         testJsRuntime(project(":kotlin-test:kotlin-test-js")) // to be sure that kotlin-test-js built before tests runned
     }
-    testRuntime(project(":kotlin-reflect"))
+    testRuntimeOnly(project(":kotlin-reflect"))
-    testRuntime(project(":kotlin-preloader")) // it's required for ant tests
+    testRuntimeOnly(project(":kotlin-preloader")) // it's required for ant tests
-    testRuntime(project(":compiler:backend-common"))
+    testRuntimeOnly(project(":compiler:backend-common"))
-    testRuntime(commonDep("org.fusesource.jansi", "jansi"))
+    testRuntimeOnly(commonDep("org.fusesource.jansi", "jansi"))
     
     antLauncherJar(commonDep("org.apache.ant", "ant"))
     antLauncherJar(toolsJar())

js/js.translator/build.gradle.kts

@@ -7,13 +7,13 @@ plugins {
 }
 
 dependencies {
-    compile(project(":core:descriptors"))
+    api(project(":core:descriptors"))
-    compile(project(":compiler:util"))
+    api(project(":compiler:util"))
-    compile(project(":compiler:frontend"))
+    api(project(":compiler:frontend"))
-    compile(project(":compiler:backend-common"))
+    api(project(":compiler:backend-common"))
-    compile(project(":js:js.ast"))
+    api(project(":js:js.ast"))
-    compile(project(":js:js.frontend"))
+    api(project(":js:js.frontend"))
-    compile(project(":js:js.parser"))
+    api(project(":js:js.parser"))
     compileOnly(project(":js:js.sourcemap"))
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     compileOnly(intellijDep()) { includeJars("trove4j", "guava", rootProject = rootProject) }

kotlin-native/Interop/Indexer/build.gradle.kts

@@ -150,8 +150,8 @@ sourceSets {
 }
 
 dependencies {
-    compile(project(":kotlin-stdlib"))
+    api(project(":kotlin-stdlib"))
-    compile(project(":kotlin-native:Interop:Runtime"))
+    api(project(":kotlin-native:Interop:Runtime"))
 
     testImplementation(kotlin("test-junit"))
 }

kotlin-native/backend.native/build.gradle

@@ -75,15 +75,11 @@ configurations {
     trove4j_jar
     kotlinCommonSources
 
-    cli_bcRuntime {
+    cli_bcApiElements {
-        extendsFrom compilerRuntime
+        extendsFrom cli_bcApi
-        extendsFrom kotlin_script_runtime_jar
     }
 
-    cli_bc {
+    cli_bcApi.extendsFrom compilerApi
-        extendsFrom cli_bcRuntime
-    }
-    cli_bcCompile.extendsFrom compilerCompile
 }
 
 dependencies {
@@ -97,30 +93,30 @@ dependencies {
         kotlinCommonSources(it) { transitive = false }
     }
 
-    compilerCompile project(":kotlin-native:utilities:basic-utils")
+    compilerApi project(":kotlin-native:utilities:basic-utils")
 
-    compilerCompile project(kotlinCompilerModule)
+    compilerApi project(kotlinCompilerModule)
-    compilerCompile project(":native:kotlin-native-utils")
+    compilerApi project(":native:kotlin-native-utils")
-    compilerCompile project(":core:descriptors")
+    compilerApi project(":core:descriptors")
-    compilerCompile project(":compiler:ir.tree")
+    compilerApi project(":compiler:ir.tree")
-    compilerCompile project(":compiler:ir.tree.impl")
+    compilerApi project(":compiler:ir.tree.impl")
-    compilerCompile project(":compiler:ir.backend.common")
+    compilerApi project(":compiler:ir.backend.common")
-    compilerCompile project(":compiler:util")
+    compilerApi project(":compiler:util")
-    compilerCompile project(":native:frontend.native")
+    compilerApi project(":native:frontend.native")
-    compilerCompile project(":compiler:cli-common")
+    compilerApi project(":compiler:cli-common")
-    compilerCompile project(":compiler:cli")
+    compilerApi project(":compiler:cli")
-    compilerCompile project(":kotlin-util-klib")
+    compilerApi project(":kotlin-util-klib")
-    compilerCompile project(":kotlin-util-klib-metadata")
+    compilerApi project(":kotlin-util-klib-metadata")
-    compilerCompile project(":compiler:ir.serialization.common")
+    compilerApi project(":compiler:ir.serialization.common")
-    compilerCompile project(":compiler:ir.psi2ir")
+    compilerApi project(":compiler:ir.psi2ir")
     use(LocalDependenciesKt) {
-        compilerCompile(intellijCoreDep()){
+        compilerApi(intellijCoreDep()){
             artifact {
                 name = "intellij-core"
                 type = "jar"
             }
         }
-        compilerCompile(intellijDep()){
+        compilerApi(intellijDep()){
             artifact {
                 name = "util"
                 type = "jar"
@@ -130,13 +126,13 @@ dependencies {
         compileOnly(jpsStandalone())
     }
 
-    compilerCompile kotlinNativeInterop['llvm'].configuration
+    compilerApi kotlinNativeInterop['llvm'].configuration
-    compilerCompile kotlinNativeInterop['files'].configuration
+    compilerApi kotlinNativeInterop['files'].configuration
 
 
-    cli_bcCompile sourceSets.compiler.output
+    cli_bcApi sourceSets.compiler.output
 
-    cli_bc sourceSets.cli_bc.output
+    cli_bcApiElements sourceSets.cli_bc.output
 }
 
 

kotlin-native/backend.native/tests/build.gradle

@@ -41,14 +41,13 @@ configurations {
     update_tests
     update_stdlib_tests
 
-    compile
+    nopPluginApi
-    nopPluginCompile
+    api.extendsFrom nopPluginApi
-    compile.extendsFrom nopPluginCompile
 }
 
 dependencies {
-    compile 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.7'
+    api 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.7'
-    cli_bc project(path: ':kotlin-native:backend.native', configuration: 'cli_bc')
+    cli_bc project(path: ':kotlin-native:backend.native', configuration: 'cli_bcApiElements')
 }
 ext.testOutputRoot = rootProject.file("test.output").absolutePath
 ext.externalTestsDir = project.file("build/external")
@@ -5814,23 +5813,23 @@ pluginTest("runtime_basic_init", "nopPlugin") {
 }
 
 dependencies {
-    nopPluginCompile project(kotlinCompilerModule)
+    nopPluginApi project(kotlinCompilerModule)
-    nopPluginCompile project(":native:kotlin-native-utils")
+    nopPluginApi project(":native:kotlin-native-utils")
-    nopPluginCompile project(":core:descriptors")
+    nopPluginApi project(":core:descriptors")
-    nopPluginCompile project(":compiler:ir.tree")
+    nopPluginApi project(":compiler:ir.tree")
-    nopPluginCompile project(":compiler:ir.tree.impl")
+    nopPluginApi project(":compiler:ir.tree.impl")
-    nopPluginCompile project(":compiler:ir.backend.common")
+    nopPluginApi project(":compiler:ir.backend.common")
-    nopPluginCompile project(":compiler:util")
+    nopPluginApi project(":compiler:util")
-    nopPluginCompile project(":native:frontend.native")
+    nopPluginApi project(":native:frontend.native")
-    nopPluginCompile project(":compiler:cli-common")
+    nopPluginApi project(":compiler:cli-common")
-    nopPluginCompile project(":compiler:cli")
+    nopPluginApi project(":compiler:cli")
-    nopPluginCompile project(":kotlin-util-klib")
+    nopPluginApi project(":kotlin-util-klib")
-    nopPluginCompile project(":kotlin-util-klib-metadata")
+    nopPluginApi project(":kotlin-util-klib-metadata")
-    nopPluginCompile project(":compiler:ir.serialization.common")
+    nopPluginApi project(":compiler:ir.serialization.common")
 
-    compile project(kotlinCompilerModule)
+    api project(kotlinCompilerModule)
-    compile project(path: ':kotlin-native:backend.native', configuration: 'cli_bc')
+    api project(path: ':kotlin-native:backend.native', configuration: 'cli_bcApiElements')
-    compile 'junit:junit:4.12'
+    api 'junit:junit:4.12'
 }
 
 project.tasks.named("test").configure {

kotlin-native/klib/build.gradle

@@ -42,7 +42,7 @@ repositories {
 
 dependencies {
     implementation project(":kotlin-stdlib")
-    implementation project(path: ':kotlin-native:backend.native', configuration: 'cli_bc')
+    implementation project(path: ':kotlin-native:backend.native', configuration: 'cli_bcApiElements')
     implementation project(":kotlin-native:utilities:basic-utils")
     testImplementation "junit:junit:4.12"
     testImplementation project(":kotlin-test:kotlin-test-junit")

libraries/examples/annotation-processor-example/build.gradle.kts

@@ -13,7 +13,7 @@ pill {
 }
 
 dependencies {
-    compile(kotlinStdlib())
+    api(kotlinStdlib())
 }
 
 sourceSets {

libraries/examples/kotlin-gradle-subplugin-example/build.gradle

@@ -12,11 +12,11 @@ pill {
 }
 
 dependencies {
-    compile project(':kotlin-gradle-plugin-api')
+    api project(':kotlin-gradle-plugin-api')
     // Use this dependency instead when building apart from the other modules:
     // compile "org.jetbrains.kotlin:kotlin-gradle-plugin-api:$kotlin_version"
 
-    compile project(':kotlin-test::kotlin-test-junit')
+    api project(':kotlin-test::kotlin-test-junit')
 
     compileOnly kotlinStdlib()
     compileOnly project(':compiler')

libraries/examples/kotlin-jsr223-daemon-local-eval-example/build.gradle.kts

@@ -19,15 +19,15 @@ val compilerClasspath by configurations.creating {
 }
 
 dependencies {
-    testCompile(kotlinStdlib())
+    testApi(kotlinStdlib())
-    testCompile(project(":kotlin-script-runtime"))
+    testApi(project(":kotlin-script-runtime"))
-    testCompile(project(":kotlin-script-util"))
+    testApi(project(":kotlin-script-util"))
-    testCompile(projectRuntimeJar(":kotlin-daemon-client"))
+    testApi(projectRuntimeJar(":kotlin-daemon-client"))
-    testCompile(projectRuntimeJar(":kotlin-daemon-embeddable"))
+    testApi(projectRuntimeJar(":kotlin-daemon-embeddable"))
-    testCompile(projectRuntimeJar(":kotlin-compiler-embeddable"))
+    testApi(projectRuntimeJar(":kotlin-compiler-embeddable"))
-    testCompile(commonDep("junit:junit"))
+    testApi(commonDep("junit:junit"))
-    testCompile(project(":kotlin-test:kotlin-test-junit"))
+    testApi(project(":kotlin-test:kotlin-test-junit"))
-    testRuntime(project(":kotlin-reflect"))
+    testRuntimeOnly(project(":kotlin-reflect"))
     compilerClasspath(project(":kotlin-reflect"))
     compilerClasspath(kotlinStdlib())
     compilerClasspath(commonDep("org.jetbrains.intellij.deps", "trove4j"))

libraries/examples/kotlin-jsr223-local-example/build.gradle.kts

@@ -12,18 +12,18 @@ pill {
 }
 
 dependencies {
-    compile(kotlinStdlib())
+    api(kotlinStdlib())
-    compile(project(":kotlin-script-runtime"))
+    api(project(":kotlin-script-runtime"))
-    compile(project(":kotlin-compiler-embeddable"))
+    api(project(":kotlin-compiler-embeddable"))
-    compile(project(":kotlin-script-util"))
+    api(project(":kotlin-script-util"))
-    runtime(project(":kotlin-scripting-compiler-embeddable"))
+    runtimeOnly(project(":kotlin-scripting-compiler-embeddable"))
-    testCompile(project(":kotlin-test:kotlin-test-junit"))
+    testApi(project(":kotlin-test:kotlin-test-junit"))
-    testCompile(commonDep("junit:junit"))
+    testApi(commonDep("junit:junit"))
-    testRuntime(project(":kotlin-reflect"))
+    testRuntimeOnly(project(":kotlin-reflect"))
     compileOnly(project(":compiler:cli-common")) // TODO: fix import (workaround for jps build)
     testCompileOnly(project(":core:util.runtime")) // TODO: fix import (workaround for jps build)
     testCompileOnly(project(":daemon-common")) // TODO: fix import (workaround for jps build)
-    testRuntime(project(":kotlin-scripting-compiler-embeddable"))
+    testRuntimeOnly(project(":kotlin-scripting-compiler-embeddable"))
 }
 
 projectTest()

libraries/examples/scripting/jvm-embeddable-host/build.gradle.kts

@@ -4,14 +4,14 @@ plugins {
 }
 
 dependencies {
-    compile(project(":examples:scripting-jvm-simple-script"))
+    api(project(":examples:scripting-jvm-simple-script"))
     compileOnly(project(":kotlin-scripting-jvm-host-unshaded"))
     testRuntimeOnly(project(":kotlin-compiler-embeddable"))
     testRuntimeOnly(project(":kotlin-scripting-compiler-embeddable"))
     testRuntimeOnly(project(":kotlin-scripting-jvm-host"))
     testRuntimeOnly(project(":kotlin-reflect"))
     testRuntimeOnly(intellijDep()) { includeJars("guava", rootProject = rootProject) }
-    testCompile(commonDep("junit"))
+    testApi(commonDep("junit"))
 }
 
 sourceSets {

libraries/examples/scripting/jvm-maven-deps/host/build.gradle.kts

@@ -4,9 +4,9 @@ plugins {
 }
 
 dependencies {
-    compile(project(":examples:scripting-jvm-maven-deps"))
+    api(project(":examples:scripting-jvm-maven-deps"))
-    compile(project(":kotlin-scripting-jvm-host-unshaded"))
+    api(project(":kotlin-scripting-jvm-host-unshaded"))
-    compile(kotlinStdlib())
+    api(kotlinStdlib())
     compileOnly(project(":kotlin-reflect-api"))
     compileOnly(project(":compiler:util"))
 
@@ -14,7 +14,7 @@ dependencies {
     testRuntimeOnly(project(":kotlin-reflect"))
     testRuntimeOnly(project(":kotlin-scripting-compiler"))
 
-    testCompile(commonDep("junit"))
+    testApi(commonDep("junit"))
 }
 
 sourceSets {

libraries/examples/scripting/jvm-maven-deps/script/build.gradle.kts

@@ -4,10 +4,10 @@ plugins {
 }
 
 dependencies {
-    compile(project(":kotlin-scripting-jvm"))
+    api(project(":kotlin-scripting-jvm"))
-    compile(project(":kotlin-scripting-dependencies"))
+    api(project(":kotlin-scripting-dependencies"))
-    compile(project(":kotlin-scripting-dependencies-maven"))
+    api(project(":kotlin-scripting-dependencies-maven"))
-    compile(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core"))
+    api(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core"))
 }
 
 sourceSets {

libraries/examples/scripting/jvm-simple-script/host/build.gradle.kts

@@ -4,13 +4,13 @@ plugins {
 }
 
 dependencies {
-    compile(project(":examples:scripting-jvm-simple-script"))
+    api(project(":examples:scripting-jvm-simple-script"))
-    compile(project(":kotlin-scripting-jvm-host-unshaded"))
+    api(project(":kotlin-scripting-jvm-host-unshaded"))
-    compile(project(":kotlin-script-util"))
+    api(project(":kotlin-script-util"))
     testRuntimeOnly(project(":kotlin-compiler"))
     testRuntimeOnly(project(":kotlin-scripting-compiler"))
     testRuntimeOnly(project(":kotlin-reflect"))
-    testCompile(commonDep("junit"))
+    testApi(commonDep("junit"))
 }
 
 sourceSets {

libraries/examples/scripting/jvm-simple-script/script/build.gradle.kts

@@ -4,7 +4,7 @@ plugins {
 }
 
 dependencies {
-    compile(project(":kotlin-scripting-jvm"))
+    api(project(":kotlin-scripting-jvm"))
 }
 
 sourceSets {

libraries/kotlin.test/annotations-common/build.gradle

@@ -5,8 +5,8 @@ apply plugin: 'kotlin-platform-common'
 JvmToolchain.updateJvmTarget(project, "1.6")
 
 dependencies {
-    compile kotlinStdlib("common")
+    api kotlinStdlib("common")
-    testCompile project(":kotlin-test:kotlin-test-common")
+    testApi project(":kotlin-test:kotlin-test-common")
 }
 
 tasks.withType(org.jetbrains.kotlin.gradle.dsl.KotlinCompile) {

libraries/kotlin.test/common/build.gradle

@@ -5,8 +5,8 @@ apply plugin: 'kotlin-platform-common'
 JvmToolchain.updateJvmTarget(project, "1.6")
 
 dependencies {
-    compile kotlinStdlib("common")
+    api kotlinStdlib("common")
-    testCompile project(":kotlin-test:kotlin-test-annotations-common")
+    testApi project(":kotlin-test:kotlin-test-annotations-common")
 }
 
 jar {

libraries/kotlin.test/js/build.gradle

@@ -10,7 +10,7 @@ configurations {
 dependencies {
     expectedBy project(':kotlin-test:kotlin-test-common')
     expectedBy project(':kotlin-test:kotlin-test-annotations-common')
-    compile kotlinStdlib("js")
+    api kotlinStdlib("js")
 }
 
 compileKotlin2Js {
@@ -73,7 +73,6 @@ task sourcesJar(type: Jar, dependsOn: classes) {
 }
 
 artifacts {
-    runtime libraryJarWithIr
     archives libraryJarWithIr
     distLibrary libraryJarWithIr
     archives sourcesJar

libraries/kotlin.test/js/it/build.gradle

@@ -12,7 +12,7 @@ apply plugin: 'kotlin-platform-js'
 
 configurations {
     nodeModules {
-        extendsFrom compile
+        extendsFrom api
         attributes {
             attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage, KotlinUsages.KOTLIN_RUNTIME))
             attribute(KotlinPlatformType.attribute, KotlinPlatformType.js)
@@ -21,7 +21,7 @@ configurations {
 }
 
 dependencies {
-    compile project(':kotlin-test:kotlin-test-js')
+    api project(':kotlin-test:kotlin-test-js')
 }
 
 // package.json contains direct links to the builddir

libraries/kotlin.test/junit/build.gradle

@@ -14,8 +14,8 @@ sourceSets {
 
 dependencies {
     expectedBy project(':kotlin-test:kotlin-test-annotations-common')
-    compile project(':kotlin-test:kotlin-test-jvm')
+    api project(':kotlin-test:kotlin-test-jvm')
-    compile('junit:junit:4.12')
+    api('junit:junit:4.12')
 }
 
 

libraries/kotlin.test/junit5/build.gradle

@@ -14,10 +14,10 @@ project.ext["jpsLibraryPath"] = rootProject.distLibDir
 
 dependencies {
     expectedBy project(':kotlin-test:kotlin-test-annotations-common')
-    compile project(':kotlin-test:kotlin-test-jvm')
+    api project(':kotlin-test:kotlin-test-jvm')
 
-    compile("org.junit.jupiter:junit-jupiter-api:5.0.0")
+    api("org.junit.jupiter:junit-jupiter-api:5.0.0")
-    testRuntime("org.junit.jupiter:junit-jupiter-engine:5.2.0")
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.2.0")
 }
 
 jar {

libraries/kotlin.test/jvm/build.gradle

@@ -16,9 +16,9 @@ sourceSets {
 
 dependencies {
     expectedBy project(':kotlin-test:kotlin-test-common')
-    compile kotlinStdlib()
+    api(kotlinStdlib())
-    testCompile project(":kotlin-test:kotlin-test-junit")
+    testApi(project(":kotlin-test:kotlin-test-junit"))
-    testCompile('junit:junit:4.12')
+    testApi('junit:junit:4.12')
 }
 
 jar {

libraries/kotlin.test/testng/build.gradle

@@ -15,8 +15,8 @@ sourceSets {
 
 dependencies {
     expectedBy project(':kotlin-test:kotlin-test-annotations-common')
-    compile project(':kotlin-test:kotlin-test-jvm')
+    api project(':kotlin-test:kotlin-test-jvm')
-    compile('org.testng:testng:6.13.1')
+    api('org.testng:testng:6.13.1')
     if (includeJava9) {
         java9CompileOnly('org.testng:testng:7.0.0')
     }

libraries/kotlinx-metadata/build.gradle.kts

@@ -19,7 +19,7 @@ sourceSets {
 }
 
 dependencies {
-    compile(kotlinStdlib())
+    api(kotlinStdlib())
     compileOnly(project(":core:metadata"))
     compileOnly(protobufLite())
 }

libraries/kotlinx-metadata/jvm/build.gradle.kts

@@ -37,7 +37,7 @@ val shadows by configurations.creating {
     isTransitive = false
 }
 configurations.getByName("compileOnly").extendsFrom(shadows)
-configurations.getByName("testCompile").extendsFrom(shadows)
+configurations.getByName("testApi").extendsFrom(shadows)
 
 dependencies {
     api(kotlinStdlib())

libraries/kotlinx-metadata/klib/build.gradle.kts

@@ -25,10 +25,10 @@ val shadows by configurations.creating {
     isTransitive = false
 }
 configurations.getByName("compileOnly").extendsFrom(shadows)
-configurations.getByName("testCompile").extendsFrom(shadows)
+configurations.getByName("testApi").extendsFrom(shadows)
 
 dependencies {
-    compile(kotlinStdlib())
+    api(kotlinStdlib())
     shadows(project(":kotlinx-metadata"))
     shadows(project(":core:compiler.common"))
     shadows(project(":core:metadata"))