Make all dependencies to idea sdk intransitive

build-common/build.gradle.kts

@@ -24,7 +24,7 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compileOnly(intellij { include("util.jar") })
+        compileOnly(intellij { include("annotations.jar", "asm-all.jar", "trove4j.jar", "util.jar") })
         testCompileOnly(intellij { include("openapi.jar") })
     }
 }

compiler/android-tests/build.gradle.kts

@@ -25,8 +25,8 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellij { include("openapi.jar") })
-        testCompile(intellij { include("idea.jar", "idea_rt.jar", "groovy-all-*.jar", "jps-builders.jar") })
+        compileOnly(intellij { include("openapi.jar") })
+        testCompile(intellij { include("openapi.jar", "idea.jar", "idea_rt.jar", "groovy-all-*.jar", "jps-builders.jar") })
         testCompile(intellijExtra("jps-standalone") { include("jps-model.jar") })
         testCompile(intellijExtra("jps-build-test"))
     }

compiler/backend-common/build.gradle.kts

@@ -3,6 +3,10 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
+configureIntellijPlugin {
+    setExtraDependencies("intellij-core")
+}
+
 dependencies {
     compile(project(":core:descriptors"))
     compile(project(":core:descriptors.jvm"))
@@ -11,6 +15,12 @@ dependencies {
     compile(project(":compiler:ir.tree"))
 }
 
+afterEvaluate {
+    dependencies {
+        compileOnly(intellijCoreJar())
+    }
+}
+
 sourceSets {
     "main" {
         projectDefault()

compiler/backend/build.gradle.kts

@@ -3,6 +3,10 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
+configureIntellijPlugin {
+    setExtraDependencies("intellij-core")
+}
+
 dependencies {
     compile(project(":compiler:util"))
     compile(project(":compiler:backend-common"))
@@ -13,6 +17,13 @@ dependencies {
     compile(project(":compiler:serialization"))
 }
 
+afterEvaluate {
+    dependencies {
+        compileOnly(intellijCoreJar())
+        compileOnly(intellij { include("annotations.jar", "asm-all.jar", "trove4j.jar", "guava-*.jar") })
+    }
+}
+
 sourceSets {
     "main" {
         projectDefault()

compiler/build.gradle.kts

@@ -73,9 +73,10 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        testCompile(intellij { include("openapi.jar", "idea.jar", "util.jar", "asm-all.jar", "commons-httpclient-3.1-patched.jar") })
+        testCompileOnly(intellijCoreJar())
+        testCompileOnly(intellij { include("openapi.jar", "idea.jar", "idea_rt.jar", "util.jar", "asm-all.jar",
+                                           "commons-httpclient-3.1-patched.jar") })
         testRuntime(intellij())
-        testRuntime(intellijCoreJar())
     }
 }
 

compiler/cli/build.gradle.kts

@@ -34,8 +34,8 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
-        compile(intellijCoreJarDependencies())
+        compileOnly(intellijCoreJar())
+        compileOnly(intellijCoreJarDependencies())
     }
 }
 

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

@@ -17,8 +17,8 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
-        compile(intellijCoreJarDependencies())
+        compileOnly(intellijCoreJar())
+        compileOnly(intellijCoreJarDependencies())
     }
 }
 

compiler/compiler-runner/build.gradle.kts

@@ -7,6 +7,10 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
+configureIntellijPlugin {
+    setExtraDependencies("intellij-core")
+}
+
 dependencies {
     compile(project(":kotlin-build-common"))
     compileOnly(project(":compiler:cli-common"))
@@ -18,6 +22,12 @@ dependencies {
     runtimeOnly(projectRuntimeJar(":kotlin-compiler-embeddable"))
 }
 
+afterEvaluate {
+    dependencies {
+        compileOnly(intellijCoreJar())
+    }
+}
+
 sourceSets {
     "main" { projectDefault() }
     "test" {}

compiler/conditional-preprocessor/build.gradle.kts

@@ -19,8 +19,8 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
-        compile(intellijCoreJarDependencies())
+        compileOnly(intellijCoreJar())
+        compileOnly(intellijCoreJarDependencies())
     }
 }
 

compiler/container/build.gradle.kts

@@ -19,7 +19,8 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
+        compileOnly(intellijCoreJar())
+        testCompile(intellijCoreJar())
         testRuntime(intellij { include("trove4j.jar") })
     }
 }

compiler/daemon/build.gradle.kts

@@ -19,8 +19,8 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
-        compile(intellijCoreJarDependencies())
+        compileOnly(intellijCoreJar())
+        compileOnly(intellijCoreJarDependencies())
     }
 }
 

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

@@ -17,8 +17,8 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
-        compile(intellijCoreJarDependencies())
+        compileOnly(intellijCoreJar())
+        compileOnly(intellijCoreJarDependencies())
     }
 }
 

