Что нового в Kotlin 1.6.0

Стабильные исчерпывающие операторы when для перечислений, запечатанных и булевых объектов

Оператор исчерпывающий when содержит ветви для всех возможных типов или значений его объекта, или для некоторых типов плюс else ветвь. Он охватывает все возможные случаи, делая ваш код безопаснее.

Вскоре мы запретим неисчерпывающие when операторы, чтобы поведение стало согласованным с when выражениями. Для плавного перехода Kotlin 1.6.0 сообщает предупреждения о неисчерпывающих when операторах с объектом-перечислением, запечатанным или булевым. Эти предупреждения станут ошибками в будущих выпусках.

sealed class Contact {
    data class PhoneCall(val number: String) : Contact()
    data class TextMessage(val number: String) : Contact()
}

fun Contact.messageCost(): Int =
    when(this) { // Error: 'when' expression must be exhaustive
        is Contact.PhoneCall -> 42
    }

fun sendMessage(contact: Contact, message: String) {
    // Starting with 1.6.0

    // Warning: Non exhaustive 'when' statements on Boolean will be
    // prohibited in 1.7, add 'false' branch or 'else' branch instead 
    when(message.isEmpty()) {
        true -> return
    }
    // Warning: Non exhaustive 'when' statements on sealed class/interface will be
    // prohibited in 1.7, add 'is TextMessage' branch or 'else' branch instead
    when(contact) {
        is Contact.PhoneCall -> TODO()
    }
}

См. эту запись в YouTrack для более подробного объяснения изменения и его последствий.

Стабильные приостанавливаемые функции в качестве супертипов

Реализация приостанавливаемых функциональных типов стала стабильной в Kotlin 1.6.0. Превью было доступно в 1.5.30.

Эта функция полезна при проектировании API, использующих Kotlin coroutines и принимающих приостанавливаемые функциональные типы. Теперь вы можете оптимизировать свой код, поместив желаемое поведение в отдельный класс, реализующий приостанавливаемый функциональный тип.

class MyClickAction : suspend () -> Unit {
    override suspend fun invoke() { TODO() }
}

fun launchOnClick(action: suspend () -> Unit) {}

Вы можете использовать экземпляр этого класса, где ранее разрешались только лямбды и ссылки на приостанавливаемые функции: launchOnClick(MyClickAction()).

В настоящее время существуют два ограничения, обусловленные особенностями реализации:

• Вы не можете смешивать обычные функциональные типы и приостанавливаемые в списке супертипов.

• Вы не можете использовать несколько приостанавливаемых функциональных супертипов.

Стабильные преобразования suspend

Kotlin 1.6.0 представляет стабильные преобразования из обычных функциональных типов в приостанавливаемые. Начиная с 1.4.0, эта функция поддерживала функциональные литералы и ссылки на вызываемые объекты. С 1.6.0 она работает с любыми выражениями. В качестве аргумента вызова теперь можно передавать любое выражение подходящего обычного функционального типа, где ожидается приостановление. Компилятор автоматически выполнит неявное преобразование.

fun getSuspending(suspending: suspend () -> Unit) {}

fun suspending() {}

fun test(regular: () -> Unit) {
    getSuspending { }           // OK
    getSuspending(::suspending) // OK
    getSuspending(regular)      // OK
}

Стабильное создание экземпляров классов аннотаций

Kotlin 1.5.30 ввел экспериментальную поддержку создания экземпляров классов аннотаций на платформе JVM. С 1.6.0 эта функция доступна по умолчанию как для Kotlin/JVM, так и для Kotlin/JS.

Дополнительную информацию о создании экземпляров классов аннотаций см. в этом KEEP.

Улучшенный вывод типов для рекурсивных обобщенных типов

Kotlin 1.5.30 внес улучшение в вывод типов для рекурсивных обобщенных типов, позволив выводить их аргументы типов только на основе верхних границ соответствующих параметров типа. Улучшение было доступно с опцией компилятора. В версии 1.6.0 и более поздних версиях оно включено по умолчанию.

// Before 1.5.30
val containerA = PostgreSQLContainer<Nothing>(DockerImageName.parse("postgres:13-alpine")).apply {
  withDatabaseName("db")
  withUsername("user")
  withPassword("password")
  withInitScript("sql/schema.sql")
}

