Что нового в Kotlin 2.3.20

Упрощенная настройка проектов Kotlin

В Kotlin 2.3.20 настроить Kotlin в проектах Maven стало проще. Теперь Kotlin поддерживает автоматическую настройку корневых каталогов исходного кода и стандартной библиотеки Kotlin.

Благодаря новой настройке при создании проекта Kotlin с системой сборки Maven или добавлении Kotlin в существующий проект Java Maven вам не нужно вручную указывать пути к корневым каталогам исходного кода или добавлять зависимость kotlin-stdlib в файл сборки POM.

<build>
    <plugins>
         <plugin>
             <groupId>org.jetbrains.kotlin</groupId>
             <artifactId>kotlin-maven-plugin</artifactId>
             <version>2.4.20</version>
             <extensions>true</extensions> <!-- Add this extension  -->
         </plugin>
    </plugins>
</build>

<project>
    <properties>
        <!-- Disable smart defaults via property -->
        <kotlin.smart.defaults.enabled>false</kotlin.smart.defaults.enabled>         
    </properties>
</project>

Lombok получил статус «Альфа»

В Kotlin 1.5.20 появился экспериментальный плагин компилятора Lombok, который позволяет создавать и использовать объявления Lombok в Java в модулях, сочетающих код Kotlin и Java.

В версии 2.3.20 плагин компилятора Lombok получил статус «Альфа», поскольку мы планируем подготовить эту функциональность к использованию в производственной среде, однако она все еще находится в разработке.

Деструктуризация на основе имен

В Kotlin 2.3.20 появились деструктурирующие объявления на основе имен, в которых переменные сопоставляются с именами свойств, а не с порядком функций componentN().

Ранее в деструктурирующих объявлениях использовалась позиционная деструктуризация:

data class User(val username: String, val email: String)

fun main() {
    val user = User("alice", "alice@example.com")

    val (email, username) = user

    println(email)
    // alice

    println(username)
    // alice@example.com
}

В этом примере, поскольку деструктуризация зависит от порядка функций componentN(), email получает значение username, а username — значение email.

Начиная с Kotlin 2.3.20 можно использовать деструктуризацию на основе имен, при которой каждая переменная ссылается на свойство по имени:

fun main() {
    val user = User("alice", "alice@example.com")

    // Uses name-based destructuring with explicit form
    (val mail = email, val name = username) = user

    println(name)
    // alice

    println(mail)
    // alice@example.com
}

Деструктуризация на основе имен имеет статус «Экспериментальная». Управлять интерпретацией деструктурирующих объявлений компилятором можно с помощью параметра компилятора -Xname-based-destructuring.

Доступны следующие режимы:

• only-syntax включает явную форму деструктуризации на основе имен, не меняя поведение существующих деструктурирующих объявлений.

• name-mismatch выводит предупреждения, если при позиционной деструктуризации в классах данных используются имена переменных, не совпадающие с именами свойств.

• complete включает сокращенную форму деструктуризации на основе имен с круглыми скобками и сохраняет поддержку позиционной деструктуризации с квадратными скобками.

В режиме complete сокращенный синтаксис деструктуризации с круглыми скобками сопоставляет переменные с именами свойств, а не с их позициями:

val (email, username) = user

kotlin {
    compilerOptions {
        freeCompilerArgs.add("-Xname-based-destructuring=only-syntax")
    }
}

<build>
    <plugins>
        <plugin>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-maven-plugin</artifactId>
            <configuration>
                <args>
                    <arg>-Xname-based-destructuring=only-syntax</arg>
                </args>
            </configuration>
        </plugin>
    </plugins>
</build>

// Uses explicit position-based destructuring
val [username, email] = user

Новый API для создания неизменяемых копий Map.Entry

В Kotlin 2.3.20 появилась функция расширения Map.Entry.copy() для создания неизменяемой копии Map.Entry. Эта функция позволяет повторно использовать записи, полученные из Map.entries, после изменения карты, предварительно скопировав их.

Map.Entry.copy() имеет статус «Экспериментальная». Чтобы включить эту возможность, используйте аннотацию @OptIn(ExperimentalStdlibApi::class) или параметр компилятора:

-opt-in=kotlin.ExperimentalStdlibApi

Вот пример использования Map.Entry.copy() для удаления записей из изменяемой карты:

