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

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

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

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

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 или в этом видео: