[K/N] Don't generate generic safe casts for Objective-C types

SvyatoslavScherbina · Space Team · commit 45d6c859c027 · 2026-04-15T08:58:23.000Z
With `genericSafeCasts=true` enabled by default, the Kotlin/Native compiler now generates additional type checks to make sure that generic type erasure doesn't allow objects of unexpected types to slip through. As a justified side effect, this also checks types of objects passed from Objective-C libraries. Objective-C is tricky, though. For example, it is common to use "duck typing" in Objective-C: if an Obj-C function has an Obj-C class or protocol as the return type, the return value doesn't need to actually be of that type: it is enough to respond to the same method calls. Such mismatches happen even in Apple's own frameworks, which caused KT-85508. So, it is justified to not generate such type checks for Objective-C types. This commit does exactly that (and also removes handling of special cases of Objective-C types there, as they are now covered with the general Obj-C type exclusion). It is also safe enough: calls to Objective-C methods mostly use dynamic dispatch, which will fail with a readable error if a method is not implemented. As a side effect, this commit also fixes KT-85399: in that case, due to a bug in cinterop (KT-56860), Kotlin translated the imported Objective-C type wrong. So, the value was of the correct type, but Kotlin didn't know it. Improving handling of Obj-C types in generic type checks is tracked in KT-85681. ^KT-85358 Fixed ^KT-85399 Fixed ^KT-85508 Fixed ^RCA: the regression reached the release because it occurs in interaction with tricky Objective-C code that wasn't present in our tests but is found in the wild. Basically, sometimes the declared Obj-C type or its Kotlin translation doesn't match the actual object type when getting values from Obj-C, and it was unexpected. This commit adds regression tests and effectively disables `genericSafeCasts` for Obj-C types to make sure these and similar problems won't occur further. The problem was triggered by enabling `genericSafeCasts` in 21b204a. (cherry picked from commit dd46827)
diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/Autoboxing.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/Autoboxing.kt
@@ -23,8 +23,6 @@ import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrConstantPrimitiveImpl
 import org.jetbrains.kotlin.ir.irAttribute
-import org.jetbrains.kotlin.ir.objcinterop.isObjCForwardDeclaration
-import org.jetbrains.kotlin.ir.objcinterop.isObjCMetaClass
 import org.jetbrains.kotlin.ir.symbols.*
 import org.jetbrains.kotlin.ir.symbols.impl.IrFieldSymbolImpl
 import org.jetbrains.kotlin.ir.symbols.impl.IrPropertySymbolImpl
@@ -182,8 +180,6 @@ private class AutoboxingTransformer(val context: Context) : AbstractValueUsageTr
     private fun IrClass.canBeAssignedTo(expectedClass: IrClass) =
             this.isNothing() || expectedClass == anyClass /* A workaround for plugins emitting classes with empty superTypes */
                     || (expectedClass.isCompanion && expectedClass.parentAsClass.isObjCClass()) // TODO: a workaround for CMP-9000.
