Что нового в Kotlin 1.7.0

Функции min() и max() коллекций возвращают значения без возможности null

В Kotlin 1.4.0 мы переименовали функции min() и max() коллекций в minOrNull() и maxOrNull(). Эти новые имена лучше отражают их поведение — возвращение null, если коллекция-приёмник пуста. Это также помогло выровнять поведение функций с соглашениями об именовании, используемыми в API коллекций Kotlin.

То же самое относилось к minBy(), maxBy(), minWith(), и maxWith(), которые все получили свои синонимы *OrNull() в Kotlin 1.4.0. Более старые функции, затронутые этим изменением, постепенно устарели.

Kotlin 1.7.0 повторно вводит оригинальные имена функций, но с типом возвращаемого значения без возможности null. Новые функции min(), max(), minBy(), maxBy(), minWith(), и maxWith() теперь строго возвращают элемент коллекции или выбрасывают исключение.

fun main() {
    val numbers = listOf<Int>()
    println(numbers.maxOrNull()) // "null"
    println(numbers.max()) // "Exception in... Collection is empty."
}

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

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

matchesAt() проверяет соответствие и возвращает логическое значение:

fun main() {
    val releaseText = "Kotlin 1.7.0 is on its way!"
    // 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"
}

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

fun main() {
    val releaseText = "Kotlin 1.7.0 is on its way!"
    val versionRegex = "\\d[.]\\d[.]\\d+".toRegex()

    println(versionRegex.matchAt(releaseText, 0)) // "null"
    println(versionRegex.matchAt(releaseText, 7)?.value) // "1.7.0"
}

Мы будем признательны за ваш отзыв по этому вопросу YouTrack.

Расширенная поддержка предыдущих версий языка и API

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

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

Доступ к аннотациям через рефлексию

Расширяющая функция KAnnotatedElement.findAnnotations(), которая была впервые представлена в 1.6.0, теперь стабильна. Эта функция рефлексии возвращает все аннотации заданного типа на элементе, включая применённые индивидуально и повторяющиеся аннотации.

@Repeatable
annotation class Tag(val name: String)

@Tag("First Tag")
@Tag("Second Tag")
fun taggedFunction() {
    println("I'm a tagged function!")
}

fun main() {
    val x = ::taggedFunction
    val foo = x as KAnnotatedElement
    println(foo.findAnnotations<Tag>())
    // [@Tag(name=First Tag), @Tag(name=Second Tag)]
}

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

Глубоко рекурсивные функции доступны в качестве экспериментальной функции с Kotlin 1.4.0, и они теперь стабильны в Kotlin 1.7.0. Используя DeepRecursiveFunction, вы можете определить функцию, которая сохраняет свой стек в куче вместо использования фактического стека вызовов. Это позволяет запускать очень глубокие рекурсивные вычисления. Чтобы вызвать глубоко рекурсивную функцию, invoke её.

В этом примере глубоко рекурсивная функция используется для вычисления глубины двоичного дерева рекурсивно. Несмотря на то, что эта функция-пример вызывает себя рекурсивно 100 000 раз, исключение StackOverflowError не выбрасывается:

class Tree(val left: Tree?, val right: Tree?)

val calculateDepth = DeepRecursiveFunction<Tree?, Int> { t ->
    if (t == null) 0 else maxOf(
        callRecursive(t.left),
        callRecursive(t.right)
    ) + 1
}

fun main() {
    // Generate a tree with a depth of 100_000
    val deepTree = generateSequence(Tree(null, null)) { prev ->
        Tree(prev, null)
    }.take(100_000).last()

    println(calculateDepth(deepTree)) // 100000
}

Рассмотрите использование глубоко рекурсивных функций в вашем коде, где глубина вашей рекурсии превышает 1000 вызовов.

Отметки времени на основе встроенных классов для исходного источника времени по умолчанию

Kotlin 1.7.0 улучшает производительность функциональности измерения времени, изменив отметки времени, возвращаемые TimeSource.Monotonic на встроенные классы значений. Это означает, что вызов функций, таких как markNow(), elapsedNow(), measureTime(), и measureTimedValue() не выделяет классы-обертки для их TimeMark экземпляров. Особенно при измерении фрагмента кода, который является частью горячей ветви, это может помочь свести к минимуму негативное влияние измерения на производительность:

@OptIn(ExperimentalTime::class)
fun main() {
    val mark = TimeSource.Monotonic.markNow() // Returned `TimeMark` is inline class
    val elapsedDuration = mark.elapsedNow()
}

Новые экспериментальные расширяющие функции для Java Optionals

