Что нового в Kotlin 1.5.30

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

С Kotlin 1.5.30 теперь вы можете вызывать конструкторы классов аннотаций в произвольном коде, чтобы получить экземпляр. Эта функция охватывает те же сценарии использования, что и соглашение Java, позволяющее реализовывать интерфейс аннотации.

annotation class InfoMarker(val info: String)

fun processInfo(marker: InfoMarker) = ...

fun main(args: Array<String>) {
    if (args.size != 0)
        processInfo(getAnnotationReflective(args))
    else
        processInfo(InfoMarker("default"))
}

Используйте опцию компилятора -language-version 1.6, чтобы включить эту функцию. Обратите внимание, что все текущие ограничения классов аннотаций, такие как ограничения на определение параметров, не являющихся val, или членов, отличных от вторичных конструкторов, остаются в силе.

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

Улучшенная конфигурация поддержки аннотаций нулевых значений

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

В Kotlin 1.5.30 вы можете указать, сообщает ли компилятор о несоответствии нулевых значений на основе информации из определённых типов аннотаций нулевых значений. Просто используйте опцию компилятора -Xnullability-annotations=@<package-name>:<report-level>. В аргументе укажите полное имя пакета аннотаций нулевых значений и один из уровней отчёта:

• ignore, чтобы игнорировать несоответствия нулевых значений

• warn, чтобы сообщать предупреждения

• strict, чтобы сообщать об ошибках.

См. полный список поддерживаемых аннотаций нулевых значений вместе с их полными именами пакетов.

Вот пример, показывающий, как включить отчёт об ошибках для недавно поддерживаемых аннотаций нулевых значений RxJava 3: -Xnullability-annotations=@io.reactivex.rxjava3.annotations:strict. Обратите внимание, что по умолчанию все такие несоответствия нулевых значений являются предупреждениями.

Поддержка Apple silicon

Kotlin 1.5.30 предоставляет поддержку для Apple silicon.

Ранее компилятор и инструменты Kotlin/Native требовали среду перевода Rosetta для работы на компьютерах с Apple silicon. В Kotlin 1.5.30 среда перевода больше не требуется — компилятор и инструменты могут работать на оборудовании Apple silicon без дополнительных действий.

Мы также добавили новые целевые платформы, которые позволяют коду Kotlin работать напрямую на Apple silicon:

• macosArm64

• iosSimulatorArm64

• watchosSimulatorArm64

• tvosSimulatorArm64

Они доступны как на компьютерах с Intel процессорами, так и на компьютерах с Apple silicon. Все существующие целевые платформы также доступны на компьютерах с Apple silicon.

Обратите внимание, что в 1.5.30 мы предоставляем только базовую поддержку целевых платформ Apple silicon в плагине Gradle kotlin-multiplatform. В частности, новые целевые платформы эмулятора не включены в ios, tvos, и watchos сокращения целевых платформ. Узнайте, как использовать целевые платформы Apple silicon с сокращениями целевых платформ. Мы будем продолжать работу над улучшением пользовательского опыта с новыми целевыми платформами.

Улучшенное Kotlin DSL для плагина CocoaPods Gradle

cocoapods {
    frameworkName = "MyFramework" // This property is deprecated 
    // and will be removed in future versions
    // New DSL for framework configuration:
    framework {
        // All Framework properties are supported
        // Framework name configuration. Use this property instead of 
        // deprecated 'frameworkName'
        baseName = "MyFramework"
        // Dynamic framework support
        isStatic = false
        // Dependency export
        export(project(":anotherKMMModule"))
        transitiveExport = false // This is default.
        // Bitcode embedding
        embedBitcode(BITCODE)
    }
}

cocoapods {
    // Maps custom Xcode configuration to NativeBuildType
    xcodeConfigurationToNativeBuildType["CUSTOM_DEBUG"] = NativeBuildType.DEBUG
    xcodeConfigurationToNativeBuildType["CUSTOM_RELEASE"] = NativeBuildType.RELEASE
}

Экспериментальная межплатформенная работа со Swift 5.5 async/await

Мы добавили поддержку вызова приостанавливаемых функций Kotlin из Objective-C и Swift в 1.4.0, и сейчас улучшаем ее, чтобы соответствовать новой функции Swift 5.5 — конкурентность с async и await модификаторами.

Компилятор Kotlin/Native теперь генерирует атрибут _Nullable_result в сгенерированных заголовках Objective-C для приостанавливаемых функций с возвращаемыми значениями, которые могут быть null. Это позволяет вызывать их из Swift как async функции с соответствующей информацией о возможном null.

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

