Convert the rest of the project to intellij repo prepared in buildSrc

build-common/build.gradle.kts

@@ -3,8 +3,6 @@ description = "Kotlin Build Common"
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin()
-
 dependencies {
     compileOnly(project(":core:util.runtime"))
     compileOnly(project(":compiler:util"))
@@ -12,21 +10,17 @@ dependencies {
     compileOnly(project(":compiler:frontend.java"))
     compileOnly(project(":js:js.serializer"))
     compileOnly(project(":js:js.frontend"))
+    compileOnly(intellijDep()) { includeJars("annotations", "asm-all", "trove4j", "util") }
     compileOnly(project(":kotlin-reflect-api"))
+
     testCompileOnly(project(":compiler:cli-common"))
     testCompile(projectTests(":compiler:tests-common"))
     testCompile(commonDep("junit:junit"))
     testCompile(protobufFull())
     testCompile(projectDist(":kotlin-stdlib"))
-    testCompileOnly(ideaSdkDeps("openapi"))
+    testCompileOnly(intellijDep()) { includeJars("openapi") }
-    testRuntime(projectDist(":kotlin-reflect"))
-}
 
-afterEvaluate {
+    testRuntime(projectDist(":kotlin-reflect"))
-    dependencies {
-        compileOnly(intellij { include("annotations.jar", "asm-all.jar", "trove4j.jar", "util.jar") })
-        testCompileOnly(intellij { include("openapi.jar") })
-    }
 }
 
 sourceSets {

build.gradle.kts

@@ -114,7 +114,6 @@ extra["JDK_17"] = jdkPath("1.7")
 extra["JDK_18"] = jdkPath("1.8")
 extra["JDK_9"] = jdkPathIfFound("9")
 
-extra["versions.intellij"] = "IC-172.4343.14"
 extra["versions.intellijSdk"] = "172.4343.14"
 extra["versions.androidBuildTools"] = "r23.0.1"
 extra["versions.protobuf-java"] = "2.6.1"

buildSrc/build.gradle.kts

@@ -43,8 +43,6 @@ repositories {
         maven(url = it)
     }
     maven(url = "https://dl.bintray.com/kotlin/kotlin-dev") // for dex-method-list
-    maven(url = "https://oss.sonatype.org/content/repositories/snapshots/") // for intellij plugin
-    maven(url = "http://dl.bintray.com/jetbrains/intellij-plugin-service") // for intellij plugin
     maven(url = "https://repo.gradle.org/gradle/libs-releases-local") // for native-platform
     jcenter()
 }
@@ -58,7 +56,6 @@ dependencies {
 //    compile("org.jetbrains.kotlin:kotlin-gradle-plugin:${rootProject.extra["bootstrap_kotlin_version"]}")
     compile("com.github.jengelman.gradle.plugins:shadow:${property("versions.shadow")}")
     compile("org.ow2.asm:asm-all:6.0_BETA")
-    compile("org.jetbrains.intellij.plugins:gradle-intellij-plugin:${property("versions.intellij-plugin")}")
 }
 
 samWithReceiver {

buildSrc/prepare-deps/intellij-sdk/build.gradle.kts

@@ -59,7 +59,7 @@ val copyIntellijSdkSources by tasks.creating { configureExtractFromConfiguration
 
 val copyJpsBuildTest by tasks.creating { configureExtractFromConfigurationTask(`jps-build-test`) { it.singleFile } }
 
-fun writeIvyXml(moduleName: String, jarFiles: FileCollection, baseDir: File, sourcesJar: File) {
+fun writeIvyXml(moduleName: String, fileName: String, jarFiles: FileCollection, baseDir: File, sourcesJar: File) {
     with(IvyDescriptorFileGenerator(DefaultIvyPublicationIdentity(customDepsOrg, moduleName, intellijVersion))) {
         addConfiguration(DefaultIvyConfiguration("default"))
         addConfiguration(DefaultIvyConfiguration("sources"))
@@ -71,7 +71,7 @@ fun writeIvyXml(moduleName: String, jarFiles: FileCollection, baseDir: File, sou
         }
         val sourcesArtifactName = sourcesJar.name.removeSuffix(".jar").substringBefore("-")
         addArtifact(DefaultIvyArtifact(sourcesJar, sourcesArtifactName, "jar", "sources", "sources").also { it.conf = "sources" })
-        writeTo(File(customDepsRepoModulesDir, "$moduleName.ivy.xml"))
+        writeTo(File(customDepsRepoModulesDir, "$fileName.ivy.xml"))
     }
 }
 
@@ -89,15 +89,15 @@ val prepareIvyXml by tasks.creating {
 //    outputs.files("$repoDir/intellij.plugin.*.ivy.xml")
     doFirst {
         val sourcesFile = File(repoDir, "${sources.name}/${sources.singleFile.name}")
-        writeIvyXml(intellij.name,
+        writeIvyXml(intellij.name, intellij.name,
                     files("$intellijSdkDir/lib/").filter { !it.name.startsWith("kotlin-") },
                     File(intellijSdkDir, "lib"),
                     sourcesFile)
         File(intellijSdkDir, "plugins").listFiles { it: File -> it.isDirectory }.forEach {
-            writeIvyXml("intellij.plugin.${it.name}", files("$it/lib/"), File(it, "lib"), sourcesFile)
+            writeIvyXml(it.name, "intellij.plugin.${it.name}", files("$it/lib/"), File(it, "lib"), sourcesFile)
         }
         flatDeps.forEach {
-            writeIvyXml(it.name, files("$repoDir/${it.name}"), File(repoDir, it.name), sourcesFile)
+            writeIvyXml(it.name, it.name, files("$repoDir/${it.name}"), File(repoDir, it.name), sourcesFile)
         }
     }
 }

buildSrc/src/main/kotlin/instrument.kt

@@ -17,6 +17,7 @@
  */
 
 import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
 import org.gradle.api.artifacts.ProjectDependency
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.FileCollection
@@ -51,6 +52,12 @@ fun Project.configureInstrumentation() {
         }
     }
 
+    val instrumentationClasspathCfg = configurations.create("instrumentationClasspath")
+
+    dependencies {
+        instrumentationClasspathCfg(intellijDep()) { includeJars("javac2", "jdom", "asm-all", "jgoodies-forms") }
+    }
+
     afterEvaluate {
         the<JavaPluginConvention>().sourceSets.all { sourceSetParam ->
             // This copy will ignore filters, but they are unlikely to be used.
@@ -66,6 +73,7 @@ fun Project.configureInstrumentation() {
             instrumentTask.apply {
                 dependsOn(sourceSetParam.classesTaskName).onlyIf { !classesDirsCopy.isEmpty }
                 sourceSet = sourceSetParam
+                instrumentationClasspath = instrumentationClasspathCfg
                 originalClassesDirs = classesDirsCopy
                 output = instrumentedClassesDir
             }
@@ -88,6 +96,8 @@ open class IntelliJInstrumentCodeTask : ConventionTask() {
 
     var sourceSet: SourceSet? = null
 
+    var instrumentationClasspath: Configuration? = null
+
     @Input
     var originalClassesDirs: FileCollection? = null
 
@@ -104,7 +114,7 @@ open class IntelliJInstrumentCodeTask : ConventionTask() {
         output?.deleteRecursively()
         copyOriginalClasses()
 
-        val classpath = project.intellij { include("javac2.jar", "jdom.jar", "asm-all.jar", "jgoodies-forms.jar") }
+        val classpath = instrumentationClasspath!!
 
         ant.withGroovyBuilder {
             "taskdef"("name" to "instrumentIdeaExtensions",

buildSrc/src/main/kotlin/intellijPluginHelpers.kt

@@ -1,24 +1,20 @@
 @file:Suppress("unused") // usages in build scripts are not tracked properly
 
-import org.gradle.api.GradleException
 import org.gradle.api.Project
 import org.gradle.api.artifacts.ModuleDependency
-import org.gradle.api.file.ConfigurableFileCollection
-import org.gradle.api.file.FileTree
-import org.gradle.api.tasks.util.PatternFilterable
-import org.gradle.kotlin.dsl.configure
 import org.gradle.kotlin.dsl.extra
-import org.gradle.kotlin.dsl.the
-import org.jetbrains.intellij.IntelliJPluginExtension
-import org.jetbrains.intellij.dependency.PluginDependency
 import org.gradle.api.artifacts.dsl.RepositoryHandler
 import org.gradle.api.artifacts.repositories.IvyArtifactRepository
 
+private fun Project.intellijRepoDir() = File("${project.rootDir.absoluteFile}/buildSrc/prepare-deps/intellij-sdk/build/repo")
+
 fun RepositoryHandler.intellijSdkRepo(project: Project): IvyArtifactRepository = ivy {
-    val baseDir = File("${project.rootDir.absoluteFile}/buildSrc/prepare-deps/intellij-sdk/build/repo")
+    val baseDir = project.intellijRepoDir()
     setUrl(baseDir)
     ivyPattern("${baseDir.canonicalPath}/[organisation]/[revision]/[module].ivy.xml")
+    ivyPattern("${baseDir.canonicalPath}/[organisation]/[revision]/intellij.plugin.[module].ivy.xml")
     artifactPattern("${baseDir.canonicalPath}/[organisation]/[revision]/[module]/lib/[artifact](-[classifier]).jar")
+    artifactPattern("${baseDir.canonicalPath}/[organisation]/[revision]/intellij/plugins/[module]/lib/[artifact](-[classifier]).jar")
     artifactPattern("${baseDir.canonicalPath}/[organisation]/[revision]/[module]/[artifact].jar")
     artifactPattern("${baseDir.canonicalPath}/[organisation]/[revision]/[module]/[artifact](-[revision])(-[classifier]).jar")
     artifactPattern("${baseDir.canonicalPath}/[organisation]/[revision]/sources/[artifact]-[revision]-[classifier].[ext]")
@@ -28,6 +24,8 @@ fun Project.intellijDep(module: String = "intellij") = "kotlin.build.custom.deps
 
 fun Project.intellijCoreDep() = intellijDep("intellij-core")
 
+fun Project.intellijPluginDep(plugin: String) = intellijDep(plugin)
+
 fun ModuleDependency.includeJars(vararg names: String) {
     names.forEach {
         artifact {
@@ -37,74 +35,11 @@ fun ModuleDependency.includeJars(vararg names: String) {
     }
 }
 
-fun ModuleDependency.includeIntellijCoreJarDependencies(project: Project, jarsFilter: (String) -> Boolean = { true }) =
+fun ModuleDependency.includeIntellijCoreJarDependencies(project: Project) =
-        includeJars(*(project.rootProject.extra["IntellijCoreDependenciesJars"] as List<String>).filter { jarsFilter(it) }.toTypedArray())
+        includeJars(*(project.rootProject.extra["IntellijCoreDependenciesJars"] as List<String>).toTypedArray())
 
-fun Project.configureIntellijPlugin(body: (IntelliJPluginExtension.() -> Unit) = {}) {
+fun ModuleDependency.includeIntellijCoreJarDependencies(project: Project, jarsFilterPredicate: (String) -> Boolean) =
+        includeJars(*(project.rootProject.extra["IntellijCoreDependenciesJars"] as List<String>).filter { jarsFilterPredicate(it) }.toTypedArray())
 
-    plugins.apply("org.jetbrains.intellij")
+fun Project.intellijRootDir() = File(intellijRepoDir(), "kotlin.build.custom.deps/${rootProject.extra["versions.intellijSdk"]}/intellij")
 
-    configure<IntelliJPluginExtension> {
-        version = rootProject.extra["versions.intellij"] as String
-        instrumentCode = false
-        configureDefaultDependencies = false
-        body()
-    }
-
-    val intellijTasks = listOf("patchPluginXml", "prepareSandbox", "prepareTestingSandbox",
-                               "verifyPlugin", "runIde", "buildPlugin", "publishPlugin")
-    intellijTasks.forEach {
-        tasks.findByName(it)?.also { it.onlyIf { false }; tasks.remove(it) }
-        ?: logger.warn("intellij task $it not found")
-    }
-    configurations.findByName("archives")?.artifacts?.clear()
-}
-
-// reimplementation of helpers from intellij plugin, since it is not convenient to use gradle closures from kotlin build scripts
-
-fun Project.intellij(filter: (PatternFilterable.() -> Unit) = {}): FileTree {
-    val jars = the<IntelliJPluginExtension>().ideaDependency?.jarFiles?.takeIf { it.isNotEmpty() }
-               ?: throw GradleException("intellij is not (yet) configured. Please note that you should configure intellij dependencies in the afterEvaluate block")
-    return files(jars).asFileTree.matching {
-        exclude("**/kotlin-*.jar")
-    }.matching(filter)
-}
-
-fun Project.intellijPlugins(vararg pluginNames: String): ConfigurableFileCollection {
-    val selectedPlugins = arrayListOf<PluginDependency>()
-    val invalidPlugins = arrayListOf<String>()
-    for (pluginName in pluginNames) {
-        val plugin = the<IntelliJPluginExtension>().pluginDependencies.find { it.id == pluginName }
-        if (plugin == null || plugin.jarFiles.isEmpty()) {
-            invalidPlugins.add(pluginName)
-        }
-        else {
-            selectedPlugins.add(plugin)
-        }
-    }
-    if (invalidPlugins.isNotEmpty()) {
-        throw GradleException("intellij plugins $invalidPlugins are not (yet) configured or not found. Please note that you should specify plugins in the intellij.plugins property and configure dependencies to them in the afterEvaluate block")
-    }
-    return project.files(selectedPlugins.map { it.jarFiles })
-}
-
-fun Project.intellijPlugin(pluginName: String, filter: (PatternFilterable.() -> Unit) = {}): FileTree {
-    val pluginDep = the<IntelliJPluginExtension>().pluginDependencies.find { it.id == pluginName }?.takeIf { it.jarFiles.isNotEmpty() }
-                    ?: throw GradleException("intellij plugin '$pluginName' is not (yet) configured or not found. Please note that you should specify plugins in the intellij.plugins property and configure dependencies to them in the afterEvaluate block")
-    return project.files(pluginDep.jarFiles).asFileTree.matching(filter)
-}
-
-fun Project.intellijExtra(extraName: String, filter: (PatternFilterable.() -> Unit) = {}): FileTree {
-    val extraDep = the<IntelliJPluginExtension>().ideaDependency?.extraDependencies?.find { it.name == extraName }?.takeIf { it.jarFiles.isNotEmpty() }
-                   ?: throw GradleException("intellij extra artifact '$extraName' is not (yet) configured or not found. Please note that you should specify extra dependencies in the intellij.extraDependencies property and configure dependencies to them in the afterEvaluate block")
-    return project.files(extraDep.jarFiles).asFileTree.matching(filter)
-}
-
-// frequent combinations
-
-fun Project.intellijCoreJar() = intellijExtra("intellij-core") { include("intellij-core.jar") }
-fun Project.intellijCoreJarDependencies(filter: (PatternFilterable.() -> Unit) = {}): FileTree =
-        intellij {
-            include(rootProject.extra["IntellijCoreDependencies"] as List<String>)
-        }
-        .matching(filter)

compiler/frontend.script/build.gradle.kts

@@ -7,7 +7,7 @@ dependencies {
     compile(project(":compiler:util"))
     compile(project(":compiler:frontend"))
     compile(projectDist(":kotlin-stdlib"))
-    compile(projectDist(":kotlin-reflect-api"))
+    compile(project(":kotlin-reflect-api"))
     compile(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) { isTransitive = false }
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 }

compiler/tests-java8/build.gradle.kts

@@ -4,7 +4,6 @@ apply { plugin("kotlin") }
 
 dependencies {
     testCompile(projectTests(":compiler:tests-common"))
-    testCompile(projectTests(":compiler"))
     testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     testCompile(projectTests(":generators:test-generator"))
     testRuntime(projectDist(":kotlin-reflect"))

eval4j/build.gradle.kts

@@ -1,22 +1,14 @@
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin()
-
 dependencies {
     compile(projectDist(":kotlin-stdlib"))
     compile(project(":compiler:backend"))
-//    compile(files(PathUtil.getJdkClassesRootsFromCurrentJre())) // TODO: make this one work instead of the nex one, since it contains more universal logic
+    compile(files(toolsJar()))
-    compile(files("${System.getProperty("java.home")}/../lib/tools.jar"))
+    compileOnly(intellijDep()) { includeJars("asm-all") }
     testCompile(projectDist(":kotlin-test:kotlin-test-junit"))
     testCompile(commonDep("junit:junit"))
-}
+    testCompile(intellijDep()) { includeJars("asm-all") }
-
-afterEvaluate {
-    dependencies {
-        compileOnly(intellij { include("asm-all.jar") })
-        testCompile(intellij { include("asm-all.jar") })
-    }
 }
 
 sourceSets {

generators/build.gradle.kts

@@ -1,10 +1,6 @@
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
-    setExtraDependencies("jps-build-test")
-}
-
 dependencies {
     compile(protobufFull())
     compile(project(":idea"))
@@ -40,19 +36,16 @@ dependencies {
     compile(projectTests(":plugins:uast-kotlin"))
     compile(projectTests(":js:js.tests"))
     compile(projectTests(":generators:test-generator"))
+    compileOnly(intellijDep("jps-build-test"))
     compileOnly(project(":kotlin-reflect-api"))
+
     testCompile(project(":idea:idea-test-framework")) { isTransitive = false }
     testCompile(project(":compiler:incremental-compilation-impl"))
     testCompile(commonDep("junit:junit"))
-    testRuntime(projectDist(":kotlin-reflect"))
+    testCompile(intellijDep("jps-build-test"))
-}
 
-afterEvaluate {
+    testRuntime(intellijDep()) { includeJars("idea_rt") }
-    dependencies {
+    testRuntime(projectDist(":kotlin-reflect"))
-        compileOnly(intellijExtra("jps-build-test"))
-        testCompile(intellijExtra("jps-build-test"))
-        testRuntime(intellij { include("idea_rt.jar") })
-    }
 }
 
 sourceSets {

generators/test-generator/build.gradle.kts

@@ -3,21 +3,14 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
-configureIntellijPlugin()
-
 dependencies {
+    compile(intellijDep()) { includeJars("util") }
     testCompile(project(":core:util.runtime"))
     testCompile(projectTests(":compiler:tests-common"))
     testCompile(projectDist(":kotlin-stdlib"))
     testCompile(commonDep("junit:junit"))
 }
 
-afterEvaluate {
-    dependencies {
-        compile(intellij { include("util.jar") })
-    }
-}
-
 sourceSets {
     "main" { }
     "test" { projectDefault() }

idea-runner/build.gradle.kts

@@ -1,26 +1,29 @@
-import org.jetbrains.intellij.IntelliJPluginExtension
 import org.jetbrains.intellij.tasks.PrepareSandboxTask
 import org.jetbrains.intellij.tasks.RunIdeTask
 
-apply { plugin("kotlin") }
+buildscript {
+    repositories {
+        maven(url = "https://oss.sonatype.org/content/repositories/snapshots/") // for intellij plugin
+        maven(url = "http://dl.bintray.com/jetbrains/intellij-plugin-service") // for intellij plugin
+        jcenter()
+    }
+    dependencies {
+        classpath("org.jetbrains.intellij.plugins:gradle-intellij-plugin:0.3.0-SNAPSHOT")
+    }
+}
 
-configureIntellijPlugin()
+apply { plugin("kotlin") }
 
 dependencies {
     compileOnly(project(":idea"))
     compileOnly(project(":idea:idea-maven"))
     compileOnly(project(":idea:idea-gradle"))
     compileOnly(project(":idea:idea-jvm"))
+    compileOnly(intellijDep())
 
     runtimeOnly(files(toolsJar()))
 }
 
-afterEvaluate {
-    dependencies {
-        compileOnly(intellij())
-    }
-}
-
 afterEvaluate {
     val ideaPluginDir: File by rootProject.extra
     val ideaSandboxDir: File by rootProject.extra
@@ -42,7 +45,7 @@ afterEvaluate {
         dependsOn(prepareSandbox)
         group = "intellij"
         description = "Runs Intellij IDEA with installed plugin."
-        setIdeaDirectory(the<IntelliJPluginExtension>().ideaDependency.classes)
+        setIdeaDirectory(intellijRootDir())
         setConfigDirectory(File(ideaSandboxDir, "config"))
         setSystemDirectory(ideaSandboxDir)
         setPluginsDirectory(ideaPluginDir.parent)

idea/build.gradle.kts

@@ -1,14 +1,7 @@
 import org.gradle.jvm.tasks.Jar
-import org.jetbrains.intellij.IntelliJPluginExtension
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
-    setPlugins("android", "copyright", "coverage", "gradle", "Groovy", "IntelliLang",
-               "java-i18n", "junit", "maven", "properties", "testng")
-    setExtraDependencies("intellij-core")
-}
-
 dependencies {
     compile(project(":kotlin-stdlib"))
     compileOnly(project(":kotlin-reflect-api"))
@@ -39,6 +32,16 @@ dependencies {
     compile(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) { isTransitive = false }
     compile("teamcity:markdown")
 
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
+    compileOnly(intellijDep()) {
+        includeJars("annotations", "openapi", "idea", "velocity", "boot", "gson-2.5", "log4j", "asm-all",
+                    "swingx-core-1.6.2", "jsr305", "forms_rt", "util", "jdom", "trove4j", "guava-21.0")
+    }
+    compileOnly(intellijPluginDep("IntelliLang"))
+    compileOnly(intellijPluginDep("copyright"))
+    compileOnly(intellijPluginDep("properties"))
+    compileOnly(intellijPluginDep("java-i18n"))
+
     testCompile(project(":kotlin-test:kotlin-test-junit"))
     testCompile(projectTests(":compiler:tests-common"))
     testCompile(project(":idea:idea-test-framework")) { isTransitive = false }
@@ -47,23 +50,6 @@ dependencies {
     testCompile(project(":idea:idea-maven")) { isTransitive = false }
     testCompile(commonDep("junit:junit"))
 
-    testCompileOnly(ideaPluginDeps("gradle-base-services", "gradle-tooling-extension-impl", "gradle-wrapper", plugin = "gradle"))
-    testCompileOnly(ideaPluginDeps("Groovy", plugin = "Groovy"))
-    testCompileOnly(ideaPluginDeps("maven", "maven-server-api", plugin = "maven"))
-
-    testCompileOnly(ideaSdkDeps("groovy-all", "velocity", "gson", "jsr305", "idea_rt"))
-
-    testRuntime(ideaSdkDeps("*.jar"))
-
-    testRuntime(ideaPluginDeps("*.jar", plugin = "junit"))
-    testRuntime(ideaPluginDeps("*.jar", plugin = "properties"))
-    testRuntime(ideaPluginDeps("*.jar", plugin = "gradle"))
-    testRuntime(ideaPluginDeps("*.jar", plugin = "Groovy"))
-    testRuntime(ideaPluginDeps("*.jar", plugin = "coverage"))
-    testRuntime(ideaPluginDeps("*.jar", plugin = "maven"))
-    testRuntime(ideaPluginDeps("*.jar", plugin = "android"))
-    testRuntime(ideaPluginDeps("*.jar", plugin = "testng"))
-
     testRuntime(project(":plugins:kapt3-idea")) { isTransitive = false }
     testRuntime(projectDist(":kotlin-reflect"))
     testRuntime(projectDist(":kotlin-preloader"))
@@ -85,26 +71,25 @@ dependencies {
     (rootProject.extra["compilerModules"] as Array<String>).forEach {
         testCompile(project(it))
     }
-}
+    testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") }
+    testCompile(intellijPluginDep("IntelliLang"))
+    testCompile(intellijPluginDep("copyright"))
+    testCompile(intellijPluginDep("properties"))
+    testCompile(intellijPluginDep("java-i18n"))
+    testCompileOnly(intellijDep()) { includeJars("groovy-all-2.4.6", "velocity", "gson-2.5", "jsr305", "idea_rt", "util",
+                                                 "log4j") }
+    testCompileOnly(intellijPluginDep("gradle")) { includeJars("gradle-base-services-3.5", "gradle-tooling-extension-impl", "gradle-wrapper-3.5") }
+    testCompileOnly(intellijPluginDep("Groovy")) { includeJars("Groovy") }
+    testCompileOnly(intellijPluginDep("maven")) { includeJars("maven", "maven-server-api") }
 
-afterEvaluate {
+    testRuntime(intellijDep())
-    dependencies {
+    testRuntime(intellijPluginDep("junit"))
-        compileOnly(intellijCoreJar())
+    testRuntime(intellijPluginDep("gradle"))
-        compileOnly(intellij {
+    testRuntime(intellijPluginDep("Groovy"))
-            include("annotations.jar", "openapi.jar", "idea.jar", "velocity.jar", "boot.jar", "gson-*.jar", "log4j.jar", "asm-all.jar",
+    testRuntime(intellijPluginDep("coverage"))
-                    "swingx-core-*.jar", "jsr305.jar", "forms_rt.jar", "util.jar", "jdom.jar", "trove4j.jar", "guava-*.jar")
+    testRuntime(intellijPluginDep("maven"))
-        })
+    testRuntime(intellijPluginDep("android"))
-        compileOnly(intellijPlugins("IntelliLang", "copyright", "properties", "java-i18n"))
+    testRuntime(intellijPluginDep("testng"))
-        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") })
-        testRuntime(intellij())
-        testRuntime(intellijPlugins("junit", "gradle", "Groovy", "coverage", "maven", "android", "testng"))
-    }
 }
 
 val processResources: Copy by tasks
@@ -132,7 +117,7 @@ projectTest {
     dependsOnTaskIfExistsRec("dist", project = rootProject)
     workingDir = rootDir
     afterEvaluate {
-        systemProperty("ideaSdk.path", the<IntelliJPluginExtension>().ideaDependency.classes.canonicalPath)
+        systemProperty("ideaSdk.path", intellijRootDir().canonicalPath)
     }
 }
 

idea/formatter/build.gradle.kts

@@ -1,17 +1,10 @@
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin()
-
 dependencies {
     compile(project(":compiler:util"))
     compile(project(":compiler:frontend"))
-}
+    compileOnly(intellijDep()) { includeJars("idea", "openapi", "util") }
-
-afterEvaluate {
-    dependencies {
-        compileOnly(intellij { include("idea.jar", "openapi.jar", "util.jar") })
-    }
 }
 
 sourceSets {

idea/ide-common/build.gradle.kts

@@ -1,23 +1,14 @@
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
-    setExtraDependencies("intellij-core")
-}
-
 dependencies {
     compile(project(":compiler:util"))
     compile(project(":compiler:frontend"))
     compile(project(":compiler:frontend.java"))
     compile(project(":js:js.frontend"))
     compile(project(":js:js.serializer"))
-}
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-
+    compileOnly(intellijDep()) { includeJars("annotations", "guava-21.0") }
-afterEvaluate {
-    dependencies {
-        compileOnly(intellijCoreJar())
-        compileOnly(intellij { include("annotations.jar", "guava-*.jar") })
-    }
 }
 
 sourceSets {

idea/idea-android/build.gradle.kts

@@ -2,15 +2,6 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 apply { plugin("kotlin") }
 
-repositories {
-    androidDxJarRepo(project)
-}
-
-configureIntellijPlugin {
-    setPlugins("android", "copyright", "coverage", "gradle", "Groovy", "IntelliLang",
-               "java-decompiler", "java-i18n", "junit", "maven", "properties", "testng")
-}
-
 val androidSdk by configurations.creating
 
 dependencies {
@@ -27,6 +18,11 @@ dependencies {
 
     compile(androidDxJar())
 
+    compileOnly(intellijDep()) { includeJars("openapi", "idea", "extensions", "util", "guava-21.0") }
+    compileOnly(intellijPluginDep("android")) {
+        includeJars("android", "android-common", "sdk-common", "sdklib", "sdk-tools", "layoutlib-api")
+    }
+
     testCompile(projectDist(":kotlin-test:kotlin-test-jvm"))
     testCompile(project(":idea:idea-test-framework")) { isTransitive = false }
     testCompile(project(":plugins:lint")) { isTransitive = false }
@@ -36,30 +32,33 @@ dependencies {
     testCompile(projectTests(":idea:idea-gradle"))
     testCompile(commonDep("junit:junit"))
 
+    testCompile(intellijDep()) { includeJars("gson-2.5") }
+    testCompile(intellijPluginDep("properties"))
+    testCompileOnly(intellijPluginDep("android")) {
+        includeJars("android", "android-common", "sdk-common", "sdklib", "sdk-tools", "layoutlib-api")
+    }
+
     testRuntime(projectDist(":kotlin-reflect"))
     testRuntime(project(":plugins:android-extensions-ide"))
     testRuntime(project(":plugins:kapt3-idea"))
     testRuntime(project(":sam-with-receiver-ide-plugin"))
     testRuntime(project(":noarg-ide-plugin"))
     testRuntime(project(":allopen-ide-plugin"))
-    androidSdk(project(":custom-dependencies:android-sdk", configuration = "androidSdk"))
-}
 
-afterEvaluate {
+    testRuntime(intellijDep())
-    dependencies {
+    testRuntime(intellijPluginDep("android"))
-        compileOnly(intellij { include("openapi.jar", "idea.jar", "extensions.jar", "util.jar", "guava-*.jar") })
+    testRuntime(intellijPluginDep("copyright"))
-        compileOnly(intellijPlugin("android") {
+    testRuntime(intellijPluginDep("coverage"))
-            include("android.jar", "android-common.jar", "sdk-common.jar", "sdklib.jar", "sdk-tools.jar", "layoutlib-api.jar")
+    testRuntime(intellijPluginDep("gradle"))
-        })
+    testRuntime(intellijPluginDep("Groovy"))
-        testCompile(intellij { include("gson-*.jar") })
+    testRuntime(intellijPluginDep("IntelliLang"))
-        testCompile(intellijPlugin("properties"))
+    testRuntime(intellijPluginDep("java-decompiler"))
-        testCompileOnly(intellijPlugin("android") {
+    testRuntime(intellijPluginDep("java-i18n"))
-            include("android.jar", "android-common.jar", "sdk-common.jar", "sdklib.jar", "sdk-tools.jar", "layoutlib-api.jar")
+    testRuntime(intellijPluginDep("junit"))
-        })
+    testRuntime(intellijPluginDep("maven"))
-        testRuntime(intellij())
+    testRuntime(intellijPluginDep("testng"))
-        testRuntime(intellijPlugins("android", "copyright", "coverage", "gradle", "Groovy", "IntelliLang",
+
-                                    "java-decompiler", "java-i18n", "junit", "maven", "testng"))
+    androidSdk(project(":custom-dependencies:android-sdk", configuration = "androidSdk"))
-    }
 }
 
 sourceSets {

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

@@ -1,22 +1,12 @@
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
-    setExtraDependencies("intellij-core")
-    setPlugins("gradle", "android")
-}
-
 dependencies {
     compile(project(":compiler:util"))
-}
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-
+    compileOnly(intellijDep()) { includeJars("guava-21.0") }
-afterEvaluate {
+    compileOnly(intellijPluginDep("gradle")) { includeJars("gradle-tooling-api-3.5") }
-    dependencies {
+    compileOnly(intellijPluginDep("android")) { includeJars("android", "android-common", "sdk-common") }
-        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") })
-    }
 }
 
 sourceSets {

idea/idea-core/build.gradle.kts

@@ -1,10 +1,5 @@
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
-    setPlugins("gradle")
-    setExtraDependencies("intellij-core")
-}
-
 dependencies {
     compile(projectDist(":kotlin-stdlib"))
     compileOnly(project(":kotlin-reflect-api"))
@@ -21,14 +16,9 @@ dependencies {
     compile(project(":plugins:android-extensions-compiler"))
     compile(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) { isTransitive = false }
     compile(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-jdk8")) { isTransitive = false }
-}
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-
+    compileOnly(intellijDep()) { includeJars("util", "openapi", "idea", "asm-all", "jdom", "annotations", "trove4j", "guava-21.0") }
-afterEvaluate {
+    compileOnly(intellijPluginDep("gradle")) { includeJars("gradle-tooling-api-3.5", "gradle") }
-    dependencies {
-        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") })
-    }
 }
 
 sourceSets {

idea/idea-gradle/build.gradle.kts

@@ -1,9 +1,5 @@
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
-    setPlugins("android", "coverage", "gradle", "Groovy", "junit", "maven", "properties", "testng")
-}
-
 val androidSdk by configurations.creating
 
 dependencies {
@@ -18,9 +14,18 @@ dependencies {
 
     compile(project(":js:js.frontend"))
 
+    compileOnly(intellijDep()) { includeJars("openapi", "idea", "external-system-rt", "forms_rt", "extensions", "jdom", "util") }
+    compileOnly(intellijPluginDep("gradle")) { includeJars("gradle-tooling-api-3.5", "gradle", "gradle-base-services-3.5") }
+    compileOnly(intellijPluginDep("Groovy")) { includeJars("Groovy") }
+    compileOnly(intellijPluginDep("junit")) { includeJars("idea-junit") }
+
     testCompile(projectTests(":idea"))
     testCompile(project(":idea:idea-test-framework"))
 
+    testCompile(intellijPluginDep("gradle")) { includeJars("gradle-wrapper-3.5", "gradle-base-services-3.5", "gradle-tooling-extension-impl", "gradle-tooling-api-3.5", "gradle") }
+    testCompileOnly(intellijPluginDep("Groovy")) { includeJars("Groovy") }
+    testCompileOnly(intellijDep()) { includeJars("groovy-all-2.4.6", "idea_rt") }
+
     testRuntime(projectDist(":kotlin-reflect"))
     testRuntime(project(":idea:idea-jvm"))
     testRuntime(project(":idea:idea-android"))
@@ -30,27 +35,18 @@ dependencies {
     testRuntime(project(":sam-with-receiver-ide-plugin"))
     testRuntime(project(":allopen-ide-plugin"))
     testRuntime(project(":noarg-ide-plugin"))
-    androidSdk(project(":custom-dependencies:android-sdk", configuration = "androidSdk"))
+    testRuntime(intellijDep())
-}
+    // TODO: the order of the plugins matters here, consider avoiding order-dependency
+    testRuntime(intellijPluginDep("junit"))
+    testRuntime(intellijPluginDep("testng")) { includeJars("jcommander", "resources_en") }
+    testRuntime(intellijPluginDep("properties")) { includeJars("resources_en") }
+    testRuntime(intellijPluginDep("gradle"))
+    testRuntime(intellijPluginDep("Groovy"))
+    testRuntime(intellijPluginDep("coverage")) { includeJars("jacocoant") }
+    testRuntime(intellijPluginDep("maven"))
+    testRuntime(intellijPluginDep("android"))
 
-afterEvaluate {
+    androidSdk(project(":custom-dependencies:android-sdk", configuration = "androidSdk"))
-    dependencies {
-        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") })
-        testRuntime(intellij())
-        // TODO: the order of the plugins matters here, consider avoiding order-dependency
-        testRuntime(intellijPlugins("junit"))
-        testRuntime(intellijPlugin("testng") { include("jcommander.jar", "resources_en.jar") })
-        testRuntime(intellijPlugin("properties") { include("resources_en.jar") })
-        testRuntime(intellijPlugins("gradle", "Groovy"))
-        testRuntime(intellijPlugin("coverage") { include("jacocoant*.jar") })
-        testRuntime(intellijPlugins("maven", "android"))
-    }
 }
 
 sourceSets {

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

@@ -1,23 +1,14 @@
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
-    setExtraDependencies("intellij-core")
-}
-
 dependencies {
     compile(projectDist(":kotlin-stdlib"))
     compileOnly(project(":kotlin-reflect-api"))
     compile(project(":compiler:util"))
     compile(project(":compiler:cli-common"))
     compile(project(":compiler:frontend.java"))
-}
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-
+    compileOnly(intellijDep()) { includeJars("jdom", "util") }
-afterEvaluate {
-    dependencies {
-        compileOnly(intellijCoreJar())
-        compileOnly(intellij { include("jdom.jar", "util.jar") })
-    }
 }
 
 sourceSets {

idea/idea-jvm/build.gradle.kts

@@ -1,25 +1,22 @@
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
-    setPlugins("junit", "testng", "coverage", "java-decompiler")
-}
-
 dependencies {
     compile(project(":idea"))
     compile(project(":compiler:light-classes"))
     compile(project(":compiler:frontend.java"))
-}
+    compileOnly(intellijDep()) { includeJars("annotations", "openapi", "idea", "extensions", "util", "velocity", "boot", "gson-2.5",
+                                             "swingx-core-1.6.2", "forms_rt", "jdom", "log4j", "guava-21.0", "asm-all") }
+    compileOnly(commonDep("com.google.code.findbugs", "jsr305"))
 
-afterEvaluate {
+    compileOnly(intellijPluginDep("junit")) { includeJars("idea-junit") }
-    dependencies {
+    compileOnly(intellijPluginDep("testng")) { includeJars("testng", "testng-plugin") }
-        compileOnly(intellij { include("openapi.jar", "idea.jar", "extensions.jar", "util.jar") })
+    compileOnly(intellijPluginDep("coverage")) { includeJars("coverage") }
-
+    compileOnly(intellijPluginDep("java-decompiler")) { includeJars("java-decompiler") }
-        compileOnly(intellijPlugin("junit") { include("idea-junit.jar") })
+    compileOnly(intellijPluginDep("IntelliLang"))
-        compileOnly(intellijPlugin("testng") { include("testng.jar", "testng-plugin.jar") })
+    compileOnly(intellijPluginDep("copyright"))
-        compileOnly(intellijPlugin("coverage") { include("coverage.jar") })
+    compileOnly(intellijPluginDep("properties"))
-        compileOnly(intellijPlugin("java-decompiler") { include("java-decompiler.jar") })
+    compileOnly(intellijPluginDep("java-i18n"))
-    }
 }
 
 

idea/idea-maven/build.gradle.kts

@@ -1,10 +1,6 @@
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
-    setPlugins("android", "coverage", "gradle", "Groovy", "junit", "maven", "properties", "testng")
-}
-
 dependencies {
     compile(project(":core:util.runtime"))
     compile(project(":compiler:frontend"))
@@ -19,10 +15,16 @@ dependencies {
     compile(project(":idea:idea-jvm"))
     compile(project(":idea:idea-jps-common"))
 
+    compileOnly(intellijDep()) { includeJars("openapi", "idea", "gson-2.5", "jdom", "extensions", "util") }
+    compileOnly(intellijPluginDep("maven")) { includeJars("maven", "maven-server-api") }
+
     testCompile(projectTests(":idea"))
     testCompile(projectTests(":compiler:tests-common"))
     testCompile(project(":idea:idea-test-framework"))
 
+    testCompileOnly(intellijDep()) { includeJars("openapi", "idea", "gson-2.5", "idea_rt") }
+    testCompileOnly(intellijPluginDep("maven")) { includeJars("maven", "maven-server-api") }
+
     testRuntime(projectDist(":kotlin-reflect"))
     testRuntime(project(":idea:idea-jvm"))
     testRuntime(project(":idea:idea-android"))
@@ -31,23 +33,17 @@ dependencies {
     testRuntime(project(":sam-with-receiver-ide-plugin"))
     testRuntime(project(":allopen-ide-plugin"))
     testRuntime(project(":noarg-ide-plugin"))
-}
 
-afterEvaluate {
+    testRuntime(intellijDep())
-    dependencies {
+    // TODO: the order of the plugins matters here, consider avoiding order-dependency
-        compileOnly(intellij { include("openapi.jar", "idea.jar", "gson-*.jar", "jdom.jar", "extensions.jar", "util.jar") })
+    testRuntime(intellijPluginDep("junit"))
-        compileOnly(intellijPlugin("maven") { include("maven.jar", "maven-server-api.jar") })
+    testRuntime(intellijPluginDep("testng")) { includeJars("jcommander", "resources_en") }
-        testCompileOnly(intellij { include("openapi.jar", "idea.jar", "gson-*.jar", "idea_rt.jar") })
+    testRuntime(intellijPluginDep("properties")) { includeJars("resources_en") }
-        testCompileOnly(intellijPlugin("maven") { include("maven.jar", "maven-server-api.jar") })
+    testRuntime(intellijPluginDep("gradle"))
-        testRuntime(intellij())
+    testRuntime(intellijPluginDep("Groovy"))
-        // TODO: the order of the plugins matters here, consider avoiding order-dependency
+    testRuntime(intellijPluginDep("coverage")) { includeJars("jacocoant") }
-        testRuntime(intellijPlugins("junit"))
+    testRuntime(intellijPluginDep("maven"))
-        testRuntime(intellijPlugin("testng") { include("jcommander.jar", "resources_en.jar") })
+    testRuntime(intellijPluginDep("android"))
-        testRuntime(intellijPlugin("properties") { include("resources_en.jar") })
-        testRuntime(intellijPlugins("gradle", "Groovy"))
-        testRuntime(intellijPlugin("coverage") { include("jacocoant*.jar") })
-        testRuntime(intellijPlugins("maven", "android"))
-    }
 }
 
 sourceSets {

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

@@ -1,8 +1,6 @@
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin()
-
 dependencies {
     compile(project(":compiler:frontend"))
     compile(project(":compiler:frontend.script"))
@@ -14,12 +12,7 @@ dependencies {
     compile(project(":kotlin-test:kotlin-test-jvm"))
     compileOnly(project(":kotlin-reflect-api"))
     compile(commonDep("junit:junit"))
-}
+    compileOnly(intellijDep()) { includeJars("openapi", "idea", "log4j") }
-
-afterEvaluate {
-    dependencies {
-        compileOnly(intellij { include("openapi.jar", "idea.jar", "log4j.jar") })
-    }
 }
 
 sourceSets {

idea/kotlin-gradle-tooling/build.gradle.kts

@@ -5,24 +5,15 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
-configureIntellijPlugin {
-    setPlugins("gradle")
-}
-
 dependencies {
     compile(projectDist(":kotlin-stdlib"))
     compile(project(":compiler:cli-common"))
-}
+    compile(intellijPluginDep("gradle")) {
-
+        includeJars("gradle-tooling-api-3.5",
-afterEvaluate {
+                    "gradle-tooling-extension-api",
-    dependencies {
+                    "gradle",
-        compile(intellijPlugin("gradle") {
+                    "gradle-core-3.5",
-            include("gradle-tooling-api-*.jar",
+                    "gradle-base-services-groovy-3.5")
-                    "gradle-tooling-extension-api.jar",
-                    "gradle.jar",
-                    "gradle-core-*.jar",
-                    "gradle-base-services-groovy-*.jar")
-        })
     }
 }
 

j2k/build.gradle.kts

@@ -17,36 +17,30 @@ val usedIntellijPlugins = arrayOf(
         "java-i18n",
         "java-decompiler")
 
-configureIntellijPlugin {
-    setPlugins(*usedIntellijPlugins)
-    setExtraDependencies("intellij-core")
-}
-
 dependencies {
     compile(projectDist(":kotlin-stdlib"))
     compile(project(":compiler:frontend"))
     compile(project(":compiler:frontend.java"))
     compile(project(":compiler:light-classes"))
     compile(project(":compiler:util"))
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
+
     testCompile(project(":idea"))
     testCompile(project(":idea:idea-test-framework"))
     testCompile(project(":compiler:light-classes"))
     testCompile(projectDist(":kotlin-test:kotlin-test-junit"))
     testCompile(commonDep("junit:junit"))
+
+    testRuntime(project(":plugins:kapt3-idea")) { isTransitive = false }
     testRuntime(project(":idea:idea-jvm"))
     testRuntime(project(":idea:idea-android"))
     testRuntime(project(":plugins:android-extensions-ide"))
     testRuntime(project(":sam-with-receiver-ide-plugin"))
     testRuntime(project(":allopen-ide-plugin"))
     testRuntime(project(":noarg-ide-plugin"))
-    testRuntime(project(":plugins:kapt3-idea")) { isTransitive = false }
+    testRuntime(intellijDep())
-}
+    usedIntellijPlugins.forEach {
-
+        testRuntime(intellijPluginDep(it))
-afterEvaluate {
-    dependencies {
-        compileOnly(intellijCoreJar())
-        testRuntime(intellij())
-        testRuntime(intellijPlugins(*usedIntellijPlugins))
     }
 }
 

jps-plugin/build.gradle.kts

@@ -2,10 +2,6 @@ apply { plugin("kotlin") }
 
 val compilerModules: Array<String> by rootProject.extra
 
-configureIntellijPlugin {
-    setExtraDependencies("intellij-core", "jps-standalone", "jps-build-test")
-}
-
 dependencies {
     compile(project(":kotlin-build-common"))
     compile(project(":core:descriptors"))
@@ -16,6 +12,8 @@ dependencies {
     compile(project(":compiler:frontend.java"))
     compile(projectRuntimeJar(":kotlin-preloader"))
     compile(project(":idea:idea-jps-common"))
+    compileOnly(intellijDep()) { includeJars("jdom", "trove4j", "jps-model", "openapi", "util") }
+    compileOnly(intellijDep("jps-standalone")) { includeJars("jps-builders", "jps-builders-6") }
     testCompileOnly(project(":kotlin-reflect-api"))
     testCompile(project(":compiler:incremental-compilation-impl"))
     testCompile(projectTests(":compiler:tests-common"))
@@ -23,24 +21,17 @@ dependencies {
     testCompile(commonDep("junit:junit"))
     testCompile(projectDist(":kotlin-test:kotlin-test-jvm"))
     testCompile(projectTests(":kotlin-build-common"))
+    testCompileOnly(intellijDep("jps-standalone")) { includeJars("jps-builders", "jps-builders-6") }
+    testCompileOnly(intellijDep()) { includeJars("openapi", "idea", "log4j") }
+    testCompile(intellijDep("jps-build-test"))
     compilerModules.forEach {
         testRuntime(project(it))
     }
+    testRuntime(intellijDep())
+    testRuntime(intellijCoreDep()) { includeJars("intellij-core") }
     testRuntime(projectDist(":kotlin-reflect"))
 }
 
-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") })
-        testCompileOnly(intellij { include("openapi.jar", "idea.jar", "log4j.jar") })
-        testCompile(intellijExtra("jps-build-test"))
-        testRuntime(intellij())
-        testRuntime(intellijCoreJar())
-    }
-}
-
 sourceSets {
     "main" { projectDefault() }
     "test" {

js/js.ast/build.gradle.kts

@@ -3,20 +3,11 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
-configureIntellijPlugin {
-    setExtraDependencies("intellij-core")
-}
-
 dependencies {
     compile(project(":compiler:util"))
     compile(project(":compiler:frontend"))
-}
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-
+    compileOnly(intellijDep()) { includeJars("trove4j") }
-afterEvaluate {
-    dependencies {
-        compileOnly(intellijCoreJar())
-        compileOnly(intellij { include("trove4j.jar")} )
-    }
 }
 
 sourceSets {

js/js.dce/build.gradle.kts

@@ -1,20 +1,11 @@
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
-    setExtraDependencies("intellij-core")
-}
-
 dependencies {
     compile(project(":compiler:util"))
     compile(project(":js:js.ast"))
     compile(project(":js:js.translator"))
-}
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-
-afterEvaluate {
-    dependencies {
-        compileOnly(intellijCoreJar())
-    }
 }
 
 sourceSets {

js/js.frontend/build.gradle.kts

@@ -3,23 +3,14 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
-configureIntellijPlugin {
-    setExtraDependencies("intellij-core")
-}
-
 dependencies {
     compile(project(":compiler:util"))
     compile(project(":compiler:frontend"))
     compile(project(":js:js.ast"))
     compile(project(":js:js.parser"))
     compile(project(":js:js.serializer"))
-}
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-
+    compileOnly(intellijDep()) { includeJars("guava-21.0") }
-afterEvaluate {
-    dependencies {
-        compileOnly(intellijCoreJar())
-        compileOnly(intellij { include("guava-*.jar")} )
-    }
 }
 
 sourceSets {

js/js.parser/build.gradle.kts

@@ -1,19 +1,10 @@
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
-    setExtraDependencies("intellij-core")
-}
-
 dependencies {
     compile(project(":compiler:util"))
     compile(project(":js:js.ast"))
-}
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-
-afterEvaluate {
-    dependencies {
-        compileOnly(intellijCoreJar())
-    }
 }
 
 sourceSets {

js/js.serializer/build.gradle.kts

@@ -3,21 +3,12 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
-configureIntellijPlugin {
-    setExtraDependencies("intellij-core")
-}
-
 dependencies {
     compile(project(":compiler:util"))
     compile(project(":compiler:frontend"))
     compile(project(":compiler:serialization"))
     compile(project(":js:js.ast"))
-}
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-
-afterEvaluate {
-    dependencies {
-        compileOnly(intellijCoreJar())
-    }
 }
 
 sourceSets {

js/js.tests/build.gradle.kts

@@ -12,10 +12,6 @@ node {
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
-    setExtraDependencies("intellij-core")
-}
-
 val antLauncherJar by configurations.creating
 
 dependencies {
@@ -24,12 +20,15 @@ dependencies {
     testCompileOnly(project(":compiler:frontend"))
     testCompileOnly(project(":compiler:cli"))
     testCompileOnly(project(":compiler:util"))
+    testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") }
+    testCompileOnly(intellijDep()) { includeJars("openapi", "idea", "idea_rt", "util") }
     testCompile(project(":js:js.translator"))
     testCompile(project(":js:js.serializer"))
     testCompile(project(":js:js.dce"))
     testCompile(commonDep("junit:junit"))
     testCompile(projectTests(":kotlin-build-common"))
     testCompile(projectTests(":generators:test-generator"))
+
     testRuntime(projectDist(":kotlin-stdlib"))
     testRuntime(projectDist(":kotlin-stdlib-js"))
     testRuntime(projectDist(":kotlin-test:kotlin-test-js")) // to be sure that kotlin-test-js built before tests runned
@@ -37,19 +36,12 @@ dependencies {
     testRuntime(projectDist(":kotlin-preloader")) // it's required for ant tests
     testRuntime(project(":compiler:backend-common"))
     testRuntime(commonDep("org.fusesource.jansi", "jansi"))
+    testRuntime(intellijDep())
 
     antLauncherJar(commonDep("org.apache.ant", "ant"))
     antLauncherJar(files(toolsJar()))
 }
 
-afterEvaluate {
-    dependencies {
-        testCompileOnly(intellijCoreJar())
-        testCompileOnly(intellij { include("openapi.jar", "idea.jar", "idea_rt.jar", "util.jar") })
-        testRuntime(intellij())
-    }
-}
-
 
 sourceSets {
     "main" {}

js/js.translator/build.gradle.kts

@@ -8,10 +8,6 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
-configureIntellijPlugin {
-    setExtraDependencies("intellij-core")
-}
-
 dependencies {
     compile(project(":core:descriptors"))
     compile(project(":compiler:util"))
@@ -20,13 +16,8 @@ dependencies {
     compile(project(":js:js.ast"))
     compile(project(":js:js.frontend"))
     compile(project(":js:js.parser"))
-}
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-
+    compileOnly(intellijDep()) { includeJars("trove4j", "guava-21.0") }
-afterEvaluate {
-    dependencies {
-        compileOnly(intellijCoreJar())
-        compileOnly(intellij { include("trove4j.jar", "guava-*.jar")} )
-    }
 }
 
 sourceSets {

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

@@ -3,8 +3,6 @@ description = "Kotlin scripting support utilities"
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin()
-
 dependencies {
     compile(project(":kotlin-stdlib"))
     compile(project(":kotlin-script-runtime"))
@@ -22,13 +20,8 @@ dependencies {
     testRuntime("com.jcabi:jcabi-aether:0.10.1")
     testRuntime("org.sonatype.aether:aether-api:1.13.1")
     testRuntime("org.apache.maven:maven-core:3.0.3")
-}
+    compileOnly(intellijDep()) { includeJars("openapi", "util") }
-
+    testCompile(intellijDep()) { includeJars("openapi", "util") }
-afterEvaluate {
-    dependencies {
-        compileOnly(intellij { include("openapi.jar", "util.jar") })
-        testCompile(intellij { include("openapi.jar", "util.jar") })
-    }
 }
 
 projectTest {

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

@@ -3,13 +3,11 @@ description = "Kotlin AllOpen Compiler Plugin"
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
-    setExtraDependencies("intellij-core")
-}
-
 dependencies {
     compileOnly(project(":compiler:plugin-api"))
     compileOnly(project(":compiler:frontend"))
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
+
     runtime(projectRuntimeJar(":kotlin-compiler"))
     runtime(projectDist(":kotlin-stdlib"))
 
@@ -19,13 +17,7 @@ dependencies {
     testCompile(projectTests(":compiler:tests-common"))
     testCompile(commonDep("junit:junit"))
 
-    testRuntime(ideaSdkDeps("*.jar"))
+    testRuntime(intellijDep())
-}
-
-afterEvaluate {
-    dependencies {
-        compileOnly(intellijCoreJar())
-    }
 }
 
 sourceSets {

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

@@ -5,10 +5,6 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
-configureIntellijPlugin {
-    setPlugins("gradle", "maven")
-}
-
 dependencies {
     compile(project(":kotlin-allopen-compiler-plugin"))
     compile(project(":compiler:util"))
@@ -17,14 +13,9 @@ dependencies {
     compile(project(":idea"))
     compile(project(":idea:idea-jps-common"))
     compile(project(":plugins:annotation-based-compiler-plugins-ide-support"))
-}
+    compileOnly(intellijDep()) { includeJars("openapi", "idea") }
-
+    compileOnly(intellijPluginDep("maven")) { includeJars("maven") }
-afterEvaluate {
+    compileOnly(intellijPluginDep("gradle")) { includeJars("gradle-tooling-api-3.5", "gradle") }
-    dependencies {
-        compileOnly(intellij { include("openapi.jar", "idea.jar") })
-        compileOnly(intellijPlugin("maven") { include("maven.jar") })
-        compileOnly(intellijPlugin("gradle") { include("gradle-tooling-api-*.jar", "gradle.jar") })
-    }
 }
 
 sourceSets {

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

@@ -3,9 +3,8 @@ description = "Kotlin Android Extensions Compiler"
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
+val robolectricClasspath by configurations.creating
-    setExtraDependencies("intellij-core")
+val androidJar by configurations.creating
-}
 
 dependencies {
     compile(project(":compiler:util"))
@@ -14,23 +13,22 @@ dependencies {
     compile(project(":compiler:frontend.java"))
     compile(project(":compiler:backend"))
     compileOnly(project(":kotlin-android-extensions-runtime"))
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
+    compileOnly(intellijDep()) { includeJars("asm-all") }
 
     testCompile(project(":compiler:util"))
     testCompile(project(":compiler:backend"))
     testCompile(project(":compiler:cli"))
     testCompile(project(":compiler:tests-common"))
+    testCompile(project(":kotlin-android-extensions-runtime"))
     testCompile(projectTests(":compiler:tests-common"))
     testCompile(projectDist(":kotlin-test:kotlin-test-jvm"))
     testCompile(commonDep("junit:junit"))
-    testRuntime(ideaPluginDeps("idea-junit", "resources_en", plugin = "junit"))
-    testCompile(project(":kotlin-android-extensions-runtime"))
-}
 
-afterEvaluate {
+    testRuntime(intellijPluginDep("junit")) { includeJars("idea-junit", "resources_en") }
-    dependencies {
+
-        compileOnly(intellijCoreJar())
+    robolectricClasspath(commonDep("org.robolectric", "robolectric"))
-        compileOnly(intellij { include("asm-all.jar") })
+    androidJar(project(":custom-dependencies:android-sdk", configuration = "androidJar"))
-    }
 }
 
 sourceSets {
@@ -54,4 +52,10 @@ projectTest {
     environment("ANDROID_EXTENSIONS_RUNTIME_CLASSES", getSourceSetsFrom(":kotlin-android-extensions-runtime")["main"].output.classesDirs.asPath)
     dependsOnTaskIfExistsRec("dist", project = rootProject)
     workingDir = rootDir
+    doFirst {
+        val androidPluginPath = File(intellijRootDir(), "plugins/android").canonicalPath
+        systemProperty("ideaSdk.androidPlugin.path", androidPluginPath)
+        systemProperty("robolectric.classpath", robolectricClasspath.asPath)
+        systemProperty("android.jar", androidJar.singleFile.canonicalPath)
+    }
 }

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

@@ -5,12 +5,8 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
-configureIntellijPlugin {
-    setPlugins("android", "copyright", "coverage", "gradle", "Groovy", "IntelliLang",
-               "java-decompiler", "java-i18n", "junit", "maven", "properties", "testng")
-}
-
 val androidSdk by configurations.creating
+val androidJar by configurations.creating
 
 dependencies {
     compile(project(":compiler:util"))
@@ -20,6 +16,9 @@ dependencies {
     compile(project(":idea:idea-gradle"))
     compile(project(":plugins:android-extensions-compiler"))
     compileOnly(project(":kotlin-android-extensions-runtime"))
+    compileOnly(intellijPluginDep("android")) { includeJars("android.jar", "android-common.jar", "sdk-common.jar", "sdk-tools.jar") }
+    compileOnly(intellijPluginDep("Groovy")) { includeJars("Groovy.jar") }
+    compileOnly(intellijDep()) { includeJars("extensions.jar", "openapi.jar", "util.jar", "idea.jar") }
 
     testCompile(project(":compiler:tests-common"))
     testCompile(project(":compiler:cli"))
@@ -32,27 +31,32 @@ dependencies {
     testCompile(projectDist(":kotlin-test:kotlin-test-jvm"))
     testCompile(commonDep("junit:junit"))
     testRuntime(projectDist(":kotlin-reflect"))
+    testCompile(intellijPluginDep("android")) { includeJars("android.jar", "android-common.jar", "sdk-common.jar", "sdk-tools.jar") }
+    testCompile(intellijPluginDep("Groovy")) { includeJars("Groovy.jar") }
+    testCompile(intellijDep()) { includeJars("extensions.jar") }
+
     testRuntime(project(":idea:idea-jvm"))
     testRuntime(project(":plugins:android-extensions-jps"))
     testRuntime(project(":sam-with-receiver-ide-plugin"))
     testRuntime(project(":noarg-ide-plugin"))
     testRuntime(project(":allopen-ide-plugin"))
     testRuntime(project(":plugins:lint"))
-    androidSdk(project(":custom-dependencies:android-sdk", configuration = "androidSdk"))
+    testRuntime(intellijDep())
-}
+    testRuntime(intellijPluginDep("junit"))
+    testRuntime(intellijPluginDep("IntelliLang"))
+    testRuntime(intellijPluginDep("testng"))
+    testRuntime(intellijPluginDep("copyright"))
+    testRuntime(intellijPluginDep("properties"))
+    testRuntime(intellijPluginDep("java-i18n"))
+    testRuntime(intellijPluginDep("gradle"))
+    testRuntime(intellijPluginDep("Groovy"))
+    testRuntime(intellijPluginDep("coverage"))
+    testRuntime(intellijPluginDep("java-decompiler"))
+    testRuntime(intellijPluginDep("maven"))
+    testRuntime(intellijPluginDep("android"))
 
-afterEvaluate {
+    androidSdk(project(":custom-dependencies:android-sdk", configuration = "androidSdk"))
-    dependencies {
+    androidJar(project(":custom-dependencies:android-sdk", configuration = "androidJar"))
-        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"))
-    }
 }
 
 sourceSets {
@@ -68,6 +72,7 @@ projectTest {
     workingDir = rootDir
     doFirst {
         systemProperty("android.sdk", androidSdk.singleFile.canonicalPath)
+        systemProperty("android.jar", androidJar.singleFile.canonicalPath)
     }
 }
 

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

@@ -1,34 +1,31 @@
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
+val androidSdk by configurations.creating
-    setPlugins("android")
-}
 
 dependencies {
     compile(project(":compiler:util"))
     compile(project(":jps-plugin"))
     compile(project(":plugins:android-extensions-compiler"))
-    compile(ideaPluginDeps("android-jps-plugin", plugin = "android", subdir = "lib/jps"))
+    compileOnly(intellijDep()) { includeJars("openapi", "jps-builders") }
+    compileOnly(intellijPluginDep("android")) { includeJars("jps/android-jps-plugin") }
+    compile(intellijPluginDep("android")) { includeJars("jps/android-jps-plugin") }
 
     testCompile(projectTests(":jps-plugin"))
     testCompile(project(":compiler:tests-common"))
     testCompile(commonDep("junit:junit"))
     testCompile(projectDist(":kotlin-test:kotlin-test-jvm"))
     testCompile(projectTests(":kotlin-build-common"))
-}
+    testCompileOnly(intellijDep()) { includeJars("openapi", "jps-builders") }
+    testCompileOnly(intellijDep("jps-build-test")) { includeJars("jps-build-test") }
 
-afterEvaluate {
+    testRuntime(intellijPluginDep("android"))
-    dependencies {
+    testRuntime(intellijCoreDep()) { includeJars("intellij-core") }
-        compileOnly(intellij { include("openapi.jar", "jps-builders.jar") })
+    testRuntime(intellijDep())
-        compile(intellijPlugin("android") { include("**/android-jps-plugin.jar") })
+    testRuntime(intellijDep("jps-build-test"))
-        testCompileOnly(intellijExtra("jps-build-test") { include("jps-build-test.jar") } )
+    testRuntime(intellijDep("jps-standalone"))
-        testRuntime(intellijPlugin("android"))
+
-        testRuntime(intellijCoreJar())
+    androidSdk(project(":custom-dependencies:android-sdk", configuration = "androidSdk"))
-        testRuntime(intellij())
-        testRuntime(intellijExtra("jps-build-test"))
-        testRuntime(intellijExtra("jps-standalone"))
-    }
 }
 
 sourceSets {
@@ -38,6 +35,9 @@ sourceSets {
 
 projectTest {
     workingDir = rootDir
+    doFirst {
+        systemProperty("android.sdk", androidSdk.singleFile.canonicalPath)
+    }
 }
 
 testsJar {}

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

@@ -3,10 +3,6 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
-configureIntellijPlugin {
-    setPlugins("gradle", "maven")
-}
-
 dependencies {
     compile(project(":compiler:util"))
     compile(project(":compiler:frontend"))
@@ -15,15 +11,10 @@ dependencies {
     compile(project(":idea:idea-jps-common"))
     compile(project(":idea:idea-gradle"))
     compile(project(":idea:idea-maven"))
-}
+    compileOnly(intellijPluginDep("maven")) { includeJars("maven.jar", "maven-server-api.jar") }
-
+        compileOnly(intellijPluginDep("gradle")) { includeJars("gradle-tooling-api-3.5.jar", "gradle.jar") }
-afterEvaluate {
+        compileOnly(intellijDep()) { includeJars("openapi.jar", "idea.jar", "extensions.jar", "jdom.jar", "util.jar") }
-    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", "extensions.jar", "jdom.jar", "util.jar") })
     }
-}
 
 sourceSets {
     "main" { projectDefault() }

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

@@ -3,10 +3,6 @@ description = "Annotation Processor for Kotlin"
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
-    setExtraDependencies("intellij-core")
-}
-
 dependencies {
     compile(project(":compiler:util"))
     compile(project(":compiler:cli"))
@@ -14,25 +10,18 @@ dependencies {
     compile(project(":compiler:frontend"))
     compile(project(":compiler:frontend.java"))
     compile(project(":compiler:plugin-api"))
+    compileOnly(project(":kotlin-annotation-processing-runtime"))
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
+    compileOnly(intellijDep()) { includeJars("asm-all") }
 
     testCompile(project(":compiler:tests-common"))
     testCompile(projectTests(":compiler:tests-common"))
-
-    compileOnly(project(":kotlin-annotation-processing-runtime"))
-
     testCompile(commonDep("junit:junit"))
+    testCompile(intellijCoreDep()) { includeJars("intellij-core") }
+    testCompile(intellijDep()) { includeJars("idea", "idea_rt", "openapi") }
     testCompile(project(":kotlin-annotation-processing-runtime"))
 }
 
-afterEvaluate {
-    dependencies {
-        compileOnly(intellijCoreJar())
-        compileOnly(intellij { include("asm-all.jar") })
-        testCompile(intellijCoreJar())
-        testCompile(intellij { include("idea.jar", "idea_rt.jar", "openapi.jar") })
-    }
-}
-
 sourceSets {
     "main" { projectDefault() }
     "test" { projectDefault() }

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

@@ -3,24 +3,15 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
-configureIntellijPlugin {
-    setPlugins("android", "gradle")
-}
-
 dependencies {
     compile(projectDist(":kotlin-stdlib"))
     compile(project(":compiler:frontend"))
     compile(project(":idea")) { isTransitive = false }
     compile(project(":idea:kotlin-gradle-tooling"))
     compile(project(":kotlin-annotation-processing"))
-}
+    compileOnly(intellijDep()) { includeJars("openapi", "external-system-rt", "util") }
-
+    compileOnly(intellijPluginDep("gradle")) { includeJars("gradle-core-3.5", "gradle-tooling-api-3.5", "gradle") }
-afterEvaluate {
+    compileOnly(intellijPluginDep("android")) { includeJars("android", "android-common", "sdklib", "sdk-common", "sdk-tools") }
-    dependencies {
-        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") })
-    }
 }
 
 sourceSets {

plugins/lint/build.gradle.kts

@@ -4,31 +4,17 @@ apply {
     plugin("java")
 }
 
-repositories {
-    androidDxJarRepo(project)
-}
-
-configureIntellijPlugin {
-    setExtraDependencies("intellij-core")
-    setPlugins("android")
-}
-
 dependencies {
     compile(project(":compiler:frontend"))
     compile(project(":idea"))
     compile(project(":idea:idea-core"))
     compile(project(":idea:idea-android"))
     compile(project(":plugins:uast-kotlin"))
-}
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-
+    compileOnly(intellijDep()) { includeJars("util", "guava-21.0", "openapi", "idea", "asm-all") }
-afterEvaluate {
+    compileOnly(intellijPluginDep("android")) {
-    dependencies {
+        includeJars("android", "android-common", "sdklib", "sdk-common", "sdk-tools",
-        compileOnly(intellijCoreJar())
+                    "repository", "lombok-ast-0.2.3", "layoutlib-api", "kxml2-2.3.0")
-        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", "layoutlib-api.jar", "kxml2-*.jar")
-        })
     }
 }
 

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

@@ -3,16 +3,14 @@ description = "Kotlin NoArg Compiler Plugin"
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
-    setExtraDependencies("intellij-core")
-}
-
 dependencies {
     compileOnly(project(":compiler:frontend"))
     compileOnly(project(":compiler:frontend.java"))
     compileOnly(project(":compiler:backend"))
     compileOnly(project(":compiler:util"))
     compileOnly(project(":compiler:plugin-api"))
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
+    compileOnly(intellijDep()) { includeJars("asm-all") }
     runtime(projectRuntimeJar(":kotlin-compiler"))
     runtime(projectDist(":kotlin-stdlib"))
 
@@ -25,13 +23,6 @@ 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

@@ -5,10 +5,6 @@ apply { plugin("kotlin") }
 
 jvmTarget = "1.6"
 
-configureIntellijPlugin {
-    setPlugins("gradle", "maven")
-}
-
 dependencies {
     compile(project(":kotlin-noarg-compiler-plugin"))
     compile(project(":compiler:util"))
@@ -19,15 +15,10 @@ dependencies {
     compile(project(":idea"))
     compile(project(":idea:idea-jps-common"))
     compile(project(":plugins:annotation-based-compiler-plugins-ide-support"))
-}
+    compileOnly(intellijDep()) { includeJars("openapi.jar", "idea.jar") }
-
+        compileOnly(intellijPluginDep("maven")) { includeJars("maven.jar") }
-afterEvaluate {
+        compileOnly(intellijPluginDep("gradle")) { includeJars("gradle-tooling-api-3.5.jar", "gradle.jar") }
-    dependencies {
-        compileOnly(intellij { include("openapi.jar", "idea.jar") })
-        compileOnly(intellijPlugin("maven") { include("maven.jar") })
-        compileOnly(intellijPlugin("gradle") { include("gradle-tooling-api-*.jar", "gradle.jar") })
     }
-}
 
 sourceSets {
     "main" { projectDefault() }

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

@@ -3,14 +3,11 @@ description = "Kotlin SamWithReceiver Compiler Plugin"
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
-    setExtraDependencies("intellij-core")
-}
-
 dependencies {
     compileOnly(project(":compiler:frontend"))
     compileOnly(project(":compiler:frontend.java"))
     compileOnly(project(":compiler:plugin-api"))
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     runtime(projectRuntimeJar(":kotlin-compiler"))
     runtime(projectDist(":kotlin-stdlib"))
     runtime(projectDist(":kotlin-reflect"))
@@ -20,13 +17,7 @@ dependencies {
     testCompile(project(":compiler:tests-common"))
     testCompile(projectTests(":compiler:tests-common"))
     testCompile(commonDep("junit:junit"))
-    testRuntime(ideaSdkDeps("*.jar"))
+    testRuntime(intellijDep())
-}
-
-afterEvaluate {
-    dependencies {
-        compileOnly(intellijCoreJar())
-    }
 }
 
 sourceSets {

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

@@ -3,15 +3,13 @@ description = "Kotlin SourceSections Compiler Plugin"
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
-    setExtraDependencies("intellij-core")
-}
-
 
 dependencies {
     compileOnly(project(":compiler:frontend"))
     compileOnly(project(":compiler:frontend.script"))
     compileOnly(project(":compiler:plugin-api"))
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
+
     testCompile(project(":compiler:frontend"))
     testCompile(project(":compiler:frontend.script"))
     testCompile(project(":compiler:plugin-api"))
@@ -23,17 +21,11 @@ dependencies {
     testCompile(project(":kotlin-daemon-client"))
     testCompile(projectTests(":compiler:tests-common"))
     testCompile(commonDep("junit:junit"))
+    testCompile(intellijCoreDep()) { includeJars("intellij-core") }
+    testCompile(intellijDep()) { includeJars("idea", "idea_rt", "openapi", "log4j", "jdom", "jps-model") }
     testRuntime(projectDist(":kotlin-reflect"))
 }
 
-afterEvaluate {
-    dependencies {
-        compileOnly(intellijCoreJar())
-        testCompile(intellijCoreJar())
-        testCompile(intellij { include("idea.jar", "idea_rt.jar", "openapi.jar", "log4j.jar", "jdom.jar", "jps-model.jar") })
-    }
-}
-
 sourceSets {
     "main" { projectDefault() }
     "test" { projectDefault() }

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

@@ -1,8 +1,6 @@
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin()
-
 dependencies {
     compile(projectDist(":kotlin-stdlib"))
     compile(project(":core:util.runtime"))
@@ -10,12 +8,7 @@ dependencies {
     compile(project(":compiler:frontend.java"))
     compile(project(":idea:ide-common"))
     compile(project(":plugins:uast-kotlin"))
-}
+    compileOnly(intellijDep()) { includeJars("openapi", "util") }
-
-afterEvaluate {
-    dependencies {
-        compileOnly(intellij { include("openapi.jar", "util.jar") })
-    }
 }
 
 sourceSets {

plugins/uast-kotlin/build.gradle.kts

@@ -1,10 +1,6 @@
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
-    setPlugins("junit", "gradle", "Groovy", "properties")
-}
-
 dependencies {
     compile(projectDist(":kotlin-stdlib"))
     compile(project(":core:util.runtime"))
@@ -12,12 +8,16 @@ dependencies {
     compile(project(":compiler:frontend"))
     compile(project(":compiler:frontend.java"))
     compile(project(":compiler:light-classes"))
+    compileOnly(intellijDep()) { includeJars("openapi", "idea", "util", "extensions", "asm-all") }
+
     testCompile(projectDist(":kotlin-test:kotlin-test-jvm"))
     testCompile(projectTests(":compiler:tests-common"))
     testCompile(commonDep("junit:junit"))
     testCompile(project(":compiler:util"))
     testCompile(project(":compiler:cli"))
     testCompile(project(":idea:idea-test-framework"))
+    testCompileOnly(intellijDep()) { includeJars("idea_rt") }
+
     testRuntime(projectDist(":kotlin-reflect"))
     testRuntime(project(":idea:idea-android"))
     testRuntime(project(":idea:idea-gradle"))
@@ -26,16 +26,12 @@ dependencies {
     testRuntime(project(":allopen-ide-plugin"))
     testRuntime(project(":noarg-ide-plugin"))
     testRuntime(project(":plugins:android-extensions-ide"))
-}
+    testRuntime(project(":plugins:kapt3-idea"))
-
+    testRuntime(intellijDep())
-afterEvaluate {
+    testRuntime(intellijPluginDep("junit"))
-    dependencies {
+    testRuntime(intellijPluginDep("gradle"))
-        compileOnly(intellij { include("openapi.jar", "idea.jar", "util.jar", "extensions.jar", "asm-all.jar") })
+    testRuntime(intellijPluginDep("Groovy"))
-        testCompileOnly(intellij { include("idea_rt.jar") })
+    testRuntime(intellijPluginDep("properties"))
-        testRuntime(project(":plugins:kapt3-idea"))
-        testRuntime(intellij())
-        testRuntime(intellijPlugins("junit", "gradle", "Groovy", "properties"))
-    }
 }
 
 sourceSets {

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

@@ -5,10 +5,6 @@ description = "Kotlin Android Extensions Compiler"
 
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
-    setExtraDependencies("intellij-core")
-}
-
 dependencies {
     compileOnly(project(":compiler:util"))
     compileOnly(project(":compiler:plugin-api"))
@@ -18,12 +14,7 @@ dependencies {
     compileOnly(project(":kotlin-android-extensions-runtime"))
     runtime(projectRuntimeJar(":kotlin-compiler-embeddable"))
     compileOnly(commonDep("com.google.android", "android"))
-}
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-
-afterEvaluate {
-    dependencies {
-        compileOnly(intellijCoreJar())
-    }
 }
 
 sourceSets {

prepare/compiler/build.gradle.kts

@@ -51,10 +51,6 @@ val compiledModulesSources = compilerModules.map {
     project(it).the<JavaPluginConvention>().sourceSets.getByName("main").allSource
 }
 
-configureIntellijPlugin {
-    setExtraDependencies("intellij-core", "jps-standalone")
-}
-
 dependencies {
     compilerModules.forEach {
         fatJarContents(project(it)) { isTransitive = false }
@@ -82,16 +78,11 @@ dependencies {
     compile(project(":kotlin-stdlib"))
     compile(project(":kotlin-script-runtime"))
     compile(project(":kotlin-reflect"))
-}
+    fatJarContents(intellijCoreDep()) { includeJars("intellij-core") }
-
+    fatJarContents(intellijDep()) { includeIntellijCoreJarDependencies(project, { !(it.startsWith("jdom") || it.startsWith("log4j")) }) }
-afterEvaluate {
+    fatJarContents(intellijDep()) { includeJars("jna-platform") }
-    dependencies {
+    fatJarContentsStripServices(intellijDep("jps-standalone")) { includeJars("jps-model") }
-        fatJarContents(intellijCoreJar())
+    fatJarContentsStripMetadata(intellijDep()) { includeJars("oromatcher", "jdom", "log4j") }
-        fatJarContents(intellijCoreJarDependencies { exclude("jdom.jar", "log4j.jar") })
-        fatJarContents(intellij { include("jna-platform.jar") })
-        fatJarContentsStripServices(intellijExtra("jps-standalone") { include("jps-model.jar") })
-        fatJarContentsStripMetadata(intellij { include("oromatcher.jar", "jdom.jar", "log4j.jar") })
-    }
 }
 
 

test-instrumenter/build.gradle.kts

@@ -3,19 +3,10 @@ import org.gradle.jvm.tasks.Jar
 plugins { java }
 apply { plugin("kotlin") }
 
-configureIntellijPlugin {
-    setExtraDependencies("intellij-core")
-}
-
 dependencies {
     compile(project(":kotlin-stdlib"))
-}
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
-
+    compileOnly(intellijDep()) { includeJars("asm-all") }
-afterEvaluate {
-    dependencies {
-        compileOnly(intellijCoreJar())
-        compileOnly(intellij { include("asm-all.jar") })
-    }
 }
 
 sourceSets {

ultimate/build.gradle.kts

@@ -6,36 +6,6 @@ description = "Kotlin IDEA Ultimate plugin"
 
 apply {
     plugin("kotlin")
-    plugin("org.jetbrains.intellij")
-}
-
-configureIntellijPlugin {
-    version = (rootProject.extra["versions.intellij"] as String).replaceFirst("IC-", "IU-")
-    setExtraDependencies("intellij-core")
-    setPlugins("CSS",
-               "DatabaseTools",
-               "JavaEE",
-               "jsp",
-               "PersistenceSupport",
-               "Spring",
-               "properties",
-               "java-i18n",
-               "gradle",
-               "Groovy",
-               "junit",
-               "uml",
-               "JavaScriptLanguage",
-               "JavaScriptDebugger",
-               "properties",
-               "coverage",
-               "maven",
-               "android",
-               "testng",
-               "IntelliLang",
-               "testng",
-               "copyright",
-               "java-decompiler",
-               "NodeJS:${rootProject.extra["versions.idea.NodeJS"]}")
 }
 
 val ideaProjectResources =  project(":idea").the<JavaPluginConvention>().sourceSets["main"].output.resourcesDir
@@ -59,6 +29,23 @@ dependencies {
     compile(project(":idea:idea-core")) { isTransitive = false }
     compile(project(":idea:ide-common")) { isTransitive = false }
     compile(project(":idea:idea-gradle")) { isTransitive = false }
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
+    compileOnly(intellijDep()) { includeJars("annotations", "trove4j", "openapi", "idea", "util", "jdom") }
+    compileOnly(intellijPluginDep("CSS"))
+    compileOnly(intellijPluginDep("DatabaseTools"))
+    compileOnly(intellijPluginDep("JavaEE"))
+    compileOnly(intellijPluginDep("jsp"))
+    compileOnly(intellijPluginDep("PersistenceSupport"))
+    compileOnly(intellijPluginDep("Spring"))
+    compileOnly(intellijPluginDep("properties"))
+    compileOnly(intellijPluginDep("java-i18n"))
+    compileOnly(intellijPluginDep("gradle"))
+    compileOnly(intellijPluginDep("Groovy"))
+    compileOnly(intellijPluginDep("junit"))
+    compileOnly(intellijPluginDep("uml"))
+    compileOnly(intellijPluginDep("JavaScriptLanguage"))
+    compileOnly(intellijPluginDep("JavaScriptDebugger"))
+    compileOnly(intellijPluginDep("NodeJS"))
 
     testCompile(projectDist(":kotlin-test:kotlin-test-jvm"))
     testCompile(project(":idea:idea-test-framework")) { isTransitive = false }
@@ -97,52 +84,31 @@ dependencies {
     springClasspath(commonDep("org.springframework", "spring-context"))
     springClasspath(commonDep("org.springframework", "spring-tx"))
     springClasspath(commonDep("org.springframework", "spring-web"))
-}
 
-afterEvaluate {
+    testCompileOnly(intellijDep()) { includeJars("gson-2.5", "annotations", "trove4j", "openapi", "idea", "util", "jdom") }
-    dependencies {
+    testRuntime(intellijDep())
-        compileOnly(intellijCoreJar())
+    testCompile(intellijPluginDep("CSS"))
-        compileOnly(intellij { include("annotations.jar", "trove4j.jar", "openapi.jar", "idea.jar", "util.jar", "jdom.jar") })
+    testCompile(intellijPluginDep("DatabaseTools"))
-        compileOnly(intellijPlugin("CSS"))
+    testCompile(intellijPluginDep("JavaEE"))
-        compileOnly(intellijPlugin("DatabaseTools"))
+    testCompile(intellijPluginDep("jsp"))
-        compileOnly(intellijPlugin("JavaEE"))
+    testCompile(intellijPluginDep("PersistenceSupport"))
-        compileOnly(intellijPlugin("jsp"))
+    testCompile(intellijPluginDep("Spring"))
-        compileOnly(intellijPlugin("PersistenceSupport"))
+    testCompile(intellijPluginDep("properties"))
-        compileOnly(intellijPlugin("Spring"))
+    testCompile(intellijPluginDep("java-i18n"))
-        compileOnly(intellijPlugin("properties"))
+    testCompile(intellijPluginDep("gradle"))
-        compileOnly(intellijPlugin("java-i18n"))
+    testCompile(intellijPluginDep("Groovy"))
-        compileOnly(intellijPlugin("gradle"))
+    testCompile(intellijPluginDep("junit"))
-        compileOnly(intellijPlugin("Groovy"))
+    testCompile(intellijPluginDep("uml"))
-        compileOnly(intellijPlugin("junit"))
+    testCompile(intellijPluginDep("JavaScriptLanguage"))
-        compileOnly(intellijPlugin("uml"))
+    testCompile(intellijPluginDep("JavaScriptDebugger"))
-        compileOnly(intellijPlugin("JavaScriptLanguage"))
+    testCompile(intellijPluginDep("NodeJS"))
-        compileOnly(intellijPlugin("JavaScriptDebugger"))
+    testRuntime(intellijPluginDep("coverage"))
-        compileOnly(intellijPlugin("NodeJS"))
+    testRuntime(intellijPluginDep("maven"))
-        testCompileOnly(intellij { include("gson-*.jar", "annotations.jar", "trove4j.jar", "openapi.jar", "idea.jar", "util.jar", "jdom.jar") })
+    testRuntime(intellijPluginDep("android"))
-        testRuntime(intellij())
+    testRuntime(intellijPluginDep("testng"))
-        testCompile(intellijPlugin("CSS"))
+    testRuntime(intellijPluginDep("IntelliLang"))
-        testCompile(intellijPlugin("DatabaseTools"))
+    testRuntime(intellijPluginDep("copyright"))
-        testCompile(intellijPlugin("JavaEE"))
+    testRuntime(intellijPluginDep("java-decompiler"))
-        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"))
-        testRuntime(intellijPlugin("testng"))
-        testRuntime(intellijPlugin("IntelliLang"))
-        testRuntime(intellijPlugin("copyright"))
-        testRuntime(intellijPlugin("java-decompiler"))
-    }
 }
 
 val preparedResources = File(buildDir, "prepResources")

ultimate/ultimate-runner/build.gradle.kts

@@ -1,13 +1,19 @@
-import org.jetbrains.intellij.IntelliJPluginExtension
 import org.jetbrains.intellij.tasks.PrepareSandboxTask
 import org.jetbrains.intellij.tasks.RunIdeTask
 
-apply { plugin("kotlin") }
+buildscript {
-
+    repositories {
-configureIntellijPlugin {
+        maven(url = "https://oss.sonatype.org/content/repositories/snapshots/") // for intellij plugin
-    version = (rootProject.extra["versions.intellij"] as String).replaceFirst("IC-", "IU-")
+        maven(url = "http://dl.bintray.com/jetbrains/intellij-plugin-service") // for intellij plugin
+        jcenter()
+    }
+    dependencies {
+        classpath("org.jetbrains.intellij.plugins:gradle-intellij-plugin:0.3.0-SNAPSHOT")
+    }
 }
 
+apply { plugin("kotlin") }
+
 dependencies {
     compileOnly(project(":idea"))
     compileOnly(project(":idea:idea-maven"))
@@ -15,12 +21,7 @@ dependencies {
     compileOnly(project(":idea:idea-jvm"))
 
     runtimeOnly(files(toolsJar()))
-}
+    compileOnly(intellijDep())
-
-afterEvaluate {
-    dependencies {
-        compileOnly(intellij())
-    }
 }
 
 afterEvaluate {
@@ -44,7 +45,7 @@ afterEvaluate {
         dependsOn(prepareSandbox)
         group = "intellij"
         description = "Runs Intellij IDEA Ultimate with installed plugin."
-        setIdeaDirectory(the<IntelliJPluginExtension>().ideaDependency.classes)
+        setIdeaDirectory(intellijRootDir())
         setConfigDirectory(File(ideaUltimateSandboxDir, "config"))
         setSystemDirectory(ideaUltimateSandboxDir)
         setPluginsDirectory(ideaUltimatePluginDir.parent)