Removed redundant usages of @Serializer annotations (#2200)

If all KSerializer members are overridden in custom serializer, then the annotation '@Serializer' is not needed

Author: shanshin

core/commonTest/src/kotlinx/serialization/SerializersLookupEnumTest.kt

@@ -16,8 +16,7 @@ class SerializersLookupEnumTest {
     @Serializable(with = EnumExternalObjectSerializer::class)
     enum class EnumExternalObject
 
-    @Serializer(forClass = EnumExternalObject::class)
-    object EnumExternalObjectSerializer {
+    object EnumExternalObjectSerializer: KSerializer<EnumExternalObject> {
         override val descriptor: SerialDescriptor = buildSerialDescriptor("tmp", SerialKind.ENUM)
 
         override fun serialize(encoder: Encoder, value: EnumExternalObject) {
@@ -29,11 +28,10 @@ class SerializersLookupEnumTest {
         }
     }
 
-    @Serializable(with = EnumExternalClassSerializer::class)
+    @Serializable(with = EnumCustomClassSerializer::class)
     enum class EnumExternalClass
 
-    @Serializer(forClass = EnumExternalClass::class)
-    class EnumExternalClassSerializer {
+    class EnumCustomClassSerializer: KSerializer<EnumExternalClass> {
         override val descriptor: SerialDescriptor = buildSerialDescriptor("tmp", SerialKind.ENUM)
 
         override fun serialize(encoder: Encoder, value: EnumExternalClass) {
@@ -97,7 +95,7 @@ class SerializersLookupEnumTest {
 
     @Test
     fun testEnumExternalClass() {
-        assertIs<EnumExternalClassSerializer>(EnumExternalClass.serializer())
-        assertIs<EnumExternalClassSerializer>(serializer<EnumExternalClass>())
+        assertIs<EnumCustomClassSerializer>(EnumExternalClass.serializer())
+        assertIs<EnumCustomClassSerializer>(serializer<EnumExternalClass>())
     }
 }

core/commonTest/src/kotlinx/serialization/SerializersLookupObjectTest.kt

@@ -11,11 +11,10 @@ import kotlin.test.*
 
 @Suppress("RemoveExplicitTypeArguments") // This is exactly what's being tested
 class SerializersLookupObjectTest {
-    @Serializable(with = ObjectExternalObjectSerializer::class)
+    @Serializable(with = ObjectCustomObjectSerializer::class)
     object ObjectExternalObject
 
-    @Serializer(forClass = ObjectExternalObject::class)
-    object ObjectExternalObjectSerializer {
+    object ObjectCustomObjectSerializer: KSerializer<ObjectExternalObject> {
         override val descriptor: SerialDescriptor = buildSerialDescriptor("tmp", StructureKind.OBJECT)
 
         override fun serialize(encoder: Encoder, value: ObjectExternalObject) {
@@ -27,11 +26,10 @@ class SerializersLookupObjectTest {
         }
     }
 
-    @Serializable(with = ObjectExternalClassSerializer::class)
+    @Serializable(with = ObjectCustomClassSerializer::class)
     object ObjectExternalClass
 
-    @Serializer(forClass = ObjectExternalClass::class)
-    class ObjectExternalClassSerializer {
+    class ObjectCustomClassSerializer: KSerializer<ObjectExternalClass> {
         override val descriptor: SerialDescriptor = buildSerialDescriptor("tmp", StructureKind.OBJECT)
 
         override fun serialize(encoder: Encoder, value: ObjectExternalClass) {
@@ -56,18 +54,18 @@ class SerializersLookupObjectTest {
 
     @Test
     fun testObjectExternalObject() {
-        assertSame(ObjectExternalObjectSerializer, ObjectExternalObject.serializer())
+        assertSame(ObjectCustomObjectSerializer, ObjectExternalObject.serializer())
         if (!isJsLegacy()) {
-            assertSame(ObjectExternalObjectSerializer, serializer<ObjectExternalObject>())
+            assertSame(ObjectCustomObjectSerializer, serializer<ObjectExternalObject>())
         }
     }
 
     @Test
     fun testObjectExternalClass() {
-        assertIs<ObjectExternalClassSerializer>(ObjectExternalClass.serializer())
+        assertIs<ObjectCustomClassSerializer>(ObjectExternalClass.serializer())
 
         if (!isJsLegacy()) {
-            assertIs<ObjectExternalClassSerializer>(serializer<ObjectExternalClass>())
+            assertIs<ObjectCustomClassSerializer>(serializer<ObjectExternalClass>())
         }
     }
 }

formats/json-tests/commonTest/src/kotlinx/serialization/EncodingExtensionsTest.kt

@@ -10,7 +10,6 @@ class EncodingExtensionsTest {
     @Serializable(with = BoxSerializer::class)
     class Box(val i: Int)
 
-    @Serializer(forClass = Box::class)
     object BoxSerializer : KSerializer<Box> {
         override val descriptor: SerialDescriptor = buildClassSerialDescriptor("Box") {
             element<Int>("i")

formats/json-tests/commonTest/src/kotlinx/serialization/EnumSerializationTest.kt

@@ -45,7 +45,6 @@ class EnumSerializationTest : JsonTestBase() {
         TWO
     }
 
-    @Serializer(WithCustom::class)
     private class CustomEnumSerializer : KSerializer<WithCustom> {
         override val descriptor: SerialDescriptor = buildSerialDescriptor("WithCustom", SerialKind.ENUM) {
             element("1", buildSerialDescriptor("WithCustom.1", StructureKind.OBJECT))

formats/json-tests/commonTest/src/kotlinx/serialization/NotNullSerializersCompatibilityOnFileTest.kt

@@ -53,7 +53,6 @@ class NotNullSerializersCompatibilityOnFileTest {
     @Serializable
     data class Holder(val nullable: Int?, val nonNullable: Int)
 
-    @Serializer(forClass = Int::class)
     object NonNullableIntSerializer : KSerializer<Int> {
         override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("NotNullIntSerializer", PrimitiveKind.INT)
 

formats/json-tests/commonTest/src/kotlinx/serialization/SerializationForNullableTypeOnFileTest.kt

@@ -16,7 +16,6 @@ class SerializationForNullableTypeOnFileTest {
     @Serializable
     data class Holder(val nullable: Int?, val nonNullable: Int)
 
-    @Serializer(forClass = Int::class)
     object NullableIntSerializer : KSerializer<Int?> {
         override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("NullableIntSerializer", PrimitiveKind.INT).nullable
 
@@ -34,7 +33,6 @@ class SerializationForNullableTypeOnFileTest {
         }
     }
 
-    @Serializer(forClass = Int::class)
     object NonNullableIntSerializer : KSerializer<Int> {
         override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("NotNullIntSerializer", PrimitiveKind.INT)
 

formats/json-tests/commonTest/src/kotlinx/serialization/SerializerForNullableTypeTest.kt

@@ -16,7 +16,6 @@ public class SerializerForNullableTypeTest : JsonTestBase() {
     @Serializable(with = StringHolderSerializer::class)
     data class StringHolder(val s: String)
 
-    @Serializer(forClass = StringHolder::class)
     object StringHolderSerializer : KSerializer<StringHolder?> {
         override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("SHS", PrimitiveKind.STRING).nullable
 

formats/json-tests/commonTest/src/kotlinx/serialization/features/BinaryPayloadExampleTest.kt

@@ -14,9 +14,8 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 
 class BinaryPayloadExampleTest {
-    @Serializable
+    @Serializable(BinaryPayload.Companion::class)
     class BinaryPayload(val req: ByteArray, val res: ByteArray) {
-        @Serializer(forClass = BinaryPayload::class)
         companion object : KSerializer<BinaryPayload> {
             override val descriptor: SerialDescriptor = buildClassSerialDescriptor("BinaryPayload") {
                 element("req", ByteArraySerializer().descriptor)
@@ -73,6 +72,7 @@ class BinaryPayloadExampleTest {
     fun payloadEquivalence() {
         val payload1 = BinaryPayload(byteArrayOf(0, 0, 0), byteArrayOf(127, 127))
         val s = Json.encodeToString(BinaryPayload.serializer(), payload1)
+        assertEquals("""{"req":"000000","res":"7F7F"}""", s)
         val payload2 = Json.decodeFromString(BinaryPayload.serializer(), s)
         assertEquals(payload1, payload2)
     }

formats/json-tests/commonTest/src/kotlinx/serialization/features/GenericCustomSerializerTest.kt

@@ -33,7 +33,6 @@ class CheckedData<T : Any>(val data: T, val checkSum: ByteArray) {
     }
 }
 
-@Serializer(forClass = CheckedData::class)
 class CheckedDataSerializer<T : Any>(private val dataSerializer: KSerializer<T>) : KSerializer<CheckedData<T>> {
     override val descriptor: SerialDescriptor = buildClassSerialDescriptor("CheckedDataSerializer") {
         val dataDescriptor = dataSerializer.descriptor

formats/json-tests/commonTest/src/kotlinx/serialization/features/inline/InlineClassesTest.kt

@@ -22,8 +22,7 @@ data class SimpleContainerForUInt(val i: UInt)
 @JvmInline
 value class MyUInt(val m: Int)
 
-@Serializer(forClass = MyUInt::class)
-object MyUIntSerializer {
+object MyUIntSerializer: KSerializer<MyUInt> {
     override val descriptor = UInt.serializer().descriptor
     override fun serialize(encoder: Encoder, value: MyUInt) {
         encoder.encodeInline(descriptor).encodeInt(value.m)

formats/json-tests/commonTest/src/kotlinx/serialization/json/JsonMapKeysTest.kt

@@ -24,7 +24,6 @@ value class ComplexCarrier(val c: IntData)
 value class PrimitiveCarrier(val c: String)
 
 data class ContextualValue(val c: String) {
-    @Serializer(forClass = ContextualValue::class)
     companion object: KSerializer<ContextualValue> {
         override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("ContextualValue", PrimitiveKind.STRING)
 

formats/json-tests/commonTest/src/kotlinx/serialization/json/MapLikeSerializerTest.kt

@@ -15,7 +15,6 @@ class MapLikeSerializerTest : JsonTestBase() {
     @Serializable
     data class StringPair(val a: String, val b: String)
 
-    @Serializer(forClass = StringPair::class)
     object StringPairSerializer : KSerializer<StringPair> {
 
         override val descriptor: SerialDescriptor = buildSerialDescriptor("package.StringPair", StructureKind.MAP) {

formats/json-tests/jsTest/src/kotlinx/serialization/json/EncodeToDynamicTest.kt

@@ -92,10 +92,9 @@ class EncodeToDynamicTest {
         WITH_SERIALNAME_red
     }
 
-    @Serializable
+    @Serializable(MyFancyClass.Companion::class)
     data class MyFancyClass(val value: String) {
 
-        @Serializer(forClass = MyFancyClass::class)
         companion object : KSerializer<MyFancyClass> {
 
             override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("MyFancyClass", PrimitiveKind.STRING)

formats/json-tests/jvmTest/src/kotlinx/serialization/SerializeJavaClassTest.kt

@@ -13,7 +13,6 @@ import java.text.SimpleDateFormat
 import java.util.*
 import kotlin.test.assertEquals
 
-@Serializer(forClass = Date::class)
 object DateSerializer : KSerializer<Date> {
     override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("java.util.Date", PrimitiveKind.STRING)
 

formats/json-tests/jvmTest/src/kotlinx/serialization/features/SerializerByTypeTest.kt

@@ -27,10 +27,10 @@ class SerializerByTypeTest {
     @Serializable
     data class Data(val l: List<String>, val b: Box<Int>)
 
-    @Serializable
+    @Serializable(WithCustomDefault.Companion::class)
     data class WithCustomDefault(val n: Int) {
-        @Serializer(forClass = WithCustomDefault::class)
-        companion object {
+
+        companion object: KSerializer<WithCustomDefault> {
             override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("WithCustomDefault", PrimitiveKind.INT)
             override fun serialize(encoder: Encoder, value: WithCustomDefault) = encoder.encodeInt(value.n)
             override fun deserialize(decoder: Decoder) = WithCustomDefault(decoder.decodeInt())

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

@@ -13,7 +13,7 @@ import kotlinx.serialization.encoding.*
 import kotlinx.serialization.json.internal.JsonDecodingException
 
 /**
- * External [Serializer] object providing [SerializationStrategy] and [DeserializationStrategy] for [JsonElement].
+ * Serializer object providing [SerializationStrategy] and [DeserializationStrategy] for [JsonElement].
  * It can only be used by with [Json] format an its input ([JsonDecoder] and [JsonEncoder]).
  * Currently, this hierarchy has no guarantees on descriptor content.
  *
@@ -24,7 +24,6 @@ import kotlinx.serialization.json.internal.JsonDecodingException
  * assertEquals(JsonObject(mapOf("key" to JsonLiteral(1.0))), literal)
  * ```
  */
-@Serializer(forClass = JsonElement::class)
 @PublishedApi
 internal object JsonElementSerializer : KSerializer<JsonElement> {
     override val descriptor: SerialDescriptor =
@@ -53,10 +52,9 @@ internal object JsonElementSerializer : KSerializer<JsonElement> {
 }
 
 /**
- * External [Serializer] object providing [SerializationStrategy] and [DeserializationStrategy] for [JsonPrimitive].
+ * Serializer object providing [SerializationStrategy] and [DeserializationStrategy] for [JsonPrimitive].
  * It can only be used by with [Json] format an its input ([JsonDecoder] and [JsonEncoder]).
  */
-@Serializer(forClass = JsonPrimitive::class)
 @PublishedApi
 internal object JsonPrimitiveSerializer : KSerializer<JsonPrimitive> {
     override val descriptor: SerialDescriptor =
@@ -79,10 +77,9 @@ internal object JsonPrimitiveSerializer : KSerializer<JsonPrimitive> {
 }
 
 /**
- * External [Serializer] object providing [SerializationStrategy] and [DeserializationStrategy] for [JsonNull].
+ * Serializer object providing [SerializationStrategy] and [DeserializationStrategy] for [JsonNull].
  * It can only be used by with [Json] format an its input ([JsonDecoder] and [JsonEncoder]).
  */
-@Serializer(forClass = JsonNull::class)
 @PublishedApi
 internal object JsonNullSerializer : KSerializer<JsonNull> {
     // technically, JsonNull is an object, but it does not call beginStructure/endStructure at all
@@ -142,10 +139,9 @@ private object JsonLiteralSerializer : KSerializer<JsonLiteral> {
 }
 
 /**
- * External [Serializer] object providing [SerializationStrategy] and [DeserializationStrategy] for [JsonObject].
+ * Serializer object providing [SerializationStrategy] and [DeserializationStrategy] for [JsonObject].
  * It can only be used by with [Json] format an its input ([JsonDecoder] and [JsonEncoder]).
  */
-@Serializer(forClass = JsonObject::class)
 @PublishedApi
 internal object JsonObjectSerializer : KSerializer<JsonObject> {
 
@@ -168,10 +164,9 @@ internal object JsonObjectSerializer : KSerializer<JsonObject> {
 }
 
 /**
- * External [Serializer] object providing [SerializationStrategy] and [DeserializationStrategy] for [JsonArray].
+ * Serializer object providing [SerializationStrategy] and [DeserializationStrategy] for [JsonArray].
  * It can only be used by with [Json] format an its input ([JsonDecoder] and [JsonEncoder]).
  */
-@Serializer(forClass = JsonArray::class)
 @PublishedApi
 internal object JsonArraySerializer : KSerializer<JsonArray> {
 

formats/protobuf/jvmTest/src/kotlinx/serialization/protobuf/PolymorphicWithJvmClassTest.kt

@@ -17,7 +17,6 @@ class PolymorphicWithJvmClassTest {
     @Serializable
     data class DateWrapper(@ProtoNumber(1) @Polymorphic val date: Date)
 
-    @Serializer(forClass = Date::class)
     object DateSerializer : KSerializer<Date> {
         override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("java.util.Date", PrimitiveKind.STRING)