libraries/commonConfiguration.gradle

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

ext.configureJavaOnlyJvm6Project = { Project project ->
    project.tasks.withType(JavaCompile) {
        sourceCompatibility = 1.6
        targetCompatibility = 1.6
        options.fork = true
        options.forkOptions.javaHome = file(JDK_16)
    }
}

List<String> tasksWithWarnings = (List<String>) rootProject.ext.get("tasksWithWarnings")

ext.configureJvm6Project = { Project project ->
    project.configure(project) {
        configurations {
            sources
        }

        project.ext.jvmTarget = "1.6"
        project.ext.javaHome = JDK_16

        task sourcesJar(type: Jar, dependsOn: classes) {
            classifier = 'sources'
            from sourceSets.main.kotlin
        }

        configureJavaOnlyJvm6Project(project)

        tasks.withType(project.compileKotlin.class) {
            kotlinOptions.jdkHome = JDK_16
            kotlinOptions.jvmTarget = "1.6"
        }

        test {
            executable = "$JDK_16/bin/java"
        }
    }

    if (!BuildPropertiesExtKt.getDisableWerror(project.kotlinBuildProperties)) {
        project.tasks.withType(org.jetbrains.kotlin.gradle.dsl.KotlinCompile.class) { task ->
            if (!tasksWithWarnings.contains(task.path)) {
                task.kotlinOptions {
                    allWarningsAsErrors = true
                    freeCompilerArgs += "-Xsuppress-deprecated-jvm-target-warning"
                }
            }
        }
    }
}

ext.compileJava9Sources = { Project project, String moduleName, Collection<FileCollection> moduleOutputs = [project.sourceSets.main.output] ->
    // module-info.java should be in java9 source set by convention
    SourceDirectorySet java9SourceSet = project.sourceSets.java9.java
    project.configurations.java9CompileClasspath.extendsFrom(project.configurations.compileClasspath)
    project.tasks.getByName("compileJava9Java").configure { JavaCompile it ->
        dependsOn(moduleOutputs)
        it.sourceCompatibility = 1.9
        it.targetCompatibility = 1.9
        it.destinationDir = file("${java9SourceSet.outputDir}/META-INF/versions/9")
        it.options.fork = true
        it.options.forkOptions.javaHome = file(JDK_9)
        it.options.sourcepath = files(java9SourceSet.srcDirs)
        def compileClasspath = project.configurations.java9CompileClasspath
        def objects = project.objects

        doFirst {
            def moduleFiles = objects.fileCollection().from(*moduleOutputs)
            def modulePath = compileClasspath.filter { !(it in moduleFiles.files) }

            options.compilerArgs = [
                    '--module-path', modulePath.asPath,
                    '--patch-module', "$moduleName=${moduleFiles.asPath}",
                    '-Xlint:-requires-transitive-automatic' // suppress automatic module transitive dependencies in kotlin.test
            ]

            classpath = objects.fileCollection().from()
        }
    }
}

ext.manifestAttributes = { Manifest manifest, Project project, String component = null, boolean multiRelease = false ->
    project.configure(manifest) {
        attributes \
                'Implementation-Vendor': 'JetBrains',
                'Implementation-Title': project.archivesBaseName,
                'Implementation-Version': project.buildNumber

        if (component != null) {
            attributes \
                'Kotlin-Runtime-Component': component,
                'Kotlin-Version': project.kotlinLanguageVersion
        }
        if (multiRelease) {
            attributes \
                'Multi-Release': 'true'
        }
    }
}

task preparePublication {
    def properties = project.properties
    assert project.version != 'unspecified'

    Map<String, String> repositoryProviders = ['sonatype-nexus-staging' : 'sonatype', 'sonatype-nexus-snapshots' : 'sonatype']
    project.ext.isRelease = !project.version.toString().contains('-SNAPSHOT')

    String repo = properties["deployRepo"] ?: properties['deploy-repo']
    String repoProvider = repositoryProviders.get(repo, repo)
    project.ext.isSonatypePublish = repoProvider == 'sonatype'
    project.ext.isSonatypeRelease = isSonatypePublish && isRelease

    String deployRepoUrl = properties["deployRepoUrl"] ?: properties["deploy-url"]
    String deployFolder = properties["deployRepoFolder"] != null ? "file://${rootProject.buildDir}/${properties["deployRepoFolder"]}" : null
    String sonatypeSnapshotsUrl = (isSonatypePublish && !isRelease) ? "https://oss.sonatype.org/content/repositories/snapshots/" : null
    String deployUrlFromParameters = deployRepoUrl ?: deployFolder ?: sonatypeSnapshotsUrl

    project.ext.isDeployStagingRepoGenerationRequired = project.ext.isSonatypeRelease && deployUrlFromParameters == null

    ext.repoUrl = deployUrlFromParameters ?: "file://${rootProject.buildDir}/repo"
    logger.info("Deployment repository preliminary url: $repoUrl ($repoProvider)")

    ext.username = properties["deployRepoUsername"] ?: properties["kotlin.${repoProvider}.user"]
    ext.password = properties["deployRepoPassword"] ?: properties["kotlin.${repoProvider}.password"]

    doLast {
        println("Deployment repository url: $repoUrl")
    }
}

ext.configurePublishing = { Project project, configure = { } ->
    ArtifactsKt.publish(project, false) { publication ->
        configure.delegate = publication
        configure()
    }
}

ext.configurePluginMarkers = { Project project, withEmptyJars = true ->
    PluginMarkersKt.publishPluginMarkers(project, withEmptyJars)
}

ext.configureJvmIrBackend = { Project project ->
    project.tasks.withType(KotlinCompile.class) { task ->
        task.kotlinOptions {
            if (!project.kotlinBuildProperties.useIRForLibraries) {
                useIR = false
                freeCompilerArgs += "-Xuse-old-backend"
            }
        }
    }
}

allprojects { project ->
    project.ext.configureSourcesJar = { lambda = {} ->
        ArtifactsKt.sourcesJar(project) { task ->
            lambda.delegate = task
            lambda()
        }
    }

    project.ext.configureJavadocJar = { lambda = {} ->
        ArtifactsKt.javadocJar(project) { task ->
            lambda.delegate = task
            lambda()
        }
    }

    project.ext.configureModularJar = { lambda = {} ->
        ArtifactsKt.modularJar(project) { task ->
            lambda.delegate = task
            lambda()
        }
    }

    dependencies.ext.kotlinStdlib = { suffix ->
        DependenciesKt.kotlinStdlib(project, suffix, null)
    }
}