Error on 'if' without an 'else' branch when used as an expression

compiler/testData/diagnostics/tests/FunctionReturnTypes.kt

@@ -69,10 +69,10 @@ fun blockReturnValueTypeMatch1() : Int {
   return if (1 > 2) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!> else <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2.0<!>
 }
 fun blockReturnValueTypeMatch2() : Int {
-  return <!TYPE_MISMATCH!>if (1 > 2) 1<!>
+  return <!TYPE_MISMATCH, INVALID_IF_AS_EXPRESSION!>if (1 > 2) 1<!>
 }
 fun blockReturnValueTypeMatch3() : Int {
-  return <!TYPE_MISMATCH!>if (1 > 2) else 1<!>
+  return <!TYPE_MISMATCH, INVALID_IF_AS_EXPRESSION!>if (1 > 2) else 1<!>
 }
 fun blockReturnValueTypeMatch4() : Int {
   if (1 > 2)
@@ -105,7 +105,7 @@ fun blockReturnValueTypeMatch9() : Int {
     <!UNUSED_EXPRESSION!>1.0<!>
 <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun blockReturnValueTypeMatch10() : Int {
-  return <!TYPE_MISMATCH!>if (1 > 2)
+  return <!TYPE_MISMATCH, INVALID_IF_AS_EXPRESSION!>if (1 > 2)
     1<!>
 }
 fun blockReturnValueTypeMatch11() : Int {

compiler/testData/diagnostics/tests/controlStructures/emptyIf.kt

@@ -4,13 +4,13 @@ fun test() {
     if (false);
     if (true);
 
-    val x = <!IMPLICIT_CAST_TO_UNIT_OR_ANY!>if (false)<!>;
+    val x = <!INVALID_IF_AS_EXPRESSION!>if (false)<!>;
     foo(x)
 
-    val y: Unit = if (false);
+    val y: Unit = <!INVALID_IF_AS_EXPRESSION!>if (false)<!>;
     foo(y)
 
     foo({if (1==1);}())
 
-    return if (true);
+    return <!INVALID_IF_AS_EXPRESSION!>if (true)<!>;
 }

compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.kt

@@ -0,0 +1,33 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+fun example() {
+    val a = if (true) true else false
+    val b = <!INVALID_IF_AS_EXPRESSION!>if (true) else false<!>
+    val c = <!INVALID_IF_AS_EXPRESSION!>if (true) true<!>
+    val d = <!INVALID_IF_AS_EXPRESSION!>if (true) true else<!>;
+    val e = <!IMPLICIT_CAST_TO_UNIT_OR_ANY!>if (true) {} else false<!>
+    val f = <!IMPLICIT_CAST_TO_UNIT_OR_ANY!>if (true) true else {}<!>
+
+    {
+        if (true) <!UNUSED_EXPRESSION!>true<!>
+    }();
+
+    {
+        if (true) true else false
+    }();
+
+    {
+        if (true) {} else false
+    }();
+
+
+    {
+        if (true) true else {}
+    }()
+
+    fun t(): Boolean {
+        return <!TYPE_MISMATCH, INVALID_IF_AS_EXPRESSION!>if (true) true<!>
+    }
+
+    return if (true) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!> else {}
+}

compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.txt

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

compiler/testData/diagnostics/tests/controlStructures/kt4310.kt

@@ -7,5 +7,5 @@ fun test(a: Boolean, b: Boolean): Int {
         <!TYPE_MISMATCH!>if (b) {
             3
         }<!>
-    }    // no error, but must be
+    }
 }

compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt

@@ -34,7 +34,7 @@ fun foo() {
 fun box() : Int {
     val d = 2
     var z = 0
-        when(d) {
+    when(d) {
         5, 3 -> z++
         else -> z = -1000
     }
@@ -100,10 +100,10 @@ fun testImplicitCoercion() {
         else -> <!UNUSED_CHANGED_VALUE!>z--<!>
     }<!>
 
-    var <!UNUSED_VARIABLE!>iff<!> = <!IMPLICIT_CAST_TO_UNIT_OR_ANY!>if (true) {
+    var <!UNUSED_VARIABLE!>iff<!> = <!INVALID_IF_AS_EXPRESSION!>if (true) {
         <!UNUSED_VALUE!>z =<!> 34
     }<!>
-    val <!UNUSED_VARIABLE!>g<!> = <!IMPLICIT_CAST_TO_UNIT_OR_ANY!>if (true) 4<!>
+    val <!UNUSED_VARIABLE!>g<!> = <!INVALID_IF_AS_EXPRESSION!>if (true) 4<!>
     val <!UNUSED_VARIABLE!>h<!> = <!IMPLICIT_CAST_TO_UNIT_OR_ANY!>if (false) 4 else {}<!>
 
     bar(if (true) {

compiler/testData/diagnostics/tests/dataFlow/EmptyIf.kt

@@ -18,7 +18,7 @@ fun f3(s: Number?) {
 }
 
 fun f4(s: Int?) {
-    var u = <!IMPLICIT_CAST_TO_UNIT_OR_ANY!>if (s!! == 42)<!>;
-    if (u == Unit) u = if (s == 239);
+    var u = <!INVALID_IF_AS_EXPRESSION!>if (s!! == 42)<!>;
+    if (u == Unit) u = <!INVALID_IF_AS_EXPRESSION!>if (s == 239)<!>;
     return u
-}
+}

compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElse.kt

@@ -1,7 +1,7 @@
 val flag = true
 
 // type of a was checked by txt
-val a/*: () -> Any*/ = l@ { // commonSupertype(Int, Unit) = Any
+val a/*: () -> Any*/ = l@ {
     if (flag) return@l 4
 }