@OptIn(ExperimentalStdlibApi::class)
fun main() {
    val map = mutableMapOf(1 to 1, 2 to 2, 3 to 3, 4 to 4)

    val toRemove = map.entries
        .filter { it.key % 2 == 0 }
        .map { it.copy() }

    map.entries.removeAll(toRemove)

    println("map = $map")
    // map = {1=1, 3=3}
}

Новый режим взаимодействия с библиотеками C и Objective-C

Если вы используете библиотеки C или Objective-C в библиотеках или приложениях Kotlin Multiplatform (KMP), предлагаем протестировать новый режим взаимодействия и поделиться результатами.

В целом Kotlin/Native позволяет импортировать библиотеки C и Objective-C в Kotlin. Однако в библиотеках KMP на эту возможность в настоящее время влияют проблемы совместимости KMP со старыми версиями компилятора.

Иными словами, если вы публикуете библиотеку KMP, скомпилированную одной версией Kotlin, импорт библиотек C или Objective-C может сделать невозможным использование этой библиотеки Kotlin в проектах с более ранней версией Kotlin.

Чтобы решить эту и другие проблемы, команда Kotlin пересматривает используемый внутри механизм взаимодействия. Начиная с Kotlin 2.3.20 новый режим можно опробовать с помощью параметра компилятора.

Изменения в разрешении перегрузок для контекстных параметров

В Kotlin 2.3.20 изменено разрешение перегрузок для объявлений с контекстными параметрами.

Ранее при разрешении перегрузок объявления с контекстными параметрами считались более конкретными, чем объявления без них.

Начиная с Kotlin 2.3.20 это правило больше не применяется, благодаря чему выбор перегрузки стал более единообразным. В результате вызовы, которые раньше успешно разрешались, теперь становятся неоднозначными и приводят к ошибке компиляции, если перегрузки различаются только контекстными параметрами. В таких случаях компилятор предупреждает о возможной неоднозначности.

Пример:

class Logger {
    fun info(msg: String) = println("INFO: $msg")
}

fun saveUser(id: Int) {
    println("Saving user $id (no logger)")
}

// Reports a warning: Contextual declaration is shadowed
context(logger: Logger)
fun saveUser(id: Int) {
    logger.info("Saving user $id")
}

fun main() {
    val logger = Logger()

    context(logger) {
        // Reports an ambiguity error in 2.3.20
        saveUser(1)
    }
}

Кроме того, в Kotlin 2.3.20 количество перегрузок kotlin.context сокращено с 22 до 6, чтобы уменьшить число избыточных кандидатов при разрешении перегрузок и автодополнении кода.

data class User(val username: String, val email: String)

fun main() {
    val user = User("alice", "alice@example.com")

    val (email, username) = user

    println(email)
    // alice

    println(username)
    // alice@example.com
}

fun main() {
    val user = User("alice", "alice@example.com")

    // Uses name-based destructuring with explicit form
    (val mail = email, val name = username) = user

    println(name)
    // alice

    println(mail)
    // alice@example.com
}

val (email, username) = user

kotlin {
    compilerOptions {
        freeCompilerArgs.add("-Xname-based-destructuring=only-syntax")
    }
}

<build>
    <plugins>
        <plugin>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-maven-plugin</artifactId>
            <configuration>
                <args>
                    <arg>-Xname-based-destructuring=only-syntax</arg>
                </args>
            </configuration>
        </plugin>
    </plugins>
</build>

// Uses explicit position-based destructuring
val [username, email] = user

Новый API для создания неизменяемых копий Map.Entry

В Kotlin 2.3.20 появилась функция расширения Map.Entry.copy() для создания неизменяемой копии Map.Entry. Эта функция позволяет повторно использовать записи, полученные из Map.entries, после изменения карты, предварительно скопировав их.

Map.Entry.copy() имеет статус «Экспериментальная». Чтобы включить эту возможность, используйте аннотацию @OptIn(ExperimentalStdlibApi::class) или параметр компилятора:

-opt-in=kotlin.ExperimentalStdlibApi

Вот пример использования Map.Entry.copy() для удаления записей из изменяемой карты:

@OptIn(ExperimentalStdlibApi::class)
fun main() {
    val map = mutableMapOf(1 to 1, 2 to 2, 3 to 3, 4 to 4)

    val toRemove = map.entries
        .filter { it.key % 2 == 0 }
        .map { it.copy() }

    map.entries.removeAll(toRemove)

    println("map = $map")
    // map = {1=1, 3=3}
}

Улучшена поддержка JPA в плагине kotlin.plugin.jpa