Улучшенное отображение Swift/Objective-C для объектов и компаньонов

Теперь доступ к объектам и компаньонам можно получить более интуитивно для разработчиков iOS нативной платформы. Например, если у вас есть следующие объекты в Kotlin:

object MyObject {
    val x = "Some value"
}

class MyClass {
    companion object {
        val x = "Some value"
    }
}

Для доступа к ним в Swift вы можете использовать свойства shared и companion:

MyObject.shared
MyObject.shared.x
MyClass.companion
MyClass.Companion.shared

Узнайте больше о межплатформенной работе Swift/Objective-C.

Устаревание связи с DLL без библиотек импорта для целей MinGW

LLD — это компоновщик из проекта LLVM, который мы планируем начать использовать в Kotlin/Native для целей MinGW из-за его преимуществ по сравнению с стандартным ld.bfd — прежде всего, из-за лучшей производительности.

Однако, последняя стабильная версия LLD не поддерживает прямую связь с DLL для целей MinGW (Windows). Для такой связи необходимы библиотеки импорта. Хотя они не нужны с Kotlin/Native 1.5.30, мы добавляем предупреждение, чтобы проинформировать вас о том, что такое использование несовместимо с LLD, который станет стандартным компоновщиком для MinGW в будущем.

Пожалуйста, поделитесь своими мыслями и опасениями по поводу перехода к компоновщику LLD на этой странице YouTrack.

Возможность использования пользовательских библиотек cinterop в общем коде для нативных платформ

Kotlin Multiplatform предоставляет возможность использования зависимых от платформы библиотек interop в общих наборах исходного кода. До версии 1.5.30 это работало только с библиотеками платформы, поставляемыми с дистрибутивом Kotlin/Native. Начиная с 1.5.30, вы можете использовать свои пользовательские cinterop библиотеки. Для включения этой функции добавьте свойство kotlin.mpp.enableCInteropCommonization=true в свой gradle.properties:

kotlin.mpp.enableGranularSourceSetsMetadata=true
kotlin.native.enableDependencyPropagation=false
kotlin.mpp.enableCInteropCommonization=true

Поддержка XCFrameworks

Теперь все проекты Kotlin Multiplatform могут иметь XCFrameworks в качестве формата вывода. Apple представила XCFrameworks как замену универсальным (fat) фреймворкам. С помощью XCFrameworks вы:

• Можете собрать логику для всех целевых платформ и архитектур в одном пакете.

• Не нужно удалять все ненужные архитектуры перед публикацией приложения в App Store.

XCFrameworks полезны, если вы хотите использовать свой Kotlin-фреймворк для устройств и симуляторов на Apple M1.

Для использования XCFrameworks обновите свой скрипт build.gradle(.kts):

import org.jetbrains.kotlin.gradle.plugin.mpp.apple.XCFramework

plugins {
    kotlin("multiplatform")
}

kotlin {
    val xcf = XCFramework()
  
    ios {
        binaries.framework {
            baseName = "shared"
            xcf.add(this)
        }
    }
    watchos {
        binaries.framework {
            baseName = "shared"
            xcf.add(this)
        }
    }
    tvos {
        binaries.framework {
            baseName = "shared"
            xcf.add(this)
        }
    }
}

import org.jetbrains.kotlin.gradle.plugin.mpp.apple.XCFrameworkConfig

plugins {
    id 'org.jetbrains.kotlin.multiplatform'
}

kotlin {
    def xcf = new XCFrameworkConfig(project)

    ios {
        binaries.framework {
            baseName = "shared"
            xcf.add(it)
        }
    }
    watchos {
        binaries.framework {
            baseName = "shared"
            xcf.add(it)
        }
    }
    tvos {
        binaries.framework {
            baseName = "shared"
            xcf.add(it)
        }
    }
}

При объявлении XCFrameworks будут зарегистрированы новые задачи Gradle:

• assembleXCFramework

• assembleDebugXCFramework (дополнительно артефакт отладки, который содержит dSYMs)

• assembleReleaseXCFramework

Подробнее о XCFrameworks можно узнать в видео WWDC.

Новая настройка публикации по умолчанию для артефактов Android

Используя плагин Gradle maven-publish, вы можете опубликовать вашу многоплатформенную библиотеку для целевой платформы Android, указав имена вариантов Android в скрипте сборки. Плагин Kotlin Gradle сгенерирует публикации автоматически.

