[Build] Remove testApi(intellijDep()) dependencies from all modules

Since IDEA moved most of it's jars to java 11 it's illegal to use them
  in our dependencies, so all modules which use `intellijDep()` should
  carefully specify which jars they use

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

@@ -35,22 +35,17 @@ dependencies {
     testApi(project(":kotlin-reflect"))
     testImplementation(project(":analysis:symbol-light-classes"))
 
-    testRuntimeOnly(intellijDep()) {
+    testApi(intellijDep()) {
         includeJars(
             "jps-model",
-            "extensions",
-            "util",
             "platform-api",
             "platform-impl",
-            "idea",
             "guava",
             "trove4j",
             "asm-all",
             "log4j",
             "jdom",
             "streamex",
-            "bootstrap",
-            "jna",
             rootProject = rootProject
         )
     }

compiler/build.gradle.kts

@@ -12,7 +12,7 @@ val otherCompilerModules = compilerModules.filter { it != path }
 val antLauncherJar by configurations.creating
 
 dependencies {
-    testImplementation(intellijDep()) // Should come before compiler, because of "progarded" stuff needed for tests
+    testImplementation(intellijDep()) { includeJars("platform-impl", rootProject = rootProject) } // Should come before compiler, because of "progarded" stuff needed for tests
 
     testApi(project(":kotlin-script-runtime"))
     testApi(project(":kotlin-test:kotlin-test-jvm"))
@@ -37,7 +37,15 @@ dependencies {
         testCompileOnly(project(it))
     }
     testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-    testCompileOnly(intellijDep()) { includeJars("idea", "idea_rt", "util", "asm-all", rootProject = rootProject) }
+
+    testRuntimeOnly(intellijDep()) {
+        includeJars(
+            "jps-model",
+            "streamex",
+            "idea_rt",
+            rootProject = rootProject
+        )
+    }
 
     testRuntimeOnly(intellijPluginDep("java"))
 

compiler/fir/analysis-tests/build.gradle.kts

@@ -33,10 +33,9 @@ dependencies {
 
     testImplementation(intellijCoreDep()) { includeJars("intellij-core") }
     testRuntimeOnly(intellijDep()) {
-        includeJars("jna", rootProject = rootProject)
+        includeJars("intellij-deps-fastutil-8.4.1-4", "jps-model", "streamex", "jna", rootProject = rootProject)
     }
 
-    testRuntimeOnly(intellijDep()) { includeJars("intellij-deps-fastutil-8.4.1-4") }
     testRuntimeOnly(toolsJar())
 }
 

compiler/fir/analysis-tests/legacy-fir-tests/build.gradle.kts

@@ -13,8 +13,6 @@ plugins {
 dependencies {
     compileOnly(intellijCoreDep()) { includeJars("intellij-core", "guava", rootProject = rootProject) }
 
-    testApi(intellijDep())
-
     testApi(commonDep("junit:junit"))
     testCompileOnly(project(":kotlin-test:kotlin-test-jvm"))
     testCompileOnly(project(":kotlin-test:kotlin-test-junit"))
@@ -30,6 +28,7 @@ dependencies {
 
     testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     testRuntimeOnly(intellijCoreDep()) { includeJars("intellij-core") }
+    testRuntimeOnly(intellijDep()) { includeJars("idea_rt", "streamex", "jps-model", rootProject = rootProject) }
 }
 
 val generationRoot = projectDir.resolve("tests-gen")

compiler/fir/fir2ir/build.gradle.kts

@@ -43,7 +43,7 @@ dependencies {
         includeJars("jna", rootProject = rootProject)
     }
 
-    testRuntimeOnly(intellijDep()) { includeJars("intellij-deps-fastutil-8.4.1-4") }
+    testRuntimeOnly(intellijDep()) { includeJars("intellij-deps-fastutil-8.4.1-4", "jps-model", "streamex", rootProject = rootProject) }
 }
 
 val generationRoot = projectDir.resolve("tests-gen")

compiler/fir/modularized-tests/build.gradle.kts

@@ -15,14 +15,14 @@ repositories {
 }
 
 dependencies {
-    testCompileOnly(intellijDep()) {
+    testApi(intellijCoreDep()) { includeJars("intellij-core")}
+    testApi(intellijDep()) {
         includeJars("extensions", "idea_rt", "util", "asm-all", "jna", rootProject = rootProject)
     }
 
     testCompileOnly(intellijPluginDep("java")) { includeJars("java-api") }
 
     testRuntimeOnly("xerces:xercesImpl:2.12.0")
-    testRuntimeOnly(intellijDep())
     testRuntimeOnly(intellijPluginDep("java"))
 
     testApi(commonDep("junit:junit"))

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

@@ -23,7 +23,6 @@ dependencies {
 
     compileOnly(intellijCoreDep()) { includeJars("intellij-core", "guava", rootProject = rootProject) }
 
-    testImplementation(intellijDep())
     testImplementation(commonDep("junit:junit"))
     testImplementation(projectTests(":compiler:tests-common"))
     testImplementation(projectTests(":compiler:fir:raw-fir:psi2fir"))

compiler/fir/raw-fir/psi2fir/build.gradle.kts

@@ -17,7 +17,7 @@ dependencies {
 
     compileOnly(intellijCoreDep()) { includeJars("intellij-core", "guava", rootProject = rootProject) }
 
-    testImplementation(intellijDep())
+    testImplementation(intellijDep()) { includeJars("platform-api", rootProject = rootProject) }
 
     testImplementation(commonDep("junit:junit"))
     testImplementation(projectTests(":compiler:tests-common"))

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

@@ -26,7 +26,7 @@ dependencies {
     testApi(intellijDep()) { includeJars("log4j", "jdom") }
     testRuntimeOnly(project(":kotlin-reflect"))
     testRuntimeOnly(project(":core:descriptors.runtime"))
-    testRuntimeOnly(intellijDep()) { includeJars("lz4-java", "jna", rootProject = rootProject) }
+    testRuntimeOnly(intellijDep()) { includeJars("lz4-java", "jna", "idea_rt", rootProject = rootProject) }
 }
 
 sourceSets {

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

@@ -25,11 +25,22 @@ dependencies {
     testApi(projectTests(":compiler:tests-compiler-utils"))
     testApi(projectTests(":compiler:tests-common-jvm6"))
 
-    testRuntimeOnly(intellijDep()) {
-        includeJars("jna", rootProject = rootProject)
+    /*
+     * Actually those dependencies are needed only at runtime, but they
+     *   declared as Api dependencies to propagate them to all modules
+     *   which depend on current one
+     */
+    testApi(intellijDep()) {
+        includeJars(
+            "intellij-deps-fastutil-8.4.1-4",
+            "idea_rt",
+            "jps-model",
+            "platform-impl",
+            "streamex",
+            "jna",
+            rootProject = rootProject
+        )
     }
-
-    testRuntimeOnly(intellijDep()) { includeJars("intellij-deps-fastutil-8.4.1-4") }
     testRuntimeOnly(toolsJar())
 }
 

compiler/tests-common/build.gradle.kts

@@ -56,20 +56,33 @@ dependencies {
     testCompileOnly(project(":kotlin-reflect-api"))
     testCompileOnly(toolsJar())
     testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-    testApi(intellijDep()) { includeJars("intellij-deps-fastutil-8.4.1-4") }
+
+    /*
+     * Actually those dependencies are needed only at runtime, but they
+     *   declared as Api dependencies to propagate them to all modules
+     *   which depend on current one
+     */
     testApi(intellijDep()) {
+        includeJars(
+            "intellij-deps-fastutil-8.4.1-4",
+            "idea_rt",
+            "jps-model",
+            "platform-impl",
+            "streamex",
+            "jna",
+            rootProject = rootProject
+        )
+    }
+    testImplementation(intellijDep()) {
         includeJars(
             "guava",
             "trove4j",
             "asm-all",
             "log4j",
             "jdom",
-            "jna",
             rootProject = rootProject
         )
-        isTransitive = false
     }
-
     testApiJUnit5()
 }
 

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

@@ -31,20 +31,11 @@ dependencies {
 
     testApi(intellijDep()) {
         includeJars(
-            "jps-model",
-            "extensions",
-            "util",
-            "platform-api",
-            "platform-impl",
-            "idea",
-            "idea_rt",
             "guava",
             "trove4j",
             "asm-all",
             "log4j",
             "jdom",
-            "streamex",
-            "bootstrap",
             rootProject = rootProject
         )
         isTransitive = false

compiler/tests-for-compiler-generator/build.gradle.kts

@@ -4,7 +4,6 @@ plugins {
 }
 
 dependencies {
-    testRuntimeOnly(intellijDep()) // Should come before compiler, because of "progarded" stuff needed for tests
     testImplementation(kotlinStdlib())
 
     testApiJUnit5()

compiler/tests-java8/build.gradle.kts

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

compiler/tests-spec/build.gradle.kts

@@ -9,12 +9,13 @@ dependencies {
     testImplementation(projectTests(":compiler:tests-common-new"))
 
     testApi(intellijDep()) {
-        includeJars("groovy", "groovy-xml", rootProject = rootProject)
-    }
-    testApi(intellijDep()) {
-        includeJars("gson", rootProject = rootProject)
+        includeJars("gson", "groovy", "groovy-xml", rootProject = rootProject)
     }
     testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") }
+    testRuntimeOnly(intellijDep()) {
+        includeJars("streamex", rootProject = rootProject)
+    }
+
     testRuntimeOnly(intellijPluginDep("java"))
     api("org.jsoup:jsoup:1.14.2")
     if (isIdeaActive) testRuntimeOnly(files("${rootProject.projectDir}/dist/kotlinc/lib/kotlin-reflect.jar"))

core/descriptors.runtime/build.gradle.kts

@@ -25,8 +25,8 @@ dependencies {
     testApi(projectTests(":compiler:tests-common"))
     testApi(projectTests(":generators:test-generator"))
 
-    testRuntimeOnly(intellijCoreDep()) { includeJars("intellij-core") }
-    testRuntimeOnly(intellijDep()) { includeJars("platform-concurrency") }
+    testApi(intellijCoreDep()) { includeJars("intellij-core") }
+    testRuntimeOnly(intellijDep()) { includeJars("platform-concurrency", "idea_rt", rootProject = rootProject) }
     testRuntimeOnly(jpsStandalone()) { includeJars("jps-model") }
 }
 

libraries/tools/kotlinp/build.gradle.kts

@@ -28,9 +28,9 @@ dependencies {
 
     testRuntimeOnly(project(":kotlinx-metadata-jvm"))
 
-    testRuntimeOnly(intellijCoreDep()) { includeJars("intellij-core") }
+    testApi(intellijCoreDep()) { includeJars("intellij-core") }
 
-    testRuntimeOnly(intellijDep()) { includeJars("platform-concurrency", "platform-objectSerializer") }
+    testRuntimeOnly(intellijDep()) { includeJars("platform-concurrency", "platform-objectSerializer", "idea_rt") }
 
     shadows(project(":kotlinx-metadata-jvm"))
     shadows("org.jetbrains.intellij.deps:asm-all:$kotlinpAsmVersion")

native/commonizer/build.gradle.kts

@@ -40,6 +40,10 @@ dependencies {
     testImplementation(project(":kotlinx-metadata-klib")) { isTransitive = false }
     testImplementation(project(":kotlinx-metadata")) { isTransitive = false }
     testImplementation(project(":native:kotlin-klib-commonizer-api"))
+    testApi(intellijCoreDep()) { includeJars("intellij-core")}
+//    testRuntimeOnly(intellijDep()) {
+//        includeJars("idea_rt", rootProject = rootProject)
+//    }
 }
 
 val runCommonizer by tasks.registering(JavaExec::class) {

plugins/allopen/allopen-cli/build.gradle.kts

@@ -18,7 +18,7 @@ dependencies {
     testApi(projectTests(":compiler:tests-common"))
     testApi(commonDep("junit:junit"))
 
-    testRuntimeOnly(intellijCoreDep()) { includeJars("intellij-core") }
+    testApi(intellijCoreDep()) { includeJars("intellij-core") }
 }
 
 sourceSets {

plugins/jvm-abi-gen/build.gradle.kts

@@ -38,6 +38,7 @@ dependencies {
 
     compileOnly(intellijCoreDep()) { includeJars("intellij-core", "asm-all", rootProject = rootProject) }
 
+    testApi(intellijDep()) { includeJars("platform-impl", rootProject = rootProject) }
     testRuntimeOnly(intellijCoreDep()) { includeJars("intellij-core") }
     testRuntimeOnly(project(":kotlin-compiler"))
 
@@ -70,4 +71,4 @@ projectTest(parallel = true) {
     dependsOn(shadowJar)
 }
 
-testsJar()
+testsJar()

plugins/noarg/noarg-cli/build.gradle.kts

@@ -21,8 +21,7 @@ dependencies {
     testApi(project(":compiler:cli"))
     testApi(projectTests(":compiler:tests-common"))
     testApi(commonDep("junit:junit"))
-
-    testRuntimeOnly(intellijCoreDep()) { includeJars("intellij-core") }
+    testApi(intellijCoreDep()) { includeJars("intellij-core")}
 }
 
 sourceSets {