Kotlin 1.7.0 版中的新功能

JVM 平台的新的 Kotlin K2 编译器 (Alpha 版)

项目	现在的 Kotlin 编译器性能	新 K2 Kotlin 编译器性能	性能提升
Kotlin	2.2 KLOC/s	4.8 KLOC/s	~ 2.2倍
YouTrack	1.8 KLOC/s	4.2 KLOC/s	~ 2.3倍
IntelliJ IDEA	1.8 KLOC/s	3.9 KLOC/s	~ 2.2倍
Space	1.2 KLOC/s	2.8 KLOC/s	~ 2.3倍

-Xuse-k2

语言功能

允许接口的实现代理给内联类的内联值

interface Bar {
    fun foo() = "foo"
}

@JvmInline
value class BarWrapper(val bar: Bar): Bar by bar

fun main() {
    val bw = BarWrapper(object: Bar {})
    println(bw.foo())
}

类型参数的下划线操作符

Kotlin 1.7.0 为类型参数引入了一个下划线操作符, _. 当其它类型已指定时, 你可以使用它来自动推断一个类型参数:

abstract class SomeClass<T> {
    abstract fun execute(): T
}

class SomeImplementation : SomeClass<String>() {
    override fun execute(): String = "Test"
}

class OtherImplementation : SomeClass<Int>() {
    override fun execute(): Int = 42
}

object Runner {
    inline fun <reified S: SomeClass<T>, T> run(): T {
        return S::class.java.getDeclaredConstructor().newInstance().execute()
    }
}

fun main() {
    // T 被推断为 String, 因为 SomeImplementation 继承自 SomeClass<String>
    val s = Runner.run<SomeImplementation, _>()
    assert(s == "Test")

    // T 被推断为 Int, 因为 OtherImplementation 继承自 SomeClass<Int>
    val n = Runner.run<OtherImplementation, _>()
    assert(n == 42)
}

明确非 null 类型的稳定版

你可以使用新的语法 T & Any, 在使用端将一个泛型类型参数标记为明确非 null. 这个语法来自交叉类型(Intersection Types) 的标记形式, 并且现在 & 左侧必须是上界可为 null 的类型参数, 右侧必须是非 null 的 Any:

fun <T> elvisLike(x: T, y: T & Any): T & Any = x ?: y

fun main() {
    // OK
    elvisLike<String>("", "").length
    // 错误: 'null' 不能作为一个非 null 类型的值
    elvisLike<String>("", null).length

    // OK
    elvisLike<String?>(null, "").length
    // 错误: 'null' 不能作为一个非 null 类型的值
    elvisLike<String?>(null, null).length
}

Kotlin/Native

支持独立的 Android 可执行文件

binaryOptions["androidProgramType"] = "nativeActivity"

修改 Kotlin/Native 编译器的下载 URL

默认的起始 URL 是 https://download.jetbrains.com/kotlin/native/builds, 如果要修改, 请使用以下 Gradle 属性:

kotlin.native.distribution.baseDownloadUrl=https://example.com

Kotlin/JS

使用 IR 时对成员名称极简化(Minification)

当你在 production 模式下构建 Kotlin/JS 应用程序时, 会自动进行这样的极简化, 并且这个功能默认启用. 如果要禁用成员名称极简化, 请使用 -Xir-minimized-member-names 编译器 flag:

kotlin {
    js(IR) {
        compilations.all {
            compileKotlinTask.kotlinOptions.freeCompilerArgs += listOf("-Xir-minimized-member-names=false")
        }
    }
}

从 js 表达式动态装载 JavaScript 模块

从 Kotlin 1.7.0 开始, 在 js 代码段内, 支持使用 JavaScript 中的 import 语句, 因此你可以在运行时动态的将包引入到你的应用程序中:

val myPackage = js("import('my-package')")

为 JavaScript 测试运行器指定环境变量

为了对 Node.js 包的解析进行微调, 或者向 Node.js 测试代码传递外部信息, 现在你可以指定供 JavaScript 测试运行器使用的环境变量. 要定义一个环境变量, 请在你的构建脚本的 testTask 代码段之内, 使用 environment() 函数, 参数是一个键-值对:

kotlin {
    js {
        nodejs {
            testTask {
                environment("key", "value")
            }
        }
    }
}

标准库

集合函数 min() 和 max() 返回非 null 值

