JetBrains
diff --git a/‎data/releases.yml
Lines changed: 2 additions & 2 deletions b/‎data/releases.yml
Lines changed: 2 additions & 2 deletions
diff --git a/‎docs/kr.tree
Lines changed: 7 additions & 3 deletions b/‎docs/kr.tree
Lines changed: 7 additions & 3 deletions
diff --git a/‎docs/topics/annotations.md
Lines changed: 155 additions & 14 deletions b/‎docs/topics/annotations.md
Lines changed: 155 additions & 14 deletions
diff --git a/‎docs/topics/ant.md
Lines changed: 8 additions & 0 deletions b/‎docs/topics/ant.md
Lines changed: 8 additions & 0 deletions
diff --git a/‎docs/topics/build-tools-api.md
Lines changed: 108 additions & 0 deletions b/‎docs/topics/build-tools-api.md
Lines changed: 108 additions & 0 deletions
@@ -1,5 +1,5 @@
 url: https://github.com/JetBrains/kotlin/releases
 
 latest:
-  version: 2.1.21
-  url: https://github.com/JetBrains/kotlin/releases/tag/v2.1.21
+  version: 2.2.0
+  url: https://github.com/JetBrains/kotlin/releases/tag/v2.2.0
@@ -33,10 +33,11 @@
 		<toc-element topic="competitive-programming.md"/>
 	</toc-element>
 	<toc-element toc-title="What's new in Kotlin">
-		<toc-element toc-title="Kotlin 2.1.20" accepts-web-file-names="whatsnew.html" topic="whatsnew2120.md"/>
+		<toc-element toc-title="Kotlin 2.2.0" accepts-web-file-names="whatsnew.html" topic="whatsnew22.md"/>
 		<toc-element toc-title="Kotlin 2.1.0" topic="whatsnew21.md"/>
-		<toc-element toc-title="Kotlin 2.2.0-RC3" topic="whatsnew-eap.md"/>
+		<toc-element toc-title="Kotlin 2.2.0-RC3" topic="whatsnew-eap.md" hidden="true"/>
 		<toc-element toc-title="Earlier versions">
+			<toc-element toc-title="Kotlin 2.1.20" topic="whatsnew2120.md"/>
 			<toc-element toc-title="Kotlin 2.0.20" topic="whatsnew2020.md"/>
 			<toc-element toc-title="Kotlin 2.0.0" topic="whatsnew20.md"/>
 			<toc-element toc-title="Kotlin 1.9.20" topic="whatsnew1920.md"/>
@@ -119,6 +120,7 @@
 				<toc-element topic="type-safe-builders.md"/>
 				<toc-element topic="using-builders-with-builder-inference.md"/>
 			</toc-element>
+			<toc-element topic="context-parameters.md"/>
 		</toc-element>
 		<toc-element topic="null-safety.md"/>
 		<toc-element topic="equality.md"/>
@@ -221,7 +223,6 @@
 			<toc-element topic="dev-server-continuous-compilation.md"/>
 			<toc-element accepts-web-file-names="debugging-kotlin-in-browser.html" topic="js-debugging.md"/>
 			<toc-element accepts-web-file-names="running-tests.html" topic="js-running-tests.md"/>
-			<toc-element topic="javascript-dce.md"/>
 			<!-- The following page is used in the Mari link service. If you wish to change it here, change the link there too -->
 			<toc-element toc-title="IR compiler" topic="js-ir-compiler.md"/>
 			<toc-element topic="js-ir-migration.md"/>
@@ -304,9 +305,11 @@
 				<toc-element topic="gradle-best-practices.md"/>
 				<toc-element toc-title="Compiler options in KGP" topic="gradle-compiler-options.md"/>
 				<toc-element toc-title="Compilation and caches in KGP" topic="gradle-compilation-and-caches.md"/>
+				<toc-element toc-title="Binary compatibility validation in KGP" topic="gradle-binary-compatibility-validation.md"/>
 				<toc-element topic="gradle-plugin-variants.md"/>
 			</toc-element>
 			<toc-element accepts-web-file-names="using-maven.html" topic="maven.md"/>
+			<toc-element topic="build-tools-api.md"/>
 			<toc-element accepts-web-file-names="using-ant.html" topic="ant.md"/>
 		</toc-element>
 		<toc-element toc-title="Dokka">