compiler/frontend.java/build.gradle.kts

@@ -3,6 +3,10 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
+configureIntellijPlugin {
+    setExtraDependencies("intellij-core")
+}
+
 dependencies {
     compile(project(":core:descriptors"))
     compile(project(":core:descriptors.jvm"))
@@ -10,6 +14,13 @@ dependencies {
     compile(project(":compiler:frontend"))
 }
 
+afterEvaluate {
+    dependencies {
+        compileOnly(intellijCoreJar())
+        compileOnly(intellij { include("annotations.jar", "asm-all.jar", "trove4j.jar", "guava-*.jar") })
+    }
+}
+
 sourceSets {
     "main" { projectDefault() }
     "test" {}

compiler/frontend.script/build.gradle.kts

@@ -3,6 +3,10 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
+configureIntellijPlugin {
+    setExtraDependencies("intellij-core")
+}
+
 dependencies {
     compile(project(":compiler:util"))
     compile(project(":compiler:frontend"))
@@ -11,6 +15,12 @@ dependencies {
     compile(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) { isTransitive = false }
 }
 
+afterEvaluate {
+    dependencies {
+        compileOnly(intellijCoreJar())
+    }
+}
+
 sourceSets {
     "main" { projectDefault() }
     "test" {}

compiler/frontend/build.gradle.kts

@@ -3,6 +3,10 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
+configureIntellijPlugin {
+    setExtraDependencies("intellij-core")
+}
+
 val jflexPath by configurations.creating
 
 dependencies {
@@ -16,6 +20,13 @@ dependencies {
     jflexPath(commonDep("org.jetbrains.intellij.deps.jflex", "jflex"))
 }
 
+afterEvaluate {
+    dependencies {
+        compileOnly(intellijCoreJar())
+        compileOnly(intellij { include("annotations.jar", "trove4j.jar", "guava-*.jar") })
+    }
+}
+
 sourceSets {
     "main" { projectDefault() }
     "test" {}

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

@@ -3,6 +3,10 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
+configureIntellijPlugin {
+    setExtraDependencies("intellij-core")
+}
+
 dependencies {
     compile(project(":core:descriptors"))
     compile(project(":core:descriptors.jvm"))
@@ -19,6 +23,15 @@ dependencies {
     testCompile(projectTests(":compiler:tests-common"))
 }
 
+afterEvaluate {
+    dependencies {
+        compileOnly(intellijCoreJar())
+        compileOnly(intellij { include("annotations.jar") })
+        testCompile(intellijCoreJar())
+        testCompile(intellij { include("annotations.jar") })
+    }
+}
+
 sourceSets {
     "main" { projectDefault() }
     "test" { projectDefault() }

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

@@ -2,6 +2,10 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
+configureIntellijPlugin {
+    setExtraDependencies("intellij-core")
+}
+
 dependencies {
     compile(project(":compiler:util"))
     compile(project(":compiler:frontend"))
@@ -9,6 +13,12 @@ dependencies {
     compile(project(":compiler:ir.tree"))
 }
 
+afterEvaluate {
+    dependencies {
+        compileOnly(intellijCoreJar())
+    }
+}
+
 sourceSets {
     "main" { projectDefault() }
     "test" {}

compiler/light-classes/build.gradle.kts

@@ -3,6 +3,10 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
+configureIntellijPlugin {
+    setExtraDependencies("intellij-core")
+}
+
 dependencies {
     compile(project(":compiler:util"))
     compile(project(":compiler:backend"))
@@ -10,6 +14,13 @@ dependencies {
     compile(project(":compiler:frontend.java"))
 }
 
+afterEvaluate {
+    dependencies {
+        compileOnly(intellijCoreJar())
+        compileOnly(intellij { include("annotations.jar", "asm-all.jar", "trove4j.jar", "guava-*.jar") })
+    }
+}
+
 sourceSets {
     "main" { projectDefault() }
     "test" {}

compiler/plugin-api/build.gradle.kts

@@ -14,7 +14,7 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
+        compileOnly(intellijCoreJar())
     }
 }
 

compiler/preloader/build.gradle.kts

@@ -9,7 +9,7 @@ configureIntellijPlugin()
 
 afterEvaluate {
     dependencies {
-        compile(intellij { include("asm-all.jar") })
+        compileOnly(intellij { include("asm-all.jar") })
     }
 }
 

compiler/resolution/build.gradle.kts

@@ -3,11 +3,19 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
+configureIntellijPlugin()
+
 dependencies {
     compile(project(":compiler:util"))
     compile(project(":core:descriptors"))
 }
 
+afterEvaluate {
+    dependencies {
+        compileOnly(intellij { include("trove4j.jar") })
+    }
+}
+
 sourceSets {
     "main" { projectDefault() }
     "test" {}

compiler/tests-common/build.gradle.kts

@@ -35,7 +35,7 @@ dependencies {
 afterEvaluate {
     dependencies {
         testCompile(intellijCoreJar())
-        testCompile(intellij { include("openapi.jar", "idea.jar", "idea_rt.jar") })
+        testCompile(intellij { include("openapi.jar", "idea.jar", "idea_rt.jar", "guava-*.jar", "trove4j.jar", "picocontainer.jar", "asm-all.jar") })
     }
 }
 

compiler/tests-java8/build.gradle.kts

@@ -12,6 +12,13 @@ dependencies {
     testRuntime(projectDist(":kotlin-reflect"))
 }
 
+afterEvaluate {
+    dependencies {
+        testCompileOnly(intellijCoreJar())
+        testRuntime(intellij())
+    }
+}
+
 sourceSets {
     "main" {}
     "test" { projectDefault() }

compiler/util/build.gradle.kts

@@ -14,9 +14,9 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
-        compile(intellijCoreJarDependencies())
-        compile(intellijExtra("jps-standalone") { include("jps-model.jar") })
+        compileOnly(intellijCoreJar())
+        compileOnly(intellijCoreJarDependencies())
+        compileOnly(intellijExtra("jps-standalone") { include("jps-model.jar") })
     }
 }
 

eval4j/build.gradle.kts

@@ -14,7 +14,8 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellij { include("asm-all.jar") })
+        compileOnly(intellij { include("asm-all.jar") })
+        testCompile(intellij { include("asm-all.jar") })
     }
 }
 

generators/build.gradle.kts

@@ -49,7 +49,8 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijExtra("jps-build-test"))
+        compileOnly(intellijExtra("jps-build-test"))
+        testCompile(intellijExtra("jps-build-test"))
         testRuntime(intellij { include("idea_rt.jar") })
     }
 }

idea/build.gradle.kts

@@ -89,14 +89,16 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
-        compile(intellij { include("util.jar") })
+        compileOnly(intellijCoreJar())
         compileOnly(intellij {
-            include("openapi.jar", "idea.jar", "velocity.jar", "boot.jar", "gson-*.jar",
-                    "swingx-core-*.jar", "jsr305.jar", "forms_rt.jar", "util.jar", "annotations.jar")
+            include("annotations.jar", "openapi.jar", "idea.jar", "velocity.jar", "boot.jar", "gson-*.jar", "log4j.jar", "asm-all.jar",
+                    "swingx-core-*.jar", "jsr305.jar", "forms_rt.jar", "util.jar", "jdom.jar", "trove4j.jar", "guava-*.jar")
         })
-        compile(intellijPlugins("IntelliLang", "copyright", "properties", "java-i18n"))
-        testCompileOnly(intellij { include("groovy-all-*.jar", "velocity.jar", "gson-*.jar", "jsr305.jar", "idea_rt.jar") })
+        compileOnly(intellijPlugins("IntelliLang", "copyright", "properties", "java-i18n"))
+        testCompileOnly(intellijCoreJar())
+        testCompile(intellijPlugins("IntelliLang", "copyright", "properties", "java-i18n"))
+        testCompileOnly(intellij { include("groovy-all-*.jar", "velocity.jar", "gson-*.jar", "jsr305.jar", "idea_rt.jar", "util.jar",
+                                           "log4j.jar") })
         testCompileOnly(intellijPlugin("gradle") { include("gradle-base-services-*.jar", "gradle-tooling-extension-impl.jar", "gradle-wrapper-*.jar") })
         testCompileOnly(intellijPlugin("Groovy") { include("Groovy.jar") })
         testCompileOnly(intellijPlugin("maven") { include("maven.jar", "maven-server-api.jar") })

idea/formatter/build.gradle.kts

@@ -10,7 +10,7 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellij { include("openapi.jar") })
+        compileOnly(intellij { include("idea.jar", "openapi.jar", "util.jar") })
     }
 }
 

idea/ide-common/build.gradle.kts

@@ -15,8 +15,8 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
-        compile(intellij { include("annotations.jar", "guava-*.jar") })
+        compileOnly(intellijCoreJar())
+        compileOnly(intellij { include("annotations.jar", "guava-*.jar") })
     }
 }
 

