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

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

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

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

Kotlin 1.7.0 повторно вводит оригинальные имена функций, но с типом возвращаемого значения non-nullable. Новые функции 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 отчёта о сборке сборки.

• 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.3

• 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>)
    }
}