Kotlin
diff --git a/.gitignore b/.gitignore
@@ -15,3 +15,6 @@ target
 
 # Modules for JS projects build
 node_modules
+
+# benchmarks.jar
+/benchmarks.jar
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,7 +1,103 @@
+1.5.0 / 2023-02-27
+==================
+
+This release contains all features and bugfixes from 1.5.0-RC plus some experimental features and bugfixes on its own (see below).
+Kotlin 1.8.10 is used as a default.
+
+### HoconEncoder and HoconDecoder interfaces and HOCON-specific serializers
+
+These interfaces work in a way similar to `JsonEncoder` and `JsonDecoder`: they allow intercepting (de)serialization process,
+making writing if custom HOCON-specific serializers easier. New `ConfigMemorySizeSerializer` and `JavaDurationSerializer` already make use of them.
+See more details in the [PR](https://github.com/Kotlin/kotlinx.serialization/pull/2094).
+Big thanks to [Alexander Mikhailov](https://github.com/alexmihailov) for contributing this!
+
+### Ability to read buffered huge strings in custom Json deserializers
+
+New interface `ChunkedDecoder` allows you to read huge strings that may not fit in memory by chunks.
+Currently, this interface is only implemented by Json decoder that works with strings and streams,
+but we may expand it later, if there's a demand for it.
+See more details in the [PR](https://github.com/Kotlin/kotlinx.serialization/pull/2012) authored by [Alexey Sviridov](https://github.com/fred01).
+
+### Bugfixes
+
+  * Improve runtime exceptions messages (#2180)
+  * Added support for null values for nullable enums in lenient mode (#2176)
+  * Prevent class loaders from leaking when using ClassValue cache (#2175)
+
+1.5.0-RC / 2023-01-25
+==================
+
+This is a release candidate for the next version with many new features to try.
+It uses Kotlin 1.8.0 by default.
+
+### Json naming strategies
+
+A long-awaited feature (#33) is available in this release.
+A new interface, `JsonNamingStrategy` and Json configuration property `namingStrategy` allow
+defining a transformation that is applied to all properties' names serialized by a Json instance.
+There's also a predefined implementation for the most common use case: `Json { namingStrategy = JsonNamingStrategy.SnakeCase }`.
+Check out the [PR](https://github.com/Kotlin/kotlinx.serialization/pull/2111) for more details and documentation.
+
+### Json unquoted literals
+
+kotlinx-serialization-json has an API for manipulating raw Json values: functions and classes `JsonObject`, `JsonPrimitive`, etc.
+In this release, there is a new addition to this API: `JsonUnquotedLiteral` constructor function.
+It allows to produce a string that is not quoted in the Json output. This function has a lot of valuable
+applications: from writing unsigned or large numbers to embedding whole Json documents without the need for re-parsing.
+For an example, read the [Encoding literal Json content docs](https://github.com/Kotlin/kotlinx.serialization/blob/v1.5.0-RC/docs/json.md#encoding-literal-json-content-experimental).
+This huge feature was contributed to us by [aSemy](https://github.com/aSemy): [#2041](https://github.com/Kotlin/kotlinx.serialization/pull/2041).
+
+### Stabilization of serializer(java.lang.Type) function family
+
+Functions `serializer`, `serializerOrNull` and extensions `SerializersModule.serializer`, `SerializersModule.serializerOrNull`
+have JVM-only overloads that accept `java.lang.Type`. These overloads are crucial for interoperability: with them, third-party Java frameworks
+like Spring, which usually rely on Java's reflection and type tokens, can retrieve `KSerializer` instance and use kotlinx.serialization properly.
+We've removed `@ExperimentalSerializationApi` from these functions, and starting from 1.5.0-RC they're considered stable with all backward compatibility guarantees.
+This change should improve third-party support for kotlinx.serialization in various frameworks.
+See the [PR](https://github.com/Kotlin/kotlinx.serialization/issues/2069) for details.
+
+### Deprecations in module builders for polymorphism
+
+Some time ago, in 1.3.2, new functions `SerializersModuleBuilder.polymorphicDefaultSerializer/polymorphicDefaultDeserializer` and `PolymorphicModuleBuilder.defaultDeserializer` were introduced
+— better names allow an easier understanding of which serializers affect what part of the process.
+In 1.5.0-RC, we finish the migration path: these functions are no longer experimental.
+And old functions, namely `SerializersModuleCollector.polymorphicDefault` and `PolymorphicModuleBuilder.default`, are now deprecated.
+See the [PR](https://github.com/Kotlin/kotlinx.serialization/issues/2076) for details.
+
+### Bundled Proguard rules
+
+The `kotlinx-serialization-core-jvm` JAR file now includes consumer Proguard rules,
+so manual Proguard configuration is no longer necessary for most of the setups.
+See updated [Android setup section](https://github.com/Kotlin/kotlinx.serialization/blob/169a14558ca13cfd731283a854d825d1f19ef195/README.md#android)
+and corresponding PRs: [#2092](https://github.com/Kotlin/kotlinx.serialization/issues/2092), [#2123](https://github.com/Kotlin/kotlinx.serialization/issues/2123).
+
+### Support for kotlin.Duration in HOCON format
+
+HOCON specifies its own formatting for duration values. Starting with this release,
+kotlinx-serialization-hocon is able to serialize and deserialize `kotlin.Duration`
+using proper representation instead of the default one. Big thanks to [Alexander Mikhailov](https://github.com/alexmihailov)
+and his PRs: [#2080](https://github.com/Kotlin/kotlinx.serialization/issues/2080), [#2073](https://github.com/Kotlin/kotlinx.serialization/issues/2073).
+
+### Functional and performance improvements
+
+  * Make DeserializationStrategy covariant at declaration-site (#1897) (thanks to [Lukellmann](https://github.com/Lukellmann))
+  * Added support for the `kotlin.Nothing` class as built-in (#1991, #2150)
+  * Further improve stream decoding performance (#2101)
+  * Introduce CharArray pooling for InputStream decoding (#2100)
+  * Consolidate exception messages and improve them (#2068)
+
+### Bugfixes
+
+  * Add stable hashCode()/equals() calculation to PrimitiveSerialDescriptor (#2136) (thanks to [Vasily Vasilkov](https://github.com/vgv))
+  * Added a factory that creates an enum serializer with annotations on the class (#2125)
+  * Correctly handle situation where different serializers can be provided for the same KClass in SealedClassSerializer (#2113)
+  * Fixed serializers caching for parametrized types from different class loaders (#2070)
+
+
 1.4.1 / 2022-10-14
 ==================
 
-This is patch release contains several bugfixes and improvements. 
+This is patch release contains several bugfixes and improvements.
 Kotlin 1.7.20 is used by default.
 
 ### Improvements

diff --git a/README.md b/README.md
@@ -4,8 +4,8 @@
 [![JetBrains official project](https://jb.gg/badges/official.svg)](https://confluence.jetbrains.com/display/ALL/JetBrains+on+GitHub)
 [![GitHub license](https://img.shields.io/badge/license-Apache%20License%202.0-blue.svg?style=flat)](http://www.apache.org/licenses/LICENSE-2.0)
 [![TeamCity build](https://img.shields.io/teamcity/http/teamcity.jetbrains.com/s/KotlinTools_KotlinxSerialization_Ko.svg)](https://teamcity.jetbrains.com/viewType.html?buildTypeId=KotlinTools_KotlinxSerialization_Ko&guest=1)
-[![Kotlin](https://img.shields.io/badge/kotlin-1.7.20-blue.svg?logo=kotlin)](http://kotlinlang.org)
-[![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlinx/kotlinx-serialization-core/1.4.1)](https://search.maven.org/artifact/org.jetbrains.kotlinx/kotlinx-serialization-core/1.4.1/pom)
+[![Kotlin](https://img.shields.io/badge/kotlin-1.8.10-blue.svg?logo=kotlin)](http://kotlinlang.org)
+[![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlinx/kotlinx-serialization-core/1.5.0)](https://search.maven.org/artifact/org.jetbrains.kotlinx/kotlinx-serialization-core/1.5.0/pom)
 [![KDoc link](https://img.shields.io/badge/API_reference-KDoc-blue)](https://kotlinlang.org/api/kotlinx.serialization/)
 [![Slack channel](https://img.shields.io/badge/chat-slack-blue.svg?logo=slack)](https://kotlinlang.slack.com/messages/serialization/)
 
@@ -29,12 +29,15 @@ Kotlin serialization consists of a compiler plugin, that generates visitor code
   * [Android](#android)
   * [Multiplatform (Common, JS, Native)](#multiplatform-common-js-native)
   * [Maven](#maven)
+  * [Bazel](#bazel)
 
 <!--- END -->
 
 * **Additional links**
   * [Kotlin Serialization Guide](docs/serialization-guide.md)
   * [Full API reference](https://kotlinlang.org/api/kotlinx.serialization/)
+  * [Submitting issues and PRs](CONTRIBUTING.md)
+  * [Building this library](docs/building.md)
 
 ## Introduction and references
 
@@ -89,17 +92,17 @@ Kotlin DSL:
 
 ```kotlin
 plugins {
-    kotlin("jvm") version "1.7.20" // or kotlin("multiplatform") or any other kotlin plugin
-    kotlin("plugin.serialization") version "1.7.20"
+    kotlin("jvm") version "1.8.10" // or kotlin("multiplatform") or any other kotlin plugin
+    kotlin("plugin.serialization") version "1.8.10"
 }
 ```       
 
 Groovy DSL:
 
 ```gradle
 plugins {
-    id 'org.jetbrains.kotlin.multiplatform' version '1.7.20'
-    id 'org.jetbrains.kotlin.plugin.serialization' version '1.7.20'
+    id 'org.jetbrains.kotlin.multiplatform' version '1.8.10'
+    id 'org.jetbrains.kotlin.plugin.serialization' version '1.8.10'
 }
 ```
 
@@ -116,7 +119,7 @@ buildscript {
     repositories { mavenCentral() }
 
     dependencies {
-        val kotlinVersion = "1.7.20"
+        val kotlinVersion = "1.8.10"
         classpath(kotlin("gradle-plugin", version = kotlinVersion))
         classpath(kotlin("serialization", version = kotlinVersion))
     }
@@ -127,7 +130,7 @@ Groovy DSL:
 
 ```gradle
 buildscript {
-    ext.kotlin_version = '1.7.20'
+    ext.kotlin_version = '1.8.10'
     repositories { mavenCentral() }
 
     dependencies {
@@ -156,7 +159,7 @@ repositories {
 }
 
 dependencies {
-    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.4.1")
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.0")
 }
 ```
 
@@ -168,104 +171,76 @@ repositories {
 }
 
 dependencies {
-    implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.4.1"
+    implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.0"
 }
 ```
 
 >We also provide `kotlinx-serialization-core` artifact that contains all serialization API but does not have bundled serialization format with it
 
 ### Android
 
-The library works on Android, but, if you're using ProGuard,
-you need to add rules to your `proguard-rules.pro` configuration to cover all classes that are serialized at runtime.
+By default, proguard rules are supplied with the library.
+[These rules](rules/common.pro) keep serializers for _all_ serializable classes that are retained after shrinking,
+so you don't need additional setup.
 
-The following configuration keeps serializers for _all_ serializable classes that are retained after shrinking.
-Uncomment and modify the last section in case you're serializing classes with named companion objects.
+**However, these rules do not affect serializable classes if they have named companion objects.**
+
+If you want to serialize classes with named companion objects, you need to add and edit rules below to your `proguard-rules.pro` configuration. 
+
+Note that the rules for R8 differ depending on the [compatibility mode](https://r8.googlesource.com/r8/+/refs/heads/master/compatibility-faq.md) used.
+
+<details>
+<summary>Example of named companion rules for ProGuard and R8 compatibility mode</summary>
 
 ```proguard
-# Keep `Companion` object fields of serializable classes.
-# This avoids serializer lookup through `getDeclaredClasses` as done for named companion objects.
--if @kotlinx.serialization.Serializable class **
--keepclassmembers class <1> {
-    static <1>$Companion Companion;
-}
+# Serializer for classes with named companion objects are retrieved using `getDeclaredClasses`.
+# If you have any, replace classes with those containing named companion objects.
+-keepattributes InnerClasses # Needed for `getDeclaredClasses`.
 
-# Keep `serializer()` on companion objects (both default and named) of serializable classes.
--if @kotlinx.serialization.Serializable class ** {
+-if @kotlinx.serialization.Serializable class
+com.example.myapplication.HasNamedCompanion, # <-- List serializable classes with named companions.
+com.example.myapplication.HasNamedCompanion2
+{
     static **$* *;
 }
--keepclassmembers class <2>$<3> {
-    kotlinx.serialization.KSerializer serializer(...);
+-keepnames class <1>$$serializer { # -keepnames suffices; class is kept when serializer() is kept.
+    static <1>$$serializer INSTANCE;
 }
-
-# Keep `INSTANCE.serializer()` of serializable objects.
--if @kotlinx.serialization.Serializable class ** {
-    public static ** INSTANCE;
-}
--keepclassmembers class <1> {
-    public static <1> INSTANCE;
-    kotlinx.serialization.KSerializer serializer(...);
-}
-
-# @Serializable and @Polymorphic are used at runtime for polymorphic serialization.
--keepattributes RuntimeVisibleAnnotations,AnnotationDefault
-
-# Serializer for classes with named companion objects are retrieved using `getDeclaredClasses`.
-# If you have any, uncomment and replace classes with those containing named companion objects.
-#-keepattributes InnerClasses # Needed for `getDeclaredClasses`.
-#-if @kotlinx.serialization.Serializable class
-#com.example.myapplication.HasNamedCompanion, # <-- List serializable classes with named companions.
-#com.example.myapplication.HasNamedCompanion2
-#{
-#    static **$* *;
-#}
-#-keepnames class <1>$$serializer { # -keepnames suffices; class is kept when serializer() is kept.
-#    static <1>$$serializer INSTANCE;
-#}
 ```
+</details>
 
-In case you want to exclude serializable classes that are used, but never serialized at runtime,
-you will need to write custom rules with narrower [class specifications](https://www.guardsquare.com/manual/configuration/usage).
 
 <details>
-<summary>Example of custom rules</summary>
-
-```proguard
--keepattributes RuntimeVisibleAnnotations,AnnotationDefault
-
-# kotlinx-serialization-json specific. Add this if you have java.lang.NoClassDefFoundError kotlinx.serialization.json.JsonObjectSerializer
--keepclassmembers class kotlinx.serialization.json.** {
-    *** Companion;
-}
--keepclasseswithmembers class kotlinx.serialization.json.** {
-    kotlinx.serialization.KSerializer serializer(...);
-}
+<summary>Example of named companion rules for R8 full mode</summary>
 
-# Application rules
+```proguard
+# Serializer for classes with named companion objects are retrieved using `getDeclaredClasses`.
+# If you have any, replace classes with those containing named companion objects.
+-keepattributes InnerClasses # Needed for `getDeclaredClasses`.
 
-# Change here com.yourcompany.yourpackage
--keepclassmembers @kotlinx.serialization.Serializable class com.yourcompany.yourpackage.** {
-    # lookup for plugin generated serializable classes
-    *** Companion;
-    # lookup for serializable objects
-    *** INSTANCE;
-    kotlinx.serialization.KSerializer serializer(...);
+-if @kotlinx.serialization.Serializable class
+com.example.myapplication.HasNamedCompanion, # <-- List serializable classes with named companions.
+com.example.myapplication.HasNamedCompanion2
+{
+    static **$* *;
 }
-# lookup for plugin generated serializable classes
--if @kotlinx.serialization.Serializable class com.yourcompany.yourpackage.**
--keepclassmembers class com.yourcompany.yourpackage.<1>$Companion {
-    kotlinx.serialization.KSerializer serializer(...);
+-keepnames class <1>$$serializer { # -keepnames suffices; class is kept when serializer() is kept.
+    static <1>$$serializer INSTANCE;
 }
 
-# Serialization supports named companions but for such classes it is necessary to add an additional rule.
-# This rule keeps serializer and serializable class from obfuscation. Therefore, it is recommended not to use wildcards in it, but to write rules for each such class.
--keepattributes InnerClasses # Needed for `getDeclaredClasses`.
--keep class com.yourcompany.yourpackage.SerializableClassWithNamedCompanion$$serializer {
-    *** INSTANCE;
+# Keep both serializer and serializable classes to save the attribute InnerClasses
+-keepclasseswithmembers, allowshrinking, allowobfuscation, allowaccessmodification class
+com.example.myapplication.HasNamedCompanion, # <-- List serializable classes with named companions.
+com.example.myapplication.HasNamedCompanion2
+{
+    *;
 }
 ```
 </details>
 
+In case you want to exclude serializable classes that are used, but never serialized at runtime,
+you will need to write custom rules with narrower [class specifications](https://www.guardsquare.com/manual/configuration/usage).
+
 ### Multiplatform (Common, JS, Native)
 
 Most of the modules are also available for Kotlin/JS and Kotlin/Native.
@@ -286,8 +261,8 @@ Ensure the proper version of Kotlin and serialization version:
 
 ```xml
 <properties>
-    <kotlin.version>1.7.20</kotlin.version>
-    <serialization.version>1.4.1</serialization.version>
+    <kotlin.version>1.8.10</kotlin.version>
+    <serialization.version>1.5.0</serialization.version>
 </properties>
 ```
 
@@ -335,3 +310,9 @@ Add dependency on serialization runtime library:
     <version>${serialization.version}</version>
 </dependency>
 ```
+
+### Bazel
+
+To setup the Kotlin compiler plugin for Bazel, follow [the
+example](https://github.com/bazelbuild/rules_kotlin/tree/master/examples/plugin/src/serialization)
+from the `rules_kotlin` repository.
diff --git a/benchmark/build.gradle b/benchmark/build.gradle
@@ -11,7 +11,7 @@ apply plugin: 'me.champeau.jmh'
 
 sourceCompatibility = 1.8
 targetCompatibility = 1.8
-jmh.jmhVersion = "1.22"
+jmh.jmhVersion = "1.35"
 
 processJmhResources {
     doFirst {
@@ -26,7 +26,7 @@ jmhJar {
 }
 
 dependencies {
-    implementation 'org.openjdk.jmh:jmh-core:1.22'
+    implementation 'org.openjdk.jmh:jmh-core:1.35'
     implementation 'com.google.guava:guava:31.1-jre'
     implementation 'com.fasterxml.jackson.core:jackson-databind:2.13.3'
     implementation 'com.fasterxml.jackson.module:jackson-module-kotlin:2.13.3'