Что нового в 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 Optional

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 отчета о сборке Gradle.

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