Adding extra information to errors and exceptions (#212)

### What's done:
- added extra information to errors and exceptions
- updated diktat to latest version and fixed indenting

Author: orchestr7

buildSrc/build.gradle.kts

@@ -10,7 +10,7 @@ dependencies {
     // this hack prevents the following bug: https://github.com/gradle/gradle/issues/9770
     implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:1.8.20")
 
-    implementation("org.cqfn.diktat:diktat-gradle-plugin:1.1.0")
+    implementation("org.cqfn.diktat:diktat-gradle-plugin:1.2.5")
     implementation("io.gitlab.arturbosch.detekt:detekt-gradle-plugin:1.15.0")
     implementation("io.github.gradle-nexus:publish-plugin:1.1.0")
     implementation("org.ajoberstar.reckon:reckon-gradle:0.13.0")

ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/TomlConfig.kt

@@ -95,13 +95,13 @@ public data class TomlInputConfig(
             ignoreUnknownNames: Boolean = false,
             allowEmptyToml: Boolean = true
         ): TomlInputConfig =
-                TomlInputConfig(
-                    ignoreUnknownNames,
-                    allowEmptyValues = false,
-                    allowNullValues = false,
-                    allowEmptyToml,
-                    allowEscapedQuotesInLiteralStrings = false
-                )
+            TomlInputConfig(
+                ignoreUnknownNames,
+                allowEmptyValues = false,
+                allowNullValues = false,
+                allowEmptyToml,
+                allowEscapedQuotesInLiteralStrings = false
+            )
     }
 }
 
@@ -135,13 +135,13 @@ public data class TomlOutputConfig(
             ignoreDefaultValues: Boolean = false,
             explicitTables: Boolean = false,
         ): TomlOutputConfig =
-                TomlOutputConfig(
-                    indentation,
-                    allowEscapedQuotesInLiteralStrings = false,
-                    ignoreNullValues = true,
-                    ignoreDefaultValues,
-                    explicitTables
-                )
+            TomlOutputConfig(
+                indentation,
+                allowEscapedQuotesInLiteralStrings = false,
+                ignoreNullValues = true,
+                ignoreDefaultValues,
+                explicitTables
+            )
     }
 }
 

ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/decoders/TomlAbstractDecoder.kt

