Important bug fix: Recursive class references to themselves caused Stack overflow exception

iris2iris · iris2iris · commit fa7d94d278f1 · 2020-10-12T02:16:16.000+04:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,8 @@
 # Changelog
 
+## v0.5.2.1
+- Important bug fix: Recursive class references to themselves caused Stack overflow exception
+
 ## v0.5.2
 - `Deserializer` reformat. `JsonItem` instances now don't need to know deserializer types except `Deserializer` itself.
 - `@JsonField` support to let json-fields be named in other way than in deserialized object fields
diff --git a/src/iris/json/serialization/DeserializerClassBuilder.kt b/src/iris/json/serialization/DeserializerClassBuilder.kt
@@ -12,9 +12,9 @@ import kotlin.reflect.full.memberProperties
  * @author [Ivan Ivanov](https://vk.com/irisism)
  */
 object DeserializerClassBuilder {
-	fun build(d: KClass<*>): DeserializerClassImpl {
+	fun build(d: KClass<*>, targetClassImpl: DeserializerClassImpl = DeserializerClassImpl()): DeserializerClassImpl {
 		var hasPolymorphies = false
-		val constructorInfo = getFieldsOrder(d.constructors)
+		val constructorInfo = getBestConstructor(d)
 		val (constr, constructorFields) = constructorInfo
 
 		val mProperties = d.memberProperties
@@ -29,23 +29,28 @@ object DeserializerClassBuilder {
 			jsonItemName to p
 		}
 
-		return DeserializerClassImpl(constr, fieldsList, hasPolymorphies)
+		targetClassImpl.constructorFunction = constr
+		targetClassImpl.fields = fieldsList
+		targetClassImpl.hasPolymorphisms = hasPolymorphies
+		return targetClassImpl
 	}
 
 	private fun getPropertyInfo(it: KProperty<*>, constructorParameter: KParameter?): DeserializerClassImpl.PropertyInfo {
-		val tType = DeserializerPrimitiveImpl.convertType(it.returnType, null)
+
 		var type: DeserializerPrimitiveImpl? = null
 		var inheritInfo: DeserializerClassImpl.PolymorphInfo? = null
 		var innerClass: Deserializer? = null
-		if (tType != null) { // simple type int/string/boolean
-			type = tType
-		} else { // there some complex class
-			val data = it.findAnnotation<PolymorphData>()
-			if (data != null) { // is polymorphic
-				val cases = mutableMapOf<Any, Deserializer>()
-				data.strings.associateTo(cases) { it.label to DeserializerFactory.getDeserializer(it.instance) }
-				data.ints.associateTo(cases) { it.label to DeserializerFactory.getDeserializer(it.instance) }
-				inheritInfo = DeserializerClassImpl.PolymorphInfo(data.sourceField, cases)
+
+		val data = it.findAnnotation<PolymorphData>()
+		if (data != null) { // is polymorphic
+			val cases = mutableMapOf<Any, Deserializer>()
+			data.strings.associateTo(cases) { it.label to DeserializerFactory.getDeserializer(it.instance) }
+			data.ints.associateTo(cases) { it.label to DeserializerFactory.getDeserializer(it.instance) }
+			inheritInfo = DeserializerClassImpl.PolymorphInfo(data.sourceField, cases)
+		} else {
+			val tType = DeserializerPrimitiveImpl.convertType(it.returnType, null)
+			if (tType != null) { // simple type int/string/boolean
+				type = tType
 			} else {
 				innerClass = DeserializerFactory.getDeserializer(it.returnType)
 			}
@@ -54,13 +59,14 @@ object DeserializerClassBuilder {
 		return DeserializerClassImpl.PropertyInfo(/*it.name, */it, constructorParameter, type, innerClass, inheritInfo)
 	}
 
-	private fun getFieldsOrder(constructors: Collection<KFunction<*>>): Pair<KFunction<*>, List<KParameter>> {
-		var best: KFunction<*>? = null
+	private fun getBestConstructor(d: KClass<*>): Pair<KFunction<*>, List<KParameter>> {
+		val constructors = d.constructors
+		if (constructors.isEmpty())
+			throw IllegalArgumentException("No any constructor for $d")
+		var best: KFunction<*> = constructors.first()
 		for (c in constructors)
-			if (best == null || c.parameters.size > best.parameters.size)
+			if (c.parameters.size > best.parameters.size)
 				best = c
-		if (best == null)
-			throw IllegalArgumentException("No any constructor")
 		return best to best.parameters
 	}
 }
diff --git a/src/iris/json/serialization/DeserializerClassImpl.kt b/src/iris/json/serialization/DeserializerClassImpl.kt
@@ -4,6 +4,7 @@ import iris.json.JsonEntry
 import iris.json.JsonItem
 import iris.json.JsonObject
 import java.util.*
+import kotlin.collections.ArrayList
 import kotlin.collections.HashMap
 import kotlin.reflect.*
 
@@ -12,7 +13,11 @@ import kotlin.reflect.*
  * @author [Ivan Ivanov](https://vk.com/irisism)
  */
 
-class DeserializerClassImpl(private val constructorFunction: KFunction<*>, private val fields: Map<String, PropertyInfo>, private val hasPolymorphisms: Boolean) : DeserializerClass {
+class DeserializerClassImpl : DeserializerClass {
+
+	var hasPolymorphisms = false
+	lateinit var fields: Map<String, PropertyInfo>
+	lateinit var constructorFunction: KFunction<*>
 
 	class PolymorphInfo(val sourceField: String, val inheritClasses: Map<Any, Deserializer>)
 
@@ -22,6 +27,8 @@ class DeserializerClassImpl(private val constructorFunction: KFunction<*>, priva
 					   , val polymorphInfo: PolymorphInfo? = null
 	)
 
+	class SetterPropertyException(message: String, cause: Throwable) : Throwable(message, cause)
+
 	override fun <T> deserialize(item: JsonItem): T {
 		return getObject((item as JsonObject).getEntries())
 	}
@@ -44,8 +51,14 @@ class DeserializerClassImpl(private val constructorFunction: KFunction<*>, priva
 			result = null
 		}
 
-		val otherFields = mutableListOf<Pair<KProperty<*>, Any?>>()
-		val constructorMap = HashMap<KParameter, Any?>(info.constructorFunction.parameters.size)
+		val conscructorParametersSize = info.constructorFunction.parameters.size
+		val otherSize = fields.size - conscructorParametersSize
+		val constructorMap = HashMap<KParameter, Any?>(conscructorParametersSize)
+		val otherFields = (if (otherSize == 0)
+			null
+		else
+			ArrayList<Pair<KProperty<*>, Any?>>(fields.size - conscructorParametersSize))
+
 		for ((key, jsonItem) in entries) {
 			val field = key.toString()
 			val param = fields[field]?: continue
@@ -54,10 +67,10 @@ class DeserializerClassImpl(private val constructorFunction: KFunction<*>, priva
 				val sourceValue = result!![polymorphInfo.sourceField]
 				if (sourceValue != null) { // already know what type is it
 					val inherit = polymorphInfo.inheritClasses[sourceValue]!!
-					val newValue: Any? = inherit.deserialize(jsonItem)//jsonItem.asObject(inherit)
+					val newValue: Any? = inherit.deserialize(jsonItem)
 					result[field] = newValue
 					param.constructorParameter?.let { constructorMap[it] = newValue }
-							?: run { otherFields += param.property to newValue }
+							?: run { otherFields!! += param.property to newValue }
 
 				} else { // need delay initialization until we know source info
 					val item = delayedInit!![polymorphInfo.sourceField]
@@ -76,28 +89,34 @@ class DeserializerClassImpl(private val constructorFunction: KFunction<*>, priva
 						val inherit = property.polymorphInfo!!.inheritClasses[value]!!
 						val newValue: Any = inherit.deserialize(item.json)
 						item.propertyInfo.constructorParameter?.let { constructorMap[it] = newValue }
-								?: run { otherFields += property.property to newValue }
+								?: run { otherFields!! += property.property to newValue }
 
 						if (delayed.items != null) {
 							for (item in delayed.items!!) {
 								val property = item.propertyInfo
 								val inherit = property.polymorphInfo!!.inheritClasses[value]!!
 								val newValue: Any = inherit.deserialize(item.json)
 								item.propertyInfo.constructorParameter?.let { constructorMap[it] = newValue }
-										?: run { otherFields += property.property to newValue }
+										?: run { otherFields!! += property.property to newValue }
 							}
 						}
 					}
 					result!![field] = value
 				}
 
 				param.constructorParameter?.let { constructorMap[it] = value }
-						?: run{ otherFields += param.property to value }
+						?: run{ otherFields!! += param.property to value }
 			}
 		}
 		val item = info.constructorFunction.callBy(constructorMap) as T
-		for (field in otherFields) {
-			(field.first as KMutableProperty<*>).setter.call(item, field.second)
+		if (otherFields != null) {
+			for (field in otherFields) {
+				try {
+					(field.first as KMutableProperty<*>).setter.call(item, field.second)
+				} catch (e: ClassCastException) {
+					throw SetterPropertyException("Property $field does not have available setter", e)
+				}
+			}
 		}
 		return item
 	}
diff --git a/src/iris/json/serialization/DeserializerCollectionImpl.kt b/src/iris/json/serialization/DeserializerCollectionImpl.kt
@@ -9,9 +9,12 @@ import kotlin.reflect.KClass
  * @author [Ivan Ivanov](https://vk.com/irisism)
  */
 
-class DeserializerCollectionImpl(val typeDeserializer: Deserializer) : DeserializerCollection {
+class DeserializerCollectionImpl : DeserializerCollection {
+
+	lateinit var typeDeserializer: Deserializer
+
 	override fun getObject(items: Collection<JsonItem>): Collection<*> {
-		val res = mutableListOf<Any?>()
+		val res = ArrayList<Any?>(items.size)
 		for (item in items)
 			res.add(typeDeserializer.deserialize(item))
 		return res
diff --git a/src/iris/json/serialization/DeserializerFactory.kt b/src/iris/json/serialization/DeserializerFactory.kt
@@ -17,37 +17,59 @@ import kotlin.reflect.jvm.jvmErasure
 object DeserializerFactory {
 	private val cache = mutableMapOf<KClass<*>, Deserializer>()
 	private val typeCache = mutableMapOf<KType, Deserializer>()
+	private val anyClass = Any::class
 
 	fun getDeserializer(d: KClass<*>, allowSuperclasses: Boolean = true): Deserializer {
-		return cache.getOrPut(d) {
-			if (allowSuperclasses) {
-				for (supers in d.superclasses)
-					cache[supers]?.let { return@getOrPut it.forSubclass(d) }
+		cache[d]?.let { return it }
+		if (allowSuperclasses) {
+			for (supers in d.superclasses) {
+				if (supers == anyClass) continue
+				cache[supers]?.let {
+					return it.forSubclass(d).also { cache[d] = it }
+				}
 			}
-			DeserializerClassBuilder.build(d)
 		}
+		val deser = DeserializerClassImpl()
+		cache[d] = deser
+		DeserializerClassBuilder.build(d, deser)
+		return deser
 	}
 
 	fun registerDeserializer(d: KClass<*>, deserializer: Deserializer) {
 		cache[d] = deserializer
 	}
 
+	fun registerDeserializer(type: KType, deserializer: Deserializer) {
+		typeCache[type] = deserializer
+	}
+
 	fun getDeserializer(type: KType): Deserializer {
-		return typeCache.getOrPut(type) {
-			DeserializerPrimitiveImpl.convertType(type, null)
-				?.let { return@getOrPut it }
-
-			with(type.jvmErasure) { when {
-					isSubclassOf(Collection::class) ->
-						DeserializerCollectionImpl(getDeserializer(type.arguments.firstOrNull()?.type?: throw IllegalStateException("Don't know how I got here")))
-					isSubclassOf(Map::class) ->
-						DeserializerMapImpl(getDeserializer(getMapType(type)))
-					isSubclassOf(JsonItem::class) ->
-						DeserializerJsonItem()
-					else ->
-						getDeserializer(this)
-			}}
-		}
+		typeCache[type]
+			?.let { return it }
+
+		DeserializerPrimitiveImpl.convertType(type, null)
+			?.let {
+				return it.also { typeCache[type] = it }
+			}
+
+		return with(type.jvmErasure) { when {
+			isSubclassOf(Collection::class) -> {
+				val deser = DeserializerCollectionImpl()
+				typeCache[type] = deser
+				deser.typeDeserializer = getDeserializer(type.arguments.firstOrNull()?.type?: throw IllegalStateException("Don't know how I got here"))
+				deser
+			}
+			isSubclassOf(Map::class) -> {
+				val deser = DeserializerMapImpl()
+				typeCache[type] = deser
+				deser.valueDeserializer = getDeserializer(getMapType(type))
+				deser
+			}
+			isSubclassOf(JsonItem::class) ->
+				DeserializerJsonItem()
+			else ->
+				getDeserializer(this)
+		}}
 	}
 
 	private fun getMapType(type: KType): KType {
diff --git a/src/iris/json/serialization/DeserializerMapImpl.kt b/src/iris/json/serialization/DeserializerMapImpl.kt
@@ -9,7 +9,10 @@ import kotlin.reflect.KClass
  * @created 09.10.2020
  * @author [Ivan Ivanov](https://vk.com/irisism)
  */
-class DeserializerMapImpl(val valueDeserializer: Deserializer) : DeserializerMap {
+class DeserializerMapImpl : DeserializerMap {
+
+	lateinit var valueDeserializer: Deserializer
+
 	override fun <T> getMap(entries: Collection<JsonEntry>): Map<String, T> {
 		return entries.associate {(key, value) ->
 			key.toString() to (valueDeserializer.deserialize(value) as T)
diff --git a/src/iris/json/serialization/annotations.kt b/src/iris/json/serialization/annotations.kt
@@ -15,4 +15,5 @@ annotation class PolymorphCaseString(val label: String, val instance: KClass<*>)
 @Target(AnnotationTarget.PROPERTY)
 annotation class PolymorphCaseInt(val label: Int, val instance: KClass<*>)
 
+@Target(AnnotationTarget.PROPERTY)
 annotation class PolymorphData(val sourceField: String, val strings: Array<PolymorphCaseString> = [], val ints: Array<PolymorphCaseInt> = [])
diff --git a/test/iris/json/flow/serialization.kt b/test/iris/json/flow/serialization.kt
@@ -56,6 +56,40 @@ fun main() {
 	testRegisteredDeserializer(); println()
 	testQuotelessFieldNames(); println()
 	testSubclassRegister(); println()
+	testRecursiveClassFields(); println()
+	testRecursiveGenericClassFields(); println()
+}
+
+fun createJsonItem(text: String): JsonItem {
+	return JsonFlowParser.start(text)
+}
+
+data class RecursiveGenericClass (
+		var inner: List<RecursiveGenericClass>? = null,
+		var someData: String? = null
+)
+
+fun testRecursiveGenericClassFields() {
+	println("testRecursiveGenericClassFields:")
+	val item = createJsonItem("""{ 
+		inner: [{inner: [{someData: "3 level"}], someData: "2 level"}], someData: "1 level"		
+		}""".trimMargin())
+	val list = item.asObject<RecursiveGenericClass>()
+	println(list)
+}
+
+data class RecursiveClass (
+		var inner: RecursiveClass? = null,
+		var someData: String? = null
+)
+
+fun testRecursiveClassFields() {
+	println("testRecursiveClassFields:")
+	val item = createJsonItem("""{ 
+		inner: {inner: {someData: "3 level"}, someData: "2 level"}, someData: "1 level"		
+		}""".trimMargin())
+	val list = item.asObject<RecursiveClass>()
+	println(list)
 }
 
 fun testSubclassRegister() {
diff --git a/test/iris/json/plain/serialization.kt b/test/iris/json/plain/serialization.kt
@@ -56,6 +56,41 @@ fun main() {
 	testRegisteredDeserializer(); println()
 	testQuotelessFieldNames(); println()
 	testSubclassRegister(); println()
+	testRecursiveClassFields(); println()
+	testRecursiveGenericClassFields(); println()
+}
+
+fun createJsonItem(text: String): JsonItem {
+	val parser = IrisJsonParser(text)
+	return parser.parse()
+}
+
+data class RecursiveGenericClass (
+	var inner: List<RecursiveGenericClass>? = null,
+	var someData: String? = null
+)
+
+fun testRecursiveGenericClassFields() {
+	println("testRecursiveGenericClassFields:")
+	val item = createJsonItem("""{ 
+		inner: [{inner: [{someData: "3 level"}], someData: "2 level"}], someData: "1 level"		
+		}""".trimMargin())
+	val list = item.asObject<RecursiveGenericClass>()
+	println(list)
+}
+
+data class RecursiveClass (
+	var inner: RecursiveClass? = null,
+	var someData: String? = null
+)
+
+fun testRecursiveClassFields() {
+	println("testRecursiveClassFields:")
+	val item = createJsonItem("""{ 
+		inner: {inner: {someData: "3 level"}, someData: "2 level"}, someData: "1 level"		
+		}""".trimMargin())
+	val list = item.asObject<RecursiveClass>()
+	println(list)
 }
 
 fun testSubclassRegister() {
@@ -80,11 +115,10 @@ fun testSubclassRegister() {
 		}
 	})
 
-	val parser = IrisJsonParser("""{ 
+	val item = createJsonItem("""{ 
 		|person1: {"type": "male", name: "Akbar", age: 35, "cashAmount": 12200.12, "property": {"name": "Домик в деревне"}}, 
 		|"person2": {"type": "female","name": "Alla Who", "height": 170, "income": 1214.81}
 		|}""".trimMargin())
-	val item = parser.parse()
 	val list = item.asObject<Map<String, Human>>()
 	println(list)
 }
