Merge remote-tracking branch 'FasterXML/2.x' into 3.x

Author: k163377

release-notes/CREDITS-2.x

@@ -18,6 +18,9 @@ Contributors:
 # 2.21.0 (not yet released)
 
 WrongWrong (@k163377)
+* #1043: Cleanup of deprecated contents
+* #1042: Remove old StrictNullChecks
+* #1041: Remove MissingKotlinParameterException
 * #1039: Update settings for 2.20
 
 # 2.20.0 (28-Aug-2025)

release-notes/VERSION-2.x

@@ -18,6 +18,10 @@ Co-maintainers:
 
 2.21.0 (not yet released)
 
+#1043: Deprecated content has been cleaned up with the version upgrade.
+#1042: The old StrictNullChecks backend has been removed.
+  This improves the throughput of deserialization slightly.
+#1041: The deprecated MissingKotlinParameterException has been removed.
 #1039: Kotlin has been upgraded to 2.1.x.
 
 2.20.0 (28-Aug-2025)

src/main/kotlin/tools/jackson/module/kotlin/Exceptions.kt

@@ -39,13 +39,12 @@ enum class KotlinFeature(internal val enabledByDefault: Boolean) {
      *
      * With this disabled, the default, collections which are typed to disallow null members (e.g. `List<String>`)
      * may contain null values after deserialization.
-     * Enabling it protects against this but has significant performance impact.
+     * Enabling this will cause an [InvalidNullException] to be thrown if null is entered.
+     *
+     * Internally, it will be the same as if [JsonSetter] (contentNulls = FAIL) had been granted.
+     *
+     * Benchmarks show that it can check for illegal nulls with throughput nearly identical to the default (see [jackson-module-kotlin#719]).
      */
-    @Deprecated(
-        level = DeprecationLevel.ERROR,
-        message = "This option will be migrated to the new backend in 2.21.",
-        replaceWith = ReplaceWith("NewStrictNullChecks")
-    )
     StrictNullChecks(enabledByDefault = false),
 
     /**
@@ -79,18 +78,18 @@ enum class KotlinFeature(internal val enabledByDefault: Boolean) {
      * Internally, it will be the same as if [JsonSetter] (contentNulls = FAIL) had been granted.
      * Benchmarks show that it can check for illegal nulls with throughput nearly identical to the default (see [jackson-module-kotlin#719]).
      *
-     * Note that in the new backend, the exception thrown has changed from [MissingKotlinParameterException] to [InvalidNullException].
-     * The message will be changed accordingly.
-     * Since 2.19, the base class of [MissingKotlinParameterException] has also been changed to [InvalidNullException],
-     * so be careful when catching it.
-     *
      * This is a temporary option for a phased backend migration,
      * which will eventually be merged into [StrictNullChecks].
      * Also, specifying both this and [StrictNullChecks] is not permitted.
      *
      * Since 3.0, this option is enabled by default.
      */
-    NewStrictNullChecks(enabledByDefault = true);
+    @Deprecated(
+        level = DeprecationLevel.WARNING,
+        message = "This option will be merged into StrictNullChecks in 2.23.",
+        replaceWith = ReplaceWith("StrictNullChecks")
+    )
+    NewStrictNullChecks(enabledByDefault = false);
 
     internal val bitSet: BitSet = (1 shl ordinal).toBitSet()
 

src/main/kotlin/tools/jackson/module/kotlin/KotlinFeature.kt

@@ -34,15 +34,11 @@ class KotlinModule private constructor(
     val nullToEmptyMap: Boolean = NullToEmptyMap.enabledByDefault,
     val nullIsSameAsDefault: Boolean = NullIsSameAsDefault.enabledByDefault,
     val singletonSupport: Boolean = SingletonSupport.enabledByDefault,
-    @Suppress("DEPRECATION_ERROR")
     strictNullChecks: Boolean = StrictNullChecks.enabledByDefault,
     val kotlinPropertyNameAsImplicitName: Boolean = KotlinPropertyNameAsImplicitName.enabledByDefault,
     val useJavaDurationConversion: Boolean = UseJavaDurationConversion.enabledByDefault,
-    private val newStrictNullChecks: Boolean = NewStrictNullChecks.enabledByDefault,
+    newStrictNullChecks: Boolean = NewStrictNullChecks.enabledByDefault,
 ) : SimpleModule(KotlinModule::class.java.name, PackageVersion.VERSION) {
-
-    private val oldStrictNullChecks: Boolean = strictNullChecks
-
     // To reduce the amount of destructive changes, no properties will be added to the public.
     val strictNullChecks: Boolean = if (strictNullChecks) {
         if (newStrictNullChecks) {
@@ -87,7 +83,7 @@ class KotlinModule private constructor(
 
         val cache = ReflectionCache(reflectionCacheSize)
 
-        context.addValueInstantiators(KotlinInstantiators(cache, nullToEmptyCollection, nullToEmptyMap, nullIsSameAsDefault, oldStrictNullChecks))
+        context.addValueInstantiators(KotlinInstantiators(cache, nullToEmptyCollection, nullToEmptyMap, nullIsSameAsDefault))
 
         if (singletonSupport) {
             // [module-kotlin#225]: keep Kotlin singletons as singletons
@@ -102,7 +98,7 @@ class KotlinModule private constructor(
                 nullToEmptyCollection = nullToEmptyCollection,
                 nullToEmptyMap = nullToEmptyMap,
                 nullIsSameAsDefault = nullIsSameAsDefault,
-                strictNullChecks = newStrictNullChecks,
+                strictNullChecks = strictNullChecks,
                 kotlinPropertyNameAsImplicitName = kotlinPropertyNameAsImplicitName
             )
         )

src/main/kotlin/tools/jackson/module/kotlin/KotlinModule.kt

@@ -22,16 +22,13 @@ internal class KotlinValueInstantiator(
     private val cache: ReflectionCache,
     private val nullToEmptyCollection: Boolean,
     private val nullToEmptyMap: Boolean,
-    private val nullIsSameAsDefault: Boolean,
-    private val strictNullChecks: Boolean
+    private val nullIsSameAsDefault: Boolean
 ) : StdValueInstantiator(src) {
     private fun JavaType.requireEmptyValue() =
         (nullToEmptyCollection && this.isCollectionLikeType) || (nullToEmptyMap && this.isMapLikeType)
 
     private fun KType.isGenericTypeVar() = javaType is TypeVariable<*>
 
-    private fun List<KTypeProjection>.markedNonNullAt(index: Int) = getOrNull(index)?.type?.isMarkedNullable == false
-
     // If the argument is a value class that wraps nullable and non-null,
     // and the input is explicit null, the value class is instantiated with null as input.
     private fun requireValueClassSpecialNullValue(
@@ -104,35 +101,6 @@ internal class KotlinValueInstantiator(
                         ).wrapWithPath(this.valueClass, pname)
                     }
                 }
-            } else if (strictNullChecks) {
-                val arguments = paramType.arguments
-
-                // To make the behavior the same as deserialization of each element using NullsFailProvider,
-                // first wrapWithPath with paramVal and key.
-                val ex = when {
-                    propType.isCollectionLikeType && arguments.markedNonNullAt(0) -> {
-                        (paramVal as Collection<*>).indexOf(null).takeIf { it >= 0 }?.let {
-                            InvalidNullException.from(ctxt, jsonProp.fullName, jsonProp.type)
-                                .wrapWithPath(paramVal, it)
-                        }
-                    }
-                    propType.isMapLikeType && arguments.markedNonNullAt(1) -> {
-                        (paramVal as Map<*, *>).entries.find { (_, v) -> v == null }?.let { (k, _) ->
-                            InvalidNullException.from(ctxt, jsonProp.fullName, jsonProp.type)
-                                .wrapWithPath(paramVal, k.toString())
-                        }
-                    }
-                    propType.isArrayType && arguments.markedNonNullAt(0) -> {
-                        (paramVal as Array<*>).indexOf(null).takeIf { it >= 0 }?.let {
-                            InvalidNullException.from(ctxt, jsonProp.fullName, jsonProp.type)
-                                .wrapWithPath(paramVal, it)
-                        }
-                    }
-                    else -> null
-                }
-
-                // Then, wrapWithPath with this property.
-                ex?.let { throw it.wrapWithPath(this.valueClass, jsonProp.name) }
             }
 
             bucket[paramDef] = paramVal
@@ -151,7 +119,6 @@ internal class KotlinInstantiators(
     private val nullToEmptyCollection: Boolean,
     private val nullToEmptyMap: Boolean,
     private val nullIsSameAsDefault: Boolean,
-    private val strictNullChecks: Boolean
 ) : ValueInstantiators.Base() {
     override fun modifyValueInstantiator(
         deserConfig: DeserializationConfig,
@@ -165,8 +132,7 @@ internal class KotlinInstantiators(
                     cache,
                     nullToEmptyCollection,
                     nullToEmptyMap,
-                    nullIsSameAsDefault,
-                    strictNullChecks
+                    nullIsSameAsDefault
                 )
             } else {
                 // TODO: return defaultInstantiator and let default method parameters and nullability go unused?  or die with exception:

src/main/kotlin/tools/jackson/module/kotlin/KotlinValueInstantiator.kt

@@ -13,8 +13,7 @@ class KotlinInstantiatorsTest {
         ReflectionCache(10),
         nullToEmptyCollection = false,
         nullToEmptyMap = false,
-        nullIsSameAsDefault = false,
-        strictNullChecks = false
+        nullIsSameAsDefault = false
     )
 
     @Test

src/test/kotlin/tools/jackson/module/kotlin/KotlinInstantiatorsTest.kt

@@ -8,13 +8,13 @@ import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
 import tools.jackson.databind.exc.InvalidNullException
 import tools.jackson.databind.json.JsonMapper
-import tools.jackson.module.kotlin.KotlinFeature.NewStrictNullChecks
+import tools.jackson.module.kotlin.KotlinFeature
 import tools.jackson.module.kotlin.kotlinModule
 import tools.jackson.module.kotlin.readValue
 
 class StrictNullChecksTest {
     private val mapper = JsonMapper.builder()
-        .addModule(kotlinModule { enable(NewStrictNullChecks) })
+        .addModule(kotlinModule { enable(KotlinFeature.StrictNullChecks) })
         .build()
 
     class ArrayWrapper(val value: Array<Int>)

src/test/kotlin/tools/jackson/module/kotlin/MissingKotlinParameterExceptionTest.kt

@@ -7,14 +7,14 @@ import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
 import tools.jackson.databind.exc.InvalidNullException
 import tools.jackson.databind.json.JsonMapper
-import tools.jackson.module.kotlin.KotlinFeature.NewStrictNullChecks
+import tools.jackson.module.kotlin.KotlinFeature
 import tools.jackson.module.kotlin.kotlinModule
 import tools.jackson.module.kotlin.readValue
 import kotlin.test.assertNull
 
 class StrictNullChecksTest {
     private val mapper = JsonMapper.builder()
-            .addModule(kotlinModule { enable(NewStrictNullChecks) })
+            .addModule(kotlinModule { enable(KotlinFeature.StrictNullChecks) })
             .build()
 
     /** collection tests */