idea/idea-android/build.gradle.kts

@@ -40,12 +40,15 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellij { include("openapi.jar", "idea.jar") })
-        compile(intellijPlugin("android") {
+        compileOnly(intellij { include("openapi.jar", "idea.jar", "extensions.jar", "util.jar", "guava-*.jar") })
+        compileOnly(intellijPlugin("android") {
             include("android.jar", "android-common.jar", "sdk-common.jar", "sdklib.jar", "sdk-tools.jar", "layoutlib-api.jar")
         })
         testCompile(intellij { include("gson-*.jar") })
         testCompile(intellijPlugin("properties"))
+        testCompileOnly(intellijPlugin("android") {
+            include("android.jar", "android-common.jar", "sdk-common.jar", "sdklib.jar", "sdk-tools.jar", "layoutlib-api.jar")
+        })
         testRuntime(intellij())
         testRuntime(intellijPlugins("android", "copyright", "coverage", "gradle", "Groovy", "IntelliLang",
                                     "java-decompiler", "java-i18n", "junit", "maven", "testng"))

idea/idea-android/idea-android-output-parser/build.gradle.kts

@@ -12,9 +12,10 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
-        compile(intellijPlugin("gradle") { include("gradle-tooling-api.jar") })
-        compile(intellijPlugin("android") { include("android.jar", "android-common.jar", "sdk-common.jar") })
+        compileOnly(intellijCoreJar())
+        compileOnly(intellij { include("guava-*.jar") })
+        compileOnly(intellijPlugin("gradle") { include("gradle-tooling-api.jar") })
+        compileOnly(intellijPlugin("android") { include("android.jar", "android-common.jar", "sdk-common.jar") })
     }
 }
 