@@ -80,21 +80,21 @@ public abstract class TomlAbstractDecoder : AbstractDecoder() {
     override fun decodeString(): String = decodePrimitiveType()
 
     protected fun DeserializationStrategy<*>.isDateTime(): Boolean =
-            descriptor == instantSerializer.descriptor ||
-                    descriptor == localDateTimeSerializer.descriptor ||
-                    descriptor == localDateSerializer.descriptor ||
-                    descriptor == localTimeSerializer.descriptor
+        descriptor == instantSerializer.descriptor ||
+                descriptor == localDateTimeSerializer.descriptor ||
+                descriptor == localDateSerializer.descriptor ||
+                descriptor == localTimeSerializer.descriptor
 
     // Cases for date-time types
     @Suppress("UNCHECKED_CAST")
     override fun <T> decodeSerializableValue(deserializer: DeserializationStrategy<T>): T =
-            when (deserializer.descriptor) {
-                instantSerializer.descriptor -> decodePrimitiveType<Instant>() as T
-                localDateTimeSerializer.descriptor -> decodePrimitiveType<LocalDateTime>() as T
-                localDateSerializer.descriptor -> decodePrimitiveType<LocalDate>() as T
-                localTimeSerializer.descriptor -> decodePrimitiveType<LocalTime>() as T
-                else -> super.decodeSerializableValue(deserializer)
-            }
+        when (deserializer.descriptor) {
+            instantSerializer.descriptor -> decodePrimitiveType<Instant>() as T
+            localDateTimeSerializer.descriptor -> decodePrimitiveType<LocalDateTime>() as T
+            localDateSerializer.descriptor -> decodePrimitiveType<LocalDate>() as T
+            localTimeSerializer.descriptor -> decodePrimitiveType<LocalTime>() as T
+            else -> super.decodeSerializableValue(deserializer)
+        }
 
     internal abstract fun decodeKeyValue(): TomlKeyValue
 
@@ -124,16 +124,16 @@ public abstract class TomlAbstractDecoder : AbstractDecoder() {
     }
 
     private inline fun <reified T> decodeFloatingPoint(content: Double, lineNo: Int): T =
-            when (T::class) {
-                Float::class -> validateAndConvertFloatingPoint(
-                    content,
-                    lineNo,
-                    FLOAT
-                ) { num: Double -> num.toFloat() as T }
+        when (T::class) {
+            Float::class -> validateAndConvertFloatingPoint(
+                content,
+                lineNo,
+                FLOAT
+            ) { num: Double -> num.toFloat() as T }
 
-                Double::class -> validateAndConvertFloatingPoint(content, lineNo, DOUBLE) { num: Double -> num as T }
-                else -> invalidType(T::class.toString(), "Signed Type")
-            }
+            Double::class -> validateAndConvertFloatingPoint(content, lineNo, DOUBLE) { num: Double -> num as T }
+            else -> invalidType(T::class.toString(), "Signed Type")
+        }
 
     /**
      * ktoml parser treats all integer literals as Long and all floating-point literals as Double,
@@ -162,19 +162,19 @@ public abstract class TomlAbstractDecoder : AbstractDecoder() {
      * we will check here, that your byte value does not exceed 127 and so on.
      */
     private inline fun <reified T> decodeInteger(content: Long, lineNo: Int): T =
-            when (T::class) {
-                Byte::class -> validateAndConvertInteger(content, lineNo, BYTE) { it.toByte() as T }
-                Short::class -> validateAndConvertInteger(content, lineNo, SHORT) { it.toShort() as T }
-                Int::class -> validateAndConvertInteger(content, lineNo, INT) { it.toInt() as T }
-                Long::class -> validateAndConvertInteger(content, lineNo, LONG) { it as T }
-                Double::class, Float::class -> throw IllegalTypeException(
-                    "Expected floating-point number, but received integer literal: <$content>. " +
-                            "Deserialized floating-point number should have a dot: <$content.0>",
-                    lineNo
-                )
+        when (T::class) {
+            Byte::class -> validateAndConvertInteger(content, lineNo, BYTE) { it.toByte() as T }
+            Short::class -> validateAndConvertInteger(content, lineNo, SHORT) { it.toShort() as T }
+            Int::class -> validateAndConvertInteger(content, lineNo, INT) { it.toInt() as T }
+            Long::class -> validateAndConvertInteger(content, lineNo, LONG) { it as T }
+            Double::class, Float::class -> throw IllegalTypeException(
+                "Expected floating-point number, but received integer literal: <$content>. " +
+                        "Deserialized floating-point number should have a dot: <$content.0>",
+                lineNo
+            )
 
-                else -> invalidType(T::class.toString(), "Signed Type")
-            }
+            else -> invalidType(T::class.toString(), "Signed Type")
+        }
 
     /**
      * ktoml parser treats all integer literals as Long and all floating-point literals as Double,

ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/decoders/TomlArrayDecoder.kt

@@ -69,8 +69,10 @@ public class TomlArrayDecoder(
         return super.beginStructure(descriptor)
     }
 
+    // decodeKeyValue is usually used for simple plain structures, but as it is present in TomlAbstractDecoder,
+    // we should implement it and have this stub
     override fun decodeKeyValue(): TomlKeyValue = throw NotImplementedError("Method `decodeKeyValue`" +
-            " should never be called for TomlListDecoder, it should use ")
+            " should never be called for TomlArrayDecoder, because it is a more complex structure")
 
     override fun decodeString(): String = currentElementDecoder.decodeString()
     override fun decodeInt(): Int = currentElementDecoder.decodeInt()

ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/decoders/TomlMainDecoder.kt

@@ -58,19 +58,20 @@ public class TomlMainDecoder(
     }
 
     override fun decodeEnum(enumDescriptor: SerialDescriptor): Int {
-        val value = decodeValue().toString()
+        val node = decodeKeyValue()
+        val value = node.value.content.toString()
         val index = enumDescriptor.getElementIndex(value)
 
         if (index == CompositeDecoder.UNKNOWN_NAME) {
-            throw InvalidEnumValueException(value, enumDescriptor)
+            throw InvalidEnumValueException(value, enumDescriptor, node.lineNo)
         }
 
         return index
     }
 
     // the iteration will go through all elements that will be found in the input
     private fun isDecodingDone() =
-            if (rootNode is TomlFile) true else elementIndex == rootNode.getNeighbourNodes().size
+        if (rootNode is TomlFile) true else elementIndex == rootNode.getNeighbourNodes().size
 
     /**
      * Getting the node with the value
@@ -103,7 +104,7 @@ public class TomlMainDecoder(
             // branch, we should throw an exception as it is not expected at all and we should catch this in tests
             else ->
                 throw InternalDecodingException(
-                    "Node of type [${node::class}] should not be processed in TomlDecoder.decodeValue(): <${node.content}>"
+                    "Node of type [${node::class}] should not be processed in TomlDecoder.decodeValue(): <${node.content}>."
                 )
         }
     }
@@ -189,9 +190,9 @@ public class TomlMainDecoder(
 
             if (!descriptor.isElementOptional(index)) {
                 throw MissingRequiredPropertyException(
-                    "Invalid number of key-value arguments provided in the input for deserialization." +
-                            " Missing required property " +
-                            "<${descriptor.getElementName(index)}> from class <${descriptor.serialName}> in the input"
+                    "Invalid number of key-value arguments provided in the input for deserialization. Missing required property " +
+                            "<${descriptor.getElementName(index)}> from class <${descriptor.serialName}> in the input. " +
+                            "(In your deserialization class you have declared this field, but it is missing in the input)"
                 )
             }
         }
@@ -201,63 +202,63 @@ public class TomlMainDecoder(
      * A hack that comes from a compiler plugin to process Inline (value) classes
      */
     override fun decodeInline(inlineDescriptor: SerialDescriptor): Decoder =
-            iterateOverStructure(inlineDescriptor, true)
+        iterateOverStructure(inlineDescriptor, true)
 
     /**
      * this method does all the iteration logic for processing code structures and collections
      * treat it as an !entry point! and the orchestrator of the decoding
      */
     override fun beginStructure(descriptor: SerialDescriptor): CompositeDecoder =
-            iterateOverStructure(descriptor, false)
+        iterateOverStructure(descriptor, false)
 
     /**
      * Entry Point into the logic, core logic of the structure traversal and linking the data from TOML AST
      * to the descriptor and vica-versa. Basically this logic is used to iterate through data structures and do processing.
      */
     private fun iterateOverStructure(descriptor: SerialDescriptor, inlineFunc: Boolean): TomlAbstractDecoder =
-            if (rootNode is TomlFile) {
-                checkMissingRequiredProperties(rootNode.children, descriptor)
-                val firstFileChild = getFirstChild(rootNode)
-
-                // inline structures has a very specific logic for decoding. Kotlinx.serialization plugin generates specific code:
-                // 'decoder.decodeInline(this.getDescriptor()).decodeLong())'. So we need simply to increment
-                // our element index by 1 (0 is the default value), because value/inline classes are always a wrapper over some SINGLE value.
-                if (inlineFunc) TomlMainDecoder(firstFileChild, config, 1) else TomlMainDecoder(firstFileChild, config, 0)
-            } else {
-                // this is a tricky index calculation, suggest not to change. We are using the previous node to get all neighbour nodes:
-                // | (parentNode)
-                // |--- neighbourNodes: (current rootNode) (next node which we would like to process now)
-                val nextProcessingNode = rootNode
-                    .getNeighbourNodes()
-                    .elementAt(elementIndex - 1)
-
-                when (nextProcessingNode) {
-                    is TomlKeyValueArray -> TomlArrayDecoder(nextProcessingNode, config)
-                    is TomlKeyValuePrimitive, is TomlStubEmptyNode -> TomlMainDecoder(nextProcessingNode, config)
-                    is TomlTablePrimitive -> {
-                        val firstTableChild = nextProcessingNode.getFirstChild() ?: throw InternalDecodingException(
-                            "Decoding process failed due to invalid structure of parsed AST tree: missing children" +
-                                    " in a table <${nextProcessingNode.fullTableKey}>"
-                        )
-                        checkMissingRequiredProperties(firstTableChild.getNeighbourNodes(), descriptor)
-                        TomlMainDecoder(firstTableChild, config)
-                    }
-                    else -> throw InternalDecodingException(
-                        "Incorrect decoding state in the beginStructure()" +
-                                " with $nextProcessingNode ($nextProcessingNode)[${nextProcessingNode.name}]"
+        if (rootNode is TomlFile) {
+            checkMissingRequiredProperties(rootNode.children, descriptor)
+            val firstFileChild = getFirstChild(rootNode)
+
+            // inline structures has a very specific logic for decoding. Kotlinx.serialization plugin generates specific code:
+            // 'decoder.decodeInline(this.getDescriptor()).decodeLong())'. So we need simply to increment
+            // our element index by 1 (0 is the default value), because value/inline classes are always a wrapper over some SINGLE value.
+            if (inlineFunc) TomlMainDecoder(firstFileChild, config, 1) else TomlMainDecoder(firstFileChild, config, 0)
+        } else {
+            // this is a tricky index calculation, suggest not to change. We are using the previous node to get all neighbour nodes:
+            // | (parentNode)
+            // |--- neighbourNodes: (current rootNode) (next node which we would like to process now)
+            val nextProcessingNode = rootNode
+                .getNeighbourNodes()
+                .elementAt(elementIndex - 1)
+
+            when (nextProcessingNode) {
+                is TomlKeyValueArray -> TomlArrayDecoder(nextProcessingNode, config)
+                is TomlKeyValuePrimitive, is TomlStubEmptyNode -> TomlMainDecoder(nextProcessingNode, config)
+                is TomlTablePrimitive -> {
+                    val firstTableChild = nextProcessingNode.getFirstChild() ?: throw InternalDecodingException(
+                        "Decoding process has failed due to invalid structure of parsed AST tree: missing children" +
+                                " in a table <${nextProcessingNode.fullTableKey}>"
                     )
+                    checkMissingRequiredProperties(firstTableChild.getNeighbourNodes(), descriptor)
+                    TomlMainDecoder(firstTableChild, config)
                 }
+                else -> throw InternalDecodingException(
+                    "Incorrect decoding state in the beginStructure()" +
+                            " with $nextProcessingNode ($nextProcessingNode)[${nextProcessingNode.name}]"
+                )
             }
+        }
 
     private fun getFirstChild(node: TomlNode) =
-            node.getFirstChild() ?: if (!config.allowEmptyToml) {
-                throw InternalDecodingException(
-                    "Missing child nodes (tables, key-values) for TomlFile." +
-                            " Was empty toml provided to the input?"
-                )
-            } else {
-                node
-            }
+        node.getFirstChild() ?: if (!config.allowEmptyToml) {
+            throw InternalDecodingException(
+                "Missing child nodes (tables, key-values) for TomlFile." +
+                        "May be an empty toml was provided to the input?"
+            )
+        } else {
+            node
+        }
 
     public companion object {
         /**

ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/encoders/TomlAbstractEncoder.kt

@@ -52,7 +52,7 @@ public abstract class TomlAbstractEncoder protected constructor(
 
         if (key !is String) {
             throw UnsupportedEncodingFeatureException(
-                "Arbitrary map key types are not supported. Must be either a string" +
+                "Arbitrary map key ($key) types are not supported. Must be either a string" +
                         " or enum. Provide a custom serializer for $type to either " +
                         "of the supported key types."
             )
@@ -253,14 +253,14 @@ public abstract class TomlAbstractEncoder protected constructor(
         rootNode: TomlNode,
         attributes: TomlEncoderAttributes = this.attributes.child()
     ): TomlAbstractEncoder =
-            TomlArrayEncoder(
-                rootNode,
-                parent = this,
-                elementIndex,
-                attributes,
-                outputConfig,
-                serializersModule
-            )
+        TomlArrayEncoder(
+            rootNode,
+            parent = this,
+            elementIndex,
+            attributes,
+            outputConfig,
+            serializersModule
+        )
 
     /**
      * Creates a new inline table encoder instance, with the encoder as its parent.
@@ -269,14 +269,14 @@ public abstract class TomlAbstractEncoder protected constructor(
      * @return The new instance.
      */
     protected open fun inlineTableEncoder(rootNode: TomlNode): TomlAbstractEncoder =
-            TomlInlineTableEncoder(
-                rootNode,
-                parent = this,
-                elementIndex,
-                attributes.child(),
-                outputConfig,
-                serializersModule
-            )
+        TomlInlineTableEncoder(
+            rootNode,
+            parent = this,
+            elementIndex,
+            attributes.child(),
+            outputConfig,
+            serializersModule
+        )
 
     /**
      * Creates a new table encoder instance.
@@ -285,11 +285,11 @@ public abstract class TomlAbstractEncoder protected constructor(
      * @return The new instance.
      */
     protected open fun tableEncoder(rootNode: TomlNode): TomlAbstractEncoder =
-            TomlMainEncoder(
-                rootNode,
-                elementIndex,
-                attributes.child(),
-                outputConfig,
-                serializersModule
-            )
+        TomlMainEncoder(
+            rootNode,
+            elementIndex,
+            attributes.child(),
+            outputConfig,
+            serializersModule
+        )
 }

ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/encoders/TomlEncoderAttributes.kt

@@ -32,7 +32,7 @@ public data class TomlEncoderAttributes(
     public var inlineComment: String = "",
     public var isImplicit: Boolean = false,
 ) {
-    public fun keyOrThrow(): String = key ?: throw InternalEncodingException("Key not set")
+    public fun keyOrThrow(): String = key ?: throw InternalEncodingException("Key is not set")
 
     public fun child(): TomlEncoderAttributes = copy(parent = copy(), isImplicit = false)
 

ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/encoders/TomlInlineTableEncoder.kt

@@ -152,7 +152,7 @@ public class TomlInlineTableEncoder internal constructor(
                 child.comments,
                 child.inlineComment
             )
-            else -> throw InternalEncodingException("Not a pair")
+            else -> throw InternalEncodingException("Tried to encode $child as a pair, but it has unknown type.")
         }
     }
 }