-                    // TODO: roll back once MapLibre is fixed (KT-85358).
-                    || (expectedClass.isObjCClass() && expectedClass.name.asString() == "MLNScaleBar")
                     || this.symbol.isSubtypeOfClass(expectedClass.symbol)
 
     private fun IrExpression.adaptIfNecessary(actualType: IrType, expectedType: IrType, skipTypeCheck: Boolean = false): IrExpression {
@@ -205,8 +201,34 @@ private class AutoboxingTransformer(val context: Context) : AbstractValueUsageTr
                         // conservatively insert type check for them (due to unsafe casts).
                         && actualClass?.canBeAssignedTo(erasedExpectedType.getClass()!!) != true
                         && actualType.getInlinedClassNative() == null
-                        && !erasedExpectedClass.isObjCForwardDeclaration()
-                        && !erasedExpectedClass.isObjCMetaClass() // See KT-65260 for details.
+                        /*
+                        Objective-C is tricky.
+
+                        First of all, it is common to use "duck typing" in Objective-C:
+                        e.g., if an Obj-C method has an Obj-C class or protocol as the return type, the return value doesn't need to
+                        actually be of that type: it is enough to respond to the same method calls.
+                        Such mismatches happen even in Apple's own frameworks, e.g. in KT-85508.
+
+                        Next, there are forward declarations, and a cast to one shouldn't be generated as we don't have enough information
+                        for that.
+
+                        Another kind of problem is when the target type can't be found by the linker, like in KT-84678.
+
+                        Finally, sometimes cinterop translates Objective-C types wrong, e.g. in KT-56860.
+                        So, even if the Objective-C code returns a real instance of the declared type, Kotlin can get the latter wrong.
+
+                        In other words, in many cases, casts to Obj-C types shouldn't be generated here.
+                        On the other hand, we won't lose much if we don't generate casts to Obj-C types here at all:
+                        most usages of Obj-C objects in Kotlin go through dynamic Objective-C method dispatch. So, having the wrong type
+                        won't lead to heap corruption. Instead, a method call can fail with "unrecognized selector sent to instance", which
+                        is close enough to a `TypeCastException`.
+                        There are also `objc_direct` methods that use direct dispatch (and thus could lead to heap corruption if the type is
+                        wrong), but they are not widely used.
+
+                        All in all, it is safe and easier to not generate casts to Obj-C types here.
+                        Improving this is tracked in KT-85681.
+                         */
+                        && !erasedExpectedClass.isObjCClass()
                 -> {
                     this.checkedCast(actualType, erasedExpectedType)
                 }
diff --git a/native/native.tests/testData/codegen/cinterop/kt57640_with_safe_casts.kt b/native/native.tests/testData/codegen/cinterop/kt57640_with_safe_casts.kt
@@ -75,9 +75,12 @@ private fun testAssignmentBaseToDerived() {
 
     val derivedFoo = derived as Foo3Protocol
     val derivedBar = derived as Bar3Protocol
-    assertFailsWith<ClassCastException> { val delegate14_Foo: Foo3Protocol? = derivedFoo.delegate }
-    assertFailsWith<ClassCastException> { val delegate15_Bar: Bar3Protocol? = derivedBar.delegate }
-    assertFailsWith<ClassCastException> { val delegate16_Bar: Bar3Protocol? = derived.delegate() }
+    // TODO KT-85681: we might want to make it throw a `ClassCastException`.
+    val delegate14_Foo: Foo3Protocol? = derivedFoo.delegate
+    // TODO KT-85681
+    val delegate15_Bar: Bar3Protocol? = derivedBar.delegate
+    // TODO KT-85681
+    val delegate16_Bar: Bar3Protocol? = derived.delegate()
 }
 
 private fun testAssignmentBaseToDerivedWithPropertyOverride() {
@@ -87,9 +90,14 @@ private fun testAssignmentBaseToDerivedWithPropertyOverride() {
 
     val derived_Foo = derived as Foo3Protocol
     val derivedBar = derived as Bar3Protocol
-    assertFailsWith<ClassCastException> { val delegate19_DerivedWithPropertyOverride: DerivedWithPropertyOverride3? = derived.delegate() }
-    assertFailsWith<ClassCastException> { val delegate14_Foo: Foo3Protocol? = derived_Foo.delegate }
-    assertFailsWith<ClassCastException> { val delegate18_Foo: Foo3Protocol? = derived_Foo.delegate() } // static type is FooProtocol?, not DerivedWithPropertyOverride?, this deserves a diagnostic test
-    assertFailsWith<ClassCastException> { val delegate15_Bar: Bar3Protocol? = derivedBar.delegate }
-    assertFailsWith<ClassCastException> { val delegate19_Bar: Bar3Protocol? = derivedBar.delegate() } // static type is BarProtocol?, not DerivedWithPropertyOverride?, this deserves a diagnostic test
+    // TODO KT-85681
+    val delegate19_DerivedWithPropertyOverride: DerivedWithPropertyOverride3? = derived.delegate()
+    // TODO KT-85681
+    val delegate14_Foo: Foo3Protocol? = derived_Foo.delegate
+    // TODO KT-85681
+    val delegate18_Foo: Foo3Protocol? = derived_Foo.delegate() // static type is FooProtocol?, not DerivedWithPropertyOverride?, this deserves a diagnostic test
+    // TODO KT-85681
+    val delegate15_Bar: Bar3Protocol? = derivedBar.delegate
+    // TODO KT-85681
+    val delegate19_Bar: Bar3Protocol? = derivedBar.delegate() // static type is BarProtocol?, not DerivedWithPropertyOverride?, this deserves a diagnostic test
 }
diff --git a/native/native.tests/testData/codegen/cinterop/objc/kt85399.kt b/native/native.tests/testData/codegen/cinterop/objc/kt85399.kt
@@ -1,10 +1,6 @@
 // TARGET_BACKEND: NATIVE
 // DISABLE_NATIVE: isAppleTarget=false
 
-// KT-85399
-// IGNORE_NATIVE: optimizationMode=DEBUG
-// IGNORE_NATIVE: optimizationMode=NO
-
 // MODULE: cinterop
 // FILE: lib.def
 language = Objective-C
diff --git a/native/native.tests/testData/codegen/cinterop/objc/kt85508.kt b/native/native.tests/testData/codegen/cinterop/objc/kt85508.kt
@@ -1,9 +1,6 @@
 // TARGET_BACKEND: NATIVE
 // WITH_PLATFORM_LIBS
 // DISABLE_NATIVE: isAppleTarget=false
-
-// KT-85508
-// DISABLE_NATIVE: isAppleTarget=true
 @file:OptIn(kotlinx.cinterop.ExperimentalForeignApi::class)
 
 import platform.Network.NW_PARAMETERS_DISABLE_PROTOCOL