До версии 1.5.30 сгенерированный метаданные публикации metadata включали атрибуты типа сборки для каждого опубликованного варианта Android, что делало его совместимым только с тем же типом сборки, который использовался потребителем библиотеки. Kotlin 1.5.30 вводит новую настройку публикации по умолчанию:

• Если все варианты Android, которые проект публикует, имеют одинаковый атрибут типа сборки, то опубликованные варианты не будут иметь атрибута типа сборки и будут совместимы с любым типом сборки.

• Если опубликованные варианты имеют разные атрибуты типа сборки, то будут опубликованы только те, которые имеют значение release, без атрибута типа сборки. Это делает варианты релизов совместимыми с любым типом сборки на стороне потребителя, в то время как варианты, не относящиеся к релизу, будут совместимы только с соответствующими типами сборки потребителя.

Чтобы отказаться от этого и сохранить атрибуты типа сборки для всех вариантов, вы можете установить эту переменную Gradle: kotlin.android.buildTypeAttribute.keep=true.

Бета-версия бэкенда компилятора JS IR

Основанный на IR бэкенд компилятора для Kotlin/JS, который был представлен в 1.4.0 в альфа-версии, достиг стадии бета-версии.

Ранее мы опубликовали руководство по миграции на JS IR бэкенд, чтобы помочь вам перенести ваши проекты на новый бэкенд. Теперь мы хотим представить плагин IDE Kotlin/JS Inspection Pack, который отображает требуемые изменения непосредственно в IntelliJ IDEA.

Улучшенное отладка для приложений с бэкендом Kotlin/JS IR

Kotlin 1.5.30 добавляет генерацию карт исходного кода JavaScript для бэкенда Kotlin/JS IR. Это улучшит опыт отладки Kotlin/JS при включенном бэкенде IR, с полной поддержкой отладки, включая точки останова, пошаговый режим и читаемые трассы вызова с соответствующими ссылками на исходный код.

Узнайте, как отладить Kotlin/JS в браузере или IntelliJ IDEA Ultimate.

Поддержка Java-инструментальных цепочек

Gradle 6.7 представил функцию "Поддержка инструментальных цепочек Java". Используя эту функцию, вы можете:

• Выполнять компиляции, тесты и исполняемые файлы, используя JDK и JRE, отличные от тех, которые используются Gradle.

• Компилировать и тестировать код с невыпущенной версией языка.

Благодаря поддержке инструментальных цепочек, Gradle может автоматически обнаруживать локальные JDK и устанавливать недостающие JDK, необходимые для сборки. Теперь сам Gradle может работать на любом JDK и по-прежнему использовать функцию кэширования сборки build cache.

Плагин Kotlin Gradle поддерживает Java-инструментальные цепочки для задач компиляции Kotlin/JVM. Java-инструментальная цепочка:

• Устанавливает jdkHome опцию, доступную для JVM-мишеней.

• Устанавливает kotlinOptions.jvmTarget на версию JDK инструментальной цепочки, если пользователь явно не задал опцию jvmTarget. Если инструментальная цепочка не настроена, поле jvmTarget использует значение по умолчанию. Узнайте больше о совместимости JVM-мишеней.

• Влияет на то, на каких JDK kapt рабочие процессы выполняются.

Используйте следующий код для задания инструментальной цепочки. Замените <MAJOR_JDK_VERSION> на желаемую версию JDK:

kotlin {
    jvmToolchain {
        (this as JavaToolchainSpec).languageVersion.set(JavaLanguageVersion.of(<MAJOR_JDK_VERSION>)) // “8”
    }
}

kotlin {
    jvmToolchain {
        languageVersion.set(JavaLanguageVersion.of(<MAJOR_JDK_VERSION>)) // “8”
    }
}

Обратите внимание, что задание инструментальной цепочки через расширение kotlin также обновит инструментальную цепочку для задач компиляции Java.

Вы можете задать инструментальную цепочку через расширение java, и задачи компиляции Kotlin будут использовать её:

java {
    toolchain {
        languageVersion.set(JavaLanguageVersion.of(<MAJOR_JDK_VERSION>)) // “8”
    }
}

Для получения информации о задании любой версии JDK для задач KotlinCompile, просмотрите документацию о задании версии JDK с помощью Task DSL.

Для версий Gradle от 6.1 до 6.6 используйте интерфейс UsesKotlinJavaToolchain для задания домашнего каталога JDK.

Изменение вывода Duration.toString()

