Sergey Bogolepov
7dc48b3837
This subproject covers much wider scope now than code coverage, so it makes sense to rename it to reflex that.
781 lines
26 KiB
Groovy
781 lines
26 KiB
Groovy
/*
|
|
* Copyright 2010-2017 JetBrains s.r.o.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
import kotlin.text.Regex
|
|
import org.jetbrains.kotlin.konan.target.*
|
|
import org.jetbrains.kotlin.konan.util.*
|
|
import org.jetbrains.kotlin.CopySamples
|
|
import org.jetbrains.kotlin.CopyCommonSources
|
|
import org.jetbrains.kotlin.PlatformInfo
|
|
import org.jetbrains.kotlin.KotlinBuildPusher
|
|
import org.jetbrains.kotlin.CollisionDetector
|
|
import org.jetbrains.kotlin.CollisionTransformer
|
|
import org.jetbrains.kotlin.CompilationDatabaseKt
|
|
import org.jetbrains.kotlin.CompareDistributionSignatures
|
|
import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
|
|
import org.apache.tools.ant.filters.ReplaceTokens
|
|
import org.jetbrains.kotlin.UtilsKt
|
|
import java.util.concurrent.ConcurrentHashMap
|
|
|
|
buildscript {
|
|
apply from: "gradle/kotlinGradlePlugin.gradle"
|
|
|
|
repositories {
|
|
if (UtilsKt.getCacheRedirectorEnabled(project)) {
|
|
maven { url "https://cache-redirector.jetbrains.com/maven-central" }
|
|
maven { url "https://cache-redirector.jetbrains.com/jcenter" }
|
|
}
|
|
else {
|
|
mavenCentral()
|
|
jcenter()
|
|
}
|
|
gradlePluginPortal()
|
|
}
|
|
|
|
dependencies {
|
|
//classpath project(":kotlin-native-utils")
|
|
classpath 'gradle.plugin.com.github.johnrengelman:shadow:7.1.2'
|
|
}
|
|
}
|
|
import org.jetbrains.kotlin.konan.*
|
|
|
|
// Allows generating wrappers for the root build and all the samples during execution of the default 'wrapper' task.
|
|
// Run './gradlew wrapper --gradle-version <version>' to update all the wrappers.
|
|
//apply plugin: org.jetbrains.kotlin.GradleWrappers
|
|
//
|
|
//wrappers.projects = ['samples', 'samples/calculator', 'samples/cocoapods/kotlin-library']
|
|
//wrapper.distributionType = Wrapper.DistributionType.ALL
|
|
|
|
// FIXME: Remove until IDEA-231214 is fixed.
|
|
//defaultTasks 'clean', 'dist'
|
|
|
|
convention.plugins.platformInfo = PlatformInfo
|
|
|
|
if (isMac()) {
|
|
checkXcodeVersion(project)
|
|
}
|
|
|
|
ext {
|
|
distDir = UtilsKt.getKotlinNativeDist(project)
|
|
dependenciesDir = DependencyProcessor.defaultDependenciesRoot
|
|
experimentalEnabled = project.hasProperty("org.jetbrains.kotlin.native.experimentalTargets")
|
|
platformManager = new PlatformManager(DistributionKt.buildDistribution(projectDir.absolutePath),
|
|
ext.experimentalEnabled)
|
|
|
|
cacheableTargetNames = platformManager.hostPlatform.cacheableTargets
|
|
cacheableTargets = cacheableTargetNames.collect { platformManager.targetByName(it) }
|
|
|
|
// Some targets miss zlib in their sysroots.
|
|
// We skip these targets when generate a corresponding platform library.
|
|
// See also: the :distDef task, targetDefFiles in the :platformLibs project.
|
|
targetsWithoutZlib = [
|
|
KonanTarget.LINUX_MIPS32.INSTANCE,
|
|
KonanTarget.LINUX_MIPSEL32.INSTANCE
|
|
]
|
|
|
|
kotlinCompilerModule= [path: ":kotlin-compiler", configuration: "runtimeElements"]
|
|
kotlinStdLibModule= project(":kotlin-stdlib")
|
|
kotlinReflectModule= project(":kotlin-reflect")
|
|
kotlinScriptRuntimeModule= project(":kotlin-script-runtime")
|
|
kotlinUtilKliMetadatabModule= project(":kotlin-util-klib-metadata")
|
|
|
|
konanVersionFull = ext.kotlinNativeVersion
|
|
gradlePluginVersion = konanVersionFull
|
|
|
|
// A separate map for each build for automatic cleaning the daemon after the build have finished.
|
|
toolClassLoadersMap = new ConcurrentHashMap<Object, URLClassLoader>()
|
|
}
|
|
|
|
allprojects {
|
|
buildscript {
|
|
repositories {
|
|
if (UtilsKt.getCacheRedirectorEnabled(project))
|
|
maven { url 'https://cache-redirector.jetbrains.com/jcenter' }
|
|
else
|
|
jcenter()
|
|
}
|
|
}
|
|
if (path != ":kotlin-native:dependencies") {
|
|
evaluationDependsOn(":kotlin-native:dependencies")
|
|
}
|
|
|
|
repositories {
|
|
if (UtilsKt.getCacheRedirectorEnabled(project))
|
|
maven { url 'https://cache-redirector.jetbrains.com/maven-central' }
|
|
else
|
|
mavenCentral()
|
|
maven {
|
|
url project.bootstrapKotlinRepo
|
|
}
|
|
}
|
|
|
|
setupHostAndTarget()
|
|
loadCommandLineProperties()
|
|
loadLocalProperties()
|
|
setupClang(project)
|
|
}
|
|
|
|
void setupHostAndTarget() {
|
|
ext.hostName = platformManager.hostName
|
|
ext.targetList = platformManager.enabled.collect { it.visibleName } as List
|
|
ext.konanTargetList = platformManager.enabled as List
|
|
}
|
|
|
|
void setupClang(Project project) {
|
|
project.extensions.platformManager = project.project(":kotlin-native").ext.platformManager
|
|
project.extensions.execClang = org.jetbrains.kotlin.ExecClang.create(project)
|
|
}
|
|
|
|
void loadLocalProperties() {
|
|
if (new File("$project.rootDir/local.properties").exists()) {
|
|
Properties props = new Properties()
|
|
props.load(new FileInputStream("$project.rootDir/local.properties"))
|
|
props.each { prop -> project.ext.set(prop.key, prop.value) }
|
|
}
|
|
}
|
|
|
|
void loadCommandLineProperties() {
|
|
if (project.hasProperty("konanc_flags")) {
|
|
throw new Error("Specify either -Ptest_flags or -Pbuild_flags.")
|
|
}
|
|
ext.globalBuildArgs = project.hasProperty("build_flags") ? ext.build_flags.split() : []
|
|
ext.globalTestArgs = project.hasProperty("test_flags") ? ext.test_flags.split() : []
|
|
ext.testTarget = project.hasProperty("test_target") ? ext.test_target : null
|
|
}
|
|
|
|
configurations {
|
|
ftpAntTask
|
|
distPack
|
|
commonSources
|
|
}
|
|
|
|
dependencies {
|
|
ftpAntTask 'org.apache.ant:ant-commons-net:1.9.9'
|
|
distPack project(':kotlin-native:Interop:Runtime')
|
|
distPack project(':kotlin-native:Interop:Indexer')
|
|
distPack project(':kotlin-native:Interop:StubGenerator')
|
|
distPack project(':kotlin-native:Interop:Skia')
|
|
distPack project(':kotlin-native:backend.native')
|
|
distPack project(':kotlin-native:utilities:cli-runner')
|
|
distPack project(':kotlin-native:utilities:basic-utils')
|
|
distPack project(':kotlin-native:klib')
|
|
distPack project(path: ':kotlin-native:endorsedLibraries:kotlinx.cli', configuration: "jvmRuntimeElements")
|
|
//distPack "org.jetbrains.kotlin:kotlin-native-shared:$konanVersion"
|
|
commonSources project(path: ':kotlin-stdlib-common', configuration: 'sources')
|
|
commonSources project(path: ':kotlin-test:kotlin-test-common', configuration: 'sources')
|
|
commonSources project(path: ':kotlin-test:kotlin-test-annotations-common', configuration: 'sources')
|
|
}
|
|
|
|
//task sharedJar {
|
|
// dependsOn gradle.includedBuild('shared').task(':jar')
|
|
//}
|
|
|
|
//task gradlePluginJar {
|
|
// dependsOn gradle.includedBuild('kotlin-native-gradle-plugin').task(':shadowJar')
|
|
//}
|
|
|
|
//task gradlePluginCheck {
|
|
// dependsOn gradle.includedBuild('kotlin-native-gradle-plugin').task(':check')
|
|
//}
|
|
|
|
task dist_compiler(dependsOn: "distCompiler")
|
|
task dist_runtime(dependsOn: "distRuntime")
|
|
task cross_dist(dependsOn: "crossDist")
|
|
task list_dist(dependsOn: "listDist")
|
|
task build {
|
|
dependsOn ':dist', ':distPlatformLibs'
|
|
}
|
|
|
|
task distCommonSources(type: CopyCommonSources) {
|
|
outputDir "$distDir/sources"
|
|
sourcePaths configurations.commonSources
|
|
zipSources true
|
|
}
|
|
|
|
task distNativeSources(type: Zip) {
|
|
destinationDirectory = file("$distDir/sources")
|
|
archiveFileName = "kotlin-stdlib-native-sources.zip"
|
|
|
|
includeEmptyDirs = false
|
|
include('**/*.kt')
|
|
|
|
from(project(':kotlin-native:runtime').file('src/main/kotlin'))
|
|
from(project(":kotlin-stdlib-common").file('../native-wasm/src/'))
|
|
from(project(':kotlin-native:Interop:Runtime').file('src/main/kotlin'))
|
|
from(project(':kotlin-native:Interop:Runtime').file('src/native/kotlin'))
|
|
from(project(':kotlin-native:Interop:JsRuntime').file('src/main/kotlin')) {
|
|
into('kotlinx/wasm/jsinterop')
|
|
}
|
|
}
|
|
|
|
task distEndorsedSources {
|
|
dependsOn(':kotlin-native:endorsedLibraries:endorsedLibsSources')
|
|
}
|
|
|
|
task distSources {
|
|
dependsOn(distCommonSources)
|
|
dependsOn(distNativeSources)
|
|
dependsOn(distEndorsedSources)
|
|
}
|
|
|
|
task shadowJar(type: ShadowJar) {
|
|
mergeServiceFiles()
|
|
destinationDirectory.set(file("$distDir/konan/lib"))
|
|
archiveBaseName.set("kotlin-native")
|
|
// Exclude trove4j because of license agreement.
|
|
exclude "*trove4j*"
|
|
exclude("META-INF/versions/9/module-info.class")
|
|
configurations = [project.configurations.distPack]
|
|
archiveClassifier.set(null)
|
|
outputs.upToDateWhen {
|
|
archiveFile.getOrNull()?.asFile.exists() ?: false
|
|
}
|
|
}
|
|
|
|
task distCompiler(type: Copy) {
|
|
// Workaround: make distCompiler no-op if we are using custom dist:
|
|
// the dist is already in place and has the compiler, so we don't have to
|
|
// build and copy the compiler to dist.
|
|
// Moreover, if we do copy it, it might overwrite the compiler files already loaded
|
|
// by this Gradle process (including the jar loaded to the custom classloader),
|
|
// causing hard-to-debug errors.
|
|
if (!UtilsKt.isDefaultNativeHome(project)) {
|
|
enabled = false
|
|
} else {
|
|
dependsOn ":kotlin-native:dependencies:update"
|
|
dependsOn ':kotlin-native:shadowJar'
|
|
dependsOn ":kotlin-native-compiler-embeddable:kotlin-native-compiler-embeddable"
|
|
}
|
|
|
|
destinationDir distDir
|
|
|
|
from(project(':kotlin-native:backend.native').file("build/nativelibs/$hostName")) {
|
|
into('konan/nativelib')
|
|
}
|
|
|
|
from(project(':kotlin-native:backend.native').file('build/external_jars/trove4j.jar')) {
|
|
into('konan/lib')
|
|
}
|
|
|
|
from(project(":kotlin-native-compiler-embeddable").file("build/libs")) {
|
|
into("konan/lib")
|
|
}
|
|
|
|
from(project(':kotlin-native:Interop').file('Indexer/build/nativelibs')) {
|
|
into('konan/nativelib')
|
|
}
|
|
|
|
from(project(':kotlin-native:Interop').file('Runtime/build/nativelibs')) {
|
|
into('konan/nativelib')
|
|
}
|
|
|
|
from(project(':kotlin-native:libllvmext').file('build/libs/llvmext/shared')) {
|
|
into('konan/nativelib')
|
|
}
|
|
|
|
from(project(':kotlin-native:llvmDebugInfoC').file('build/libs/debugInfo/shared')) {
|
|
into('konan/nativelib')
|
|
}
|
|
|
|
from(project(':kotlin-native:llvmDebugInfoC').file('src/scripts/konan_lldb.py')) {
|
|
into('tools')
|
|
}
|
|
|
|
from(project(':kotlin-native:utilities').file('env_blacklist')) {
|
|
into('tools')
|
|
}
|
|
|
|
from(file('cmd')) {
|
|
fileMode(0755)
|
|
into('bin')
|
|
if (!PlatformInfo.isWindows()) {
|
|
exclude('**/*.bat')
|
|
}
|
|
}
|
|
|
|
from(project.file('konan')) {
|
|
into('konan')
|
|
exclude('**/*.properties')
|
|
}
|
|
|
|
from(project.file('konan')) {
|
|
into('konan')
|
|
include('**/*.properties')
|
|
filter(ReplaceTokens, tokens: [compilerVersion: konanVersionFull.toString()])
|
|
// Set LLVM variant that will be used by default in the distribution.
|
|
// `user` - smaller, includes only necessary components.
|
|
// `dev` - bigger, includes (almost) every possible component. Use this one,
|
|
// if your feature requires component that is not a part of user distribution (yet).
|
|
// Note: by default konan.properties use `dev` variant because it is needed for building our LLVM dynamic library.
|
|
String llvmVariant = 'user'
|
|
filter(ReplaceTokens,
|
|
beginToken: '$',
|
|
endToken: '',
|
|
tokens: [("llvm.${hostName}.dev".toString()): "\$llvm.${hostName}.${llvmVariant}".toString()]
|
|
)
|
|
}
|
|
if (experimentalEnabled) {
|
|
file('konan/experimentalTargetsEnabled').text = ""
|
|
} else {
|
|
delete('konan/experimentalTargetsEnabled')
|
|
}
|
|
}
|
|
|
|
task distDef(type: Copy) {
|
|
destinationDir project.file("$distDir/konan/platformDef/")
|
|
|
|
platformManager.targetValues.each { target ->
|
|
from(project(":kotlin-native:platformLibs").file("src/platform/${target.family.name().toLowerCase()}")) {
|
|
into target.visibleName
|
|
include '**/*.def'
|
|
if (target in targetsWithoutZlib) {
|
|
exclude '**/zlib.def'
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
task listDist(type: Exec) {
|
|
commandLine 'find', distDir
|
|
}
|
|
|
|
task distRuntime(type: Copy) {
|
|
dependsOn "${hostName}CrossDistRuntime"
|
|
}
|
|
|
|
task distEndorsedLibraries {
|
|
dependsOn "${hostName}CrossDistEndorsedLibraries"
|
|
}
|
|
|
|
task distStdlibCache {
|
|
if (hostName in cacheableTargetNames) {
|
|
dependsOn("${hostName}StdlibCache")
|
|
}
|
|
}
|
|
|
|
task distEndorsedCache {
|
|
if (hostName in cacheableTargetNames) {
|
|
dependsOn("${hostName}EndorsedCache")
|
|
}
|
|
}
|
|
|
|
def stdlib = 'klib/common/stdlib'
|
|
def stdlibDefaultComponent = "$stdlib/default"
|
|
def endorsedLibs = 'klib/common/endorsedLibraries'
|
|
def endorsedLibsBase = 'klib/common'
|
|
|
|
task crossDistRuntime {
|
|
dependsOn.addAll(targetList.collect { "${it}CrossDistRuntime" })
|
|
}
|
|
|
|
task crossDistEndorsedLibraries {
|
|
dependsOn.addAll(targetList.collect { "${it}CrossDistEndorsedLibraries" })
|
|
}
|
|
|
|
task crossDistPlatformLibs {
|
|
dependsOn.addAll(targetList.collect { "${it}PlatformLibs" })
|
|
}
|
|
|
|
task crossDistStdlib {
|
|
dependsOn.addAll(targetList.collect { "${it}CrossDistStdlib" })
|
|
}
|
|
|
|
task crossDistStdlibCache {
|
|
dependsOn.addAll(targetList.findAll { it in cacheableTargetNames }.collect { "${it}StdlibCache" })
|
|
}
|
|
|
|
task crossDistEndorsedCache {
|
|
dependsOn.addAll(targetList.findAll { it in cacheableTargetNames }.collect { "${it}EndorsedCache" })
|
|
}
|
|
|
|
def endorsedLibsCopyTask = task("crossDistEndorsedLibrariesCopy", type: Copy) {
|
|
destinationDir project.file("$distDir/$endorsedLibsBase")
|
|
|
|
from(project(':kotlin-native:endorsedLibraries').file("build")) {
|
|
include('**')
|
|
exclude('cache')
|
|
}
|
|
}
|
|
|
|
targetList.each { target ->
|
|
task("${target}CrossDistStdlib", type: Copy) {
|
|
dependsOn ":kotlin-native:runtime:${target}Stdlib"
|
|
// TODO: add explicit dependency on host task with IR klib stdlib parts
|
|
// As for now it is possibly to build up distribution from the tc-dist to crossdist
|
|
// by request of tests that need cross-targets or platform libs. It may create undesired
|
|
// issues with overwriting the file being used by the concurrent build/test.
|
|
// This building (by request) should be turned off when this to-do is fixed.
|
|
// if (target != hostName) {
|
|
// dependsOn ":kotlin-native:${hostName}CrossDistStdlib"
|
|
// }
|
|
|
|
destinationDir project.file("$distDir/$stdlib")
|
|
|
|
from(project(':kotlin-native:runtime').file("build/${target}Stdlib")) {
|
|
if (target == hostName) {
|
|
include('**')
|
|
} else {
|
|
// We don't want to rewrite stdlib parts as they are the same and may be already used
|
|
// by the other build phases like caching or endorsed libraries.
|
|
include('*/targets/**')
|
|
include('*/manifest')
|
|
}
|
|
eachFile {
|
|
if (name == 'manifest') {
|
|
def existingManifest = file("$destinationDir/$path")
|
|
if (existingManifest.exists()) {
|
|
UtilsKt.mergeManifestsByTargets(project, file, existingManifest)
|
|
exclude()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
duplicatesStrategy = DuplicatesStrategy.EXCLUDE
|
|
}
|
|
|
|
task("${target}CrossDistBitcodeCopy", type: Copy) {
|
|
dependsOn ":kotlin-native:runtime:${target}Runtime"
|
|
|
|
destinationDir project.file("$distDir/konan/targets/")
|
|
|
|
from(project(':kotlin-native:runtime').file("build/bitcode/main/$target")) {
|
|
include("*.bc")
|
|
exclude("runtime.bc")
|
|
into("$target/native")
|
|
}
|
|
}
|
|
|
|
task("${target}CrossDistRuntime", type: Copy) {
|
|
dependsOn ":kotlin-native:runtime:${target}Runtime"
|
|
dependsOn ":kotlin-native:${target}CrossDistStdlib"
|
|
dependsOn "${target}CrossDistBitcodeCopy"
|
|
|
|
destinationDir project.file("$distDir/$stdlibDefaultComponent")
|
|
|
|
if (target == 'wasm32') {
|
|
into("targets/wasm32/included") {
|
|
from(project(':kotlin-native:runtime').file('src/main/js'))
|
|
from(project(':kotlin-native:runtime').file('src/launcher/js'))
|
|
from(project(':kotlin-native:Interop:JsRuntime').file('src/main/js'))
|
|
}
|
|
}
|
|
}
|
|
|
|
task("${target}PlatformLibs") {
|
|
dependsOn ":kotlin-native:platformLibs:${target}Install"
|
|
if (target in cacheableTargetNames) {
|
|
dependsOn(":kotlin-native:platformLibs:${target}Cache")
|
|
}
|
|
}
|
|
|
|
if (target in cacheableTargetNames) {
|
|
task ("${target}StdlibCache", type: Copy) {
|
|
dependsOn "${target}CrossDistStdlib"
|
|
dependsOn ":kotlin-native:runtime:${target}StdlibCache"
|
|
|
|
destinationDir project.file("$distDir/klib/cache/")
|
|
|
|
from("${project(":kotlin-native:runtime").buildDir}/cache/$target") {
|
|
include('**')
|
|
}
|
|
}
|
|
|
|
task ("${target}EndorsedCache", type: Copy) {
|
|
dependsOn "${target}CrossDistStdlib"
|
|
dependsOn ":kotlin-native:endorsedLibraries:${target}Cache"
|
|
|
|
destinationDir project.file("$distDir/klib/cache")
|
|
|
|
from("${project(':kotlin-native:endorsedLibraries').buildDir}/cache/$target") {
|
|
include('**')
|
|
}
|
|
}
|
|
}
|
|
|
|
task("${target}CrossDist") {
|
|
dependsOn "${target}CrossDistRuntime", "distCompiler"
|
|
dependsOn "${target}CrossDistEndorsedLibraries"
|
|
if (target in cacheableTargetNames) {
|
|
dependsOn "${target}StdlibCache", "${target}EndorsedCache"
|
|
}
|
|
}
|
|
|
|
task("${target}CrossDistEndorsedLibraries") {
|
|
def endorsedLibsBuildTask = ":kotlin-native:endorsedLibraries:${target}EndorsedLibraries"
|
|
dependsOn endorsedLibsBuildTask
|
|
dependsOn endorsedLibsCopyTask
|
|
// There is only one copy task for endorsed libs, because they are already copied into a single dir,
|
|
// while having target-tasks will make Gradle issue warnings on incorrect inputs and outputs usage.
|
|
// So this copy task should run after the all build tasks.
|
|
endorsedLibsCopyTask.mustRunAfter(endorsedLibsBuildTask)
|
|
}
|
|
}
|
|
|
|
task distPlatformLibs {
|
|
dependsOn ':kotlin-native:platformLibs:hostInstall'
|
|
dependsOn ':kotlin-native:platformLibs:hostCache'
|
|
}
|
|
|
|
task dist {
|
|
dependsOn "distCompiler",
|
|
"distRuntime",
|
|
"distEndorsedLibraries",
|
|
"distDef",
|
|
"distStdlibCache",
|
|
"distEndorsedCache"
|
|
}
|
|
|
|
task crossDist {
|
|
dependsOn "distCompiler",
|
|
"crossDistRuntime",
|
|
"crossDistEndorsedLibraries",
|
|
"distDef",
|
|
"crossDistStdlib",
|
|
"crossDistStdlibCache",
|
|
"crossDistEndorsedCache"
|
|
}
|
|
|
|
task bundle {
|
|
dependsOn 'bundleRegular', 'bundlePrebuilt'
|
|
}
|
|
|
|
task bundleRegular(type: (isWindows()) ? Zip : Tar) {
|
|
def simpleOsName = HostManager.platformName()
|
|
archiveBaseName.set("kotlin-native-$simpleOsName-$konanVersionFull")
|
|
from(UtilsKt.getKotlinNativeDist(project)) {
|
|
include '**'
|
|
exclude 'dependencies'
|
|
exclude 'klib/testLibrary'
|
|
// Don't include platform libraries into the bundle (generate them at the user side instead).
|
|
exclude 'klib/platform'
|
|
// Exclude platform libraries caches too. Keep caches for stdlib and endorsed libs.
|
|
exclude 'klib/cache/*/org.jetbrains.kotlin.native.platform.*/**'
|
|
into archiveBaseName
|
|
}
|
|
}
|
|
|
|
task bundlePrebuilt(type: (isWindows()) ? Zip : Tar) {
|
|
dependsOn("crossDistPlatformLibs")
|
|
def simpleOsName = HostManager.platformName()
|
|
archiveBaseName.set("kotlin-native-prebuilt-$simpleOsName-$konanVersionFull")
|
|
from(UtilsKt.getKotlinNativeDist(project)) {
|
|
include '**'
|
|
exclude 'dependencies'
|
|
exclude 'klib/testLibrary'
|
|
into archiveBaseName
|
|
}
|
|
}
|
|
|
|
void configurePackingLicensesToBundle(AbstractArchiveTask task, boolean containsPlatformLibraries) {
|
|
task.from(project.projectDir) {
|
|
include 'licenses/**'
|
|
if (!containsPlatformLibraries || !isMac()) {
|
|
exclude '**/xcode_license.pdf'
|
|
}
|
|
into task.archiveBaseName
|
|
}
|
|
|
|
task.from(project.rootProject.file("license")) {
|
|
into "${task.archiveBaseName.get()}/licenses"
|
|
}
|
|
}
|
|
|
|
configurePackingLicensesToBundle(bundleRegular, /* containsPlatformLibraries = */ false)
|
|
configurePackingLicensesToBundle(bundlePrebuilt, /* containsPlatformLibraries = */ true)
|
|
|
|
configure([bundleRegular, bundlePrebuilt]) {
|
|
dependsOn("crossDist")
|
|
dependsOn("crossDistStdlibCache")
|
|
dependsOn("crossDistEndorsedCache")
|
|
dependsOn("distSources")
|
|
dependsOn("distDef")
|
|
from(project.projectDir) {
|
|
include 'RELEASE_NOTES.md'
|
|
into baseName
|
|
}
|
|
|
|
destinationDirectory.set(file('.'))
|
|
|
|
if (isWindows()) {
|
|
zip64 true
|
|
} else {
|
|
archiveExtension.set('tar.gz')
|
|
compression = Compression.GZIP
|
|
}
|
|
}
|
|
|
|
task 'tc-dist'(type: (isWindows()) ? Zip : Tar) {
|
|
dependsOn('dist')
|
|
dependsOn('distSources')
|
|
def simpleOsName = HostManager.platformName()
|
|
archiveBaseName.set("kotlin-native-dist-$simpleOsName-$konanVersionFull")
|
|
from(UtilsKt.getKotlinNativeDist(project)) {
|
|
include '**'
|
|
exclude 'dependencies'
|
|
into archiveBaseName
|
|
}
|
|
|
|
destinationDirectory.set(file('.'))
|
|
|
|
if (isWindows()) {
|
|
zip64 true
|
|
} else {
|
|
archiveExtension.set('tar.gz')
|
|
compression = Compression.GZIP
|
|
}
|
|
}
|
|
|
|
task samples {
|
|
dependsOn 'samplesZip', 'samplesTar'
|
|
}
|
|
|
|
task samplesZip(type: Zip)
|
|
task samplesTar(type: Tar) {
|
|
extension = 'tar.gz'
|
|
compression = Compression.GZIP
|
|
}
|
|
|
|
configure([samplesZip, samplesTar]) {
|
|
baseName "kotlin-native-samples-$konanVersionFull"
|
|
destinationDir = projectDir
|
|
into(baseName)
|
|
|
|
from(file('samples')) {
|
|
// Process properties files separately.
|
|
exclude '**/gradle.properties'
|
|
}
|
|
|
|
from(project.projectDir) {
|
|
include 'licenses/**'
|
|
}
|
|
|
|
from(file('samples')) {
|
|
include '**/gradle.properties'
|
|
filter {
|
|
it.startsWith('org.jetbrains.kotlin.native.home=') || it.startsWith('# Use custom Kotlin/Native home:') ? null : it
|
|
}
|
|
}
|
|
|
|
// Exclude build artifacts.
|
|
exclude '**/build'
|
|
exclude '**/.gradle'
|
|
exclude '**/.idea'
|
|
exclude '**/*.kt.bc-build/'
|
|
}
|
|
|
|
project.tasks.register("copy_samples") {
|
|
dependsOn 'copySamples'
|
|
}
|
|
project.tasks.register("copySamples", CopySamples) {
|
|
destinationDir file('build/samples-under-test')
|
|
}
|
|
|
|
task uploadBundle {
|
|
dependsOn ':kotlin-native:bundle'
|
|
if (isMac()) {
|
|
dependsOn ':kotlin-native:bundleRestricted'
|
|
}
|
|
doLast {
|
|
def kind = (konanVersionFull.meta == MetaVersion.DEV) ? "dev" : "releases"
|
|
def ftpSettings = [
|
|
server: project.findProperty("cdnUrl") ?: System.getenv("CDN_URL"),
|
|
userid: project.findProperty("cdnUser") ?: System.getenv("CDN_USER"),
|
|
password: project.findProperty("cdnPass") ?: System.getenv("CDN_PASS"),
|
|
remoteDir: "/builds/$kind/$konanVersion/${HostManager.platformName()}"
|
|
]
|
|
ant {
|
|
taskdef(name: 'ftp',
|
|
classname: 'org.apache.tools.ant.taskdefs.optional.net.FTP',
|
|
classpath: configurations.ftpAntTask.asPath)
|
|
ftp([action: "mkdir"] + ftpSettings)
|
|
ftp(ftpSettings) {
|
|
fileset(file: bundle.archivePath)
|
|
}
|
|
if (isMac()) {
|
|
ftp(ftpSettings) {
|
|
fileset(file: bundleRestricted.archivePath)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
task teamcityCompilerVersion {
|
|
doLast {
|
|
println("##teamcity[setParameter name='kotlin.native.version.base' value='$konanVersion']")
|
|
println("##teamcity[setParameter name='kotlin.native.version.full' value='$konanVersionFull']")
|
|
println("##teamcity[setParameter name='kotlin.native.version.meta' value='${konanVersionFull.meta.toString().toLowerCase()}']")
|
|
println("##teamcity[buildNumber '${konanVersionFull.toString(true, true)}']")
|
|
}
|
|
}
|
|
|
|
task clean(type: Delete) {
|
|
dependsOn subprojects.collect { it.tasks.matching { it.name == "clean" } }
|
|
doFirst {
|
|
delete distDir
|
|
delete buildDir
|
|
delete bundle.outputs.files
|
|
delete "${projectDir}/compile_commands.json"
|
|
}
|
|
}
|
|
|
|
task pusher(type: KotlinBuildPusher){
|
|
kotlinVersion = project.kotlinVersion
|
|
konanVersion = project.ext.kotlinNativeVersion
|
|
buildServer = "buildserver.labs.intellij.net"
|
|
compilerConfigurationId = System.getenv("TEAMCITY_COMPILER_ID") ?: "Kotlin_KotlinDev_Compiler"
|
|
overrideConfigurationId = System.getenv("TEAMCITY_OVERRIDE_NATIVE_ID") ?: "Kotlin_KotlinDev_DeployMavenArtifacts_OverrideNative"
|
|
token = project.findProperty("teamcityBearToken") ?: System.getenv("TEAMCITY_BEAR_TOKEN")
|
|
}
|
|
|
|
targetList.each { target ->
|
|
CompilationDatabaseKt.mergeCompilationDatabases(project, "${target}CompilationDatabase".toString(), [
|
|
":kotlin-native::common:${target}CompilationDatabase".toString(),
|
|
":kotlin-native:runtime:${target}CompilationDatabase".toString()
|
|
]).configure {
|
|
outputFile = file("$buildDir/${target}/compile_commands.json")
|
|
}
|
|
}
|
|
|
|
task compdb(type: Copy) {
|
|
dependsOn "${hostName}CompilationDatabase"
|
|
from "$buildDir/${hostName}/compile_commands.json"
|
|
into "$projectDir"
|
|
}
|
|
|
|
targetList.each { targetName ->
|
|
task "${targetName}CheckPlatformAbiCompatibility"(type: CompareDistributionSignatures) {
|
|
dependsOn "${targetName}PlatformLibs"
|
|
|
|
libraries = new CompareDistributionSignatures.Libraries.Platform(targetName)
|
|
if (project.hasProperty("anotherDistro")) {
|
|
oldDistribution = project.findProperty("anotherDistro")
|
|
}
|
|
onMismatchMode = CompareDistributionSignatures.OnMismatchMode.FAIL
|
|
}
|
|
}
|
|
|
|
task "checkStdlibAbiCompatibility"(type: CompareDistributionSignatures) {
|
|
dependsOn "distRuntime"
|
|
|
|
libraries = CompareDistributionSignatures.Libraries.Standard.INSTANCE
|
|
if (project.hasProperty("anotherDistro")) {
|
|
oldDistribution = project.findProperty("anotherDistro")
|
|
}
|
|
onMismatchMode = CompareDistributionSignatures.OnMismatchMode.FAIL
|
|
}
|