analysis/analysis-api/build.gradle.kts

import org.jetbrains.kotlin.build.foreign.CheckForeignClassUsageTask
import org.jetbrains.kotlin.gradle.dsl.abi.ExperimentalAbiValidation

plugins {
    id("common-configuration")
    id("test-federation-convention")
    id("com.autonomousapps.dependency-analysis")
    kotlin("jvm")
    id("kotlin-git.gradle-build-conventions.foreign-class-usage-checker")
    id("project-tests-convention")
    id("test-inputs-check-v2")
}

kotlin {
    explicitApiWarning()
}

dependencies {
    compileOnly(commonDependency("org.jetbrains.kotlin:kotlin-reflect")) { isTransitive = false }

    compileOnly(project(":core:language.model"))
    compileOnly(project(":core:language.targets"))
    compileOnly(project(":core:language.version-settings"))
    compileOnly(project(":compiler:psi:psi-api"))
    compileOnly(project(":core:compiler.common"))
    compileOnly(project(":core:compiler.common.jvm"))
    compileOnly(project(":core:compiler.common.js"))
    implementation(kotlinxCollectionsImmutable())

    api(intellijCore())
    api(libs.intellij.asm)
    api(libs.guava)

    testImplementation(platform(libs.junit.bom))
    testImplementation(libs.junit.jupiter.api)
    testRuntimeOnly(libs.junit.jupiter.engine)
    testRuntimeOnly(libs.junit.platform.launcher)

    testImplementation(testFixtures(project(":compiler:psi:psi-api")))
    testImplementation(testFixtures(project(":compiler:tests-common")))
    testImplementation(project(":analysis:analysis-internal-utils"))
}

private val unstableNonPublicMarkers = listOf(
    "org.jetbrains.kotlin.analysis.api.KaImplementationDetail",
    "org.jetbrains.kotlin.analysis.api.KaNonPublicApi",
    "org.jetbrains.kotlin.analysis.api.KaIdeApi",
)

private val stableNonPublicMarkers = unstableNonPublicMarkers + listOf(
    "org.jetbrains.kotlin.analysis.api.KaExperimentalApi",
    "org.jetbrains.kotlin.analysis.api.KaPlatformInterface", // Platform interface is not stable yet
    "org.jetbrains.kotlin.analysis.api.KaContextParameterApi",
)

kotlin {
    explicitApi()

    @OptIn(ExperimentalAbiValidation::class)
    abiValidation {
        filters {
            exclude.annotatedWith.addAll(stableNonPublicMarkers)
        }
    }
}

sourceSets {
    "main" { projectDefault() }
    "test" { none() }
}

projectTests {
    testCodebaseTask()
}

val checkForeignClassUsage by tasks.registering(CheckForeignClassUsageTask::class) {
    outputFile = file("api/analysis-api.foreign")
    nonPublicMarkers.addAll(stableNonPublicMarkers)
}

val checkForeignClassUsageUnstable by tasks.registering(CheckForeignClassUsageTask::class) {
    outputFile = file("api-unstable/analysis-api.foreign")
    nonPublicMarkers.addAll(unstableNonPublicMarkers)
}