Теперь плагин kotlin.plugin.jpa автоматически применяет плагин компилятора all-open с новым встроенным пресетом JPA, а также существующий плагин компилятора no-arg.

Ранее использование kotlin("plugin.jpa") включало только плагин no-arg с пресетами JPA.

В этом выпуске мы улучшили пресет kotlin.plugin.jpa, чтобы плагин all-open настраивался автоматически. Это обеспечивает ожидаемую работу ленивых ассоциаций: они не вызывают жадную загрузку и дополнительные запросы.

Начиная с Kotlin 2.3.20:

• Плагин компилятора all-open предоставляет пресет JPA.

• Плагин Gradle org.jetbrains.kotlin.plugin.jpa автоматически применяет плагин org.jetbrains.kotlin.plugin.all-open с включенным пресетом JPA.

• Настройка JPA в Maven по умолчанию включает all-open с пресетом JPA. (Поддержка в IntelliJ IDEA доступна начиная с версии 2026.1.)

• Зависимость Maven org.jetbrains.kotlin:kotlin-maven-noarg теперь неявно включает org.jetbrains.kotlin:kotlin-maven-allopen, поэтому больше не нужно добавлять ее явно в блок <plugin><dependencies>.

В результате сущности JPA с приведенными ниже аннотациями автоматически обрабатываются как open и получают конструкторы без аргументов без дополнительной настройки:

• javax.persistence.Entity

• javax.persistence.Embeddable

• javax.persistence.MappedSuperclass

• jakarta.persistence.Entity

• jakarta.persistence.Embeddable

• jakarta.persistence.MappedSuperclass

Это изменение упрощает настройку сборки и улучшает работу Kotlin с платформами JPA сразу после установки.

Поддержка аннотации Vert.x @Nullable

В Kotlin 2.3.20 добавлена поддержка аннотации io.vertx.codegen.annotations.Nullable. Теперь компилятор распознает эту аннотацию и по умолчанию сообщает о несоответствиях nullability в виде предупреждений.

Чтобы включить строгие проверки nullability и повысить уровень этих предупреждений до ошибок, добавьте в файл сборки следующий параметр компилятора:

// build.gradle(.kts)
kotlin {
    compilerOptions {
        freeCompilerArgs.add("-Xnullability-annotations=@io.vertx.codegen.annotations:strict")
    }
}

<!-- pom.xml -->
<build>
    <plugins>
        <plugin>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-maven-plugin</artifactId>
            <configuration>
                <args>
                    <arg>-Xnullability-annotations=@io.vertx.codegen.annotations:strict</arg>
                </args>
            </configuration>
        </plugin>
    </plugins>
</build>

Поддержка аннотаций Java для неизменяемых коллекций

В Kotlin 2.3.20 добавлена поддержка аннотаций Java org.jetbrains.annotations.Unmodifiable и org.jetbrains.annotations.UnmodifiableView.

Начиная с Kotlin 2.3.20 коллекции, возвращаемые из объявлений Java с этими аннотациями, считаются доступными только для чтения в Kotlin. При присваивании такой коллекции переменной изменяемого типа коллекции выводится предупреждение о несоответствии типов. В Kotlin 2.5.0 это предупреждение планируется преобразовать в ошибку.

Пример:

// Java
public class Java {
    public static @UnmodifiableView List<Object> unmodifiableView() {
        return List.of();
    }

    public static @Unmodifiable List<Object> unmodifiable() {
        return List.of();
    }
}

// Kotlin

fun main() {
    // Reports a warning: Java type mismatch
    val mutableView: MutableList<Any> = Java.unmodifiableView()
    val mutableCopy: MutableList<Any> = Java.unmodifiable()
}

Средство проверки кросс-компиляции

В Kotlin 2.3.20 появился способ определить, поддерживается ли кросс-компиляция для указанной цели. Это может быть полезно для сторонних плагинов, отслеживающих состояние задач компиляции.

Как правило, Kotlin/Native поддерживает кросс-компиляцию: любой поддерживаемый хост может создавать артефакты .klib для поддерживаемых целевых платформ. Однако создание артефактов для целевых платформ Apple по-прежнему ограничено, если в проекте используются зависимости cinterop.

Новый API crossCompilationSupported теперь проверяет, поддерживается ли кросс-компиляция: целевая платформа должна быть включена диспетчером хостов, и ни одна из компиляций для этой целевой платформы не должна включать зависимости cinterop. Проверка включена по умолчанию.

Подробнее о поддерживаемых целевых платформах и хостах см. в документации Kotlin/Native.