在 Kotlin 1.4.0 中, 我们将集合函数 min() 和 max() 重命名为 minOrNull() 和 maxOrNull(). 这些新名称更好的反应函数的行为 – 如果接受者集合为空, 则返回 null. 还有助于让 Kotlin 集合 API 的函数行为与命名规约保持整体一致.

对函数 minBy(), maxBy(), minWith(), 和 maxWith() 也是如此, 在 Kotlin 1.4.0 中, 所有这些函数都有了对应的 *OrNull() 同义函数. 被这个变更影响的旧函数, 已被逐渐废弃.

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."
}

在明确指定的下标处查找正规表达式匹配

在 1.5.30 中引入的 Regex.matchAt() 和 Regex.matchesAt() 函数现在升级为稳定版. 这些函数提供了一种方法, 在一个 String 或 CharSequence 中的一个指定的位置, 检查正规表达式是否存在一个完整的匹配.

matchesAt() 检查一个匹配, 并返回一个 boolean 结果:

fun main() {
    val releaseText = "Kotlin 1.7.0 is on its way!"
    // 正规表达式: 一个数字, 点号, 一个数字, 点号, 一个或多个数字
    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"
}

通过反射访问注解

@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)]
}

深度递归(Deep Recursive) 函数升级为稳定版

从 Kotlin 1.4.0 开始, 深度递归(Deep Recursive)函数作为实验性功能引入, 现在在 Kotlin 1.7.0 中升级为稳定版. 使用 DeepRecursiveFunction, 你可以定义一个函数, 让它的调用栈保存在 heap 内存中, 而不是使用实际的调用栈. 因此你可以运行非常深的递归计算. 要调用一个深度递归函数, 只需要 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() {
    // 生成一个深度为 100_000 的树
    val deepTree = generateSequence(Tree(null, null)) { prev ->
        Tree(prev, null)
    }.take(100_000).last()

    println(calculateDepth(deepTree)) // 输出结果为: 100000
}

对默认的时间源(Time Source)使用基于内联类的时间标记器(Time mark)

Kotlin 1.7.0 改善了时间测量功能的性能, 方法是将 TimeSource.Monotonic 返回的时间标记器(Time mark) 改为内联的值类. 因此, 调用 markNow(), elapsedNow(), measureTime(), 和 measureTimedValue() 之类的函数, 不会为它们的 TimeMark 实例包装类分配内存. 尤其是在测量一个热点部分中的一段代码时, 这个功能可以减少测量对性能的影响:

@OptIn(ExperimentalTime::class)
fun main() {
    val mark = TimeSource.Monotonic.markNow() // 返回的 `TimeMark` 是内联类
    val elapsedDuration = mark.elapsedNow()
}

对 Java Optionals 的新的扩展函数(实验性功能)

Kotlin 1.7.0 带来了新的便利函数, 可以简化 Java 中的 Optional 类的使用. 这些新函数可以用来在 JVM 上解封和转换 optional 对象, 让使用 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 有值, 会将值转换为一个 List, Set, 或 Sequence, 否则返回一个空集合. 扩展函数 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 中支持命名捕获组(Named Capturing Group)

要为一个捕获组指定一个名称, 请在你的正规表达式中使用 (?<name>group) 语法. 要得到被这个组匹配的文本, 请调用新引入的函数 MatchGroupCollection.get(), 参数是组的名称.

通过名称获取匹配的组的值

我们来看看这个示例, 它匹配城市的座标. 要得到正规表达式匹配的组的集合, 请使用 groups. 比较一下得到组的两种方法, 一种是通过组的编号(下标)来得到, 另一种是通过组的名称来得到, 然后使用 value 得到组的内容:

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" — 通过名称得到组
    println(match.groups[2]?.value) // 输出结果为: "TX" — 通过下标得到组
}

命名的反向引用

你现在还可以在反向引用组时使用组的名称. 反向引用会匹配在前面曾经被一个捕获组匹配过的相同的文字. 要使用这个功能, 请在你的正规表达式中使用 \k<name> 语法:

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"
}

在替换表达式中使用命名的组

在替换字符串中出现的 ${name} 会被替换为这个名称对应的捕获组的内容. 你可以比较在替换表达式通过名称和通过下标引用组的方法:

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" — 通过名称引用组
    println(dateRegex.replace(input, "\$3-\$2-\$1")) // 输出结果为: "Date of birth: 2022-04-27" — 通过下标引用组
}

Gradle

增量编译的新方案