До Kotlin 1.5.30 функция Duration.toString() возвращала строковое представление своего аргумента, выраженное в единицах измерения, которые давали наиболее компактное и удобочитаемое числовое значение. Отныне она будет возвращать строку, выраженную как комбинацию числовых компонентов, каждый в своих собственных единицах. Каждый компонент — это число, за которым следует сокращённое название единицы: d, h, m, s. Например:

Также изменён способ представления отрицательных периодов. Отрицательный период предваряется знаком минус (-), а если он состоит из нескольких компонентов, он заключён в скобки: -12m и -(1h 30m).

Обратите внимание, что короткие периоды менее секунды представлены одним числом с одной из подсекундных единиц. Например, ms (миллисекунды), us (микросекунды) или ns (наносекунды): 140.884ms, 500us, 24ns. Научная запись больше не используется для их представления.

Если требуется выразить период в одной единице, используйте перегруженную функцию Duration.toString(unit, decimals).

Парсинг Duration из строки

В Kotlin 1.5.30 в API Duration появились новые функции:

• parse(), которая поддерживает парсинг результатов:

  • toString().

  • toString(unit, decimals).

  • toIsoString().

• parseIsoString(), которая парсит только формат, созданный функцией toIsoString().

• parseOrNull() и parseIsoStringOrNull(), которые ведут себя как функции выше, но возвращают null вместо того, чтобы выбрасывать IllegalArgumentException при некорректном формате периода.

Вот несколько примеров использования parse() и parseOrNull():

import kotlin.time.Duration
import kotlin.time.ExperimentalTime

@ExperimentalTime
fun main() {
//sampleStart
    val isoFormatString = "PT1H30M"
    val defaultFormatString = "1h 30m"
    val singleUnitFormatString = "1.5h"
    val invalidFormatString = "1 hour 30 minutes"
    println(Duration.parse(isoFormatString)) // "1h 30m"
    println(Duration.parse(defaultFormatString)) // "1h 30m"
    println(Duration.parse(singleUnitFormatString)) // "1h 30m"
    //println(Duration.parse(invalidFormatString)) // throws exception
    println(Duration.parseOrNull(invalidFormatString)) // "null"
//sampleEnd
}

И вот несколько примеров использования parseIsoString() и parseIsoStringOrNull():

import kotlin.time.Duration
import kotlin.time.ExperimentalTime

@ExperimentalTime
fun main() {
//sampleStart
    val isoFormatString = "PT1H30M"
    val defaultFormatString = "1h 30m"
    println(Duration.parseIsoString(isoFormatString)) // "1h 30m"
    //println(Duration.parseIsoString(defaultFormatString)) // throws exception
    println(Duration.parseIsoStringOrNull(defaultFormatString)) // "null"
//sampleEnd
}

Сопоставление с регулярным выражением в определённой позиции

Новые функции Regex.matchAt() и Regex.matchesAt() позволяют проверить, есть ли точное совпадение регулярного выражения в определённой позиции в String или CharSequence.

matchesAt() возвращает boolean-результат:

fun main(){
//sampleStart
    val releaseText = "Kotlin 1.5.30 is released!"
    // regular expression: one digit, dot, one digit, dot, one or more digits
    val versionRegex = "\\d[.]\\d[.]\\d+".toRegex()
    println(versionRegex.matchesAt(releaseText, 0)) // "false"
    println(versionRegex.matchesAt(releaseText, 7)) // "true"
//sampleEnd
}

matchAt() возвращает совпадение, если оно найдено, или null, если нет:

fun main(){
//sampleStart
    val releaseText = "Kotlin 1.5.30 is released!"
    val versionRegex = "\\d[.]\\d[.]\\d+".toRegex()
    println(versionRegex.matchAt(releaseText, 0)) // "null"
    println(versionRegex.matchAt(releaseText, 7)?.value) // "1.5.30"
//sampleEnd
}

Разбиение регулярного выражения на последовательность

Новая функция Regex.splitToSequence() — ленивый аналог split(). Она разбивает строку по совпадениям заданного регулярного выражения, но возвращает результат как последовательность, поэтому все операции с этим результатом выполняются лениво.

fun main(){
//sampleStart
    val colorsText = "green, red , brown&blue, orange, pink&green"
    val regex = "[,\\s]+".toRegex()
    val mixedColor = regex.splitToSequence(colorsText)
        .onEach { println(it) }
        .firstOrNull { it.contains('&') }
    println(mixedColor) // "brown&blue"
//sampleEnd
}

Аналогичная функция была добавлена в CharSequence:

    val mixedColor = colorsText.splitToSequence(regex)