Новый DSL для отключения кэша компиляции

В Kotlin 2.3.20 появился новый DSL для отключения кэша компиляции в проектах Kotlin/Native. Он призван сделать решение об отключении кэша более обдуманным и явным.

Поскольку отключение кэша значительно замедляет сборку Kotlin/Native, использовать его следует только временно и в исключительных случаях. Поэтому теперь отключение кэша привязано к конкретной версии Kotlin и должно сопровождаться причиной, которая служит документацией.

Если вам необходимо отключить кэш компиляции в проекте, обновите блок binaries {} в файле сборки Gradle следующим образом:

kotlin {
    listOf(
        iosX64(),
        iosArm64(),
        iosSimulatorArm64()
    ).forEach {
        // Specify your binary kind
        it.binaries.framework {
            baseName = "CacheKind"
            isStatic = true

            // Disable cache with the new DSL
            disableNativeCache(
                 version = DisableCacheInKotlinVersion.2_3_0, 
                 reason = "Cache bug",
                 issue = URI("https://youtrack.com/YY-1111")
            )
        }
    }
}

• version — версия Kotlin, для которой отключен кэш компиляции.

• reason (обязательно) — причина отключения кэша компиляции.

• issue (необязательно) — URL соответствующей задачи в системе отслеживания ошибок.

Новый DSL заменяет устаревшее свойство Gradle kotlin.native.cacheKind. Его можно безопасно удалить из файла gradle.properties.

Другие советы по сокращению времени компиляции см. в документации Kotlin/Native.

Повышение производительности операций со строками

Теперь Kotlin/Wasm использует встроенные функции строк JS для операций со значениями kotlin.String. Благодаря этому Kotlin/Wasm может использовать оптимизации строк движка JavaScript в браузерах и средах выполнения Wasm, поддерживающих это предложение. Оптимизация применяется к таким операциям, как конкатенация, интерполяция, StringBuilder.append() и преобразование чисел в строки.

Это даёт следующие результаты:

• Интерполяция строк в целевых тестах производительности выполняется до 4,6 раза быстрее.

• Размер двоичных файлов Wasm в сборке приложения KotlinConf уменьшился примерно на 5%.

• Медианный показатель по всем тестам производительности Wasm улучшился примерно на 1%.

• В сценариях с интенсивным добавлением данных StringBuilder.append() и конкатенация экземпляров kotlin.String выполняются как минимум на 20% быстрее.

Сокращение времени компиляции и оптимизация использования памяти

В Kotlin 2.3.20 добавлены оптимизации компилятора, значительно сокращающие потребление памяти во время компиляции, особенно в крупных проектах. Эти оптимизации также повышают производительность инкрементальных сборок.

В ходе тестирования мы зафиксировали сокращение времени чистой сборки на 65% и времени инкрементальной сборки на 21%.

Поддержка аннотации @nativeInvoke

В Kotlin 2.3.20 добавлена поддержка аннотации @nativeInvoke для целевой платформы wasmJs. Эта аннотация позволяет обращаться с объектом или классом Kotlin так, как если бы он был функцией JavaScript. Она предназначена для обозначения функции-члена объявления external (класса или интерфейса) в качестве «оператора вызова» объекта JavaScript.

Если аннотировать функцию, каждый вызов этой функции в Kotlin будет преобразован в прямой вызов самого объекта JavaScript:

import kotlin.js.nativeInvoke

@OptIn(ExperimentalWasmJsInterop::class)
external class JsAction {
    @nativeInvoke
    operator fun invoke(data: String)
}

fun main() {
    val action = JsAction() 
    action("Run task")
}

Это временное решение, которое будет использоваться до разработки стабильного взаимодействия между Kotlin/Wasm и JavaScript. В будущих выпусках оно может быть изменено или удалено, а при его использовании компилятор выводит предупреждение.

Подробнее о взаимодействии Kotlin/Wasm с JavaScript см. в разделе Взаимодействие с JavaScript.

Реализация интерфейсов Kotlin на JavaScript/TypeScript

В Kotlin 2.3.20 снято ограничение на реализацию интерфейсов Kotlin на стороне JavaScript/TypeScript. Раньше интерфейсы Kotlin можно было экспортировать в TypeScript только как интерфейсы TypeScript; реализовывать их в TypeScript было запрещено.

Теперь любой интерфейс Kotlin можно реализовать следующим образом:

// Kotlin
@JsExport
interface DataProcessor {
    suspend fun process(): String
}


@JsExport
fun registerProcessor(processor: DataProcessor) { ... }

// TypeScript
import { DataProcessor, registerProcessor } from "my-kmp-library"


class JsonProcessor implements DataProcessor {
    readonly [DataProcessor.Symbol] = true


    async process(): Promise<string> {
        return "processed JSON data"
    }
}

registerProcessor(new JsonProcessor())

Также можно повторно использовать реализации Kotlin по умолчанию из TypeScript. Хотя в TypeScript нет понятия реализаций по умолчанию в интерфейсах, это ограничение можно обойти, делегируя вызовы объекту DefaultImpls:

// Kotlin
@JsExport
interface Logger {
    fun log(): String = "[INFO] Default log entry"
    val prefix: String get() = "LOG"
}

// TypeScript
import { Logger, acceptLogger } from "my-kmp-library"

class ConsoleLogger implements Logger {
    readonly [Logger.Symbol] = true


    // Delegates to the default method implementation
    log(): string {
        return Logger.DefaultImpls.log(this);
    }

    // Delegates to the default property implementation
    get prefix(): string {
        return Logger.DefaultImpls.prefix.get(this);
    }
}

acceptLogger(new ConsoleLogger())

kotlin { 
    js {
        // ...
        generateTypeScriptDefinitions()
        compilerOptions {
            freeCompilerArgs.add("-Xenable-implementing-interfaces-from-typescript")
        }
    }
}

Поддержка платформы компиляции SWC

Начиная с Kotlin 2.3.20, Kotlin/JS поддерживает платформу компиляции SWC. Она помогает преобразовывать новые версии кода JavaScript/TypeScript в более старый и совместимый код JavaScript.

Передача преобразования кода внешнему инструменту позволяет сократить количество вариантов, создаваемых компилятором Kotlin/JS, и ускорить модернизацию компилятора, сосредоточившись только на поддержке новейших возможностей JavaScript. Сейчас последней поддерживаемой версией ECMAScript по-прежнему является es2015.

Кроме того, передача работы по транспиляции позволяет улучшить функцию встраиваемого JavaScript. Сейчас она поддерживает только синтаксис ES5 (это изменится в версии 2.4.0). Поддержка нового синтаксиса при компиляции для более старых версий была бы сложной задачей, поскольку для этого компилятору пришлось бы транспилировать код JS непосредственно в блоке встроенного JS. С помощью SWC мы сможем добавить современный синтаксис JS, а инструмент преобразует код в синтаксис, необходимый для целевой версии, используемой конечным пользователем.

Переход на SWC также даёт возможность реализовать в плагине Kotlin Gradle DSL на основе browserlist. Это позволит указывать целевые браузеры или среды вместо конкретных версий JS.

kotlin.js.delegated.transpilation=true

Совместимость с Gradle 9.3.0

Kotlin 2.3.20 полностью совместим с версиями Gradle от 7.6.3 до 9.3.0. Также можно использовать версии Gradle вплоть до последнего выпуска. Однако следует учитывать, что это может привести к предупреждениям об устаревших функциях, а некоторые новые возможности Gradle могут не работать.

Улучшения проверки бинарной совместимости в KGP

В Kotlin 2.2.0 впервые появилась поддержка проверки бинарной совместимости в плагине Kotlin Gradle. В Kotlin 2.3.20 добавлены два улучшения.

Во-первых, в названиях задач Gradle для проверки бинарной совместимости больше нет слова «Legacy». Мы внесли это изменение, поскольку прежнее соглашение об именовании сбивало разработчиков Kotlin с толку:

В Kotlin 2.3.20 старые названия задач по-прежнему доступны, чтобы упростить переход на новые.

Во-вторых, если включить проверку бинарной совместимости в проекте, Gradle теперь автоматически запускает задачу checkKotlinAbi при запуске задачи check. Раньше Gradle не запускал задачу checkKotlinAbi, хотя задача check должна запускать все задачи проверки. Это приводило к непоследовательному поведению в проектах Gradle.

Компиляция Kotlin/JVM по умолчанию использует Build tools API

В Kotlin 2.3.20 компиляция Kotlin/JVM в плагине Kotlin Gradle по умолчанию использует Build tools API (BTA). Это изменение внутренней инфраструктуры компиляции ускоряет разработку поддержки компилятора Kotlin в инструментах сборки.

Если вы заметили проблемы, поделитесь отзывом в нашем трекере задач.

Упрощённая настройка проектов Kotlin