idea/idea-core/build.gradle.kts

@@ -25,9 +25,9 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
-        compile(intellij { include("util.jar", "openapi.jar", "idea.jar") })
-        compile(intellijPlugin("gradle") { include("gradle-tooling-api-*.jar", "gradle.jar") })
+        compileOnly(intellijCoreJar())
+        compileOnly(intellij { include("util.jar", "openapi.jar", "idea.jar", "asm-all.jar", "jdom.jar", "annotations.jar", "trove4j.jar", "guava-*.jar") })
+        compileOnly(intellijPlugin("gradle") { include("gradle-tooling-api-*.jar", "gradle.jar") })
     }
 }
 

idea/idea-gradle/build.gradle.kts

@@ -32,9 +32,10 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compileOnly(intellij { include("openapi.jar", "idea.jar", "external-system-rt.jar", "forms_rt.jar") })
+        compileOnly(intellij { include("openapi.jar", "idea.jar", "external-system-rt.jar", "forms_rt.jar", "extensions.jar", "jdom.jar", "util.jar") })
         compileOnly(intellijPlugin("gradle") { include("gradle-tooling-api-*.jar", "gradle.jar", "gradle-base-services-*.jar") })
         compileOnly(intellijPlugin("Groovy") { include("Groovy.jar") })
+        compileOnly(intellijPlugin("junit") { include("idea-junit.jar") })
         testCompile(intellijPlugin("gradle") { include("gradle-wrapper-*.jar", "gradle-base-services-*.jar", "gradle-tooling-extension-impl.jar", "gradle-tooling-api-*.jar", "gradle.jar") })
         testCompileOnly(intellijPlugin("Groovy") { include("Groovy.jar") })
         testCompileOnly(intellij { include("groovy-all-*.jar", "idea_rt.jar") })

idea/idea-jps-common/build.gradle.kts

@@ -15,8 +15,8 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
-        compile(intellij { include("util.jar") })
+        compileOnly(intellijCoreJar())
+        compileOnly(intellij { include("jdom.jar", "util.jar") })
     }
 }
 

idea/idea-jvm/build.gradle.kts

@@ -13,12 +13,12 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compileOnly(intellij { include("openapi.jar", "idea.jar") })
+        compileOnly(intellij { include("openapi.jar", "idea.jar", "extensions.jar", "util.jar") })
 
-        compile(intellijPlugin("junit") { include("idea-junit.jar") })
-        compile(intellijPlugin("testng") { include("testng.jar", "testng-plugin.jar") })
-        compile(intellijPlugin("coverage") { include("coverage.jar") })
-        compile(intellijPlugin("java-decompiler") { include("java-decompiler.jar") })
+        compileOnly(intellijPlugin("junit") { include("idea-junit.jar") })
+        compileOnly(intellijPlugin("testng") { include("testng.jar", "testng-plugin.jar") })
+        compileOnly(intellijPlugin("coverage") { include("coverage.jar") })
+        compileOnly(intellijPlugin("java-decompiler") { include("java-decompiler.jar") })
     }
 }
 

idea/idea-maven/build.gradle.kts

@@ -35,7 +35,7 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compileOnly(intellij { include("openapi.jar", "idea.jar", "gson-*.jar") })
+        compileOnly(intellij { include("openapi.jar", "idea.jar", "gson-*.jar", "jdom.jar", "extensions.jar", "util.jar") })
         compileOnly(intellijPlugin("maven") { include("maven.jar", "maven-server-api.jar") })
         testCompileOnly(intellij { include("openapi.jar", "idea.jar", "gson-*.jar", "idea_rt.jar") })
         testCompileOnly(intellijPlugin("maven") { include("maven.jar", "maven-server-api.jar") })

idea/idea-test-framework/build.gradle.kts