// With compiler option in 1.5.30 or by default starting with 1.6.0
val containerB = PostgreSQLContainer(DockerImageName.parse("postgres:13-alpine"))
  .withDatabaseName("db")
  .withUsername("user")
  .withPassword("password")
  .withInitScript("sql/schema.sql")

Изменения в выводе типов билдеров

Вывод типов билдеров — это вид вывода типов, полезный при вызове универсальных функций билдеров. Он может выводить аргументы типов вызова с помощью информации о типах из вызовов внутри его лямбда-аргумента.

Мы вносим несколько изменений, которые приближают нас к полной стабильности вывода типов билдеров. Начиная с 1.6.0:

• Вы можете делать вызовы, возвращающие экземпляр еще не выведенного типа внутри лямбды билдера, без указания опции компилятора -Xunrestricted-builder-inference, введенной в 1.5.30.

• С -Xenable-builder-inference вы можете писать свои собственные билдеры без применения аннотации @BuilderInference.

• С -Xenable-builder-inference вывод типов билдеров автоматически активируется, если обычный вывод типов не может получить достаточную информацию о типе.

Узнайте, как писать пользовательские универсальные билдеры.

Поддержка аннотаций для параметров типа класса

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

@Target(AnnotationTarget.TYPE_PARAMETER)
annotation class BoxContent

class Box<@BoxContent T> {}

Аннотации для всех параметров типа передаются в байт-код JVM, так что обработчики аннотаций могут их использовать.

Для использования в мотивационном примере см. эту запись в YouTrack.

Дополнительную информацию об аннотациях см. здесь.

Повторяющиеся аннотации с сохранением в ходе выполнения для целевой JVM 1.8

Java 8 представила повторяющиеся аннотации, которые могут применяться несколько раз к одному элементу кода. Для этого необходимо наличие двух деклараций в коде Java: самой повторяющейся аннотации, помеченной @java.lang.annotation.Repeatable, и содержащей аннотации для хранения её значений.

В Kotlin повторяющиеся аннотации требуют только @kotlin.annotation.Repeatable в декларации аннотации, чтобы сделать её повторяющейся. До версии 1.6.0 данная функция поддерживала только SOURCE сохранение и была несовместима с повторяющимися аннотациями Java. Kotlin 1.6.0 устраняет эти ограничения. @kotlin.annotation.Repeatable теперь принимает любое сохранение и делает аннотацию повторяющейся как в Kotlin, так и в Java. Повторяющиеся аннотации Java теперь также поддерживаются со стороны Kotlin.

Хотя вы можете объявить содержащую аннотацию, это необязательно. Например:

• Если аннотация @Tag помечена как @kotlin.annotation.Repeatable, компилятор Kotlin автоматически генерирует класс содержащей аннотации под именем @Tag.Container:

  @Repeatable 
  annotation class Tag(val name: String)
  
  // The compiler generates @Tag.Container containing annotation
  

• Чтобы установить пользовательское имя для содержащей аннотации, примените @kotlin.jvm.JvmRepeatable мета-аннотацию и передайте явно объявленный класс содержащей аннотации в качестве аргумента:

  @JvmRepeatable(Tags::class)
  annotation class Tag(val name: String)
  
  annotation class Tags(val value: Array<Tag>)
  

Рефлексия Kotlin теперь поддерживает как повторяющиеся аннотации Kotlin, так и Java через новую функцию KAnnotatedElement.findAnnotations().

Узнайте больше о повторяющихся аннотациях Kotlin в этом KEEP.

Оптимизация делегированных свойств, вызывающих get/set для данного экземпляра KProperty

Мы оптимизировали сгенерированный JVM байткод, исключив поле $delegate и сгенерировав непосредственный доступ к связанному свойству.

Например, в следующем коде

class Box<T> {
    private var impl: T = ...

    var content: T by ::impl
}

Kotlin больше не генерирует поле content$delegate. Методы доступа к свойству переменной content вызывают переменную impl непосредственно, минуя операторы getValue/setValue делегированного свойства и, таким образом, избегая необходимости в объекте ссылки на свойство типа KProperty.

