Fix dependencies rewriting and gradle integration tests after applying rewriting

buildSrc/src/main/kotlin/embeddable.kt

@@ -20,26 +20,87 @@ val packagesToRelocate =
                 "org.picocontainer",
                 "jline",
                 "gnu",
-                "javax.inject",
                 "org.fusesource")
 
-fun Project.embeddableCompiler(taskName: String = "embeddable", body: Jar.() -> Unit = {}): Jar {
+// The shaded compiler "dummy" is used to rewrite dependencies in projects that are used with the embeddable compiler
+// on the runtime and use some shaded dependencies from the compiler
+// To speed-up rewriting process we want to have this dummy as small as possible.
+// But due to the shadow plugin bug (https://github.com/johnrengelman/shadow/issues/262) it is not possible to use
+// packagesToRelocate list to for the include list. Therefore the exclude list has to be created.
+val packagesToExcludeFromDummy =
+        listOf("org/jetbrains/kotlin/**",
+               "org/intellij/lang/annotations/**",
+               "org/jetbrains/jps/**",
+               "META-INF/**",
+               "com/sun/jna/**",
+               "com/thoughtworks/xstream/**",
+               "javaslang/**",
+               "*.proto",
+               "messages/**",
+               "net/sf/cglib/**",
+               "one/util/streamex/**",
+               "org/iq80/snappy/**",
+               "org/jline/**",
+               "org/json/**",
+               "org/xmlpull/**",
+               "*.txt")
 
-    val compilerJar = configurations.create("compilerJar")
+private fun ShadowJar.configureEmbeddableCompilerRelocation(withJavaxInject: Boolean = true) {
+    relocate("com.google.protobuf", "org.jetbrains.kotlin.protobuf")
+    packagesToRelocate.forEach {
+        relocate(it, "$kotlinEmbeddableRootPackage.$it")
+    }
+    if (withJavaxInject) {
+        relocate("javax.inject", "$kotlinEmbeddableRootPackage.javax.inject")
+    }
+    relocate("org.fusesource", "$kotlinEmbeddableRootPackage.org.fusesource") {
+        // TODO: remove "it." after #KT-12848 get addressed
+        exclude("org.fusesource.jansi.internal.CLibrary")
+    }
+}
+
+private fun Project.compilerShadowJar(taskName: String, body: ShadowJar.() -> Unit): Jar {
+
+    val compilerJar = configurations.getOrCreate("compilerJar")
     dependencies.add(compilerJar.name, dependencies.project(":kotlin-compiler", configuration = "runtimeJar"))
 
     return task<ShadowJar>(taskName) {
         destinationDir = File(buildDir, "libs")
         duplicatesStrategy = DuplicatesStrategy.EXCLUDE
         from(compilerJar)
-        relocate("com.google.protobuf", "org.jetbrains.kotlin.protobuf")
-        packagesToRelocate.forEach {
-            relocate(it, "$kotlinEmbeddableRootPackage.$it")
+        body()
+    }
+}
+
+fun Project.embeddableCompiler(taskName: String = "embeddable", body: ShadowJar.() -> Unit = {}): Jar =
+        compilerShadowJar(taskName) {
+            configureEmbeddableCompilerRelocation()
+            body()
         }
-        relocate("org.fusesource", "$kotlinEmbeddableRootPackage.org.fusesource") {
-            // TODO: remove "it." after #KT-12848 get addressed
-            exclude("org.fusesource.jansi.internal.CLibrary")
+
+fun Project.compilerDummyForDependenciesRewriting(taskName: String = "compilerDummy", body: ShadowJar.() -> Unit = {}): Jar =
+        compilerShadowJar(taskName) {
+            exclude(packagesToExcludeFromDummy)
+            body()
         }
+
+const val COMPILER_DUMMY_JAR_CONFIGURATION_NAME = "compilerDummyJar"
+
+fun Project.compilerDummyJar(task: Jar, body: Jar.() -> Unit = {}) {
+    task.body()
+    addArtifact(COMPILER_DUMMY_JAR_CONFIGURATION_NAME, task, task)
+}
+
+fun Project.embeddableCompilerDummyForDependenciesRewriting(taskName: String = "embeddable", body: Jar.() -> Unit = {}): Jar {
+    val compilerDummyJar = configurations.getOrCreate("compilerDummyJar")
+    dependencies.add(compilerDummyJar.name,
+                     dependencies.project(":kotlin-compiler-embeddable", configuration = COMPILER_DUMMY_JAR_CONFIGURATION_NAME))
+
+    return task<ShadowJar>(taskName) {
+        destinationDir = File(buildDir, "libs")
+        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+        from(compilerDummyJar)
+        configureEmbeddableCompilerRelocation(withJavaxInject = false)
         body()
     }
 }
@@ -56,7 +117,7 @@ fun Project.rewriteDepsToShadedJar(originalJarTask: Jar, shadowJarTask: Zip, bod
         }
         shadowJarTask.apply {
             dependsOn(originalJarTask)
-            from(originalJarTask)
+            from(originalJarTask)// { include("**") }
             classifier = "shadow"
         }
         dependsOn(shadowJarTask)
@@ -65,4 +126,5 @@ fun Project.rewriteDepsToShadedJar(originalJarTask: Jar, shadowJarTask: Zip, bod
     }
 }
 
-fun Project.rewriteDepsToShadedCompiler(originalJarTask: Jar, body: Jar.() -> Unit = {}): Jar = rewriteDepsToShadedJar(originalJarTask, embeddableCompiler(), body)
+fun Project.rewriteDepsToShadedCompiler(originalJarTask: Jar, body: Jar.() -> Unit = {}): Jar =
+        rewriteDepsToShadedJar(originalJarTask, embeddableCompilerDummyForDependenciesRewriting(), body)