@@ -18,7 +18,7 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellij { include("openapi.jar", "idea.jar") })
+        compileOnly(intellij { include("openapi.jar", "idea.jar", "log4j.jar") })
     }
 }
 

j2k/build.gradle.kts

@@ -19,6 +19,7 @@ val usedIntellijPlugins = arrayOf(
 
 configureIntellijPlugin {
     setPlugins(*usedIntellijPlugins)
+    setExtraDependencies("intellij-core")
 }
 
 dependencies {
@@ -43,6 +44,7 @@ dependencies {
 
 afterEvaluate {
     dependencies {
+        compileOnly(intellijCoreJar())
         testRuntime(intellij())
         testRuntime(intellijPlugins(*usedIntellijPlugins))
     }

jps-plugin/build.gradle.kts

@@ -31,9 +31,10 @@ dependencies {
 
 afterEvaluate {
     dependencies {
+        compileOnly(intellij { include("jdom.jar", "trove4j.jar", "jps-model.jar", "openapi.jar", "util.jar") })
         compileOnly(intellijExtra("jps-standalone") { include("jps-builders.jar", "jps-builders-6.jar") })
         testCompileOnly(intellijExtra("jps-standalone") { include("jps-builders.jar", "jps-builders-6.jar") })
-        testCompile(intellij { include("openapi.jar", "idea.jar") })
+        testCompileOnly(intellij { include("openapi.jar", "idea.jar", "log4j.jar") })
         testCompile(intellijExtra("jps-build-test"))
         testRuntime(intellij())
         testRuntime(intellijCoreJar())

js/js.ast/build.gradle.kts

@@ -14,12 +14,11 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
-        compile(intellij { include("trove6j.jar")} )
+        compileOnly(intellijCoreJar())
+        compileOnly(intellij { include("trove4j.jar")} )
     }
 }
 
-
 sourceSets {
     "main" { projectDefault() }
     "test" {}

js/js.dce/build.gradle.kts

@@ -13,7 +13,7 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
+        compileOnly(intellijCoreJar())
     }
 }
 

js/js.frontend/build.gradle.kts

@@ -17,7 +17,8 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
+        compileOnly(intellijCoreJar())
+        compileOnly(intellij { include("guava-*.jar")} )
     }
 }
 

js/js.parser/build.gradle.kts

@@ -12,7 +12,7 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
+        compileOnly(intellijCoreJar())
     }
 }
 

js/js.serializer/build.gradle.kts

@@ -16,7 +16,7 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
+        compileOnly(intellijCoreJar())
     }
 }
 

js/js.tests/build.gradle.kts

@@ -12,7 +12,9 @@ node {
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin()
+configureIntellijPlugin {
+    setExtraDependencies("intellij-core")
+}
 
 val antLauncherJar by configurations.creating
 
@@ -42,7 +44,9 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        testCompile(intellij { include("openapi.jar", "idea.jar", "idea_rt.jar") })
+        testCompileOnly(intellijCoreJar())
+        testCompileOnly(intellij { include("openapi.jar", "idea.jar", "idea_rt.jar", "util.jar") })
+        testRuntime(intellij())
     }
 }
 

js/js.translator/build.gradle.kts

@@ -24,7 +24,8 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
+        compileOnly(intellijCoreJar())
+        compileOnly(intellij { include("trove4j.jar", "guava-*.jar")} )
     }
 }
 

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

@@ -1,3 +1,8 @@
+
+plugins {
+    id 'org.jetbrains.intellij'
+}
+
 apply plugin: 'kotlin'
 apply plugin: 'maven'
 
@@ -6,6 +11,13 @@ repositories {
     jcenter()
 }
 
+intellij {
+    version = rootProject.ext["versions.intellij"]
+    instrumentCode = false
+    configureDefaultDependencies = false
+    extraDependencies = ['intellij-core']
+}
+
 dependencies {
     compile project(':kotlin-gradle-plugin-api')
     // Use this dependency instead when building apart from the other modules:
@@ -20,4 +32,10 @@ dependencies {
     compileOnly project(':compiler:cli')
     
     compileOnly gradleApi()
+}
+
+afterEvaluate {
+    dependencies {
+        compileOnly intellijExtra('intellij-core')
+    }
 }

libraries/tools/kotlin-gradle-plugin/build.gradle

@@ -13,6 +13,10 @@ buildscript {
     }
 }
 
+plugins {
+    id 'org.jetbrains.intellij'
+}
+
 configureJvmProject(project)
 configurePublishing(project)
 
@@ -22,6 +26,13 @@ repositories {
     maven { url 'https://maven.google.com' }
 }
 
+intellij {
+    version = rootProject.ext["versions.intellij"]
+    instrumentCode = false
+    configureDefaultDependencies = false
+    extraDependencies = ['intellij-core']
+}
+
 configurations {
     agp25CompileOnly
 }