В Kotlin 2.3.20 настройка Kotlin в проектах Maven стала проще. Теперь Kotlin поддерживает автоматическую настройку корневых каталогов исходного кода и стандартной библиотеки Kotlin.

Благодаря новой конфигурации при создании нового проекта Kotlin с помощью системы сборки Maven или добавлении Kotlin в существующий проект Java Maven не нужно вручную указывать пути к корневым каталогам исходного кода или добавлять зависимость kotlin-stdlib в файл сборки POM.

<build>
    <plugins>
         <plugin>
             <groupId>org.jetbrains.kotlin</groupId>
             <artifactId>kotlin-maven-plugin</artifactId>
             <version>2.4.20</version>
             <extensions>true</extensions> <!-- Add this extension  -->
         </plugin>
    </plugins>
</build>

<project>
    <properties>
        <!-- Disable smart defaults via property -->
        <kotlin.smart.defaults.enabled>false</kotlin.smart.defaults.enabled>         
    </properties>
</project>

Улучшения операций сборки

В этом выпуске BTA улучшает управление операциями сборки в инструментах сборки. Операции сборки позволяют инструментам сборки взаимодействовать с компилятором Kotlin. Каждая операция сборки представляет собой реализацию интерфейса BuildOperation.

Теперь можно отменять операции сборки, реализующие интерфейс CancellableBuildOperation, с помощью функции cancel().

Функция cancel() работает по принципу «по возможности». Это означает, что отмена операции не гарантируется.

Например:

val operation = toolchains.jvm.jvmCompilationOperationBuilder(sources, destination) {}

toolchains.createBuildSession().use {
    try {
        it.executeOperation(operation.build())
    } catch (e: OperationCancelledException) {
        println("Build operation has been cancelled.")
    }
}

// ...

// From another thread:
operation.cancel()

Кроме того, операции сборки стали надёжнее: теперь их можно создавать так, чтобы после запуска их нельзя было изменить. Для этого инструмент сборки должен использовать шаблон проектирования «строитель»:

1. Настройте объект с помощью изменяемого строителя.

2. Вызовите функцию build(), чтобы создать неизменяемый экземпляр объекта.

Например:

fun prepareBuildOperation(toolchains: KotlinToolchains, sources: List<Path>, destination: Path): JvmCompilationOperation {
    val builder = toolchains.jvm.jvmCompilationOperationBuilder(sources, destination)

    // Configure the operation using the builder
    builder.compilerArguments[CommonToolArguments.VERBOSE] = true
    builder[COMPILER_ARGUMENTS_LOG_LEVEL] = CompilerArgumentsLogLevel.ERROR

    // Return an immutable operation
    return builder.build()
}

Единообразный сбор метрик в разных инструментах сборки

До Kotlin 2.3.20 инфраструктура метрик сборки была ориентирована на Gradle, что влияло на такие её части, как названия метрик. Кроме того, не все метрики были доступны для разных стратегий выполнения компилятора.

В Kotlin 2.3.20 BTA обеспечивает сбор метрик для JVM, не зависящий от инструмента сборки. BTA также предоставляет единый набор метрик независимо от стратегии выполнения компилятора. Метрики, относящиеся к конкретному способу компиляции или стратегии выполнения компилятора, предоставляются только в соответствующих случаях. Например, метрики инкрементальной компиляции доступны только для инкрементальных сборок, а метрики, относящиеся к демону, — только при использовании демона Kotlin.

Теперь инструменты сборки могут настроить объект BuildMetricsCollector для операции сборки, чтобы собирать метрики, помогающие пользователям оценить производительность сборки:

val operation =
    kotlinToolchains.jvm.jvmCompilationOperationBuilder(sources, outputDirectory)
operation[BuildOperation.METRICS_COLLECTOR] = object : BuildMetricsCollector {
    override fun collectMetric(
        name: String,
        type: BuildMetricsCollector.ValueType,
        value: Long
    ) {
        // ...
    }
}

Упрощённая настройка плагинов компилятора с помощью инструментов сборки

В Kotlin 2.3.20 BTA предоставляет новый, более простой способ настройки плагинов компилятора средствами сборки. Такой подход позволяет инструментам сборки напрямую передавать конфигурацию пользователям.

Вместо настройки плагинов компилятора через командную строку с помощью экспериментальных параметров компилятора инструменты сборки могут использовать параметр kotlin.buildtools.api.arguments.CommonCompilerArguments.COMPILER_PLUGINS для настройки списка объектов, представляющих конфигурации плагинов компилятора: