tessl/maven-org-jetbrains-kotlin--kotlin-gradle-plugin

Official Gradle plugin for the Kotlin programming language that provides comprehensive build support for Kotlin projects including compilation, multiplatform development, Android integration, and native development capabilities

—

Pending

Overview

Eval results

Files

Compilation Tasks

Name: tessl/maven-org-jetbrains-kotlin--kotlin-gradle-plugin
Author: tessl

This document covers the Gradle tasks responsible for compiling Kotlin code across different platforms.

Core Compilation Tasks

KotlinCompile

The main JVM compilation task.

abstract class KotlinCompile : AbstractCompile(), KotlinCompilationTask<KotlinJvmCompilerOptions> {
    abstract override val compilerOptions: KotlinJvmCompilerOptions
    abstract val destinationDirectory: DirectoryProperty
    abstract val classpath: ConfigurableFileCollection
    abstract val libraries: ConfigurableFileCollection
    abstract val source: ConfigurableFileTree
    
    // Incremental compilation support
    abstract val incrementalProps: Property<IncrementalCompilationSpec>
    abstract val usePreciseJavaTracking: Property<Boolean>
}

Usage Example:

tasks.withType<KotlinCompile>().configureEach {
    compilerOptions {
        jvmTarget.set(JvmTarget.JVM_11)
        freeCompilerArgs.add("-Xjsr305=strict")
    }
}

// Configure specific compilation task
tasks.named<KotlinCompile>("compileKotlin") {
    destinationDirectory.set(layout.buildDirectory.dir("classes/kotlin/main"))
}

AbstractKotlinCompile

Base class for all Kotlin compilation tasks.

abstract class AbstractKotlinCompile<T : KotlinCommonCompilerOptions> : AbstractCompile(), KotlinCompilationTask<T> {
    abstract override val compilerOptions: T
    abstract val kotlinSourceDirectories: ConfigurableFileCollection
    abstract val commonSourceSet: ConfigurableFileCollection
    abstract val moduleName: Property<String>
    
    // Compiler execution
    fun execute()
    
    // Source file handling
    fun getFilteredKotlinSources(): List<File>
}

Kotlin2JsCompile

JavaScript compilation task.

abstract class Kotlin2JsCompile : AbstractKotlinCompile<KotlinJsCompilerOptions> {
    abstract val outputFileProperty: RegularFileProperty
    abstract val optionalOutputFile: RegularFileProperty
    abstract val kotlinJsModuleKind: Property<KotlinJsModuleKind>
    
    // JS-specific properties
    abstract val enhancedIncrementalSupport: Property<Boolean>
    abstract val sourceMapEmbedSources: Property<SourceMapEmbedSources>
}

Usage Example:

tasks.withType<Kotlin2JsCompile>().configureEach {
    compilerOptions {
        target.set("es2015")
        moduleKind.set(KotlinJsModuleKind.MODULE_ES)
        sourceMap.set(true)
    }
}

KotlinCompileCommon

Common/metadata compilation task for multiplatform projects.

abstract class KotlinCompileCommon : AbstractKotlinCompile<KotlinMultiplatformCommonCompilerOptions> {
    abstract val expectActualLinker: Property<Boolean>
    abstract val refinesMetadata: ConfigurableFileCollection
}

Native Compilation Tasks

KotlinNativeCompile

Native compilation task.

abstract class KotlinNativeCompile : AbstractKotlinCompile<KotlinNativeCompilerOptions> {
    abstract val target: Property<String>
    abstract val debuggable: Property<Boolean>
    abstract val optimized: Property<Boolean>
    abstract val binaryOptions: MapProperty<String, String>
}

KotlinNativeLink

Native linking task for creating final binaries.

abstract class KotlinNativeLink : DefaultTask() {
    abstract val binary: Property<NativeBinary>
    abstract val destinationDirectory: DirectoryProperty
    abstract val outputFile: RegularFileProperty
    abstract val linkerArgs: ListProperty<String>
    abstract val libraries: ConfigurableFileCollection
    abstract val exportLibraries: ConfigurableFileCollection
}

Usage Example:

tasks.withType<KotlinNativeLink>().configureEach {
    linkerArgs.addAll("-linker-option", "-L/usr/local/lib")
}