@@ -65,6 +76,12 @@ dependencies {
     testCompileOnly project(':kotlin-annotation-processing-gradle')
 }
 
+afterEvaluate {
+    dependencies {
+        compileOnly intellijExtra('intellij-core')
+    }
+}
+
 tasks.withType(project.compileKotlin.class) {
     kotlinOptions.jdkHome = JDK_18
 }

libraries/tools/kotlin-script-util/build.gradle.kts

@@ -3,6 +3,8 @@ description = "Kotlin scripting support utilities"
 
 apply { plugin("kotlin") }
 
+configureIntellijPlugin()
+
 dependencies {
     compile(project(":kotlin-stdlib"))
     compile(project(":kotlin-script-runtime"))
@@ -22,6 +24,13 @@ dependencies {
     testRuntime("org.apache.maven:maven-core:3.0.3")
 }
 
+afterEvaluate {
+    dependencies {
+        compileOnly(intellij { include("openapi.jar", "util.jar") })
+        testCompile(intellij { include("openapi.jar", "util.jar") })
+    }
+}
+
 projectTest()
 
 runtimeJar()

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

@@ -21,9 +21,9 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellij { include("openapi.jar", "idea.jar") })
-        compile(intellijPlugin("maven") { include("maven.jar") })
-        compile(intellijPlugin("gradle") { include("gradle-tooling-api-*.jar", "gradle.jar") })
+        compileOnly(intellij { include("openapi.jar", "idea.jar") })
+        compileOnly(intellijPlugin("maven") { include("maven.jar") })
+        compileOnly(intellijPlugin("gradle") { include("gradle-tooling-api-*.jar", "gradle.jar") })
     }
 }
 

plugins/android-extensions/android-extensions-compiler/build.gradle.kts

@@ -28,7 +28,8 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
+        compileOnly(intellijCoreJar())
+        compileOnly(intellij { include("asm-all.jar") })
     }
 }
 

plugins/android-extensions/android-extensions-idea/build.gradle.kts

@@ -40,8 +40,12 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijPlugin("android") { include("android.jar", "android-common.jar", "sdk-common.jar", "sdk-tools.jar") })
-        compile(intellijPlugin("Groovy") { include("Groovy.jar") })
+        compileOnly(intellijPlugin("android") { include("android.jar", "android-common.jar", "sdk-common.jar", "sdk-tools.jar") })
+        compileOnly(intellijPlugin("Groovy") { include("Groovy.jar") })
+        compileOnly(intellij { include("extensions.jar", "openapi.jar", "util.jar", "idea.jar")} )
+        testCompile(intellijPlugin("android") { include("android.jar", "android-common.jar", "sdk-common.jar", "sdk-tools.jar") })
+        testCompile(intellijPlugin("Groovy") { include("Groovy.jar") })
+        testCompile(intellij { include("extensions.jar")} )
         testRuntime(intellij())
         testRuntime(intellijPlugins("junit", "IntelliLang", "testng", "copyright", "properties", "java-i18n",
                                     "gradle", "Groovy", "coverage", "java-decompiler", "maven", "android"))

plugins/android-extensions/android-extensions-jps/build.gradle.kts

