[FIR] KT-56723: Ensure safe access over non-expressions is always Unit

^KT-56723 Fixed

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

@@ -0,0 +1,91 @@
+import kotlin.reflect.KProperty
+
+fun foo(f: () -> Unit) {
+    f()
+}
+
+class Wrapper(var s: String)
+
+fun bar(w: Wrapper?) {
+    // K1: type is () -> Unit, K2: type is () -> Unit?
+    val lambda = {
+        w?.s = "X"
+    }
+    // K1: Ok, K2: ARGUMENT_TYPE_MISMATCH
+    foo(lambda)
+}
+
+class Wrapper2(val w: Wrapper?)
+
+fun baz(w2: Wrapper2?) {
+    val lambda = {
+        w2?.w?.s = "X"
+    }
+    foo(lambda)
+}
+
+object Indexible {
+    operator fun get(index: Int) = "$index"
+    operator fun set(index: Int, value: String) {}
+}
+class IndexibleRef(val ind: Indexible)
+class IndexibleRefRef(val ref: IndexibleRef?)
+
+fun ban(refRef: IndexibleRefRef?, ref: IndexibleRef?) {
+    val lambda = {
+        ref?.ind[1] = "X"
+    }
+    foo(lambda)
+
+    val lambda2 = {
+        refRef?.ref?.ind[1] = "X"
+    }
+    foo(lambda2)
+
+    val lambda3 = {
+        ref?.ind?.set(1, "X")
+    }
+    foo(<!ARGUMENT_TYPE_MISMATCH!>lambda3<!>)
+
+    val lambda4 = {
+        refRef?.ref?.ind?.set(1, "X")
+    }
+    foo(<!ARGUMENT_TYPE_MISMATCH!>lambda4<!>)
+}
+
+object PlusAssignable {
+    operator fun plusAssign(index: Int) {}
+}
+
+object Indexible2 {
+    operator fun get(index: Int) = PlusAssignable
+    operator fun set(index: Int, value: String) {}
+}
+
+class Indexible2Ref(val ind: Indexible2)
+
+fun bam(ref: Indexible2Ref?) {
+    val lambda = {
+        ref?.ind[1] += 1
+    }
+    foo(lambda)
+
+    val lambd2 = {
+        ref?.ind?.get(1)?.plusAssign(1)
+    }
+    foo(lambda)
+}
+
+class DelegatedHolder {
+    var delegated by object {
+        operator fun getValue(thisRef: Any?, desc: KProperty<*>) = "test"
+        operator fun setValue(thisRef: Any?, desc: KProperty<*>, value: String) {}
+    }
+}
+
+fun bap(holder: DelegatedHolder?) {
+    val lambda = {
+        holder?.delegated = "Y"
+    }
+    foo(lambda)
+}