KotlinNativeTest

Native test execution task.

abstract class KotlinNativeTest : AbstractTestTask() {
    abstract val executable: RegularFileProperty
    abstract val workingDir: DirectoryProperty
    abstract val args: ListProperty<String>
    abstract val environment: MapProperty<String, String>
}

Task Configuration

Kotlin Task Configuration DSL

// Configure all Kotlin compilation tasks
tasks.withType<KotlinCompile>().configureEach {
    compilerOptions {
        jvmTarget.set(JvmTarget.JVM_11)
        freeCompilerArgs.addAll(
            "-Xjsr305=strict",
            "-Xcontext-receivers"
        )
    }
}

// Configure JS compilation tasks
tasks.withType<Kotlin2JsCompile>().configureEach {
    compilerOptions {
        sourceMap.set(true)
        moduleKind.set(KotlinJsModuleKind.MODULE_COMMONJS)
    }
}

// Configure common/metadata compilation
tasks.withType<KotlinCompileCommon>().configureEach {
    compilerOptions {
        progressiveMode.set(true)
    }
}

Incremental Compilation

interface IncrementalCompilationSpec {
    val enabled: Property<Boolean>
    val useClasspathSnapshot: Property<Boolean>
    val preciseJavaTracking: Property<Boolean>
}

Configuration Example:

tasks.withType<KotlinCompile>().configureEach {
    usePreciseJavaTracking.set(true)
    
    incrementalProps.set(
        objects.newInstance<IncrementalCompilationSpec>().apply {
            enabled.set(true)
            useClasspathSnapshot.set(true)
            preciseJavaTracking.set(true)
        }
    )
}

Compiler Arguments and Options

Free Compiler Arguments

Common compiler arguments that can be passed to any Kotlin compilation task.

compilerOptions {
    freeCompilerArgs.addAll(
        // Language features
        "-Xcontext-receivers",
        "-Xvalue-classes",
        
        // JVM-specific
        "-Xjsr305=strict",
        "-Xjvm-default=all",
        
        // Multiplatform
        "-Xexpect-actual-classes",
        
        // Experimental features
        "-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
        "-opt-in=kotlin.ExperimentalStdlibApi"
    )
}

JVM Target Configuration

enum class JvmTarget(val description: String) {
    JVM_1_8("1.8"),
    JVM_9("9"),
    JVM_10("10"),
    JVM_11("11"),
    JVM_15("15"),
    JVM_17("17"),
    JVM_19("19"),
    JVM_20("20"),
    JVM_21("21")
}

Module Kind for JavaScript

enum class KotlinJsModuleKind {
    MODULE_AMD,
    MODULE_COMMONJS,
    MODULE_PLAIN,
    MODULE_UMD,
    MODULE_ES
}

Task Dependencies and Ordering

Compilation Task Dependencies

// Ensure test compilation depends on main compilation
tasks.named("compileTestKotlin") {
    dependsOn("compileKotlin")
}

// Custom task dependencies
tasks.register("customCompile") {
    dependsOn(tasks.withType<KotlinCompile>())
}

Source Set Compilation

Each source set gets its own compilation task:

// Main source set
tasks.named<KotlinCompile>("compileKotlin")

// Test source set  
tasks.named<KotlinCompile>("compileTestKotlin")

// Custom source set
sourceSets {
    create("integration") {
        // Creates compileIntegrationKotlin task
    }
}

Compiler Tool Configurations

Kapt Configuration

tasks.withType<KaptTask>().configureEach {
    useBuildCache = false
}

kapt {
    correctErrorTypes = true
    useBuildCache = false
    mapDiagnosticLocations = true
    arguments {
        arg("dagger.hilt.shareTestComponents", "true")
    }
}

KSP (Kotlin Symbol Processing)

// When using KSP plugin
tasks.withType<KspTask>().configureEach {
    // KSP-specific configuration
}

Install with Tessl CLI

npx tessl i tessl/maven-org-jetbrains-kotlin--kotlin-gradle-plugin

docs

compilation-tasks.md

dependency-management.md

dsl-extensions.md

index.md

javascript-webassembly.md

multiplatform-targets.md

plugin-configuration.md

tile.json

tessl/maven-org-jetbrains-kotlin--kotlin-gradle-plugin