@@ -20,6 +20,7 @@ dependencies {
 
 afterEvaluate {
     dependencies {
+        compileOnly(intellij { include("openapi.jar", "jps-builders.jar") })
         compile(intellijPlugin("android") { include("**/android-jps-plugin.jar") })
         testCompileOnly(intellijExtra("jps-build-test") { include("jps-build-test.jar") } )
         testRuntime(intellijPlugin("android"))

plugins/annotation-based-compiler-plugins-ide-support/build.gradle.kts

@@ -21,7 +21,7 @@ afterEvaluate {
     dependencies {
         compileOnly(intellijPlugin("maven") { include("maven.jar", "maven-server-api.jar") })
         compileOnly(intellijPlugin("gradle") { include("gradle-tooling-api-*.jar", "gradle.jar") })
-        compileOnly(intellij { include("openapi.jar", "idea.jar") })
+        compileOnly(intellij { include("openapi.jar", "idea.jar", "extensions.jar", "jdom.jar", "util.jar") })
     }
 }
 

plugins/kapt3/kapt3-compiler/build.gradle.kts

@@ -3,7 +3,9 @@ description = "Annotation Processor for Kotlin"
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin()
+configureIntellijPlugin {
+    setExtraDependencies("intellij-core")
+}
 
 dependencies {
     compile(project(":compiler:util"))
@@ -24,6 +26,9 @@ dependencies {
 
 afterEvaluate {
     dependencies {
+        compileOnly(intellijCoreJar())
+        compileOnly(intellij { include("asm-all.jar") })
+        testCompile(intellijCoreJar())
         testCompile(intellij { include("idea.jar", "idea_rt.jar", "openapi.jar") })
     }
 }

plugins/kapt3/kapt3-idea/build.gradle.kts

@@ -17,9 +17,9 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellij { include("openapi.jar", "external-system-rt.jar") })
-        compile(intellijPlugin("gradle") { include("gradle-core-*.jar", "gradle-tooling-api-*.jar", "gradle.jar") })
-        compile(intellijPlugin("android") { include("android.jar", "android-common.jar", "sdklib.jar", "sdk-common.jar", "sdk-tools.jar") })
+        compileOnly(intellij { include("openapi.jar", "external-system-rt.jar", "util.jar") })
+        compileOnly(intellijPlugin("gradle") { include("gradle-core-*.jar", "gradle-tooling-api-*.jar", "gradle.jar") })
+        compileOnly(intellijPlugin("android") { include("android.jar", "android-common.jar", "sdklib.jar", "sdk-common.jar", "sdk-tools.jar") })
     }
 }
 

plugins/lint/build.gradle.kts

@@ -19,11 +19,11 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
-        compile(intellij { include("util.jar", "guava-*.jar") })
-        compile(intellijPlugin("android") {
+        compileOnly(intellijCoreJar())
+        compileOnly(intellij { include("util.jar", "guava-*.jar", "openapi.jar", "idea.jar", "asm-all.jar") })
+        compileOnly(intellijPlugin("android") {
             include("android.jar", "android-common.jar", "sdklib.jar", "sdk-common.jar", "sdk-tools.jar",
-                    "repository.jar", "lombok-ast-*.jar")
+                    "repository.jar", "lombok-ast-*.jar", "layoutlib-api.jar", "kxml2-*.jar")
         })
     }
 }

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

@@ -3,6 +3,10 @@ description = "Kotlin NoArg Compiler Plugin"
 
 apply { plugin("kotlin") }
 
+configureIntellijPlugin {
+    setExtraDependencies("intellij-core")
+}
+
 dependencies {
     compileOnly(project(":compiler:frontend"))
     compileOnly(project(":compiler:frontend.java"))
@@ -21,6 +25,13 @@ dependencies {
     testRuntime(ideaSdkDeps("*.jar"))
 }
 
+afterEvaluate {
+    dependencies {
+        compileOnly(intellijCoreJar())
+        compileOnly(intellij { include("asm-all.jar") })
+    }
+}
+
 sourceSets {
     "main" { projectDefault() }
     "test" { projectDefault() }

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

@@ -23,9 +23,9 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellij { include("openapi.jar", "idea.jar") })
-        compile(intellijPlugin("maven") { include("maven.jar") })
-        compile(intellijPlugin("gradle") { include("gradle-tooling-api-*.jar", "gradle.jar") })
+        compileOnly(intellij { include("openapi.jar", "idea.jar") })
+        compileOnly(intellijPlugin("maven") { include("maven.jar") })
+        compileOnly(intellijPlugin("gradle") { include("gradle-tooling-api-*.jar", "gradle.jar") })
     }
 }
 

plugins/sam-with-receiver/sam-with-receiver-cli/build.gradle.kts

@@ -3,6 +3,10 @@ description = "Kotlin SamWithReceiver Compiler Plugin"
 
 apply { plugin("kotlin") }
 
