added config option to allow unsafe mapping of platform types to non-nullable target (#273)

ErwinOlie · stefankoppier · web-flow · commit 21deeb6c74a0 · 2025-11-08T11:18:03.000+01:00
* added config option to allow unsafe mapping of Java platform types to non-nullable target

* remove unused class

* fix compile error

* fix java classes not found in maven tests

* applied suggested rename UseStrictJavaNullability -&gt; UseStrictPlatformTypeNullabilityValidation

* applied better comment suggestions

* update changelog

---------

Co-authored-by: Stefan Koppier &lt;stefan.koppier@outlook.com&gt;
diff --git a/compiler-plugin/src/main/kotlin/tech/mappie/MappieCommandLineProcessor.kt b/compiler-plugin/src/main/kotlin/tech/mappie/MappieCommandLineProcessor.kt
@@ -31,6 +31,12 @@ class MappieCommandLineProcessor : CommandLineProcessor {
             description = "strictness of enum validation",
             required = false,
         ),
+        CliOption(
+            optionName = OPTION_STRICTNESS_JAVA_NULLABILITY,
+            valueDescription = "boolean",
+            description = "strictness of java nullability validation",
+            required = false,
+        ),
         CliOption(
             optionName = OPTION_STRICTNESS_VISIBILITY,
             valueDescription = "boolean",
@@ -56,6 +62,7 @@ class MappieCommandLineProcessor : CommandLineProcessor {
             OPTION_WARNINGS_AS_ERRORS -> configuration.put(ARGUMENT_WARNINGS_AS_ERRORS, value.toBooleanStrict())
             OPTION_USE_DEFAULT_ARGUMENTS -> configuration.put(ARGUMENT_USE_DEFAULT_ARGUMENTS, value.toBooleanStrict())
             OPTION_STRICTNESS_ENUMS -> configuration.put(ARGUMENT_STRICTNESS_ENUMS, value.toBooleanStrict())
+            OPTION_STRICTNESS_JAVA_NULLABILITY -> configuration.put(ARGUMENT_STRICTNESS_JAVA_NULLABILITY, value.toBooleanStrict())
             OPTION_STRICTNESS_VISIBILITY -> configuration.put(ARGUMENT_STRICTNESS_VISIBILITY, value.toBooleanStrict())
             OPTION_REPORT_ENABLED -> configuration.put(ARGUMENT_REPORT_ENABLED, value.toBooleanStrict())
             OPTION_REPORT_DIR -> configuration.put(ARGUMENT_REPORT_DIR, value)
@@ -67,13 +74,15 @@ class MappieCommandLineProcessor : CommandLineProcessor {
         const val OPTION_WARNINGS_AS_ERRORS = "warnings-as-errors"
         const val OPTION_USE_DEFAULT_ARGUMENTS = "use-default-arguments"
         const val OPTION_STRICTNESS_ENUMS = "strict-enums"
+        const val OPTION_STRICTNESS_JAVA_NULLABILITY = "strict-platform-type-nullability"
         const val OPTION_STRICTNESS_VISIBILITY = "strict-visibility"
         const val OPTION_REPORT_ENABLED = "report-enabled"
         const val OPTION_REPORT_DIR = "report-dir"
 
         val ARGUMENT_WARNINGS_AS_ERRORS = CompilerConfigurationKey<Boolean>(OPTION_WARNINGS_AS_ERRORS)
         val ARGUMENT_USE_DEFAULT_ARGUMENTS = CompilerConfigurationKey<Boolean>(OPTION_USE_DEFAULT_ARGUMENTS)
         val ARGUMENT_STRICTNESS_ENUMS = CompilerConfigurationKey<Boolean>(OPTION_STRICTNESS_ENUMS)
+        val ARGUMENT_STRICTNESS_JAVA_NULLABILITY = CompilerConfigurationKey<Boolean>(OPTION_STRICTNESS_JAVA_NULLABILITY)
         val ARGUMENT_STRICTNESS_VISIBILITY = CompilerConfigurationKey<Boolean>(OPTION_STRICTNESS_VISIBILITY)
         val ARGUMENT_REPORT_ENABLED = CompilerConfigurationKey<Boolean>(OPTION_REPORT_ENABLED)
         val ARGUMENT_REPORT_DIR = CompilerConfigurationKey<String>(OPTION_REPORT_DIR)
diff --git a/compiler-plugin/src/main/kotlin/tech/mappie/MappieCompilerPluginRegistrar.kt b/compiler-plugin/src/main/kotlin/tech/mappie/MappieCompilerPluginRegistrar.kt
@@ -15,6 +15,7 @@ import tech.mappie.MappieCommandLineProcessor.Companion.ARGUMENT_REPORT_DIR
 import tech.mappie.MappieCommandLineProcessor.Companion.ARGUMENT_REPORT_ENABLED
 import tech.mappie.MappieCommandLineProcessor.Companion.ARGUMENT_USE_DEFAULT_ARGUMENTS
 import tech.mappie.MappieCommandLineProcessor.Companion.ARGUMENT_WARNINGS_AS_ERRORS
+import tech.mappie.MappieCommandLineProcessor.Companion.ARGUMENT_STRICTNESS_JAVA_NULLABILITY
 import tech.mappie.compiler_plugin.BuildConfig
 import tech.mappie.config.MappieConfiguration
 import tech.mappie.config.MappieModule
@@ -38,6 +39,7 @@ class MappieCompilerPluginRegistrar : CompilerPluginRegistrar() {
             warningsAsErrors = configuration.get(ARGUMENT_WARNINGS_AS_ERRORS, false),
             useDefaultArguments = configuration.get(ARGUMENT_USE_DEFAULT_ARGUMENTS, true),
             strictEnums = configuration.get(ARGUMENT_STRICTNESS_ENUMS, true),
+            strictplatformTypeNullability = configuration.get(ARGUMENT_STRICTNESS_JAVA_NULLABILITY, true),
             strictVisibility = configuration.get(ARGUMENT_STRICTNESS_VISIBILITY, false),
             reportEnabled = configuration.get(ARGUMENT_REPORT_ENABLED, false),
             reportDir = configuration.get(ARGUMENT_REPORT_DIR, ""),
diff --git a/compiler-plugin/src/main/kotlin/tech/mappie/config/MappieConfiguration.kt b/compiler-plugin/src/main/kotlin/tech/mappie/config/MappieConfiguration.kt
@@ -6,6 +6,7 @@ data class MappieConfiguration(
     val warningsAsErrors: Boolean,
     val useDefaultArguments: Boolean,
     val strictEnums: Boolean,
+    val strictplatformTypeNullability: Boolean,
     val strictVisibility: Boolean,
     val reportEnabled: Boolean,
     val reportDir: String,
diff --git a/compiler-plugin/src/main/kotlin/tech/mappie/config/options/StrictJavaNullability.kt b/compiler-plugin/src/main/kotlin/tech/mappie/config/options/StrictJavaNullability.kt
@@ -0,0 +1,22 @@
+package tech.mappie.config.options
+
+import org.jetbrains.kotlin.ir.declarations.IrFunction
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
+import org.jetbrains.kotlin.ir.types.classOrFail
+import org.jetbrains.kotlin.ir.util.getValueArgument
+import org.jetbrains.kotlin.ir.util.isTrueConst
+import org.jetbrains.kotlin.ir.util.parentAsClass
+import org.jetbrains.kotlin.name.Name
+import tech.mappie.MappieContext
+import tech.mappie.util.CLASS_ID_USE_STRICT_JAVA_NULLABILITY
+
+fun MappieContext.useStrictPlatformTypeNullabilityValidationClassSymbol() =
+    pluginContext.referenceClass(CLASS_ID_USE_STRICT_JAVA_NULLABILITY)
+
+fun MappieContext.getUseStrictPlatformTypeNullabilityValidationAnnotation(origin: IrFunction): IrConstructorCall? =
+    origin.parentAsClass.annotations.firstOrNull { it.type.classOrFail == useStrictPlatformTypeNullabilityValidationClassSymbol() }
+
+fun MappieContext.useStrictPlatformTypeNullabilityValidation(origin: IrFunction): Boolean =
+    getUseStrictPlatformTypeNullabilityValidationAnnotation(origin)
+        ?.let { it.getValueArgument(Name.identifier("value"))?.isTrueConst() ?: true }
+        ?: configuration.strictplatformTypeNullability
diff --git a/compiler-plugin/src/main/kotlin/tech/mappie/fir/MappieAdditionalCheckersExtension.kt b/compiler-plugin/src/main/kotlin/tech/mappie/fir/MappieAdditionalCheckersExtension.kt
@@ -13,8 +13,8 @@ class MappieAdditionalCheckersExtension(session: FirSession) : FirAdditionalChec
     override val expressionCheckers = object : ExpressionCheckers() {
         override val annotationCallCheckers = setOf(
             UseDefaultArgumentsAnnotationChecker(),
-            UseStrictVisibilityAnnotationChecker(),
             UseStrictEnumsAnnotationChecker(),
+            UseStrictVisibilityAnnotationChecker(),
         )
 
         override val functionCallCheckers: Set<FirFunctionCallChecker> = setOf(
diff --git a/compiler-plugin/src/main/kotlin/tech/mappie/ir/analysis/problems/classes/UnsafePlatformTypeAssignmentProblems.kt b/compiler-plugin/src/main/kotlin/tech/mappie/ir/analysis/problems/classes/UnsafePlatformTypeAssignmentProblems.kt
@@ -4,6 +4,7 @@ import org.jetbrains.kotlin.ir.types.removeAnnotations
 import org.jetbrains.kotlin.ir.util.isNullable
 import org.jetbrains.kotlin.ir.util.dumpKotlinLike
 import org.jetbrains.kotlin.ir.util.fileEntry
+import tech.mappie.config.options.useStrictPlatformTypeNullabilityValidation
 import tech.mappie.ir.resolving.ClassMappingRequest
 import tech.mappie.ir.resolving.classes.sources.*
 import tech.mappie.ir.resolving.classes.targets.ClassMappingTarget
@@ -20,7 +21,12 @@ class UnsafePlatformTypeAssignmentProblems(
     private val mappings: Map<ClassMappingTarget, ClassMappingSource>,
 ) {
 
-    fun all(): List<Problem> = mappings.mapNotNull { validate(it.key, it.value) }
+    fun all(): List<Problem> =
+        if (context.useStrictPlatformTypeNullabilityValidation(context.function)) {
+            mappings.mapNotNull { validate(it.key, it.value) }
+        } else {
+            emptyList()
+        }
 
     private fun validate(target: ClassMappingTarget, source: ClassMappingSource): Problem? {
         val sourceTypeString = source.type.removeAnnotations().dumpKotlinLike()
diff --git a/compiler-plugin/src/main/kotlin/tech/mappie/util/Identifiers.kt b/compiler-plugin/src/main/kotlin/tech/mappie/util/Identifiers.kt
@@ -76,10 +76,12 @@ val CLASS_ID_OBJECT_MAPPIE4 = ClassId(PACKAGE_TECH_MAPPIE_API, Name.identifier("
 
 val CLASS_ID_OBJECT_MAPPIE5 = ClassId(PACKAGE_TECH_MAPPIE_API, Name.identifier("ObjectMappie5"))
 
-val CLASS_ID_USE_STRICT_VISIBILITY = ClassId(PACKAGE_TECH_MAPPIE_API_CONFIG, Name.identifier("UseStrictVisibility"))
-
 val CLASS_ID_USE_DEFAULT_ARGUMENTS = ClassId(PACKAGE_TECH_MAPPIE_API_CONFIG, Name.identifier("UseDefaultArguments"))
 
 val CLASS_ID_USE_STRICT_ENUMS = ClassId(PACKAGE_TECH_MAPPIE_API_CONFIG, Name.identifier("UseStrictEnums"))
 
+val CLASS_ID_USE_STRICT_JAVA_NULLABILITY = ClassId(PACKAGE_TECH_MAPPIE_API_CONFIG, Name.identifier("UseStrictPlatformTypeNullabilityValidation"))
+
+val CLASS_ID_USE_STRICT_VISIBILITY = ClassId(PACKAGE_TECH_MAPPIE_API_CONFIG, Name.identifier("UseStrictVisibility"))
+
 val CLASS_ID_RECORD = ClassId(FqName("java.lang"), Name.identifier("Record"))
diff --git a/gradle-plugin/src/main/kotlin/tech/mappie/MappieExtension.kt b/gradle-plugin/src/main/kotlin/tech/mappie/MappieExtension.kt
@@ -53,6 +53,11 @@ abstract class MappieStrictnessExtension {
      */
     abstract val enums: Property<Boolean>
 
+    /**
+     * Report a warning if a nullable platform type is used to assign to a non-nullable target.
+     */
+    abstract val platformTypeNullability: Property<Boolean>
+
     /**
      * Whether to require called elements to be visible from the current scope.
      */
diff --git a/gradle-plugin/src/main/kotlin/tech/mappie/MappieGradlePlugin.kt b/gradle-plugin/src/main/kotlin/tech/mappie/MappieGradlePlugin.kt
@@ -30,6 +30,9 @@ class MappieGradlePlugin : KotlinCompilerPluginSupportPlugin {
                     extension.strictness.enums.orNull?.apply {
                         add(SubpluginOption("strict-enums", this.toString()))
                     }
+                    extension.strictness.platformTypeNullability.orNull?.apply {
+                        add(SubpluginOption("strict-platform-type-nullability", this.toString()))
+                    }
                     extension.strictness.visibility.orNull?.apply {
                         add(SubpluginOption("strict-visibility", this.toString()))
                     }
diff --git a/gradle-plugin/src/test/kotlin/tech/mappie/testing/configuration/strictness/JavaNullabilityStrictnessTest.kt b/gradle-plugin/src/test/kotlin/tech/mappie/testing/configuration/strictness/JavaNullabilityStrictnessTest.kt
@@ -0,0 +1,142 @@
+package tech.mappie.testing.configuration.strictness
+
+import tech.mappie.testing.TestBase
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class platformTypeNullabilityStrictnessTest : TestBase() {
+
+    @Test
+    fun `java nullability warning is emitted when enabled`() {
+        kotlin("build.gradle.kts",
+            """
+            mappie {
+                strictness {
+                    platformTypeNullability = true        
+                }
+            }                
+            """.trimIndent()
+        )
+
+        java("src/main/java/Input.java",
+            """
+            public class Input {
+                private String value;
+
+                public Input(String value) {
+                    this.value = value;
+                }
+
+                public String getValue() {
+                    return value;
+                }
+            }
+            """.trimIndent()
+        )
+
+        kotlin("src/main/kotlin/Mapper.kt",
+            """
+            import tech.mappie.api.ObjectMappie
+
+            data class Output(val value: String)
+
+            object Mapper : ObjectMappie<Input, Output>()
+            """.trimIndent()
+        )
+
+        val result = runner.withArguments("build").build()
+
+        assertThat(result.output.lines())
+            .anyMatch { it.contains("is unsafe to assign") }
+    }
+
+    @Test
+    fun `java nullability warning is not emitted when disabled`() {
+        kotlin("build.gradle.kts",
+            """
+            mappie {
+                strictness {
+                    platformTypeNullability = false        
+                }
+            }                
+            """.trimIndent()
+        )
+
+        java("src/main/java/Input.java",
+            """
+            public class Input {
+                private String value;
+
+                public Input(String value) {
+                    this.value = value;
+                }
+
+                public String getValue() {
+                    return value;
+                }
+            }
+            """.trimIndent()
+        )
+
+        kotlin("src/main/kotlin/Mapper.kt",
+            """
+            import tech.mappie.api.ObjectMappie
+
+            data class Output(val value: String)
+
+            object Mapper : ObjectMappie<Input, Output>()
+            """.trimIndent()
+        )
+
+        val result = runner.withArguments("build").build()
+
+        assertThat(result.output.lines())
+            .noneMatch { it.contains("is unsafe to assign") }
+    }
+
+    @Test
+    fun `java nullability warning is not emitted when disabled locally`() {
+        kotlin("build.gradle.kts",
+            """
+            mappie {
+                strictness {
+                    platformTypeNullability = true        
+                }
+            }                
+            """.trimIndent()
+        )
+
+        java("src/main/java/Input.java",
+            """
+            public class Input {
+                private String value;
+
+                public Input(String value) {
+                    this.value = value;
+                }
+
+                public String getValue() {
+                    return value;
+                }
+            }
+            """.trimIndent()
+        )
+
+        kotlin("src/main/kotlin/Mapper.kt",
+            """
+            import tech.mappie.api.ObjectMappie
+            import tech.mappie.api.config.UseStrictPlatformTypeNullabilityValidation
+
+            data class Output(val value: String)
+
+            @UseStrictPlatformTypeNullabilityValidation(false)
+            object Mapper : ObjectMappie<Input, Output>()
+            """.trimIndent()
+        )
+
+        val result = runner.withArguments("build").build()
+
+        assertThat(result.output.lines())
+            .noneMatch { it.contains("is unsafe to assign") }
+    }
+}
diff --git a/mappie-api/src/commonMain/kotlin/tech/mappie/api/config/MappieOptions.kt b/mappie-api/src/commonMain/kotlin/tech/mappie/api/config/MappieOptions.kt
@@ -6,5 +6,8 @@ public annotation class UseDefaultArguments(val value: Boolean = true)
 @Target(AnnotationTarget.CLASS)
 public annotation class UseStrictEnums(val value: Boolean = true)
 
+@Target(AnnotationTarget.CLASS)
+public annotation class UseStrictPlatformTypeNullabilityValidation(val value: Boolean = true)
+
 @Target(AnnotationTarget.CLASS)
 public annotation class UseStrictVisibility(val value: Boolean = true)
diff --git a/maven-plugin/src/test/kotlin/tech/mappie/testing/MavenTestBase.kt b/maven-plugin/src/test/kotlin/tech/mappie/testing/MavenTestBase.kt
@@ -35,6 +35,7 @@ abstract class MavenTestBase {
 
     @BeforeEach
     fun setup() {
+        directory.resolve("src/main/java").mkdirs()
         directory.resolve("src/main/kotlin").mkdirs()
         directory.resolve("src/test/kotlin").mkdirs()
 
@@ -63,8 +64,6 @@ abstract class MavenTestBase {
                 </repositories>
                 
                 <build>
-                    <sourceDirectory>src/main/kotlin</sourceDirectory>
-                    <testSourceDirectory>src/test/kotlin</testSourceDirectory>
                     <plugins>
                           <plugin>
                             <groupId>org.apache.maven.plugins</groupId>
@@ -82,12 +81,24 @@ abstract class MavenTestBase {
                                     <goals>
                                         <goal>compile</goal>
                                     </goals>
+                                    <configuration>
+                                        <sourceDirs>
+                                            <sourceDir>src/main/java</sourceDir>
+                                            <sourceDir>src/main/kotlin</sourceDir>
+                                        </sourceDirs>
+                                    </configuration>
                                 </execution>
                                 <execution>
                                     <id>test-compile</id>
                                     <goals>
                                         <goal>test-compile</goal>
                                     </goals>
+                                    <configuration>
+                                        <sourceDirs>
+                                            <sourceDir>src/test/java</sourceDir>
+                                            <sourceDir>src/test/kotlin</sourceDir>
+                                        </sourceDirs>
+                                    </configuration>
                                 </execution>
                             </executions>
                             <configuration>
@@ -183,6 +194,12 @@ abstract class MavenTestBase {
         }
     }
 
+    protected fun java(file: String, @Language("java") code: String) {
+        directory.resolve(file).apply {
+            appendText(code)
+        }
+    }
+
     companion object {
         private const val VERSION = BuildConfig.VERSION
 
diff --git a/maven-plugin/src/test/kotlin/tech/mappie/testing/configuration/strictness/MavenJavaNullabilityStrictnessTest.kt b/maven-plugin/src/test/kotlin/tech/mappie/testing/configuration/strictness/MavenJavaNullabilityStrictnessTest.kt
diff --git a/website/src/changelog.md b/website/src/changelog.md
diff --git a/website/src/posts/getting-started/posts/gradle.md b/website/src/posts/getting-started/posts/gradle.md
diff --git a/website/src/posts/getting-started/posts/maven.md b/website/src/posts/getting-started/posts/maven.md
diff --git a/website/src/posts/object-mapping/posts/configuration.md b/website/src/posts/object-mapping/posts/configuration.md
diff --git a/website/src/posts/object-mapping/posts/java.md b/website/src/posts/object-mapping/posts/java.md

Original file line number	Diff line number	Diff line change
`@@ -13,8 +13,8 @@ class MappieAdditionalCheckersExtension(session: FirSession) : FirAdditionalChec`
`13`	`13`	`override val expressionCheckers = object : ExpressionCheckers() {`
`14`	`14`	`override val annotationCallCheckers = setOf(`
`15`	`15`	`UseDefaultArgumentsAnnotationChecker(),`
`16`		`- UseStrictVisibilityAnnotationChecker(),`
`17`	`16`	`UseStrictEnumsAnnotationChecker(),`
	`17`	`+ UseStrictVisibilityAnnotationChecker(),`
`18`	`18`	`)`
`19`	`19`
`20`	`20`	`override val functionCallCheckers: Set<FirFunctionCallChecker> = setOf(`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,9 @@ class MappieGradlePlugin : KotlinCompilerPluginSupportPlugin {`
`30`	`30`	`extension.strictness.enums.orNull?.apply {`
`31`	`31`	`add(SubpluginOption("strict-enums", this.toString()))`
`32`	`32`	`}`
	`33`	`+ extension.strictness.platformTypeNullability.orNull?.apply {`
	`34`	`+ add(SubpluginOption("strict-platform-type-nullability", this.toString()))`
	`35`	`+ }`
`33`	`36`	`extension.strictness.visibility.orNull?.apply {`
`34`	`37`	`add(SubpluginOption("strict-visibility", this.toString()))`
`35`	`38`	`}`