From 87af14849da72179cad0aaf5ca30c325b3ee1da9 Mon Sep 17 00:00:00 2001 From: Vyacheslav Gerasimov Date: Fri, 26 Oct 2018 18:25:22 +0300 Subject: [PATCH] as34: Restore compatibility with 183 platform in AS 3.4 --- .../idea/run/runConfigurationsCompat.kt.as34 | 29 ++++ prepare/compiler/build.gradle.kts.as34 | 155 ++++++++++++++++++ 2 files changed, 184 insertions(+) create mode 100644 idea/idea-jvm/src/org/jetbrains/kotlin/idea/run/runConfigurationsCompat.kt.as34 create mode 100644 prepare/compiler/build.gradle.kts.as34 diff --git a/idea/idea-jvm/src/org/jetbrains/kotlin/idea/run/runConfigurationsCompat.kt.as34 b/idea/idea-jvm/src/org/jetbrains/kotlin/idea/run/runConfigurationsCompat.kt.as34 new file mode 100644 index 00000000000..76daf1f43e5 --- /dev/null +++ b/idea/idea-jvm/src/org/jetbrains/kotlin/idea/run/runConfigurationsCompat.kt.as34 @@ -0,0 +1,29 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +@file:Suppress("IncompatibleAPI") + +package org.jetbrains.kotlin.idea.run + +import com.intellij.execution.configurations.LocatableConfigurationBase +import com.intellij.execution.configurations.ModuleBasedConfiguration +import com.intellij.execution.configurations.RunConfigurationBase +import org.jdom.Element + +// Generalized in 183 +// BUNCH: 183 +typealias RunConfigurationBaseAny = RunConfigurationBase + +// Generalized in 183 +// BUNCH: 183 +typealias ModuleBasedConfigurationAny = ModuleBasedConfiguration<*> + +// Generalized in 183 +// BUNCH: 183 +typealias LocatableConfigurationBaseAny = LocatableConfigurationBase + +// Generalized in 183 +// BUNCH: 183 +typealias ModuleBasedConfigurationElement = ModuleBasedConfiguration \ No newline at end of file diff --git a/prepare/compiler/build.gradle.kts.as34 b/prepare/compiler/build.gradle.kts.as34 new file mode 100644 index 00000000000..956f38d7da1 --- /dev/null +++ b/prepare/compiler/build.gradle.kts.as34 @@ -0,0 +1,155 @@ +import java.io.File +import proguard.gradle.ProGuardTask +import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar +import org.gradle.api.artifacts.maven.Conf2ScopeMappingContainer.COMPILE +import org.gradle.api.file.DuplicatesStrategy + +description = "Kotlin Compiler" + +plugins { + // HACK: java plugin makes idea import dependencies on this project as source (with empty sources however), + // this prevents reindexing of kotlin-compiler.jar after build on every change in compiler modules + java +} + +// You can run Gradle with "-Pkotlin.build.proguard=true" to enable ProGuard run on kotlin-compiler.jar (on TeamCity, ProGuard always runs) +val shrink = + findProperty("kotlin.build.proguard")?.toString()?.toBoolean() + ?: hasProperty("teamcity") + +val compilerManifestClassPath = "kotlin-stdlib.jar kotlin-reflect.jar kotlin-script-runtime.jar" + +val fatJarContents by configurations.creating + +val fatJarContentsStripMetadata by configurations.creating +val fatJarContentsStripServices by configurations.creating +val fatSourcesJarContents by configurations.creating +val fatJar by configurations.creating +val compilerJar by configurations.creating +val runtimeJar by configurations.creating +val compile by configurations // maven plugin writes pom compile scope from compile configuration by default +val libraries by configurations.creating { + extendsFrom(compile) +} + +val default by configurations +default.extendsFrom(runtimeJar) + +val compilerBaseName = name + +val outputJar = fileFrom(buildDir, "libs", "$compilerBaseName.jar") + +val compilerModules: Array by rootProject.extra + +compilerModules.forEach { evaluationDependsOn(it) } + +val compiledModulesSources = compilerModules.map { + project(it).mainSourceSet.allSource +} + +dependencies { + compile(project(":kotlin-stdlib")) + compile(project(":kotlin-script-runtime")) + compile(project(":kotlin-reflect")) + + libraries(project(":kotlin-annotations-jvm")) + libraries( + files( + firstFromJavaHomeThatExists("jre/lib/rt.jar", "../Classes/classes.jar"), + firstFromJavaHomeThatExists("jre/lib/jsse.jar", "../Classes/jsse.jar"), + toolsJar() + ) + ) + + compilerModules.forEach { + fatJarContents(project(it)) { isTransitive = false } + } + + compiledModulesSources.forEach { + fatSourcesJarContents(it) + } + + fatJarContents(project(":core:builtins", configuration = "builtins")) + fatJarContents(commonDep("javax.inject")) + fatJarContents(commonDep("org.jline", "jline")) + fatJarContents(commonDep("org.fusesource.jansi", "jansi")) + fatJarContents(protobufFull()) + fatJarContents(commonDep("com.google.code.findbugs", "jsr305")) + fatJarContents(commonDep("io.javaslang", "javaslang")) + fatJarContents(commonDep("org.jetbrains.kotlinx", "kotlinx-coroutines-core")) { isTransitive = false } + + fatJarContents(intellijCoreDep()) { includeJars("intellij-core") } + fatJarContents(intellijDep()) { includeIntellijCoreJarDependencies(project, { !(it.startsWith("jdom") || it.startsWith("log4j")) }) } + fatJarContents(intellijDep()) { includeJars("jna-platform", "lz4-1.3.0") } + fatJarContentsStripServices(intellijDep("jps-standalone")) { includeJars("jps-model") } + fatJarContentsStripMetadata(intellijDep()) { includeJars("oro-2.0.8", "jdom", "log4j" ) } +} + +noDefaultJar() + +val packCompiler by task { + configurations = listOf(fatJar) + setDuplicatesStrategy(DuplicatesStrategy.EXCLUDE) + destinationDir = File(buildDir, "libs") + + setupPublicJar(compilerBaseName, "before-proguard") + + from(fatJarContents) + + dependsOn(fatJarContentsStripServices) + from { + fatJarContentsStripServices.files.map { + zipTree(it).matching { exclude("META-INF/services/**") } + } + } + + dependsOn(fatJarContentsStripMetadata) + from { + fatJarContentsStripMetadata.files.map { + zipTree(it).matching { exclude("META-INF/jb/**", "META-INF/LICENSE") } + } + } + + manifest.attributes["Class-Path"] = compilerManifestClassPath + manifest.attributes["Main-Class"] = "org.jetbrains.kotlin.cli.jvm.K2JVMCompiler" +} + +val proguard by task { + dependsOn(packCompiler) + configuration("$rootDir/compiler/compiler.pro") + + val outputJar = fileFrom(buildDir, "libs", "$compilerBaseName-after-proguard.jar") + + inputs.files(packCompiler.outputs.files.singleFile) + outputs.file(outputJar) + + // TODO: remove after dropping compatibility with ant build + doFirst { + System.setProperty("kotlin-compiler-jar-before-shrink", packCompiler.outputs.files.singleFile.canonicalPath) + System.setProperty("kotlin-compiler-jar", outputJar.canonicalPath) + } + + libraryjars(mapOf("filter" to "!META-INF/versions/**"), libraries) + + printconfiguration("$buildDir/compiler.pro.dump") +} + +val pack = if (shrink) proguard else packCompiler + +dist( + targetName = "$compilerBaseName.jar", + fromTask = pack +) + +runtimeJarArtifactBy(pack, pack.outputs.files.singleFile) { + name = compilerBaseName + classifier = "" +} + +sourcesJar { + from(fatSourcesJarContents) +} + +javadocJar() + +publish()