Fix review notes, tune initialCapacity in ConcurrentHashMap

Author: sandwwraith

core/commonMain/src/kotlinx/serialization/Annotations.kt

@@ -145,6 +145,9 @@ public annotation class Serializer(
  * // Prints "{"int":42}"
  * println(Json.encodeToString(CustomName(42)))
  * ```
+ *
+ * If a name of class or property is overridden with this annotation, original source code name is not available for the library.
+ * Tools like `JsonNamingStrategy` and `ProtoBufSchemaGenerator` would see and transform [value] from [SerialName] annotation.
  */
 @Target(AnnotationTarget.PROPERTY, AnnotationTarget.CLASS)
 // @Retention(AnnotationRetention.RUNTIME) still runtime, but KT-41082

formats/json/commonMain/src/kotlinx/serialization/json/JsonNamingStrategy.kt

@@ -26,7 +26,7 @@ import kotlinx.serialization.descriptors.*
  * * Collision of the transformed name with any other (transformed) properties serial names or any alternative names
  * specified with [JsonNames] will lead to a deserialization exception.
  *
- * * Naming strategies do not transform serial names of the classes used for the polymorphism, as they always should be specified explicitly.
+ * * Naming strategies do not transform serial names of the types used for the polymorphism, as they always should be specified explicitly.
  * Values from [JsonClassDiscriminator] or global [JsonBuilder.classDiscriminator] also are not altered.
  *
  * ### Controversy about using global naming strategies

formats/json/commonMain/src/kotlinx/serialization/json/internal/JsonNamesMap.kt

@@ -29,7 +29,7 @@ internal fun SerialDescriptor.buildDeserializationNamesMap(json: Json): Map<Stri
     }
 
     val builder: MutableMap<String, Int> =
-        mutableMapOf() // can be not concurrent because it is only read after creation and never written to?
+        mutableMapOf() // can be not concurrent because it is only read after creation and safely published to concurrent map
     val strategy = namingStrategy(json)
     for (i in 0 until elementsCount) {
         getElementAnnotations(i).filterIsInstance<JsonNames>().singleOrNull()?.names?.forEach { name ->

formats/json/commonMain/src/kotlinx/serialization/json/internal/SchemaCache.kt

@@ -16,11 +16,13 @@ private typealias DescriptorData<T> = MutableMap<DescriptorSchemaCache.Key<T>, T
  * To be able to work with it from multiple threads in Kotlin/Native, use @[ThreadLocal] in appropriate places.
  */
 internal class DescriptorSchemaCache {
-    private val map: MutableMap<SerialDescriptor, DescriptorData<Any>> = createMapForCache(1)
+    // 16 is default CHM size, as we do not know number of descriptors in an application (but it's likely not 1)
+    private val map: MutableMap<SerialDescriptor, DescriptorData<Any>> = createMapForCache(16)
 
     @Suppress("UNCHECKED_CAST")
     public operator fun <T : Any> set(descriptor: SerialDescriptor, key: Key<T>, value: T) {
-        map.getOrPut(descriptor, { createMapForCache(1) })[key as Key<Any>] = value as Any
+        // Initial capacity = number of known DescriptorSchemaCache.Key instances
+        map.getOrPut(descriptor, { createMapForCache(2) })[key as Key<Any>] = value as Any
     }
 
     public fun <T : Any> getOrPut(descriptor: SerialDescriptor, key: Key<T>, defaultValue: () -> T): T {

formats/json/commonMain/src/kotlinx/serialization/json/internal/TreeJsonDecoder.kt

@@ -134,7 +134,7 @@ private sealed class AbstractJsonTreeDecoder(
 
     override fun decodeTaggedChar(tag: String): Char = getPrimitiveValue(tag).primitive("char") { content.single() }
 
-    private inline fun <T: Any> JsonPrimitive.primitive(primitive: String, block: JsonPrimitive.() -> T?): T {
+    private inline fun <T : Any> JsonPrimitive.primitive(primitive: String, block: JsonPrimitive.() -> T?): T {
         try {
             return block() ?: unparsedPrimitive(primitive)
         } catch (e: IllegalArgumentException) {
@@ -236,9 +236,16 @@ private open class JsonTreeDecoder(
         }
         // Slow path
         val deserializationNamesMap = json.deserializationNamesMap(descriptor)
-        val nameInObject = value.keys.find { deserializationNamesMap[it] == index }
-        val fallbackName = strategy?.serialNameForJson(descriptor, index, descriptor.getElementName(index)) // Key not found exception should be thrown with transformed named, not original
-        return nameInObject ?: fallbackName ?: baseName
+        value.keys.find { deserializationNamesMap[it] == index }?.let {
+            return it
+        }
+
+        val fallbackName = strategy?.serialNameForJson(
+            descriptor,
+            index,
+            baseName
+        ) // Key not found exception should be thrown with transformed name, not original
+        return fallbackName ?: baseName
     }
 
     override fun currentElement(tag: String): JsonElement = value.getValue(tag)
@@ -259,10 +266,10 @@ private open class JsonTreeDecoder(
 
         @Suppress("DEPRECATION_ERROR")
         val names: Set<String> = when {
-                strategy == null && !configuration.useAlternativeNames -> descriptor.jsonCachedSerialNames()
-                strategy != null -> json.deserializationNamesMap(descriptor).keys
-                else -> descriptor.jsonCachedSerialNames() + json.schemaCache[descriptor, JsonDeserializationNamesKey]?.keys.orEmpty()
-            }
+            strategy == null && !configuration.useAlternativeNames -> descriptor.jsonCachedSerialNames()
+            strategy != null -> json.deserializationNamesMap(descriptor).keys
+            else -> descriptor.jsonCachedSerialNames() + json.schemaCache[descriptor, JsonDeserializationNamesKey]?.keys.orEmpty()
+        }
 
         for (key in value.keys) {
             if (key !in names && key != polyDiscriminator) {

formats/json/jsMain/src/kotlinx/serialization/json/internal/DynamicDecoders.kt

@@ -112,9 +112,15 @@ private open class DynamicInput(
         }
         // Slow path
         val deserializationNamesMap = json.deserializationNamesMap(descriptor)
-        val nameInObject = (keys as Array<String>).find { deserializationNamesMap[it] == index }
-        val fallbackName = strategy?.serialNameForJson(descriptor, index, descriptor.getElementName(index)) // Key not found exception should be thrown with transformed name, not original
-        return nameInObject ?: fallbackName ?: mainName
+        (keys as Array<String>).find { deserializationNamesMap[it] == index }?.let {
+            return it
+        }
+        val fallbackName = strategy?.serialNameForJson(
+            descriptor,
+            index,
+            mainName
+        ) // Key not found exception should be thrown with transformed name, not original
+        return fallbackName ?: mainName
     }
 
     override fun decodeTaggedEnum(tag: String, enumDescriptor: SerialDescriptor): Int {