@@ -377,6 +380,7 @@
 	<toc-element toc-title="Other resources">
 		<toc-element topic="faq.md"/>
 		<toc-element toc-title="Kotlin compatibility guides">
+			<toc-element topic="compatibility-guide-22.md"/>
 			<toc-element topic="compatibility-guide-21.md"/>
 			<toc-element topic="compatibility-guide-20.md"/>
 			<toc-element topic="compatibility-guide-19.md"/>
 
@@ -1,6 +1,6 @@
 [//]: # (title: Annotations)
 
-Annotations are means of attaching metadata to code. To declare an annotation, put the `annotation` modifier in front of a class:
+Annotations are a means of attaching metadata to code. To declare an annotation, put the `annotation` modifier in front of a class:
 
 ```kotlin
 annotation class Fancy
@@ -137,14 +137,14 @@ val f = @Suspendable { Fiber.sleep(10) }
 
 ## Annotation use-site targets
 
-When you're annotating a property or a primary constructor parameter, there are multiple Java elements which are
+When you're annotating a property or a primary constructor parameter, there are multiple Java elements that are
 generated from the corresponding Kotlin element, and therefore multiple possible locations for the annotation in
 the generated Java bytecode. To specify how exactly the annotation should be generated, use the following syntax:
 
 ```kotlin
-class Example(@field:Ann val foo,    // annotate Java field
-              @get:Ann val bar,      // annotate Java getter
-              @param:Ann val quux)   // annotate Java constructor parameter
+class Example(@field:Ann val foo,    // annotate only the Java field
+              @get:Ann val bar,      // annotate only the Java getter
+              @param:Ann val quux)   // annotate only the Java constructor parameter
 ```
 
 The same syntax can be used to annotate the entire file. To do this, put an annotation with the target `file` at
@@ -157,7 +157,7 @@ package org.jetbrains.demo
 ```
 
 If you have multiple annotations with the same target, you can avoid repeating the target by adding brackets after the
-target and putting all the annotations inside the brackets:
+target and putting all the annotations inside the brackets (except for the `all` meta-target):
 
 ```kotlin
 class Example {
@@ -169,27 +169,168 @@ class Example {
 The full list of supported use-site targets is:
 
   * `file`
-  * `property` (annotations with this target are not visible to Java)
   * `field`
+  * `property` (annotations with this target are not visible to Java)
   * `get` (property getter)
   * `set` (property setter)
+  * `all` (an experimental meta-target for properties, see [below](#all-meta-target) for its purpose and usage)
   * `receiver` (receiver parameter of an extension function or property)
+
+    To annotate the receiver parameter of an extension function, use the following syntax:
+
+    ```kotlin
+    fun @receiver:Fancy String.myExtension() { ... }
+    ```
+    
   * `param` (constructor parameter)
   * `setparam` (property setter parameter)
   * `delegate` (the field storing the delegate instance for a delegated property)
 
-To annotate the receiver parameter of an extension function, use the following syntax:
+### Defaults when no use-site targets are specified
+
+If you don't specify a use-site target, the target is chosen according to the `@Target` annotation of the annotation
+being used.
+If there are multiple applicable targets, the first applicable target from the following list is used:
+
+* `param`
+* `property`
+* `field`
+
+Let's use the [`@Email` annotation from Jakarta Bean Validation](https://jakarta.ee/specifications/bean-validation/3.0/apidocs/jakarta/validation/constraints/email):
+
+```java
+@Target(value={METHOD,FIELD,ANNOTATION_TYPE,CONSTRUCTOR,PARAMETER,TYPE_USE})
+public @interface Email { }
+```
+
+With this annotation, consider the following example:
 
 ```kotlin
-fun @receiver:Fancy String.myExtension() { ... }
+data class User(val username: String,
+                // @Email is equivalent to @param:Email
+                @Email val email: String) {
+    // @Email is equivalent to @field:Email
+    @Email val secondaryEmail: String? = null
+}
 ```
 
-If you don't specify a use-site target, the target is chosen according to the `@Target` annotation of the annotation
-being used. If there are multiple applicable targets, the first applicable target from the following list is used:
+Kotlin 2.2.0 introduced an experimental defaulting rule which should
+make propagating annotations to parameters, fields, and properties more predictable.
 
-  * `param`
-  * `property`
-  * `field`
+With the new rule, if there are multiple applicable targets, one or more is chosen as follows:
+
+* If the constructor parameter target (`param`) is applicable, it is used.
+* If the property target (`property`) is applicable, it is used.
+* If the field target (`field`) is applicable while `property` isn't, `field` is used.
+
+Using the same example:
+
+```kotlin
+data class User(val username: String,
+                // @Email is now equivalent to @param:Email @field:Email
+                @Email val email: String) {
+    // @Email is still equivalent to @field:Email
+    @Email val secondaryEmail: String? = null
+}
+```
+
+If there are multiple targets, and none of `param`, `property`, or `field` are applicable, the annotation is invalid.
+
+To enable the new defaulting rule, use the following line in your Gradle configuration:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xannotation-default-target=param-property")
+    }
+}
+```
+
+Whenever you'd like to use the old behavior, you can:
+
+* In a specific case, specify the necessary target explicitly, for example, using `@param:Annotation` instead of `@Annotation`.
+* For a whole project, use this flag in your Gradle build file:
+
+    ```kotlin
+    // build.gradle.kts
+    kotlin {
+        compilerOptions {
+            freeCompilerArgs.add("-Xannotation-default-target=first-only")
+        }
+    }
+    ```
+
+### `all` meta-target
+
+<primary-label ref="experimental-opt-in"/>
+
+The `all` target makes it easier to apply the same annotation not only to the parameter and the property or field, but also to the corresponding getter and setter.
+
+Specifically, the annotation marked with `all` is propagated, if applicable:
+
+* To the constructor parameter (`param`) if the property is defined in the primary constructor.
+* To the property itself (`property`).
+* To the backing field (`field`) if the property has one.
+* To the getter (`get`).
+* To the setter parameter (`setparam`) if the property is defined as `var`.
+* To the Java-only target `RECORD_COMPONENT` if the class has the `@JvmRecord` annotation.
+
+Let's use the [`@Email` annotation from Jakarta Bean Validation](https://jakarta.ee/specifications/bean-validation/3.0/apidocs/jakarta/validation/constraints/email),
+which is defined as follows:
+
+```java
+@Target(value={METHOD,FIELD,ANNOTATION_TYPE,CONSTRUCTOR,PARAMETER,TYPE_USE})
+public @interface Email { }
+```
+
+In the example below, this `@Email` annotation is applied to all relevant targets:
+
+```kotlin
+data class User(
+    val username: String,
+    // Applies `@Email` to `param`, `field` and `get`
+    @all:Email val email: String,
+    // Applies `@Email` to `param`, `field`, `get`, and `set_param`
+    @all:Email var name: String,
+) {
+    // Applies `@Email` to `field` and `getter` (no `param` since it's not in the constructor)
+    @all:Email val secondaryEmail: String? = null
+}
+```
+
+You can use the `all` meta-target with any property, both inside and outside the primary constructor.
+
+#### Limitations
+
+The `all` target comes with some limitations:
+
+* It does not propagate an annotation to types, potential extension receivers, or context receivers or parameters.
+* It cannot be used with multiple annotations:
+    ```kotlin
+    @all:[A B] // forbidden, use `@all:A @all:B`
+    val x: Int = 5
+    ```
+* It cannot be used with [delegated properties](delegated-properties.md).
+
+#### How to enable
+
+To enable the `all` meta-target in your project, use the following compiler option in the command line:
+
+```Bash
+-Xannotation-target-all
+```
+
+Or add it to the `compilerOptions {}` block of your Gradle build file:
+
+```kotlin
+// build.gradle.kts
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xannotation-target-all")
+    }
+}
+```
 
 ## Java annotations
 
 
@@ -1,5 +1,13 @@
 [//]: # (title: Ant)
 
+> Starting with Kotlin 2.2.0, support for the Ant build system in Kotlin is deprecated.
+> We plan to remove Ant support in Kotlin 2.3.0.
+> 
+> However, if you're interested in becoming an external maintainer for Ant,
+> leave a comment in [this YouTrack issue](https://youtrack.jetbrains.com/issue/KT-75875/).
+> 
+{style="warning"}
+
 ## Getting the Ant tasks
 
 Kotlin provides three tasks for Ant:
 
@@ -0,0 +1,108 @@
+[//]: # (title: Build tools API)
+
+<primary-label ref="experimental-general"/>
+
+<tldr>Currently, the BTA supports Kotlin/JVM only.</tldr>
+
+Kotlin 2.2.0 introduces an experimental Build tools API (BTA) that simplifies how build systems integrate with the 
+Kotlin compiler.
+
+Previously, adding full Kotlin support to a build system (like incremental compilation, Kotlin compiler plugins, 
+daemons, and Kotlin Multiplatform) required significant effort. The BTA aims to reduce this complexity by providing
+a unified API between build systems and the Kotlin compiler ecosystem.
+
+The BTA defines a single entry point that build systems can implement. This removes the need to deeply integrate with internal compiler details.
+
+> The BTA itself is not yet publicly available for direct use in your own build tool integrations.
+> If you're interested in the proposal or want to share feedback, see the [KEEP](https://github.com/Kotlin/KEEP/issues/421).
+> Follow the status of its implementation in [YouTrack](https://youtrack.jetbrains.com/issue/KT-76255).
+> 
+{style="warning"}
+
+## Integration with Gradle
+
+The Kotlin Gradle plugin (KGP) has experimental support for the BTA, and you need to opt in to use it.
+
+> We'd appreciate your feedback on your experience with the KGP in [YouTrack](https://youtrack.jetbrains.com/issue/KT-56574).
+> 
+{style="note"}
+
+### How to enable
+
+Add the following property to your `gradle.properties` file:
+
+```kotlin
+kotlin.compiler.runViaBuildToolsApi=true
+```
+
+### Configure different compiler versions
+
+With the BTA, you can now use a different Kotlin compiler version than the version used by the KGP. This is useful when:
+
+* You want to try new Kotlin features but haven't updated your build scripts yet.
+* You need the latest plugin fixes but want to stay on an older compiler version for now.
+
+Here's an example of how to configure this in your `build.gradle.kts` file:
+
+```kotlin
+import org.jetbrains.kotlin.buildtools.api.ExperimentalBuildToolsApi
+import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
+
+plugins {
+	kotlin("jvm") version "2.2.0"
+}
+
+group = "org.jetbrains.example"
+version = "1.0-SNAPSHOT"
+
+repositories {
+	mavenCentral()
+}
+
+kotlin {
+	jvmToolchain(8)
+	@OptIn(ExperimentalBuildToolsApi::class, ExperimentalKotlinGradlePluginApi::class)
+	compilerVersion.set("2.1.21") // <-- different version than 2.2.0
+}
+```
+
+#### Compatible Kotlin compiler and KGP versions
+
+The BTA supports:
+
+* The three previous major Kotlin compiler versions.
+* One major version forward.
+
+For example, in KGP 2.2.0, the supported Kotlin compiler versions are:
+
+* 1.9.25
+* 2.0.x
+* 2.1.x
+* 2.2.x
+* 2.3.x
+
+#### Limitations
+
+Using different compiler versions together with compiler plugins may lead to Kotlin compiler exceptions. The Kotlin team
+plans to address this in future Kotlin releases.
+
+### Enable incremental compilation with "in process" strategy
+
+The KGP supports three [compiler execution strategies](gradle-compilation-and-caches.md#defining-kotlin-compiler-execution-strategy).
+Ordinarily, the "in-process" strategy (which runs the compiler in the Gradle daemon) doesn't support incremental compilation.
+
+With the BTA, the "in-process" strategy now supports incremental compilation. To enable it, add the following property to
+your `gradle.properties` file:
+
+```kotlin
+kotlin.compiler.execution.strategy=in-process
+```
+
+## Integration with Maven
+
+From Kotlin 2.2.0, the BTA is enabled by default in the [`kotlin-maven-plugin`](maven.md).
+
+Although the BTA doesn't give direct benefits for Maven users yet, it provides a solid foundation for developing features like:
+
+* [Kotlin daemon support](https://youtrack.jetbrains.com/issue/KT-77587)
+* [Incremental compilation stabilization](https://youtrack.jetbrains.com/issue/KT-77086)