Kotlin 1.7.0 поставляется с новыми удобными функциями, которые упрощают работу с Optional классами в Java. Эти новые функции могут использоваться для распаковки и преобразования необязательных объектов в JVM и помогают сделать работу с Java API более лаконичной.

Расширяющие функции getOrNull(), getOrDefault(), и getOrElse() позволяют получить значение Optional, если оно присутствует. В противном случае вы получаете значение по умолчанию, null, или значение, возвращаемое функцией, соответственно:

val presentOptional = Optional.of("I'm here!")

println(presentOptional.getOrNull())
// "I'm here!"

val absentOptional = Optional.empty<String>()

println(absentOptional.getOrNull())
// null
println(absentOptional.getOrDefault("Nobody here!"))
// "Nobody here!"
println(absentOptional.getOrElse {
    println("Optional was absent!")
    "Default value!"
})
// "Optional was absent!"
// "Default value!"

Расширяющие функции toList(), toSet(), и asSequence() преобразуют значение присутствующего Optional в список, множество или последовательность, или возвращают пустую коллекцию в противном случае. Расширяющая функция toCollection() добавляет Optional значение в уже существующую целевую коллекцию:

val presentOptional = Optional.of("I'm here!")
val absentOptional = Optional.empty<String>()
println(presentOptional.toList() + "," + absentOptional.toList())
// ["I'm here!"], []
println(presentOptional.toSet() + "," + absentOptional.toSet())
// ["I'm here!"], []
val myCollection = mutableListOf<String>()
absentOptional.toCollection(myCollection)
println(myCollection)
// []
presentOptional.toCollection(myCollection)
println(myCollection)
// ["I'm here!"]
val list = listOf(presentOptional, absentOptional).flatMap { it.asSequence() }
println(list)
// ["I'm here!"]

Эти расширяющие функции вводятся как экспериментальные в Kotlin 1.7.0. Вы можете узнать больше о Optional расширениях в этой KEEP. Как всегда, мы приветствуем ваши отзывы в отслеживателе проблем Kotlin.

Поддержка именованных групп захвата в JS и Native

Начиная с Kotlin 1.7.0, именованные группы захвата поддерживаются не только на JVM, но и на платформах JS и Native.

Чтобы присвоить имя группе захвата, используйте синтаксис (?<name>group) в вашем регулярном выражении. Чтобы получить текст, сопоставленный группой, вызовите новую функцию MatchGroupCollection.get() и передайте имя группы.

fun main() {
    val regex = "\\b(?<city>[A-Za-z\\s]+),\\s(?<state>[A-Z]{2}):\\s(?<areaCode>[0-9]{3})\\b".toRegex()
    val input = "Coordinates: Austin, TX: 123"
    val match = regex.find(input)!!
    println(match.groups["city"]?.value) // "Austin" — by name
    println(match.groups[2]?.value) // "TX" — by number
}

fun backRef() {
    val regex = "(?<title>\\w+), yes \\k<title>".toRegex()
    val match = regex.find("Do you copy? Sir, yes Sir!")!!
    println(match.value) // "Sir, yes Sir"
    println(match.groups["title"]?.value) // "Sir"
}

fun dateReplace() {
    val dateRegex = Regex("(?<dd>\\d{2})-(?<mm>\\d{2})-(?<yyyy>\\d{4})")
    val input = "Date of birth: 27-04-2022"
    println(dateRegex.replace(input, "\${yyyy}-\${mm}-\${dd}")) // "Date of birth: 2022-04-27" — by name
    println(dateRegex.replace(input, "\$3-\$2-\$1")) // "Date of birth: 2022-04-27" — by number
}

Новый подход к инкрементальной компиляции

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

Мы ожидаем, что вы увидите наибольшую пользу от нового подхода, если используете кэш сборки или часто вносите изменения в не-Kotlin модули Gradle. Наши тесты для проекта Kotlin на модуле kotlin-gradle-plugin показывают улучшение более чем на 80% для изменений после попадания в кэш.

Чтобы попробовать этот новый подход, установите следующую опцию в вашем gradle.properties:

kotlin.incremental.useClasspathSnapshot=true

Узнайте, как реализован новый подход к инкрементальной компиляции, в этой статье блога.

Наш план — стабилизировать эту технологию и добавить поддержку других бэкэндов (например, JS) и систем сборки. Мы будем благодарны за сообщения в YouTrack о любых проблемах или странном поведении, с которым вы столкнулись при использовании этой схемы компиляции. Спасибо!