如果你使用构建缓存, 或在非 Kotlin Gradle 模块中频繁的进行修改, 那么我们期待你会看到新方案的显著改进. 我们对 Kotlin 项目的 kotlin-gradle-plugin 模块的测试显示, 对在缓存命中之后的变更, 性能改善超过 80%.

要试用这个新方案, 请在你的 gradle.properties 中设置以下选项:

kotlin.incremental.useClasspathSnapshot=true

对 Kotlin 编译器任务的构建报告

要启用构建报告, 请在 gradle.properties 中声明构建报告输出的保存位置:

kotlin.build.report.output=file

Kotlin Gradle plugin API 中的更新

新的接口, 用于带有用户可配置输入的 Kotlin/JVM 和 Kotlin/kapt 任务.
一个新的 KotlinBasePlugin 接口, 所有的 Kotlin plugin 继承这个接口. 如果你想要在任何 Kotlin Gradle plugin (JVM, JS, Multiplatform, Native, 以及其他平台) 被应用时触发某些配置动作, 可以使用这个接口:
```
project.plugins.withType<org.jetbrains.kotlin.gradle.plugin.KotlinBasePlugin>() {
    // 在这里配置你的动作
}
```
你可以在这个 YouTrack ticket 中留下关于 KotlinBasePlugin 的反馈.
我们完成了 Android Gradle plugin 的基础工作, 让它能够配置 Kotlin 编译, 因此你不需要在你的构建中添加 Kotlin Android Gradle plugin. 请参见 Android Gradle Plugin 发布公告, 查看添加了哪些功能, 并试用它!

可以通过 plugin API 使用 sam-with-receiver plugin

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

在 kapt 中, 对每个注解处理器生成的文件的统计

过去, kotlin-kapt Gradle plugin 可以对每个处理器报告性能统计. 从 Kotlin 1.7.0 开始, 它还可以每个注解处理器报告生成的文件数量统计.

在你的 build.gradle.kts 中, 将 showProcessorStats flag 设置为 true:
```
kapt {
    showProcessorStats = true
}
```
在你的 gradle.properties 中, 将 kapt.verbose Gradle 属性设置为 true:
```
kapt.verbose=true
```

统计结果会出现在 log 中, 级别为 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

废弃了系统属性 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 章节.

删除了废弃的选项, 方法, 和 plugin

删除了 useExperimentalAnnotation 方法

在 Kotlin 1.7.0 中, 我们完成了 Gradle 方法 useExperimentalAnnotation 的废弃周期. 如果使用一个模块中的一个 API 需要使用者的同意, 请改用 optIn().

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

删除了工具链扩展方法中的类型转换

在 Kotlin 1.7.0 之前, 在使用 Kotlin DSL 配置 Gradle 工具链时, 你必须将它类型转换为 JavaToolchainSpec 类:

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

现在, 你可以省略 (this as JavaToolchainSpec) 部分:

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

Kotlin 1.7.0 版中的新功能﻿

JVM 平台的新的 Kotlin K2 编译器 (Alpha 版)﻿

tip

语言功能﻿

允许接口的实现代理给内联类的内联值﻿

类型参数的下划线操作符﻿

note

构建器推断的稳定版﻿

明确要求使用者同意(Opt-in Requirement)的稳定版﻿

明确非 null 类型的稳定版﻿

Kotlin/JVM﻿

编译器性能优化﻿

新的编译器选项: -Xjdk-release﻿

note

对函数式接口构造器的可调用引用: 稳定版﻿

删除了 JVM 编译目标版本 1.6﻿

Kotlin/Native﻿

对新的内存管理器的性能改进﻿

note

对 JVM 和 JS IR 后端统一的编译器 plugin ABI﻿

warning

支持独立的 Android 可执行文件﻿

与 Swift async/await 交互: 返回 Void 而不是 KotlinUnit﻿

禁止未声明的异常通过 Objective-C 桥﻿

与 CocoaPods 集成的改进﻿

修改 Kotlin/Native 编译器的下载 URL﻿

note

Kotlin/JS﻿

对新的 IR 后端的性能改进﻿

使用 IR 时对成员名称极简化(Minification)﻿

在 IR 后端中使用 polyfill 支持旧的浏览器﻿

从 js 表达式动态装载 JavaScript 模块﻿

为 JavaScript 测试运行器指定环境变量﻿

标准库﻿

集合函数 min() 和 max() 返回非 null 值﻿

