Resolve anonymous functions in block as expression

#KT-7265 Fixed

compiler/testData/diagnostics/tests/declarationChecks/FunctionWithMissingNames.kt

@@ -18,9 +18,9 @@ class Outer {
 }
 
 fun outerFun() {
-    <!FUNCTION_DECLARATION_WITH_NO_NAME, CONFLICTING_OVERLOADS!>fun ()<!> {}
-    <!FUNCTION_DECLARATION_WITH_NO_NAME!>fun B.()<!> {}
+    fun () {}
+    fun B.() {}
 
-    <!FUNCTION_DECLARATION_WITH_NO_NAME, CONFLICTING_OVERLOADS!>@a fun ()<!> {}
-    <!FUNCTION_DECLARATION_WITH_NO_NAME!>fun @a A.()<!> {}
+    @a fun () {}
+    fun @a A.() {}
 }

compiler/testData/diagnostics/tests/declarationChecks/anonymousFunAsLastExpressionInBlock.kt

@@ -0,0 +1,43 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+// !CHECK_TYPE
+fun foo(block: () -> (() -> Int)) {}
+
+fun test() {
+    foo { fun(): Int {return 1} }
+    foo({ fun() = 1 })
+
+    val x1 =
+        if (1 == 1)
+            fun(): Int {return 1}
+        else
+            fun() = 1
+
+    val x2 =
+            if (1 == 1) {
+                fun(): Int {
+                    return 1
+                }
+            }
+            else
+                fun() = 1
+
+    val x3 = when (1) {
+        0 -> fun(): Int {return 1}
+        else -> fun() = 1
+    }
+
+    val x31 = when (1) {
+        0 -> {
+            fun(): Int {return 1}
+        }
+        else -> fun() = 1
+    }
+
+    val x4 = {
+        y: Int -> fun(): Int {return 1}
+    }
+
+    x4 checkType { _<Function1<Int, Function0<Int>>>() }
+
+    <!UNUSED_LAMBDA_EXPRESSION!>{ y: Int -> fun(): Int {return 1} }<!>
+}

compiler/testData/diagnostics/tests/declarationChecks/anonymousFunAsLastExpressionInBlock.txt

@@ -0,0 +1,4 @@
+package
+
+public fun foo(/*0*/ block: () -> () -> kotlin.Int): kotlin.Unit
+public fun test(): kotlin.Unit

compiler/testData/diagnostics/tests/declarationChecks/anonymousFunUnusedLastExpressionInBlock.kt

@@ -0,0 +1,21 @@
+fun unusedExpressions() {
+    if (1 == 1)
+        fun(): Int {return 1}
+    else
+        fun() = 1
+
+    if (1 == 1) {
+        fun(): Int {
+            return 1
+        }
+    }
+    else
+        fun() = 1
+
+    when (1) {
+        0 -> fun(): Int {return 1}
+        else -> fun() = 1
+    }
+
+    fun() = 1
+}

compiler/testData/diagnostics/tests/declarationChecks/anonymousFunUnusedLastExpressionInBlock.txt

@@ -0,0 +1,3 @@
+package
+
+public fun unusedExpressions(): kotlin.Unit

compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.kt

@@ -0,0 +1,58 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+// !CHECK_TYPE
+fun foo(block: () -> (() -> Int)) {}
+
+fun test() {
+    val x = fun <!ANONYMOUS_FUNCTION_WITH_NAME!>named1<!>(x: Int): Int { return 1 }
+    x checkType { _<Function1<Int, Int>>() }
+
+    foo { <!EXPECTED_TYPE_MISMATCH(\(\) -> Int)!>fun named2(): Int {return 1}<!> }
+    foo({ <!EXPECTED_TYPE_MISMATCH!>fun named3() = 1<!> })
+
+    val x1 =
+        if (1 == 1)
+            // TODO: Diagnostic content could be better
+            <!EXPECTED_TYPE_MISMATCH(\(\) -> Int)!>fun named4(): Int {return 1}<!>
+        else
+            <!EXPECTED_TYPE_MISMATCH!>fun named5() = 1<!>
+
+    val x2 =
+            if (1 == 1) {
+                <!EXPECTED_TYPE_MISMATCH!>fun named6(): Int {
+                    return 1
+                }<!>
+            }
+            else
+                <!EXPECTED_TYPE_MISMATCH!>fun named7() = 1<!>
+
+    val x3 = when (1) {
+        0 -> <!EXPECTED_TYPE_MISMATCH!>fun named8(): Int {return 1}<!>
+        else -> <!EXPECTED_TYPE_MISMATCH!>fun named9() = 1<!>
+    }
+
+    val x31 = when (1) {
+        0 -> {
+            <!EXPECTED_TYPE_MISMATCH!>fun named10(): Int {return 1}<!>
+        }
+        else -> <!EXPECTED_TYPE_MISMATCH!>fun named11() = 1<!>
+    }
+
+    val x4 = {
+        y: Int -> fun named12(): Int {return 1}
+    }
+
+    x4 checkType { _<Function1<Int, Unit>>() }
+
+    <!UNUSED_LAMBDA_EXPRESSION!>{ y: Int -> fun named14(): Int {return 1} }<!>
+}
+
+fun <T> run(block: () -> T): T = null!!
+fun run2(block: () -> Unit): Unit = null!!
+
+fun success() {
+    run { fun named1() = 1 }
+    run2 { fun named2() = 1 }
+
+    val x = run { fun named3() = 1 }
+    x checkType { _<Unit>() }
+}

compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.txt

@@ -0,0 +1,7 @@
+package
+
+public fun foo(/*0*/ block: () -> () -> kotlin.Int): kotlin.Unit
+public fun </*0*/ T> run(/*0*/ block: () -> T): T
+public fun run2(/*0*/ block: () -> kotlin.Unit): kotlin.Unit
+public fun success(): kotlin.Unit
+public fun test(): kotlin.Unit