Спасибо нашим коллегам из Google за реализацию!

Узнайте больше о делегированных свойствах.

Предварительный просмотр нового менеджера памяти

С Kotlin 1.6.0 вы можете попробовать предварительный просмотр нового менеджера памяти Kotlin/Native. Это приближает нас к устранению различий между платформами JVM и Native для предоставления согласованного опыта разработчика в многоплатформенных проектах.

Одно из заметных изменений — ленивая инициализация свойств верхнего уровня, как и в Kotlin/JVM. Свойство верхнего уровня инициализируется при первом обращении к свойству или функции верхнего уровня из того же файла. Этот режим также включает глобальную межпроцедурную оптимизацию (активна только для релизных бинарных файлов), которая удаляет избыточные проверки инициализации.

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

Поддержка Xcode 13

Kotlin/Native 1.6.0 поддерживает Xcode 13 — последнюю версию Xcode. Вы можете обновить Xcode и продолжить работу над своими Kotlin-проектами для платформ Apple.

Компиляция Windows-целей на любом хосте

Начиная с версии 1.6.0, вам не нужен Windows-хост для компиляции Windows-целей mingwX64 и mingwX86. Их можно скомпилировать на любом хосте, поддерживающем Kotlin/Native.

Обновления LLVM и линковщика

Мы переработали зависимость LLVM, используемую Kotlin/Native внутри. Это приносит различные преимущества, включая:

• Обновлённая версия LLVM до 11.1.0.

• Уменьшен размер зависимости. Например, на macOS он теперь составляет около 300 МБ вместо 1200 МБ в предыдущей версии.

• Исключена зависимость от библиотеки ncurses5, которая недоступна в современных дистрибутивах Linux.

В дополнение к обновлению LLVM, Kotlin/Native теперь использует линковщик LLD (линковщик из проекта LLVM) для целей MingGW. Он предоставляет различные преимущества по сравнению с ранее использовавшимся линковщиком ld.bfd и позволит улучшить производительность исполняемых файлов во время выполнения, а также поддерживать кэши компилятора для целей MinGW. Обратите внимание, что LLD требует импортных библиотек для связи с DLL. Узнайте больше в этом потоке Stack Overflow.

Улучшения производительности

Kotlin/Native 1.6.0 предоставляет следующие улучшения производительности:

• Время компиляции: кэши компилятора включены по умолчанию для linuxX64 и iosArm64 целей. Это ускоряет большинство компиляций в режиме отладки (кроме первой). Измерения показали увеличение скорости примерно на 200% в наших тестовых проектах. Кэши компилятора были доступны для этих целей с Kotlin 1.5.0 с дополнительными свойствами Gradle; теперь вы можете их удалить.

• Время выполнения: итерирование по массивам с помощью for циклов теперь ускорилось до 12% благодаря оптимизациям в сгенерированном коде LLVM.

Единый ABI компилятора плагинов с JVM и JS IR бэкендами

В предыдущих версиях авторы плагинов компилятора должны были предоставлять отдельные артефакты для Kotlin/Native из-за различий в ABI.

Начиная с 1.6.0, плагин Kotlin Multiplatform Gradle может использовать встраиваемый jar-файл компилятора — тот, который используется для JVM и JS IR бэкендов — для Kotlin/Native. Это шаг к унификации опыта разработки плагинов компилятора, так как теперь вы можете использовать одни и те же артефакты плагина компилятора для Native и других поддерживаемых платформ.

Это предварительная версия такой поддержки, и она требует включения. Чтобы начать использование общих артефактов плагина компилятора для Kotlin/Native, добавьте следующую строку в gradle.properties: kotlin.native.useEmbeddableCompilerJar=true.

В будущем мы планируем использовать встраиваемый jar-файл компилятора для Kotlin/Native по умолчанию, поэтому для нас важно узнать, как предварительная версия работает для вас.

Если вы автор плагина компилятора, пожалуйста, попробуйте этот режим и проверьте, работает ли он для вашего плагина. В зависимости от структуры вашего плагина могут потребоваться шаги миграции. См. эту проблему YouTrack для инструкций по миграции и оставьте свои отзывы в комментариях.