在明确指定的下标处查找正规表达式匹配﻿

延长对旧的语言和 API 版本的支持﻿

通过反射访问注解﻿

深度递归(Deep Recursive) 函数升级为稳定版﻿

对默认的时间源(Time Source)使用基于内联类的时间标记器(Time mark)﻿

note

对 Java Optionals 的新的扩展函数(实验性功能)﻿

在 JS 和 Native 中支持命名捕获组(Named Capturing Group)﻿

通过名称获取匹配的组的值﻿

命名的反向引用﻿

在替换表达式中使用命名的组﻿

Gradle﻿

增量编译的新方案﻿

warning

note

对 Kotlin 编译器任务的构建报告﻿

warning

note

提升最小支持版本﻿

支持 Gradle plugin 变体(Variant)﻿

note

Kotlin Gradle plugin API 中的更新﻿

可以通过 plugin API 使用 sam-with-receiver plugin﻿

编译任务中的更新﻿

在 kapt 中, 对每个注解处理器生成的文件的统计﻿

note

废弃了系统属性 kotlin.compiler.execution.strategy﻿

删除了废弃的选项, 方法, 和 plugin﻿

删除了 useExperimentalAnnotation 方法﻿

删除了废弃的编译器选项﻿

note

删除了废弃的 plugin﻿

tip

删除了废弃的 coroutines DSL 选项和属性﻿

删除了工具链扩展方法中的类型转换﻿

迁移到 Kotlin 1.7.0﻿

安装 Kotlin 1.7.0﻿

note

将既有的项目迁移到 Kotlin 1.7.0, 或使用 Kotlin 1.7.0 创建新的项目﻿

Kotlin 1.7.0 兼容性指南﻿

Kotlin 1.7.0 版中的新功能

JVM 平台的新的 Kotlin K2 编译器 (Alpha 版)

语言功能

允许接口的实现代理给内联类的内联值

类型参数的下划线操作符

构建器推断的稳定版

明确要求使用者同意(Opt-in Requirement)的稳定版

明确非 null 类型的稳定版

Kotlin/JVM

编译器性能优化

新的编译器选项: -Xjdk-release

对函数式接口构造器的可调用引用: 稳定版

删除了 JVM 编译目标版本 1.6

Kotlin/Native

对新的内存管理器的性能改进

对 JVM 和 JS IR 后端统一的编译器 plugin ABI

支持独立的 Android 可执行文件

与 Swift async/await 交互: 返回 `Void` 而不是 `KotlinUnit`

禁止未声明的异常通过 Objective-C 桥

与 CocoaPods 集成的改进

修改 Kotlin/Native 编译器的下载 URL

Kotlin/JS

对新的 IR 后端的性能改进

使用 IR 时对成员名称极简化(Minification)

在 IR 后端中使用 polyfill 支持旧的浏览器

从 js 表达式动态装载 JavaScript 模块

为 JavaScript 测试运行器指定环境变量

标准库

集合函数 min() 和 max() 返回非 null 值

在明确指定的下标处查找正规表达式匹配

延长对旧的语言和 API 版本的支持

通过反射访问注解

深度递归(Deep Recursive) 函数升级为稳定版

对默认的时间源(Time Source)使用基于内联类的时间标记器(Time mark)

对 Java Optionals 的新的扩展函数(实验性功能)

在 JS 和 Native 中支持命名捕获组(Named Capturing Group)

通过名称获取匹配的组的值

命名的反向引用

在替换表达式中使用命名的组

Gradle

增量编译的新方案

对 Kotlin 编译器任务的构建报告

提升最小支持版本

支持 Gradle plugin 变体(Variant)

Kotlin Gradle plugin API 中的更新

可以通过 plugin API 使用 sam-with-receiver plugin

编译任务中的更新

在 kapt 中, 对每个注解处理器生成的文件的统计

废弃了系统属性 kotlin.compiler.execution.strategy

删除了废弃的选项, 方法, 和 plugin

删除了 useExperimentalAnnotation 方法

删除了废弃的编译器选项

删除了废弃的 plugin

删除了废弃的 coroutines DSL 选项和属性

删除了工具链扩展方法中的类型转换

迁移到 Kotlin 1.7.0

安装 Kotlin 1.7.0

将既有的项目迁移到 Kotlin 1.7.0, 或使用 Kotlin 1.7.0 创建新的项目

Kotlin 1.7.0 兼容性指南