Fixes for generation of both nullable and non-nullable in the same mapper (#307)

Author: stefankoppier

compiler-plugin/src/main/kotlin/tech/mappie/ir/MappieDefinitions.kt

@@ -87,7 +87,6 @@ interface MappieDefinition {
     val target: IrType
 
     fun referenceMapFunction() = clazz.functions.first { it.isMappieMapFunction() }
-    fun referenceMapNullableFunction() = clazz.functions.first { it.isMappieMapNullableFunction() }
 }
 
 data class InternalMappieDefinition(

compiler-plugin/src/main/kotlin/tech/mappie/ir/generation/TransformationConstructor.kt

@@ -63,14 +63,14 @@ fun IrBuilderWithScope.constructTransformation(
                 val definition = definitions.first().clazz
 
                 if (definition is IrMappieGeneratedClass) {
-                    context.logger.log(internal("failed to reference generated mapper ${definition.name}."))
+                    context.logger.log(internal("failed to reference generated mapper ${definition.name} in ${origin.clazz.name}."))
 
                     irCall(referenceFunctionError()).apply {
                         arguments[0] = IrConstImpl.string(
                             SYNTHETIC_OFFSET,
                             SYNTHETIC_OFFSET,
                             context.pluginContext.irBuiltIns.stringType,
-                            "Failed to reference generated mapper ${definition.name}"
+                            "Failed to reference generated mapper ${definition.name} in ${origin.clazz.name}"
                         )
                     }
                 } else {
@@ -80,7 +80,7 @@ fun IrBuilderWithScope.constructTransformation(
                     }
                 }
             } else {
-                context.logger.log(internal("failed to reference generated mapper."))
+                context.logger.log(internal("failed to reference an unique generated mapper in ${origin.clazz.name}. Possible options: " + definitions.joinToString(prefix = "'", postfix = "'") { it.clazz.name.asString() }))
 
                 irCall(referenceFunctionError()).apply {
                     arguments[0] = IrConstImpl.string(

compiler-plugin/src/main/kotlin/tech/mappie/ir/generation/classes/ClassMappieCodeGenerationModelFactory.kt

@@ -1,6 +1,7 @@
 package tech.mappie.ir.generation.classes
 
 import org.jetbrains.kotlin.ir.types.IrType
+import org.jetbrains.kotlin.ir.types.makeNullable
 import org.jetbrains.kotlin.ir.types.typeOrFail
 import org.jetbrains.kotlin.ir.util.dumpKotlinLike
 import tech.mappie.ir.MappieContext
@@ -91,7 +92,7 @@ class ClassMappieCodeGenerationModelFactory {
     private fun generated(origin: InternalMappieDefinition, mappings: Map<ClassMappingTarget, ClassMappingSource>): Map<GeneratedMappieDefinition, CodeGenerationModel> =
         mappings.entries.fold(mutableMapOf<GeneratedMappieDefinition, CodeGenerationModel>()) { acc, (target, source) ->
             acc.apply {
-                fun isUnique(source: IrType, target: IrType) = acc.entries.none { it.key.target == target && it.key.source == source }
+                fun isUnique(source: IrType, target: IrType) = acc.entries.none { it.key.target.makeNullable() == target.makeNullable() && it.key.source.makeNullable() == source.makeNullable() }
 
                 val source = source as? TransformableClassMappingSource
                 when (val transformation = source?.transformation) {

compiler-plugin/src/test/kotlin/tech/mappie/testing/lists/MapTwoListsOfDifferentTypeTest.kt

@@ -0,0 +1,38 @@
+package tech.mappie.testing.lists
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import tech.mappie.testing.MappieTestCase
+
+class MapTwoListsOfDifferentTypeTest : MappieTestCase() {
+
+    data class Input(val first: List<FirstInput>, val second: List<SecondInput>)
+    data class FirstInput(val value: String)
+    data class SecondInput(val value: Int)
+
+    data class Output(val first: List<FirstOutput>, val second: List<SecondOutput>)
+    data class FirstOutput(val value: String)
+    data class SecondOutput(val value: Int)
+
+    @Test
+    fun `map two lists of different type should succeed`() {
+        compile {
+            file("Test.kt",
+                """
+                import tech.mappie.api.ObjectMappie
+                import tech.mappie.testing.lists.MapTwoListsOfDifferentTypeTest.*
+
+                class Mapper : ObjectMappie<Input, Output>()
+                """
+            )
+        } satisfies {
+            isOk()
+            hasNoWarningsOrErrors()
+
+            val mapper = objectMappie<Input, Output>()
+
+            assertThat(mapper.map(Input(listOf(FirstInput("a")), listOf(SecondInput(1)))))
+                .isEqualTo(Output(listOf(FirstOutput("a")), listOf(SecondOutput(1))))
+        }
+    }
+}

compiler-plugin/src/test/kotlin/tech/mappie/testing/objects/GeneratedClassNullToNullTest.kt

@@ -5,9 +5,9 @@ import org.junit.jupiter.api.Test
 import tech.mappie.testing.MappieTestCase
 
 class GeneratedClassNullToNullTest : MappieTestCase() {
-    data class Input(val a: InnerInput?)
+    data class Input(val a: InnerInput, val b: InnerInput?)
     @Suppress("unused") enum class InnerInput { FIRST, SECOND }
-    data class Output(val a: InnerOutput?)
+    data class Output(val a: InnerOutput, val b: InnerOutput?)
     @Suppress("unused") enum class InnerOutput { FIRST, SECOND }
 
     @Test
@@ -27,11 +27,11 @@ class GeneratedClassNullToNullTest : MappieTestCase() {
 
             val mapper = objectMappie<Input, Output>()
 
-            assertThat(mapper.map(Input(InnerInput.FIRST)))
-                .isEqualTo(Output(InnerOutput.FIRST))
+            assertThat(mapper.map(Input(InnerInput.SECOND,InnerInput.FIRST)))
+                .isEqualTo(Output(InnerOutput.SECOND, InnerOutput.FIRST))
 
-            assertThat(mapper.map(Input(null)))
-                .isEqualTo(Output(null))
+            assertThat(mapper.map(Input(InnerInput.FIRST, null)))
+                .isEqualTo(Output(InnerOutput.FIRST, null))
         }
     }
 }

compiler-plugin/src/test/kotlin/tech/mappie/testing/objects/GeneratedDoubleNestedClassTest.kt

@@ -0,0 +1,34 @@
+package tech.mappie.testing.objects
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import tech.mappie.testing.MappieTestCase
+
+class GeneratedDoubleNestedClassTest : MappieTestCase() {
+    data class Input(val a: InnerInput, val b: InnerInput?)
+    data class InnerInput(val value: InnerInput?)
+    data class Output(val a: InnerOutput, val b: InnerOutput?)
+    data class InnerOutput(val value: InnerOutput?)
+
+    @Test
+    fun `map object with nested class without declaring mapping should succeed`() {
+        compile {
+            file("Test.kt",
+                """
+                import tech.mappie.api.ObjectMappie
+                import tech.mappie.testing.objects.GeneratedDoubleNestedClassTest.*
+
+                class Mapper : ObjectMappie<Input, Output>()
+                """
+            )
+        } satisfies {
+            isOk()
+            hasNoWarningsOrErrors()
+
+            val mapper = objectMappie<Input, Output>()
+
+            assertThat(mapper.map(Input(InnerInput(InnerInput(null)), null)))
+                .isEqualTo(Output(InnerOutput(InnerOutput(null)), null))
+        }
+    }
+}

compiler-plugin/src/test/kotlin/tech/mappie/testing/objects/GeneratedDoubleNullableClassTest.kt

@@ -0,0 +1,34 @@
+package tech.mappie.testing.objects
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import tech.mappie.testing.MappieTestCase
+
+class GeneratedDoubleNullableClassTest : MappieTestCase() {
+    data class Input(val a: InnerInput, val b: InnerInput?)
+    data class InnerInput(val value: String)
+    data class Output(val a: InnerOutput, val b: InnerOutput?)
+    data class InnerOutput(val value: String)
+
+    @Test
+    fun `map object with nested class without declaring mapping should succeed`() {
+        compile {
+            file("Test.kt",
+                """
+                import tech.mappie.api.ObjectMappie
+                import tech.mappie.testing.objects.GeneratedDoubleNullableClassTest.*
+
+                class Mapper : ObjectMappie<Input, Output>()
+                """
+            )
+        } satisfies {
+            isOk()
+            hasNoWarningsOrErrors()
+
+            val mapper = objectMappie<Input, Output>()
+
+            assertThat(mapper.map(Input(InnerInput("a"), InnerInput("b"))))
+                .isEqualTo(Output(InnerOutput("a"), InnerOutput("b")))
+        }
+    }
+}