Make LateinitIntrinsicApplicabilityChecker warning for Native and JS

This checker was enabled only on JVM by mistake. It's now fixed, but we don't want to make it an error in minor release. So it will be an warning in 1.8.20 and an error in 1.9.0 ^KT-27002
2022-12-13 17:10:14 +01:00
parent 17e9a6a781
commit 4928e284f6
18 changed files with 691 additions and 6 deletions
@@ -0,0 +1,106 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -NOTHING_TO_INLINE
+// !LANGUAGE: +NativeJsProhibitLateinitIsInitalizedIntrinsicWithoutPrivateAccess
+// FILE: stdlibInternal.kt
+
+package kotlin.internal
+
+@Target(AnnotationTarget.VALUE_PARAMETER)
+@Retention(AnnotationRetention.BINARY)
+internal annotation class AccessibleLateinitPropertyLiteral
+
+// FILE: stdlib.kt
+package kotlin
+
+import kotlin.internal.AccessibleLateinitPropertyLiteral
+import kotlin.reflect.KProperty0
+
+inline val @receiver:AccessibleLateinitPropertyLiteral KProperty0<*>.isInitialized: Boolean
+    get() = true
+
+
+// FILE: test.kt
+
+interface Base {
+    var x: String
+}
+
+open class Foo : Base {
+    override lateinit var x: String
+    private lateinit var y: String
+
+    var nonLateInit: Int = 1
+
+    fun ok() {
+        val b: Boolean = this::x.isInitialized
+
+        val otherInstance = Foo()
+        otherInstance::x.isInitialized
+
+        (this::x).isInitialized
+        (@Suppress("ALL") (this::x)).isInitialized
+
+        object {
+            fun local() {
+                class Local {
+                    val xx = this@Foo::x.isInitialized
+                    val yy = this@Foo::y.isInitialized
+                }
+            }
+        }
+    }
+
+    fun onLiteral() {
+        val p = this::x
+        p.<!LATEINIT_INTRINSIC_CALL_ON_NON_LITERAL!>isInitialized<!>
+    }
+
+    fun onNonLateinit() {
+        this::nonLateInit.<!LATEINIT_INTRINSIC_CALL_ON_NON_LATEINIT!>isInitialized<!>
+    }
+
+    inline fun inlineFun() {
+        this::x.<!LATEINIT_INTRINSIC_CALL_IN_INLINE_FUNCTION!>isInitialized<!>
+
+        object {
+            val z = this@Foo::x.isInitialized
+        }
+    }
+
+    inner class InnerSubclass : Foo() {
+        fun innerOk() {
+            // This is access to Foo.x declared lexically above
+            this@Foo::x.isInitialized
+
+            // This is access to InnerSubclass.x which is inherited from Foo.x
+            this::x.isInitialized
+        }
+    }
+}
+
+fun onNonAccessible() {
+    Foo()::x.<!LATEINIT_INTRINSIC_CALL_ON_NON_ACCESSIBLE_PROPERTY!>isInitialized<!>
+}
+
+fun onNonLateinit() {
+    Foo()::nonLateInit.<!LATEINIT_INTRINSIC_CALL_ON_NON_LATEINIT!>isInitialized<!>
+}
+
+object Unrelated {
+    fun onNonAccessible() {
+        Foo()::x.<!LATEINIT_INTRINSIC_CALL_ON_NON_ACCESSIBLE_PROPERTY!>isInitialized<!>
+    }
+}
+
+class FooImpl : Foo() {
+    fun onNonAccessible() {
+        this::x.<!LATEINIT_INTRINSIC_CALL_ON_NON_ACCESSIBLE_PROPERTY!>isInitialized<!>
+    }
+}
+
+// FILE: other.kt
+
+class OtherFooImpl : Foo() {
+    fun onNonAccessible() {
+        this::x.<!LATEINIT_INTRINSIC_CALL_ON_NON_ACCESSIBLE_PROPERTY!>isInitialized<!>
+    }
+}