Merge branch 'master' into kug-inclusion-kotlin-devs-brasil

lucasfugisawa · web-flow · commit 043681957228 · 2024-05-28T18:11:59.000-03:00
diff --git a/CODEOWNERS b/CODEOWNERS
@@ -1,7 +1,7 @@
 * @zoobestik @nikpachoo @krutilov
 
 # Community events
-/data/events.yml @MKrishtal
+/data/events.yml @MKrishtal @meilalina
 /data/user-groups.yml @MKrishtal @meilalina
 /data/universities.yml @Belosnegova
 
diff --git a/docs/topics/gradle/gradle-compiler-options.md b/docs/topics/gradle/gradle-compiler-options.md
@@ -171,7 +171,7 @@ Here is a complete list of options for Gradle tasks:
 | Name                      | Description                                                                                                                                                                                                                                   | Possible values                                                                                         | Default value               |
 |---------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------|-----------------------------|
 | `javaParameters`          | Generate metadata for Java 1.8 reflection on method parameters                                                                                                                                                                                |                                                                                                         | false                       |
-| `jvmTarget`               | Target version of the generated JVM bytecode                                                                                                                                                                                                  | "1.8", "9", "10", ...,  "20", "21". Also, see [Types for compiler options](#types-for-compiler-options) | "%defaultJvmTargetVersion%" |
+| `jvmTarget`               | Target version of the generated JVM bytecode                                                                                                                                                                                                  | "1.8", "9", "10", ...,  "21", "22". Also, see [Types for compiler options](#types-for-compiler-options) | "%defaultJvmTargetVersion%" |
 | `noJdk`                   | Don't automatically include the Java runtime into the classpath                                                                                                                                                                               |                                                                                                         | false                       |
 | `jvmTargetValidationMode` | <list><li>Validation of the [JVM target compatibility](gradle-configure-project.md#check-for-jvm-target-compatibility-of-related-compile-tasks) between Kotlin and Java</li><li>A property for tasks of the `KotlinCompile` type.</li></list> | `WARNING`, `ERROR`, `INFO`                                                                              | `ERROR`                     |
 
diff --git a/docs/topics/k2-compiler-migration-guide.md b/docs/topics/k2-compiler-migration-guide.md
@@ -293,6 +293,8 @@ fun main(input: Rho) {
     var unknownObject: Rho = input
 
     // Check if unknownObject inherits from the Tau interface
+    // Note, it's possible that unknownObject inherits from both
+    // Rho and Tau interfaces.
     if (unknownObject is Tau) {
 
         // Use the overloaded inc() operator from interface Rho,
diff --git a/docs/topics/kapt.md b/docs/topics/kapt.md
@@ -276,6 +276,29 @@ kapt.incremental.apt=false
 
 Note that incremental annotation processing requires [incremental compilation](gradle-compilation-and-caches.md#incremental-compilation)
 to be enabled as well.
+
+## Inherit annotation processors from superconfigurations
+
+You can define a common set of annotation processors in a separate Gradle configuration as a 
+superconfiguration and extend it further in kapt-specific configurations for your subprojects.
+
+As an example, for a subproject using [Dagger](https://dagger.dev/), in your `build.gradle(.kts)` file, use the following configuration:
+
+```kotlin
+val commonAnnotationProcessors by configurations.creating
+configurations.named("kapt") { extendsFrom(commonAnnotationProcessors) }
+
+dependencies {
+    implementation("com.google.dagger:dagger:2.48.1")
+    commonAnnotationProcessors("com.google.dagger:dagger-compiler:2.48.1")
+}
+```
+
+In this example, the `commonAnnotationProcessors` Gradle configuration is your common superconfiguration for annotation processing
+that you want to be used for all your projects. You use the [`extendsFrom()`](https://docs.gradle.org/current/dsl/org.gradle.api.artifacts.Configuration.html#org.gradle.api.artifacts.Configuration:extendsFrom)
+method to add `commonAnnotationProcessors` as a superconfiguration. kapt sees that the `commonAnnotationProcessors` 
+Gradle configuration has a dependency on the Dagger annotation processor. Therefore, kapt includes the Dagger annotation processor
+in its configuration for annotation processing.
  
 ## Java compiler options
 
diff --git a/docs/topics/kug-guidelines.md b/docs/topics/kug-guidelines.md
@@ -3,13 +3,13 @@
 A Kotlin User Group, or KUG, is a community that is dedicated to Kotlin and that offers you a place to share your
 Kotlin programming experience with like-minded people.
 
-To become an KUG, your community should have some specific features shared by every KUG. It should:
+To become a KUG, your community should have some specific features shared by every KUG. It should:
 * Provide Kotlin-related content, with regular meetups as the main form of activity.
 * Host regular events (at least once every 3 months) with open registration and without any restriction for attendance.
 * Be driven and organized by the community, and it should not use events to earn money or gain any other business
   benefits from members and attendees.
-* Follow and ensure a code of conduct in order to provide a welcoming environment for attendees of any background and
-  experience (check-out our recommended [Code of Conduct](https://confluence.jetbrains.com/display/ALL/JetBrains+Open+Source+and+Community+Code+of+Conduct)).
+* Follow and ensure a code of conduct to provide a welcoming environment for attendees of any background and
+  experience (check out our recommended [Code of Conduct](https://github.com/jetbrains#code-of-conduct)).
 
 There are no limits regarding the format for KUG meetups. They can take place in whatever fashion works best for the
 community, whether that includes presentations, hands-on labs, lectures, hackathons, or informal beer-driven get-togethers.
@@ -20,7 +20,8 @@ community, whether that includes presentations, hands-on labs, lectures, hackath
 
 ## How to run a KUG?
 
-* In order to promote group cohesion and prevent miscommunication, we recommend keeping to a limit of one KUG per city. Check out [the list of KUGs](https://kotlinlang.org/community/user-groups) to see if there is already a KUG in your area.
+* To promote group cohesion and prevent miscommunication, we recommend keeping to a limit of one KUG per city. 
+  Check out [the list of KUGs](https://kotlinlang.org/community/user-groups/) to see if there is already a KUG in your area.
 * Use the official KUG logo and branding. Check out [the branding guidelines](kotlin-brand-assets.md#kotlin-user-group-brand-assets).
 * Keep your user group active. Run meetups regularly, at least once every 3 months.
 * Announce your KUG meetups at least 2 weeks in advance. The announcement should contain a list of talks
@@ -48,4 +49,4 @@ If you organize any other tech communities, you can apply for support as well. B
 * Free licenses for JetBrains products to raffle off at meetups.
 * Information about Kotlin official events and campaigns.
 * Kotlin stickers.
-* Help with recruiting Kotlin speakers for your events.
+* Help with recruiting Kotlin speakers for your events.
diff --git a/docs/topics/maven.md b/docs/topics/maven.md
@@ -322,17 +322,17 @@ The following attributes are supported:
 
 ### Attributes specific to JVM
 
-| Name              | Property name                   | Description                                                                                          | Possible values                                                                                                              | Default value               |
-|-------------------|---------------------------------|------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------|-----------------------------|
-| `nowarn`          |                                 | Generate no warnings                                                                                 | true, false                                                                                                                  | false                       |
+| Name              | Property name                   | Description                                                                                          | Possible values                                                                                                       | Default value               |
+|-------------------|---------------------------------|------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------|-----------------------------|
+| `nowarn`          |                                 | Generate no warnings                                                                                 | true, false                                                                                                           | false                       |
 | `languageVersion` | kotlin.compiler.languageVersion | Provide source compatibility with the specified version of Kotlin                                    | "1.3" (DEPRECATED), "1.4" (DEPRECATED), "1.5", "1.6", "1.7", "1.8", "1.9", "2.0" (EXPERIMENTAL), "2.1" (EXPERIMENTAL) |                             |
 | `apiVersion`      | kotlin.compiler.apiVersion      | Allow using declarations only from the specified version of bundled libraries                        | "1.3" (DEPRECATED), "1.4" (DEPRECATED), "1.5", "1.6", "1.7", "1.8", "1.9", "2.0" (EXPERIMENTAL), "2.1" (EXPERIMENTAL) |                             |
-| `sourceDirs`      |                                 | The directories containing the source files to compile                                               |                                                                                                                              | The project source roots    |
-| `compilerPlugins` |                                 | Enabled compiler plugins                                                                             |                                                                                                                              | []                          |
-| `pluginOptions`   |                                 | Options for compiler plugins                                                                         |                                                                                                                              | []                          |
-| `args`            |                                 | Additional compiler arguments                                                                        |                                                                                                                              | []                          |
-| `jvmTarget`       | `kotlin.compiler.jvmTarget`     | Target version of the generated JVM bytecode                                                         | "1.8", "9", "10", ..., "21"                                                                                                  | "%defaultJvmTargetVersion%" |
-| `jdkHome`         | `kotlin.compiler.jdkHome`       | Include a custom JDK from the specified location into the classpath instead of the default JAVA_HOME |                                                                                                                              |                             |
+| `sourceDirs`      |                                 | The directories containing the source files to compile                                               |                                                                                                                       | The project source roots    |
+| `compilerPlugins` |                                 | Enabled compiler plugins                                                                             |                                                                                                                       | []                          |
+| `pluginOptions`   |                                 | Options for compiler plugins                                                                         |                                                                                                                       | []                          |
+| `args`            |                                 | Additional compiler arguments                                                                        |                                                                                                                       | []                          |
+| `jvmTarget`       | `kotlin.compiler.jvmTarget`     | Target version of the generated JVM bytecode                                                         | "1.8", "9", "10", ..., "22"                                                                                           | "%defaultJvmTargetVersion%" |
+| `jdkHome`         | `kotlin.compiler.jdkHome`       | Include a custom JDK from the specified location into the classpath instead of the default JAVA_HOME |                                                                                                                       |                             |
 
 ## Use BOM
 
diff --git a/docs/topics/multiplatform/multiplatform-plugin-releases.md b/docs/topics/multiplatform/multiplatform-plugin-releases.md
@@ -41,12 +41,12 @@ Compatible Kotlin version
 
 **0.8.2**
 
-Released: 25 January, 2024
+Released: 16 May, 2024
 
 </td>
 <td>
 
-* Support for the new Canary Android Studio Jellyfish.
+* Support for Android Studio Jellyfish and for the new Canary version, Koala.
 * Added declarations of `sourceCompatibility` and `targetCompatibility` in the shared module.
 
 </td>
diff --git a/docs/topics/tour/kotlin-tour-control-flow.md b/docs/topics/tour/kotlin-tour-control-flow.md
@@ -46,8 +46,8 @@ fun main() {
 ```
 {kotlin-runnable="true" kotlin-min-compiler-version="1.3" id="kotlin-tour-if"}
 
-There is no ternary operator `condition ? then : else` in Kotlin. Instead, `if` can be used as an expression. When using
-`if` as an expression, there are no curly braces `{}`:
+There is no ternary operator `condition ? then : else` in Kotlin. Instead, `if` can be used as an expression. If there is
+only one line of code per action, the curly braces `{}` are optional:
 
 ```kotlin
 fun main() { 
@@ -405,7 +405,7 @@ fun main() {
                 number % 15 == 0 -> "fizzbuzz"
                 number % 3 == 0 -> "fizz"
                 number % 5 == 0 -> "buzz"
-                else -> number.toString()
+                else -> "$number"
             }
         )
     }
@@ -447,4 +447,4 @@ fun main() {
 
 ## Next step
 
-[Functions](kotlin-tour-functions.md)
+[Functions](kotlin-tour-functions.md)
diff --git a/docs/topics/tour/kotlin-tour-functions.md b/docs/topics/tour/kotlin-tour-functions.md
@@ -276,8 +276,8 @@ Kotlin allows you to write even more concise code for functions by using lambda
 For example, the following `uppercaseString()` function:
 
 ```kotlin
-fun uppercaseString(string: String): String {
-    return string.uppercase()
+fun uppercaseString(text: String): String {
+    return text.uppercase()
 }
 fun main() {
     println(uppercaseString("hello"))
@@ -290,7 +290,7 @@ Can also be written as a lambda expression:
 
 ```kotlin
 fun main() {
-    println({ string: String -> string.uppercase() }("hello"))
+    println({ text: String -> text.uppercase() }("hello"))
     // HELLO
 }
 ```
@@ -304,10 +304,10 @@ Within the lambda expression, you write:
 * the function body after the `->`.
 
 In the previous example:
-* `string` is a function parameter.
-* `string` has type `String`.
+* `text` is a function parameter.
+* `text` has type `String`.
 * the function returns the result of the [`.uppercase()`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.text/uppercase.html)
-function called on `string`.
+function called on `text`.
 
 > If you declare a lambda without parameters, then there is no need to use `->`. For example:
 > ```kotlin
@@ -328,7 +328,7 @@ To assign a lambda expression to a variable, use the assignment operator `=`:
 
 ```kotlin
 fun main() {
-    val upperCaseString = { string: String -> string.uppercase() }
+    val upperCaseString = { text: String -> text.uppercase() }
     println(upperCaseString("hello"))
     // HELLO
 }
@@ -406,7 +406,7 @@ For example: `(String) -> String` or `(Int, Int) -> Int`.
 This is what a lambda expression looks like if a function type for `upperCaseString()` is defined:
 
 ```kotlin
-val upperCaseString: (String) -> String = { string -> string.uppercase() }
+val upperCaseString: (String) -> String = { text -> text.uppercase() }
 
 fun main() {
     println(upperCaseString("hello"))
@@ -462,7 +462,7 @@ any parameters within the parentheses:
 ```kotlin
 fun main() {
     //sampleStart
-    println({ string: String -> string.uppercase() }("hello"))
+    println({ text: String -> text.uppercase() }("hello"))
     // HELLO
     //sampleEnd
 }
diff --git a/docs/topics/tour/kotlin-tour-null-safety.md b/docs/topics/tour/kotlin-tour-null-safety.md
@@ -77,7 +77,7 @@ fun describeString(maybeString: String?): String {
 }
 
 fun main() {
-    var nullString: String? = null
+    val nullString: String? = null
     println(describeString(nullString))
     // Empty or null string
 }
@@ -96,7 +96,7 @@ In the following example, the `lengthString()` function uses a safe call to retu
 fun lengthString(maybeString: String?): Int? = maybeString?.length
 
 fun main() { 
-    var nullString: String? = null
+    val nullString: String? = null
     println(lengthString(nullString))
     // null
 }
@@ -119,7 +119,7 @@ is skipped and `null` is returned:
 
 ```kotlin
 fun main() {
-    var nullString: String? = null
+    val nullString: String? = null
     println(nullString?.uppercase())
     // null
 }
@@ -138,7 +138,7 @@ As a result, the Elvis operator returns `0`:
 
 ```kotlin
 fun main() {
-    var nullString: String? = null
+    val nullString: String? = null
     println(nullString?.length ?: 0)
     // 0
 }
diff --git a/docs/topics/typecasts.md b/docs/topics/typecasts.md
@@ -262,8 +262,9 @@ val x: String = y as String
 
 If the cast isn't possible, the compiler throws an exception. This is why it's called _unsafe_.
 
-In the previous example, if `y` is `null`, the code above also throws an exception. This is because `null` can't be cast to `String`, as `null` isn't [nullable](null-safety.md).
-To make the example work for possible null values, use a nullable type on the right-hand side of the cast:
+In the previous example, if `y` is `null`, the code above also throws an exception. This is because `null` can't be cast
+to `String`, as `String` isn't [nullable](null-safety.md). To make the example work for possible null values, use a nullable
+type on the right-hand side of the cast:
 
 ```kotlin
 val x: String? = y as String?
diff --git a/docs/topics/whatsnew20.md b/docs/topics/whatsnew20.md

Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ fun describeString(maybeString: String?): String {`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`fun main() {`
`80`		`- var nullString: String? = null`
	`80`	`+ val nullString: String? = null`
`81`	`81`	`println(describeString(nullString))`
`82`	`82`	`// Empty or null string`
`83`	`83`	`}`
@@ -96,7 +96,7 @@ In the following example, the `lengthString()` function uses a safe call to retu
`96`	`96`	`fun lengthString(maybeString: String?): Int? = maybeString?.length`
`97`	`97`
`98`	`98`	`fun main() {`
`99`		`- var nullString: String? = null`
	`99`	`+ val nullString: String? = null`
`100`	`100`	`println(lengthString(nullString))`
`101`	`101`	`// null`
`102`	`102`	`}`
@@ -119,7 +119,7 @@ is skipped and `null` is returned:
`119`	`119`
`120`	`120`	```kotlin
`121`	`121`	`fun main() {`
`122`		`- var nullString: String? = null`
	`122`	`+ val nullString: String? = null`
`123`	`123`	`println(nullString?.uppercase())`
`124`	`124`	`// null`
`125`	`125`	`}`
@@ -138,7 +138,7 @@ As a result, the Elvis operator returns `0`:
`138`	`138`
`139`	`139`	```kotlin
`140`	`140`	`fun main() {`
`141`		`- var nullString: String? = null`
	`141`	`+ val nullString: String? = null`
`142`	`142`	`println(nullString?.length ?: 0)`
`143`	`143`	`// 0`
`144`	`144`	`}`