Команда Kotlin выражает огромную благодарность Ивану Гавриловичу, Нгуену Хунгу, Седрику Шанпо и другим внешним участникам за их помощь.

Отчеты о сборке для задач компилятора Kotlin

Kotlin 1.7.0 вводит отчеты о сборке, которые помогают отслеживать производительность компилятора. Отчеты содержат продолжительность различных фаз компиляции и причины, по которым компиляция не могла быть инкрементальной.

Отчеты о сборке полезны, когда вы хотите разобраться с проблемами задач компилятора, например:

• Когда сборка Gradle занимает слишком много времени, и вы хотите понять причину низкой производительности.

• Когда время компиляции одного и того же проекта различается, иногда занимая секунды, а иногда минуты.

Чтобы включить отчеты о сборке, укажите, где сохранить вывод отчёта о сборке в gradle.properties:

kotlin.build.report.output=file

Доступны следующие значения (и их комбинации):

• file сохраняет отчеты о сборке в локальном файле.

• build_scan сохраняет отчеты о сборке в разделе custom values скана сборки build scan.

• http отправляет отчеты о сборке с помощью HTTP(S). Метод POST отправляет метрики в формате JSON. Данные могут меняться от версии к версии. Текущую версию отправляемых данных можно посмотреть в репозитории Kotlin.

Есть два распространённых случая, когда анализ отчетов о сборке для длительных компиляций может помочь вам решить:

• Сборка не была инкрементальной. Проанализируйте причины и устраните лежащие в основе проблемы.

• Сборка была инкрементальной, но заняла слишком много времени. Попробуйте переорганизовать исходные файлы — разделите большие файлы, сохраняйте отдельные классы в разных файлах, переименуйте большие классы, объявляйте функции верхнего уровня в разных файлах и так далее.

Узнайте больше о новых отчетах о сборке в этой статье блога.

Вы можете попробовать использовать отчеты о сборке в вашей инфраструктуре. Если у вас есть какие-либо отзывы, вы столкнулись с проблемами или хотите предложить улучшения, не стесняйтесь сообщать об этом в наш трекер задач. Спасибо!

Изменение минимально поддерживаемых версий

Начиная с Kotlin 1.7.0, минимально поддерживаемая версия Gradle — 6.7.1. Нам пришлось повысить версию, чтобы поддержать варианты плагинов Gradle и новый API Gradle. В будущем нам не придётся так часто повышать минимально поддерживаемую версию благодаря функции вариантов плагинов Gradle.

Также минимально поддерживаемая версия Android Gradle Plugin теперь 3.6.4.

Поддержка вариантов плагинов Gradle

Gradle 7.0 представил новую функцию для авторов плагинов Gradle — плагины с вариантами. Эта функция упрощает добавление поддержки новых возможностей Gradle, сохраняя совместимость с версиями Gradle ниже 7.1. Узнайте больше о выборе вариантов в Gradle.

С помощью вариантов плагинов Gradle мы можем поставлять различные варианты плагина Kotlin Gradle для разных версий Gradle. Цель — поддерживать базовый Kotlin-компилятор в main варианте, что соответствует старейшим поддерживаемым версиям Gradle. Каждый вариант будет содержать реализации функций Gradle из соответствующего релиза. Последний вариант будет поддерживать самый широкий набор функций Gradle. С помощью этого подхода мы можем расширить поддержку более старых версий Gradle с ограниченным функционалом.

В настоящее время существует только два варианта плагина Kotlin Gradle:

• main для версий Gradle 6.7.1–6.9.2

• gradle70 для версий Gradle 7.0 и выше

В будущих версиях Kotlin мы можем добавить больше.

Чтобы проверить, какой вариант использует ваш билд, включите уровень --info логгирования и найдите строку в выводе, начинающуюся с Using Kotlin Gradle plugin, например Using Kotlin Gradle plugin main variant.

Оставьте свой отзыв на этом билете YouTrack.

Обновления в API плагина Kotlin Gradle

Артефакт API плагина Kotlin Gradle претерпел несколько улучшений:

• Появились новые интерфейсы для задач Kotlin/JVM и Kotlin/kapt с настраиваемыми пользователем входными данными.

• Появился новый KotlinBasePlugin интерфейс, от которого наследуются все Kotlin-плагины. Используйте этот интерфейс, когда хотите запустить действие конфигурации всякий раз, когда применяется любой плагин Kotlin Gradle (JVM, JS, Multiplatform, Native и другие платформы):

  project.plugins.withType<org.jetbrains.kotlin.gradle.plugin.KotlinBasePlugin>() {
      // Configure your action here
  }
  

  Вы можете оставить свой отзыв об KotlinBasePlugin на этом билете YouTrack.

