Что нового в 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 для IntelliJ и JaCoCo агентов покрытия кода Kotlin. Он работает со всеми конструкциями языка, включая встроенные функции.

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