[FIR] Report UNINITIALIZED_VARIABLE for top-level properties

When checking top-level properties, check with initialization enabled.
This makes sure the same errors are reported for member and top-level
properties.

compiler/testData/diagnostics/tests/Properties.fir.kt

@@ -1,4 +1,4 @@
-var x : Int = 1 + x
+var x : Int = 1 + <!UNINITIALIZED_VARIABLE!>x<!>
    get() : Int = 1
    set(value : <!WRONG_SETTER_PARAMETER_TYPE!>Long<!>) {
       field = value.toInt()

compiler/testData/diagnostics/tests/backingField/TopLevelPropertyInitialization.fir.kt

@@ -1,31 +1,119 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -WRONG_INVOCATION_KIND
 // WITH_STDLIB
 
-val a: Int
-val b = 1.also { a = 2 }
-<!MUST_BE_INITIALIZED!>val c: Int<!>
-val d by lazy { <!CAPTURED_VAL_INITIALIZATION!>c<!> = 2; 1 }
-val e: Int
-    get() {
-        <!VAL_REASSIGNMENT!>c<!> = 3
-        return c
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
+import kotlin.properties.ReadOnlyProperty
+
+@OptIn(ExperimentalContracts::class)
+inline fun <T> inPlaceRun(block: () -> T): T {
+    contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
+    return block()
+}
+
+fun <T> notInPlaceRun(block: () -> T): T = null!!
+
+fun <T> simpleDelegate(value: T): ReadOnlyProperty<Any?, T> = null!!
+
+@OptIn(ExperimentalContracts::class)
+fun <T> inPlaceDelegate(block: () -> T): ReadOnlyProperty<Any?, T> {
+    contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
+    return null!!
+}
+
+fun <T> notInPlaceDelegate(block: () -> T): ReadOnlyProperty<Any?, T> = null!!
+
+class Some {
+    val a: String = <!UNINITIALIZED_VARIABLE!>a<!>
+    val b: String = inPlaceRun { <!UNINITIALIZED_VARIABLE!>b<!> }
+    val c: String = notInPlaceRun { c }
+
+    val d: String by simpleDelegate(<!UNINITIALIZED_VARIABLE!>d<!>)
+    val e: String by inPlaceDelegate { <!UNINITIALIZED_VARIABLE!>e<!> }
+    val f: String by notInPlaceDelegate { f }
+
+    val g: Int
+    val h = 1.also { g = 2 }
+    <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>val i: Int<!>
+    val j by lazy { <!CAPTURED_MEMBER_VAL_INITIALIZATION!>i<!> = 2; 1 }
+    val k: Int
+        get() {
+            <!VAL_REASSIGNMENT!>i<!> = 3
+            return i
+        }
+
+    val l: Comparator<String> = object : Comparator<String> {
+        val delegate: Comparator<String> get() = n
+        override fun compare(o1: String, o2: String): Int = delegate.compare(o1, o2)
     }
 
-class Class {
-    val i: Int
-    val j = 1.also { i = 2 }
-    <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>val k: Int<!>
-    val l by lazy { <!CAPTURED_MEMBER_VAL_INITIALIZATION!>k<!> = 2; 1 }
-    val n: Int
-        get() {
-            <!VAL_REASSIGNMENT!>k<!> = 3
-            return k
-        }
+    val m: Comparator<String> = object : Comparator<String> by <!UNINITIALIZED_VARIABLE!>n<!> {}
+
+    val n: Comparator<String> = Comparator { _, _ -> 0 }
+
+    val t: String = <!UNINITIALIZED_VARIABLE!>z<!>
+    val u: String = inPlaceRun { <!UNINITIALIZED_VARIABLE!>z<!> }
+    val v: String = notInPlaceRun { z }
+    val w: String by simpleDelegate(<!UNINITIALIZED_VARIABLE!>z<!>)
+    val x: String by inPlaceDelegate { <!UNINITIALIZED_VARIABLE!>z<!> }
+    val y: String by notInPlaceDelegate { z }
+    val z: String = "VALUE"
+
+    companion object {
+        const val A: String = <!UNINITIALIZED_VARIABLE!>B<!>
+        const val B: String = "CONSTANT"
+
+        val tConst: String = Z
+        val uConst: String = inPlaceRun { Z }
+        val vConst: String = notInPlaceRun { Z }
+        val wConst: String by simpleDelegate(Z)
+        val xConst: String by inPlaceDelegate { Z }
+        val yConst: String by notInPlaceDelegate { Z }
+        const val Z: String = "CONSTANT"
+    }
 }
 
-fun main() {
-    val x: Int
-    val y = 1.also { x = 2 }
-    val z: Int
-    val w by lazy { <!CAPTURED_VAL_INITIALIZATION!>z<!> = 2; 1 }
+val a: String = <!UNINITIALIZED_VARIABLE!>a<!>
+val b: String = inPlaceRun { <!UNINITIALIZED_VARIABLE!>b<!> }
+val c: String = notInPlaceRun { c }
+
+val d: String by simpleDelegate(<!UNINITIALIZED_VARIABLE!>d<!>)
+val e: String by inPlaceDelegate { <!UNINITIALIZED_VARIABLE!>e<!> }
+val f: String by notInPlaceDelegate { f }
+
+val g: Int
+val h = 1.also { g = 2 }
+<!MUST_BE_INITIALIZED!>val i: Int<!>
+val j by lazy { <!CAPTURED_VAL_INITIALIZATION!>i<!> = 2; 1 }
+val k: Int
+    get() {
+        <!VAL_REASSIGNMENT!>i<!> = 3
+        return i
+    }
+
+val l: Comparator<String> = object : Comparator<String> {
+    val delegate: Comparator<String> get() = n
+    override fun compare(o1: String, o2: String): Int = delegate.compare(o1, o2)
 }
+val m: Comparator<String> = object : Comparator<String> by <!UNINITIALIZED_VARIABLE!>n<!> {}
+val n: Comparator<String> = Comparator { _, _ -> 0 }
+
+val t: String = <!UNINITIALIZED_VARIABLE!>z<!>
+val u: String = inPlaceRun { <!UNINITIALIZED_VARIABLE!>z<!> }
+val v: String = notInPlaceRun { z }
+val w: String by simpleDelegate(<!UNINITIALIZED_VARIABLE!>z<!>)
+val x: String by inPlaceDelegate { <!UNINITIALIZED_VARIABLE!>z<!> }
+val y: String by notInPlaceDelegate { z }
+val z: String = "VALUE"
+
+val tConst: String = Z
+val uConst: String = inPlaceRun { Z }
+val vConst: String = notInPlaceRun { Z }
+val wConst: String by simpleDelegate(Z)
+val xConst: String by inPlaceDelegate { Z }
+val yConst: String by notInPlaceDelegate { Z }
+const val Z: String = "CONSTANT"
+
+const val A: String = <!UNINITIALIZED_VARIABLE!>B<!>
+const val B: String = "CONSTANT"

compiler/testData/diagnostics/tests/backingField/TopLevelPropertyInitialization.kt

@@ -1,31 +1,119 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -WRONG_INVOCATION_KIND
 // WITH_STDLIB
 
-val a: Int
-val b = 1.also { a = 2 }
-<!MUST_BE_INITIALIZED!>val c: Int<!>
-val d by lazy { c = 2; 1 }
-val e: Int
-    get() {
-        <!VAL_REASSIGNMENT!>c<!> = 3
-        return c
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
+import kotlin.properties.ReadOnlyProperty
+
+@OptIn(ExperimentalContracts::class)
+inline fun <T> inPlaceRun(block: () -> T): T {
+    contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
+    return block()
+}
+
+fun <T> notInPlaceRun(block: () -> T): T = null!!
+
+fun <T> simpleDelegate(value: T): ReadOnlyProperty<Any?, T> = null!!
+
+@OptIn(ExperimentalContracts::class)
+fun <T> inPlaceDelegate(block: () -> T): ReadOnlyProperty<Any?, T> {
+    contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
+    return null!!
+}
+
+fun <T> notInPlaceDelegate(block: () -> T): ReadOnlyProperty<Any?, T> = null!!
+
+class Some {
+    val a: String = <!UNINITIALIZED_VARIABLE!>a<!>
+    val b: String = inPlaceRun { <!UNINITIALIZED_VARIABLE!>b<!> }
+    val c: String = notInPlaceRun { <!UNINITIALIZED_VARIABLE!>c<!> }
+
+    val d: String by simpleDelegate(<!DEBUG_INFO_LEAKING_THIS!>d<!>)
+    val e: String by inPlaceDelegate { e }
+    val f: String by notInPlaceDelegate { f }
+
+    val g: Int
+    val h = 1.also { g = 2 }
+    <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>val i: Int<!>
+    val j by lazy { <!CAPTURED_MEMBER_VAL_INITIALIZATION!>i<!> = 2; 1 }
+    val k: Int
+        get() {
+            <!VAL_REASSIGNMENT!>i<!> = 3
+            return i
+        }
+
+    val l: Comparator<String> = object : Comparator<String> {
+        val delegate: Comparator<String> get() = n
+        override fun compare(o1: String, o2: String): Int = delegate.compare(o1, o2)
     }
 
-class Class {
-    val i: Int
-    val j = 1.also { i = 2 }
-    <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>val k: Int<!>
-    val l by lazy { <!CAPTURED_MEMBER_VAL_INITIALIZATION!>k<!> = 2; 1 }
-    val n: Int
-        get() {
-            <!VAL_REASSIGNMENT!>k<!> = 3
-            return k
-        }
+    val m: Comparator<String> = object : Comparator<String> by <!UNINITIALIZED_VARIABLE!>n<!> {}
+
+    val n: Comparator<String> = Comparator { _, _ -> 0 }
+
+    val t: String = <!UNINITIALIZED_VARIABLE!>z<!>
+    val u: String = inPlaceRun { z }
+    val v: String = notInPlaceRun { z }
+    val w: String by simpleDelegate(<!UNINITIALIZED_VARIABLE!>z<!>)
+    val x: String by inPlaceDelegate { z }
+    val y: String by notInPlaceDelegate { z }
+    val z: String = "VALUE"
+
+    companion object {
+        const val A: String = <!UNINITIALIZED_VARIABLE!>B<!>
+        const val B: String = "CONSTANT"
+
+        val tConst: String = <!UNINITIALIZED_VARIABLE!>Z<!>
+        val uConst: String = inPlaceRun { Z }
+        val vConst: String = notInPlaceRun { Z }
+        val wConst: String by simpleDelegate(<!UNINITIALIZED_VARIABLE!>Z<!>)
+        val xConst: String by inPlaceDelegate { Z }
+        val yConst: String by notInPlaceDelegate { Z }
+        const val Z: String = "CONSTANT"
+    }
 }
 
-fun main() {
-    val x: Int
-    val y = 1.also { x = 2 }
-    val z: Int
-    val w by lazy { <!CAPTURED_VAL_INITIALIZATION!>z<!> = 2; 1 }
+val a: String = <!UNINITIALIZED_VARIABLE!>a<!>
+val b: String = inPlaceRun { <!UNINITIALIZED_VARIABLE!>b<!> }
+val c: String = notInPlaceRun { <!UNINITIALIZED_VARIABLE!>c<!> }
+
+val d: String by simpleDelegate(d)
+val e: String by inPlaceDelegate { e }
+val f: String by notInPlaceDelegate { f }
+
+val g: Int
+val h = 1.also { g = 2 }
+<!MUST_BE_INITIALIZED!>val i: Int<!>
+val j by lazy { i = 2; 1 }
+val k: Int
+    get() {
+        <!VAL_REASSIGNMENT!>i<!> = 3
+        return i
+    }
+
+val l: Comparator<String> = object : Comparator<String> {
+    val delegate: Comparator<String> get() = n
+    override fun compare(o1: String, o2: String): Int = delegate.compare(o1, o2)
 }
+val m: Comparator<String> = object : Comparator<String> by <!UNINITIALIZED_VARIABLE!>n<!> {}
+val n: Comparator<String> = Comparator { _, _ -> 0 }
+
+val t: String = <!UNINITIALIZED_VARIABLE!>z<!>
+val u: String = inPlaceRun { z }
+val v: String = notInPlaceRun { z }
+val w: String by simpleDelegate(<!UNINITIALIZED_VARIABLE!>z<!>)
+val x: String by inPlaceDelegate { z }
+val y: String by notInPlaceDelegate { z }
+val z: String = "VALUE"
+
+val tConst: String = <!UNINITIALIZED_VARIABLE!>Z<!>
+val uConst: String = inPlaceRun { Z }
+val vConst: String = notInPlaceRun { Z }
+val wConst: String by simpleDelegate(<!UNINITIALIZED_VARIABLE!>Z<!>)
+val xConst: String by inPlaceDelegate { Z }
+val yConst: String by notInPlaceDelegate { Z }
+const val Z: String = "CONSTANT"
+
+const val A: String = <!UNINITIALIZED_VARIABLE!>B<!>
+const val B: String = "CONSTANT"

compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.fir.kt

@@ -255,7 +255,7 @@ class Outer() {
 }
 
 class ForwardAccessToBackingField() { //kt-147
-    val a = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, UNINITIALIZED_VARIABLE!>a<!> // error
+    val a = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>a<!> // error
     val b = <!UNINITIALIZED_VARIABLE!>c<!> // error
     val c = 1
 }

compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesOrderInPackage.fir.kt

@@ -1,4 +0,0 @@
-package a
-
-val a : Int = b
-val b : Int = a

compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesOrderInPackage.kt

@@ -1,4 +1,5 @@
+// FIR_IDENTICAL
 package a
 
 val a : Int = <!UNINITIALIZED_VARIABLE!>b<!>
-val b : Int = a
+val b : Int = a

compiler/testData/diagnostics/tests/controlFlowAnalysis/repeatUnitializedErrorOnlyForLocalVars.fir.kt

@@ -1,7 +1,7 @@
 package aa
 
-val a : Int = b
-val b : Int = a + b
+val a : Int = <!UNINITIALIZED_VARIABLE!>b<!>
+val b : Int = a + <!UNINITIALIZED_VARIABLE!>b<!>
 
 class C {
     val a : Int = <!UNINITIALIZED_VARIABLE!>b<!>

compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.fir.kt

@@ -7,7 +7,7 @@ val a by <!RECURSION_IN_IMPLICIT_TYPES, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBL
 
 val b by Delegate(<!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>b<!>)
 
-val c by d
+val c by <!UNINITIALIZED_VARIABLE!>d<!>
 val d by <!RECURSION_IN_IMPLICIT_TYPES, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>c<!>
 
 class Delegate(i: Int) {

compiler/testData/diagnostics/tests/regressions/Jet81.fir.kt

@@ -3,7 +3,7 @@
 
 class Test {
   private val y = object {
-    val a = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, UNINITIALIZED_VARIABLE!>y<!>;
+    val a = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>y<!>;
   }
 
   val z = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>y.a<!>;