• Мы заложили основу для плагина Android Gradle для конфигурации Kotlin-компиляции внутри него, что означает, что вам не нужно добавлять плагин Kotlin Android Gradle в свой билд. Следите за объявлениями релизов плагина Android Gradle, чтобы узнать о добавленной поддержке и попробовать её!

Плагин sam-with-receiver доступен через API плагинов

Плагин компиляции sam-with-receiver теперь доступен через DSL плагинов Gradle:

plugins {
    id("org.jetbrains.kotlin.plugin.sam.with.receiver") version "$kotlin_version"
}

Изменения в задачах компиляции

Задачи компиляции претерпели множество изменений в этом релизе:

• Задачи компиляции Kotlin больше не наследуют задачу Gradle AbstractCompile. Они наследуют только DefaultTask.

• Задача AbstractCompile имеет входные данные sourceCompatibility и targetCompatibility. Поскольку задача AbstractCompile больше не наследуется, эти входные данные больше недоступны в скриптах пользователей Kotlin.

• Входной параметр SourceTask.stableSources больше недоступен, и вы должны использовать входной параметр sources. setSource(...) методы всё ещё доступны.

• Все задачи компиляции теперь используют входной параметр libraries для списка библиотек, необходимых для компиляции. Задача KotlinCompile всё ещё имеет устаревшее свойство Kotlin classpath, которое будет удалено в будущих версиях.

• Задачи компиляции всё ещё реализуют интерфейс PatternFilterable, который позволяет фильтровать Kotlin-исходники. Входной параметр sourceFilesExtensions был удалён в пользу использования PatternFilterable методов.

• Устаревший Gradle destinationDir: File вывод был заменён на destinationDirectory: DirectoryProperty вывод.

• Задача Kotlin/Native AbstractNativeCompile теперь наследует базовый класс AbstractKotlinCompileTool. Это первый шаг к интеграции инструментов билда Kotlin/Native во все другие инструменты.

Пожалуйста, оставьте свой отзыв на этом билете YouTrack.

Статистика сгенерированных файлов каждым обработчиком аннотаций в kapt

Плагин Gradle kotlin-kapt уже отчитывается о статистике производительности для каждого процессора. Начиная с Kotlin 1.7.0, он также может отчитываться о статистике количества сгенерированных файлов для каждого обработчика аннотаций.

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

Включите статистику в два этапа:

• Установите флаг showProcessorStats в значение true в вашем build.gradle.kts.

  kapt {
      showProcessorStats = true
  }
  
  

• Установите свойство Gradle kapt.verbose в значение true в вашем gradle.properties.

  kapt.verbose=true
  

Статистика будет отображаться в логах на уровне info. Вы увидите строку Annotation processor stats:, за которой следуют данные о времени выполнения каждого обработчика аннотаций. После этих строк будет строка Generated files report:, за которой следуют данные о количестве сгенерированных файлов для каждого обработчика аннотаций. Например:

[INFO] Annotation processor stats:
[INFO] org.mapstruct.ap.MappingProcessor: total: 290 ms, init: 1 ms, 3 round(s): 289 ms, 0 ms, 0 ms
[INFO] Generated files report:
[INFO] org.mapstruct.ap.MappingProcessor: total sources: 2, sources per round: 2, 0, 0

Пожалуйста, оставьте свой отзыв на этом билете YouTrack.

Устаревание системного свойства kotlin.compiler.execution.strategy

Kotlin 1.6.20 представил новые свойства для определения стратегии выполнения компилятора Kotlin. В Kotlin 1.7.0 начался процесс устаревания старого системного свойства kotlin.compiler.execution.strategy в пользу новых свойств.

При использовании системного свойства kotlin.compiler.execution.strategy вы получите предупреждение. Это свойство будет удалено в будущих релизах. Чтобы сохранить старое поведение, замените системное свойство свойством Gradle с таким же именем. Вы можете сделать это в gradle.properties, например:

kotlin.compiler.execution.strategy=out-of-process

Вы также можете использовать свойство задачи компиляции compilerExecutionStrategy. Узнайте больше об этом на странице Gradle.

Удаление устаревших опций, методов и плагинов

sourceSets {
    all {
        languageSettings.optIn("org.mylibrary.OptInAnnotation")
    }
}

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

kotlin {
    jvmToolchain {
        languageVersion.set(JavaLanguageVersion.of(<MAJOR_JDK_VERSION>)
    }
}