1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
/*
* Copyright 2017-2022 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
*/
package kotlinx.serialization.internal
import kotlinx.serialization.*
import java.lang.reflect.*
import kotlin.reflect.*
@Suppress("NOTHING_TO_INLINE")
internal actual inline fun <T> Array<T>.getChecked(index: Int): T {
return get(index)
}
@Suppress("NOTHING_TO_INLINE")
internal actual inline fun BooleanArray.getChecked(index: Int): Boolean {
return get(index)
}
internal actual fun <T : Any> KClass<T>.compiledSerializerImpl(): KSerializer<T>? =
this.constructSerializerForGivenTypeArgs()
@Suppress("UNCHECKED_CAST")
internal actual fun <T : Any, E : T?> ArrayList<E>.toNativeArrayImpl(eClass: KClass<T>): Array<E> =
toArray(java.lang.reflect.Array.newInstance(eClass.java, size) as Array<E>)
internal actual fun KClass<*>.platformSpecificSerializerNotRegistered(): Nothing = serializerNotRegistered()
internal fun Class<*>.serializerNotRegistered(): Nothing {
throw SerializationException(this.kotlin.notRegisteredMessage())
}
internal actual fun <T : Any> KClass<T>.constructSerializerForGivenTypeArgs(vararg args: KSerializer<Any?>): KSerializer<T>? {
return java.constructSerializerForGivenTypeArgs(*args)
}
internal fun <T: Any> Class<T>.constructSerializerForGivenTypeArgs(vararg args: KSerializer<Any?>): KSerializer<T>? {
if (isEnum && isNotAnnotated()) {
return createEnumSerializer()
}
// Fall-through if the serializer is not found -- lookup on companions (for sealed interfaces) or fallback to polymorphic if applicable
if (isInterface) interfaceSerializer()?.let { return it }
// Search for serializer defined on companion object.
val serializer = invokeSerializerOnDefaultCompanion<T>(this, *args)
if (serializer != null) return serializer
// Check whether it's serializable object
findObjectSerializer()?.let { return it }
// Search for default serializer if no serializer is defined in companion object.
// It is required for named companions
val fromNamedCompanion = findInNamedCompanion(*args)
if (fromNamedCompanion != null) return fromNamedCompanion
// Check for polymorphic
return if (isPolymorphicSerializer()) {
PolymorphicSerializer(this.kotlin)
} else {
null
}
}
@Suppress("UNCHECKED_CAST")
private fun <T: Any> Class<T>.findInNamedCompanion(vararg args: KSerializer<Any?>): KSerializer<T>? {
val namedCompanion = findNamedCompanionByAnnotation()
if (namedCompanion != null) {
invokeSerializerOnCompanion<T>(namedCompanion, *args)?.let { return it }
}
// fallback strategy for old compiler - try to locate plugin-generated singleton (without type parameters) serializer
return try {
declaredClasses.singleOrNull { it.simpleName == ("\$serializer") }
?.getField("INSTANCE")?.get(null) as? KSerializer<T>
} catch (e: NoSuchFieldException) {
null
}
}
private fun <T: Any> Class<T>.findNamedCompanionByAnnotation(): Any? {
val companionClass = declaredClasses.firstOrNull { clazz ->
clazz.getAnnotation(NamedCompanion::class.java) != null
} ?: return null
return companionOrNull(companionClass.simpleName)
}
private fun <T: Any> Class<T>.isNotAnnotated(): Boolean {
/*
* For annotated enums search serializer directly (or do not search at all?)
*/
return getAnnotation(Serializable::class.java) == null &&
getAnnotation(Polymorphic::class.java) == null
}
private fun <T: Any> Class<T>.isPolymorphicSerializer(): Boolean {
/*
* Last resort: check for @Polymorphic or Serializable(with = PolymorphicSerializer::class)
* annotations.
*/
if (getAnnotation(Polymorphic::class.java) != null) {
return true
}
val serializable = getAnnotation(Serializable::class.java)
if (serializable != null && serializable.with == PolymorphicSerializer::class) {
return true
}
return false
}
private fun <T: Any> Class<T>.interfaceSerializer(): KSerializer<T>? {
/*
* Interfaces are @Polymorphic by default.
* Check if it has no annotations or `@Serializable(with = PolymorphicSerializer::class)`,
* otherwise bailout.
*/
val serializable = getAnnotation(Serializable::class.java)
if (serializable == null || serializable.with == PolymorphicSerializer::class) {
return PolymorphicSerializer(this.kotlin)
}
return null
}
private fun <T : Any> invokeSerializerOnDefaultCompanion(jClass: Class<*>, vararg args: KSerializer<Any?>): KSerializer<T>? {
val companion = jClass.companionOrNull("Companion") ?: return null
return invokeSerializerOnCompanion(companion, *args)
}
@Suppress("UNCHECKED_CAST")
private fun <T : Any> invokeSerializerOnCompanion(companion: Any, vararg args: KSerializer<Any?>): KSerializer<T>? {
return try {
val types = if (args.isEmpty()) emptyArray() else Array(args.size) { KSerializer::class.java }
companion.javaClass.getDeclaredMethod("serializer", *types)
.invoke(companion, *args) as? KSerializer<T>
} catch (e: NoSuchMethodException) {
null
} catch (e: InvocationTargetException) {
val cause = e.cause ?: throw e
throw InvocationTargetException(cause, cause.message ?: e.message)
}
}
private fun Class<*>.companionOrNull(companionName: String) =
try {
val companion = getDeclaredField(companionName)
companion.isAccessible = true
companion.get(null)
} catch (e: Throwable) {
null
}
@Suppress("UNCHECKED_CAST")
private fun <T : Any> Class<T>.createEnumSerializer(): KSerializer<T> {
val constants = enumConstants
return EnumSerializer(canonicalName, constants as Array<out Enum<*>>) as KSerializer<T>
}
private fun <T : Any> Class<T>.findObjectSerializer(): KSerializer<T>? {
// Special case to avoid IllegalAccessException on Java11+ (#2449)
// There are no serializable objects in the stdlib anyway.
if (this.canonicalName?.let { it.startsWith("java.") || it.startsWith("kotlin.") } != false) return null
// Check it is an object without using kotlin-reflect
val field =
declaredFields.singleOrNull { it.name == "INSTANCE" && it.type == this && Modifier.isStatic(it.modifiers) }
?: return null
// Retrieve its instance and call serializer()
val instance = field.get(null)
val method =
methods.singleOrNull { it.name == "serializer" && it.parameterTypes.isEmpty() && it.returnType == KSerializer::class.java }
?: return null
val result = method.invoke(instance)
@Suppress("UNCHECKED_CAST")
return result as? KSerializer<T>
}
internal actual fun isReferenceArray(rootClass: KClass<Any>): Boolean = rootClass.java.isArray
|