+configureIntellijPlugin {
+    setExtraDependencies("intellij-core")
+}
+
 dependencies {
     compileOnly(project(":compiler:frontend"))
     compileOnly(project(":compiler:frontend.java"))
@@ -19,6 +23,12 @@ dependencies {
     testRuntime(ideaSdkDeps("*.jar"))
 }
 
+afterEvaluate {
+    dependencies {
+        compileOnly(intellijCoreJar())
+    }
+}
+
 sourceSets {
     "main" { projectDefault() }
     "test" { projectDefault() }

plugins/source-sections/source-sections-compiler/build.gradle.kts

@@ -3,7 +3,10 @@ description = "Kotlin SourceSections Compiler Plugin"
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin()
+configureIntellijPlugin {
+    setExtraDependencies("intellij-core")
+}
+
 
 dependencies {
     compileOnly(project(":compiler:frontend"))
@@ -25,6 +28,8 @@ dependencies {
 
 afterEvaluate {
     dependencies {
+        compileOnly(intellijCoreJar())
+        testCompile(intellijCoreJar())
         testCompile(intellij { include("idea.jar", "idea_rt.jar", "openapi.jar") })
     }
 }

plugins/uast-kotlin-idea/build.gradle.kts

@@ -1,6 +1,8 @@
 
 apply { plugin("kotlin") }
 
+configureIntellijPlugin()
+
 dependencies {
     compile(projectDist(":kotlin-stdlib"))
     compile(project(":core:util.runtime"))
@@ -10,6 +12,12 @@ dependencies {
     compile(project(":plugins:uast-kotlin"))
 }
 
+afterEvaluate {
+    dependencies {
+        compileOnly(intellij { include("openapi.jar", "util.jar") })
+    }
+}
+
 sourceSets {
     "main" { projectDefault() }
     "test" {}

plugins/uast-kotlin/build.gradle.kts

@@ -32,12 +32,13 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compileOnly(intellij { include("openapi.jar", "idea.jar") })
+        compileOnly(intellij { include("openapi.jar", "idea.jar", "util.jar", "extensions.jar", "asm-all.jar") })
+        compileOnly(intellijPlugins("junit", "gradle", "Groovy", "android",
+                                    "maven", // TODO: check whether it works in AS (it was marked optional before
+                                    "properties"))
         testCompileOnly(intellij { include("idea_rt.jar") })
+        testCompile(intellijPlugins("junit", "gradle", "Groovy", "android", "maven", "properties"))
         testRuntime(intellij())
-        compile(intellijPlugins("junit", "gradle", "Groovy", "android",
-                                "maven", // TODO: check whether it works in AS (it was marked optional before
-                                "properties"))
     }
 }
 

test-instrumenter/build.gradle.kts

@@ -13,8 +13,8 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
-        compile(intellij { include("asm-all.jar") })
+        compileOnly(intellijCoreJar())
+        compileOnly(intellij { include("asm-all.jar") })
     }
 }
 

ultimate/build.gradle.kts

@@ -101,26 +101,40 @@ dependencies {
 
 afterEvaluate {
     dependencies {
-        compile(intellijCoreJar())
-        compile(intellij { include("annotations.jar", "trove4j.jar", "openapi.jar", "idea.jar", "util.jar", "jdom.jar") })
-        compile(intellijPlugin("CSS"))
-        compile(intellijPlugin("DatabaseTools"))
-        compile(intellijPlugin("JavaEE"))
-        compile(intellijPlugin("jsp"))
-        compile(intellijPlugin("PersistenceSupport"))
-        compile(intellijPlugin("Spring"))
-        compile(intellijPlugin("properties"))
-        compile(intellijPlugin("java-i18n"))
-        compile(intellijPlugin("gradle"))
-        compile(intellijPlugin("Groovy"))
-        compile(intellijPlugin("junit"))
-        compile(intellijPlugin("uml"))
-        compile(intellijPlugin("JavaScriptLanguage"))
-        compile(intellijPlugin("JavaScriptDebugger"))
-        compile(intellijPlugin("NodeJS"))
-        testCompile(intellij { include("gson-*.jar") })
+        compileOnly(intellijCoreJar())
+        compileOnly(intellij { include("annotations.jar", "trove4j.jar", "openapi.jar", "idea.jar", "util.jar", "jdom.jar") })
+        compileOnly(intellijPlugin("CSS"))
+        compileOnly(intellijPlugin("DatabaseTools"))
+        compileOnly(intellijPlugin("JavaEE"))
+        compileOnly(intellijPlugin("jsp"))
+        compileOnly(intellijPlugin("PersistenceSupport"))
+        compileOnly(intellijPlugin("Spring"))
+        compileOnly(intellijPlugin("properties"))
+        compileOnly(intellijPlugin("java-i18n"))
+        compileOnly(intellijPlugin("gradle"))
+        compileOnly(intellijPlugin("Groovy"))
+        compileOnly(intellijPlugin("junit"))
+        compileOnly(intellijPlugin("uml"))
+        compileOnly(intellijPlugin("JavaScriptLanguage"))
+        compileOnly(intellijPlugin("JavaScriptDebugger"))
+        compileOnly(intellijPlugin("NodeJS"))
+        testCompileOnly(intellij { include("gson-*.jar", "annotations.jar", "trove4j.jar", "openapi.jar", "idea.jar", "util.jar", "jdom.jar") })
         testRuntime(intellij())
-        testRuntime(intellijPlugin("properties"))
+        testCompile(intellijPlugin("CSS"))
+        testCompile(intellijPlugin("DatabaseTools"))
+        testCompile(intellijPlugin("JavaEE"))
+        testCompile(intellijPlugin("jsp"))
+        testCompile(intellijPlugin("PersistenceSupport"))
+        testCompile(intellijPlugin("Spring"))
+        testCompile(intellijPlugin("properties"))
+        testCompile(intellijPlugin("java-i18n"))
+        testCompile(intellijPlugin("gradle"))
+        testCompile(intellijPlugin("Groovy"))
+        testCompile(intellijPlugin("junit"))
+        testCompile(intellijPlugin("uml"))
+        testCompile(intellijPlugin("JavaScriptLanguage"))
+        testCompile(intellijPlugin("JavaScriptDebugger"))
+        testCompile(intellijPlugin("NodeJS"))
         testRuntime(intellijPlugin("coverage"))
         testRuntime(intellijPlugin("maven"))
         testRuntime(intellijPlugin("android"))