Подробные сообщения об ошибках для сбоев связи klib

Компилятор Kotlin/Native теперь предоставляет подробные сообщения об ошибках для ошибок связи klib. Сообщения теперь содержат ясные описания ошибок, а также информацию о возможных причинах и способах их исправления.

Например:

• 1.5.30:

  e: java.lang.IllegalStateException: IrTypeAliasSymbol expected: Unbound public symbol for public kotlinx.coroutines/CancellationException|null[0]
  <stack trace>
  

• 1.6.0:

  e: The symbol of unexpected type encountered during IR deserialization: IrClassPublicSymbolImpl, kotlinx.coroutines/CancellationException|null[0].
  IrTypeAliasSymbol is expected.
  
  This could happen if there are two libraries, where one library was compiled against the different version of the other library than the one currently used in the project.
  Please check that the project configuration is correct and has consistent versions of dependencies.
  
  The list of libraries that depend on "org.jetbrains.kotlinx:kotlinx-coroutines-core (org.jetbrains.kotlinx:kotlinx-coroutines-core-macosx64)" and may lead to conflicts:
  <list of libraries and potential version mismatches>
  
  Project dependencies:
  <dependencies tree>
  

Переработанный API обработки необработанных исключений

Мы унифицировали обработку необработанных исключений во всем времени выполнения Kotlin/Native и выделили стандартную обработку как функцию processUnhandledException(throwable: Throwable) для использования сторонними средами выполнения, такими как kotlinx.coroutines. Эта обработка также применяется к исключениям, которые выходят за пределы обработки в Worker.executeAfter(), но только для нового менеджера памяти.

Улучшения API также затронули обработчики, которые были установлены setUnhandledExceptionHook(). Ранее такие обработчики сбрасывались после того, как время выполнения Kotlin/Native вызывало обработчик с необработанным исключением, и программа всегда завершалась сразу после этого. Теперь эти обработчики могут использоваться более одного раза, и если вы хотите, чтобы программа всегда завершалась при возникновении необработанного исключения, либо не устанавливайте обработчик необработанных исключений (setUnhandledExceptionHook()), либо убедитесь, что вызываете terminateWithUnhandledException() в конце своего обработчика. Это поможет вам отправлять исключения в стороннюю службу отслеживания сбоев (например, Firebase Crashlytics), а затем завершать программу. Исключение, которое выходит за пределы обработки в main(), и исключения, пересекающие границу взаимодействия, всегда будут завершать программу, даже если обработчик не вызвал terminateWithUnhandledException().

Возможность использования предварительно установленных Node.js и Yarn

Теперь вы можете отключить загрузку Node.js и Yarn при построении проектов Kotlin/JS и использовать уже установленные экземпляры на хосте. Это полезно для построения на серверах без подключения к интернету, таких как сервера CI.

Чтобы отключить загрузку внешних компонентов, добавьте следующие строки в ваш build.gradle(.kts):

• Yarn:

  rootProject.plugins.withType<org.jetbrains.kotlin.gradle.targets.js.yarn.YarnPlugin> {
      rootProject.the<org.jetbrains.kotlin.gradle.targets.js.yarn.YarnRootExtension>().download = false // or true for default behavior
  }
  

  rootProject.plugins.withType(org.jetbrains.kotlin.gradle.targets.js.yarn.YarnPlugin) {
      rootProject.extensions.getByType(org.jetbrains.kotlin.gradle.targets.js.yarn.YarnRootExtension).download = false
  }
  

• Node.js:

  rootProject.plugins.withType<org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootPlugin> {
      rootProject.the<org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootExtension>().download = false // or true for default behavior
  }
  
  

  rootProject.plugins.withType(org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootPlugin) {
      rootProject.extensions.getByType(org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootExtension).download = false
  }
  

Kover – инструмент для измерения покрытия кода Kotlin

В Kotlin 1.6.0 мы представили Kover – плагин Gradle для агентов измерения покрытия кода Kotlin для IntelliJ и JaCoCo. Он работает со всеми языковыми конструкциями, включая встроенные функции.

Узнайте больше о Kover на его GitHub репозитории или в этом видео: