diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProvider.kt
index 6f9a33f81b9..2c5cd06c435 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProvider.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProvider.kt
@@ -717,7 +717,7 @@ class ControlFlowInformationProvider private constructor(
                 val elseExpression = element.`else`
 
                 if (thenExpression == null || elseExpression == null) {
-                    trace.report(INVALID_IF_AS_EXPRESSION.on(element))
+                    trace.report(INVALID_IF_AS_EXPRESSION.on(element.ifKeyword))
                 }
                 else {
                     checkImplicitCastOnConditionalExpression(element)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java
index 70c1ae5ab7a..f5c4a94707a 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java
@@ -776,7 +776,7 @@ public interface Errors {
 
     DiagnosticFactory0<KtElement> SENSELESS_NULL_IN_WHEN = DiagnosticFactory0.create(WARNING);
 
-    DiagnosticFactory0<KtIfExpression> INVALID_IF_AS_EXPRESSION = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<PsiElement> INVALID_IF_AS_EXPRESSION = DiagnosticFactory0.create(ERROR);
 
     // Nullability
 
diff --git a/compiler/testData/diagnostics/tests/FunctionReturnTypes.kt b/compiler/testData/diagnostics/tests/FunctionReturnTypes.kt
index 19fd0991854..7a6a50f89f1 100644
--- a/compiler/testData/diagnostics/tests/FunctionReturnTypes.kt
+++ b/compiler/testData/diagnostics/tests/FunctionReturnTypes.kt
@@ -15,15 +15,15 @@ fun test5(): Any = l@{ return@l }
 fun test6(): Any = {<!RETURN_NOT_ALLOWED!>return<!> 1}
 
 fun bbb() {
-  return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>
+    return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>
 }
 
 fun foo(<!UNUSED_PARAMETER!>expr<!>: StringBuilder): Int {
-  val c = 'a'
-  when(c) {
-    0.toChar() -> throw Exception("zero")
-    else -> throw Exception("nonzero" + c)
-  }
+    val c = 'a'
+    when(c) {
+        0.toChar() -> throw Exception("zero")
+        else -> throw Exception("nonzero" + c)
+    }
 }
 
 
@@ -47,92 +47,92 @@ fun blockReturnValueTypeMatch() : Int {return 1}
 fun blockReturnValueTypeMismatchUnit() : Int {return <!TYPE_MISMATCH!>Unit<!>}
 
 fun blockAndAndMismatch() : Int {
-  <!UNUSED_EXPRESSION!>true && false<!>
-<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+    <!UNUSED_EXPRESSION!>true && false<!>
+    <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun blockAndAndMismatch1() : Int {
-  return <!TYPE_MISMATCH!>true && false<!>
+    return <!TYPE_MISMATCH!>true && false<!>
 }
 fun blockAndAndMismatch2() : Int {
-  (return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>) && (return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>false<!>)
+    (return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>) && (return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>false<!>)
 }
 
 fun blockAndAndMismatch3() : Int {
-  <!UNUSED_EXPRESSION!>true || false<!>
-<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+    <!UNUSED_EXPRESSION!>true || false<!>
+    <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun blockAndAndMismatch4() : Int {
-  return <!TYPE_MISMATCH!>true || false<!>
+    return <!TYPE_MISMATCH!>true || false<!>
 }
 fun blockAndAndMismatch5() : Int {
-  (return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>) || (return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>false<!>)
+    (return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>) || (return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>false<!>)
 }
 fun blockReturnValueTypeMatch1() : Int {
-  return if (1 > 2) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!> else <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2.0<!>
+    return if (1 > 2) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!> else <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2.0<!>
 }
 fun blockReturnValueTypeMatch2() : Int {
-  return <!TYPE_MISMATCH, INVALID_IF_AS_EXPRESSION!>if (1 > 2) 1<!>
+    return <!TYPE_MISMATCH!><!INVALID_IF_AS_EXPRESSION!>if<!> (1 > 2) 1<!>
 }
 fun blockReturnValueTypeMatch3() : Int {
-  return <!TYPE_MISMATCH, INVALID_IF_AS_EXPRESSION!>if (1 > 2) else 1<!>
+    return <!TYPE_MISMATCH!><!INVALID_IF_AS_EXPRESSION!>if<!> (1 > 2) else 1<!>
 }
 fun blockReturnValueTypeMatch4() : Int {
-  if (1 > 2)
-    return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!>
-  else return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2.0<!>
+    if (1 > 2)
+        return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!>
+    else return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2.0<!>
 }
 fun blockReturnValueTypeMatch5() : Int {
-  if (1 > 2)
-    return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!>
-  return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2.0<!>
+    if (1 > 2)
+        return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!>
+    return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2.0<!>
 }
 fun blockReturnValueTypeMatch6() : Int {
-  if (1 > 2)
+    if (1 > 2)
     else return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!>
-  return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2.0<!>
+    return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2.0<!>
 }
 fun blockReturnValueTypeMatch7() : Int {
-  if (1 > 2)
+    if (1 > 2)
     <!UNUSED_EXPRESSION!>1.0<!>
-  else <!UNUSED_EXPRESSION!>2.0<!>
-<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+    else <!UNUSED_EXPRESSION!>2.0<!>
+    <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun blockReturnValueTypeMatch8() : Int {
-  if (1 > 2)
+    if (1 > 2)
     <!UNUSED_EXPRESSION!>1.0<!>
-  else <!UNUSED_EXPRESSION!>2.0<!>
-  return 1
+    else <!UNUSED_EXPRESSION!>2.0<!>
+    return 1
 }
 fun blockReturnValueTypeMatch9() : Int {
-  if (1 > 2)
+    if (1 > 2)
     <!UNUSED_EXPRESSION!>1.0<!>
-<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+    <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun blockReturnValueTypeMatch10() : Int {
-  return <!TYPE_MISMATCH, INVALID_IF_AS_EXPRESSION!>if (1 > 2)
+    return <!TYPE_MISMATCH!><!INVALID_IF_AS_EXPRESSION!>if<!> (1 > 2)
     1<!>
 }
 fun blockReturnValueTypeMatch11() : Int {
-  if (1 > 2)
-  else <!UNUSED_EXPRESSION!>1.0<!>
-<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+    if (1 > 2)
+    else <!UNUSED_EXPRESSION!>1.0<!>
+    <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun blockReturnValueTypeMatch12() : Int {
-  if (1 > 2)
-    return 1
-  else return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!>
+    if (1 > 2)
+        return 1
+    else return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!>
 }
 fun blockNoReturnIfValDeclaration(): Int {
-  val <!UNUSED_VARIABLE!>x<!> = 1
-<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+    val <!UNUSED_VARIABLE!>x<!> = 1
+    <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun blockNoReturnIfEmptyIf(): Int {
-  if (1 < 2) {} else {}
-<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+    if (1 < 2) {} else {}
+    <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun blockNoReturnIfUnitInOneBranch(): Int {
-  if (1 < 2) {
-    return 1
-  } else {
-    if (3 < 4) {
+    if (1 < 2) {
+        return 1
     } else {
-      return 2
+        if (3 < 4) {
+        } else {
+            return 2
+        }
     }
-  }
-<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+    <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun nonBlockReturnIfEmptyIf(): Int = if (1 < 2) <!TYPE_MISMATCH!>{}<!> else <!TYPE_MISMATCH!>{}<!>
 fun nonBlockNoReturnIfUnitInOneBranch(): Int = if (1 < 2) <!TYPE_MISMATCH!>{}<!> else 2
 
@@ -145,7 +145,7 @@ fun illegalConstantBlock(): String {
     return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>
 }
 fun illegalIfBody(): Int =
-    if (1 < 2) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>'a'<!> else { <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!> }
+        if (1 < 2) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>'a'<!> else { <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!> }
 fun illegalIfBlock(): Boolean {
     if (1 < 2)
         return false
@@ -166,7 +166,7 @@ fun f1(): Int = if (1 < 2) 1 else returnNothing()
 
 public fun f2() = 1
 class B() {
-   protected fun f() = "ss"
+    protected fun f() = "ss"
 }
 
 fun testFunctionLiterals() {
diff --git a/compiler/testData/diagnostics/tests/controlStructures/emptyIf.kt b/compiler/testData/diagnostics/tests/controlStructures/emptyIf.kt
index bf67e7d5a44..13ce5412108 100644
--- a/compiler/testData/diagnostics/tests/controlStructures/emptyIf.kt
+++ b/compiler/testData/diagnostics/tests/controlStructures/emptyIf.kt
@@ -4,13 +4,13 @@ fun test() {
     if (false);
     if (true);
 
-    val x = <!INVALID_IF_AS_EXPRESSION!>if (false)<!>;
+    val x = <!INVALID_IF_AS_EXPRESSION!>if<!> (false);
     foo(x)
 
-    val y: Unit = <!INVALID_IF_AS_EXPRESSION!>if (false)<!>;
+    val y: Unit = <!INVALID_IF_AS_EXPRESSION!>if<!> (false);
     foo(y)
 
     foo({if (1==1);}())
 
-    return <!INVALID_IF_AS_EXPRESSION!>if (true)<!>;
+    return <!INVALID_IF_AS_EXPRESSION!>if<!> (true);
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/controlStructures/ifWhenToAnyComplexExpressions.kt b/compiler/testData/diagnostics/tests/controlStructures/ifWhenToAnyComplexExpressions.kt
index fd2c21c06bf..1ddb4e9eefc 100644
--- a/compiler/testData/diagnostics/tests/controlStructures/ifWhenToAnyComplexExpressions.kt
+++ b/compiler/testData/diagnostics/tests/controlStructures/ifWhenToAnyComplexExpressions.kt
@@ -8,23 +8,23 @@ fun testMixedIfAndWhen() =
         if (true)
             when {
                 true -> if (true) <!IMPLICIT_CAST_TO_ANY!>42<!>
-                        else <!IMPLICIT_CAST_TO_ANY!>1<!>
-                true -> if (true) <!IMPLICIT_CAST_TO_ANY!>42<!>
-                        else <!IMPLICIT_CAST_TO_ANY!>println()<!>
-                else -> <!INVALID_IF_AS_EXPRESSION!>if (true) <!IMPLICIT_CAST_TO_ANY!>println()<!><!>
+                else <!IMPLICIT_CAST_TO_ANY!>1<!>
+                    true -> if (true) <!IMPLICIT_CAST_TO_ANY!>42<!>
+                else <!IMPLICIT_CAST_TO_ANY!>println()<!>
+                else -> <!INVALID_IF_AS_EXPRESSION!>if<!> (true) <!IMPLICIT_CAST_TO_ANY!>println()<!>
             }
         else <!IMPLICIT_CAST_TO_ANY!>println()<!>
 
 fun testWrappedExpressions() =
         if (true) {
             println()
-            <!INVALID_IF_AS_EXPRESSION!>if (true) {
+            <!INVALID_IF_AS_EXPRESSION!>if<!> (true) {
                 println()
                 if (true) {
                     <!IMPLICIT_CAST_TO_ANY!>println()<!>
                 }
                 else <!IMPLICIT_CAST_TO_ANY!>{}<!>
-            }<!>
+            }
         }
         else {
             (((<!IMPLICIT_CAST_TO_ANY!>((42)) + 1<!>)))
diff --git a/compiler/testData/diagnostics/tests/controlStructures/ifWhenWithoutElse.kt b/compiler/testData/diagnostics/tests/controlStructures/ifWhenWithoutElse.kt
index b4b093a65ea..d3de167ac60 100644
--- a/compiler/testData/diagnostics/tests/controlStructures/ifWhenWithoutElse.kt
+++ b/compiler/testData/diagnostics/tests/controlStructures/ifWhenWithoutElse.kt
@@ -10,13 +10,13 @@ val mlist = MList()
 
 fun work() {}
 
-val xx1 = <!INVALID_IF_AS_EXPRESSION!>if (true) 42<!>
-val xx2: Unit = <!INVALID_IF_AS_EXPRESSION!>if (true) 42<!>
-val xx3 = idAny(<!INVALID_IF_AS_EXPRESSION!>if (true) 42<!>)
-val xx4 = id(<!INVALID_IF_AS_EXPRESSION!>if (true) 42<!>)
-val xx5 = idUnit(<!INVALID_IF_AS_EXPRESSION!>if (true) 42<!>)
-val xx6 = null ?: <!INVALID_IF_AS_EXPRESSION!>if (true) 42<!>
-val xx7 = "" + <!INVALID_IF_AS_EXPRESSION!>if (true) 42<!>
+val xx1 = <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 42
+val xx2: Unit = <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 42
+val xx3 = idAny(<!INVALID_IF_AS_EXPRESSION!>if<!> (true) 42)
+val xx4 = id(<!INVALID_IF_AS_EXPRESSION!>if<!> (true) 42)
+val xx5 = idUnit(<!INVALID_IF_AS_EXPRESSION!>if<!> (true) 42)
+val xx6 = null ?: <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 42
+val xx7 = "" + <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 42
 
 val wxx1 = <!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }
 val wxx2: Unit = <!NO_ELSE_IN_WHEN!>when<!> { true -> <!CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!> }
@@ -40,12 +40,12 @@ val ufn4: () -> Unit = { when { true -> <!UNUSED_EXPRESSION!>42<!> } }
 val ufn5: () -> Unit = { when { true -> mlist.add() } }
 val ufn6: () -> Unit = { when { true -> work() } }
 
-fun f1() = <!INVALID_IF_AS_EXPRESSION!>if (true) work()<!>
-fun f2() = <!INVALID_IF_AS_EXPRESSION!>if (true) mlist.add()<!>
-fun f3() = <!INVALID_IF_AS_EXPRESSION!>if (true) 42<!>
-fun f4(): Unit = <!INVALID_IF_AS_EXPRESSION!>if (true) work()<!>
-fun f5(): Unit = <!INVALID_IF_AS_EXPRESSION!>if (true) mlist.add()<!>
-fun f6(): Unit = <!INVALID_IF_AS_EXPRESSION!>if (true) 42<!>
+fun f1() = <!INVALID_IF_AS_EXPRESSION!>if<!> (true) work()
+fun f2() = <!INVALID_IF_AS_EXPRESSION!>if<!> (true) mlist.add()
+fun f3() = <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 42
+fun f4(): Unit = <!INVALID_IF_AS_EXPRESSION!>if<!> (true) work()
+fun f5(): Unit = <!INVALID_IF_AS_EXPRESSION!>if<!> (true) mlist.add()
+fun f6(): Unit = <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 42
 fun g1() = <!NO_ELSE_IN_WHEN!>when<!> { true -> work() }
 fun g2() = <!NO_ELSE_IN_WHEN!>when<!> { true -> mlist.add() }
 fun g3() = <!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }
@@ -54,7 +54,7 @@ fun g5(): Unit = <!NO_ELSE_IN_WHEN!>when<!> { true -> <!TYPE_MISMATCH!>mlist.add
 fun g6(): Unit = <!NO_ELSE_IN_WHEN!>when<!> { true -> <!CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!> }
 
 fun foo1(x: String?) {
-    "" + <!INVALID_IF_AS_EXPRESSION!>if (true) 42<!>
+    "" + <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 42
     w@while (true) {
         x ?: if (true) break
         x ?: when { true -> break@w }
diff --git a/compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.kt b/compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.kt
index f7b6180580d..e47e1abb44a 100644
--- a/compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.kt
+++ b/compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.kt
@@ -2,9 +2,9 @@
 
 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 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 = if (true) <!IMPLICIT_CAST_TO_ANY!>{}<!> else <!IMPLICIT_CAST_TO_ANY!>false<!>
     val f = if (true) <!IMPLICIT_CAST_TO_ANY!>true<!> else <!IMPLICIT_CAST_TO_ANY!>{}<!>
 
@@ -26,7 +26,7 @@ fun example() {
     }()
 
     fun t(): Boolean {
-        return <!TYPE_MISMATCH, INVALID_IF_AS_EXPRESSION!>if (true) true<!>
+        return <!TYPE_MISMATCH!><!INVALID_IF_AS_EXPRESSION!>if<!> (true) true<!>
     }
 
     return if (true) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!> else {}
diff --git a/compiler/testData/diagnostics/tests/controlStructures/kt10322.kt b/compiler/testData/diagnostics/tests/controlStructures/kt10322.kt
index 68bd3148541..75498130867 100644
--- a/compiler/testData/diagnostics/tests/controlStructures/kt10322.kt
+++ b/compiler/testData/diagnostics/tests/controlStructures/kt10322.kt
@@ -1,7 +1,7 @@
 fun test1() {
     run {
         if (true) {
-            <!INVALID_IF_AS_EXPRESSION!>if (true) {}<!>
+            <!INVALID_IF_AS_EXPRESSION!>if<!> (true) {}
         }
         else {
             1
diff --git a/compiler/testData/diagnostics/tests/controlStructures/kt4310.kt b/compiler/testData/diagnostics/tests/controlStructures/kt4310.kt
index 92239f7037d..422cabb622d 100644
--- a/compiler/testData/diagnostics/tests/controlStructures/kt4310.kt
+++ b/compiler/testData/diagnostics/tests/controlStructures/kt4310.kt
@@ -4,7 +4,7 @@ fun test(a: Boolean, b: Boolean): Int {
     return if(a) {
         1
     } else {
-        <!TYPE_MISMATCH, INVALID_IF_AS_EXPRESSION!>if (b) {
+        <!TYPE_MISMATCH!><!INVALID_IF_AS_EXPRESSION!>if<!> (b) {
             3
         }<!>
     }
diff --git a/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt b/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt
index 447b413ade9..d35bb352c1b 100644
--- a/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt
+++ b/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt
@@ -95,21 +95,21 @@ fun testImplicitCoercion() {
 
     var <!UNUSED_VARIABLE!>u<!> = when(d) {
         3 -> {
-            <!IMPLICIT_CAST_TO_ANY!><!UNUSED_VALUE!>z =<!> 34<!>
-        }
+        <!IMPLICIT_CAST_TO_ANY!><!UNUSED_VALUE!>z =<!> 34<!>
+    }
         else -> <!UNUSED_CHANGED_VALUE, IMPLICIT_CAST_TO_ANY!>z--<!>
     }
 
-    var <!UNUSED_VARIABLE!>iff<!> = <!INVALID_IF_AS_EXPRESSION!>if (true) {
+    var <!UNUSED_VARIABLE!>iff<!> = <!INVALID_IF_AS_EXPRESSION!>if<!> (true) {
         <!UNUSED_VALUE!>z =<!> 34
-    }<!>
-    val <!UNUSED_VARIABLE!>g<!> = <!INVALID_IF_AS_EXPRESSION!>if (true) 4<!>
+    }
+    val <!UNUSED_VARIABLE!>g<!> = <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 4
     val <!UNUSED_VARIABLE!>h<!> = if (false) <!IMPLICIT_CAST_TO_ANY!>4<!> else <!IMPLICIT_CAST_TO_ANY!>{}<!>
 
     bar(if (true) {
         <!CONSTANT_EXPECTED_TYPE_MISMATCH!>4<!>
     }
-    else {
+        else {
         <!UNUSED_VALUE!>z =<!> 342
     })
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlow/EmptyIf.kt b/compiler/testData/diagnostics/tests/dataFlow/EmptyIf.kt
index e54c9a7ae6c..3d616d95e36 100644
--- a/compiler/testData/diagnostics/tests/dataFlow/EmptyIf.kt
+++ b/compiler/testData/diagnostics/tests/dataFlow/EmptyIf.kt
@@ -18,7 +18,7 @@ fun f3(s: Number?) {
 }
 
 fun f4(s: Int?) {
-    var u = <!INVALID_IF_AS_EXPRESSION!>if (s!! == 42)<!>;
-    if (u == Unit) u = <!INVALID_IF_AS_EXPRESSION!>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
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.kt b/compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.kt
index c7da3add29b..f98be643f81 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.kt
@@ -10,20 +10,20 @@ fun test() {
     foo({ <!EXPECTED_TYPE_MISMATCH!>fun named3() = 1<!> })
 
     val x1 =
-        if (1 == 1)
-            // TODO: Diagnostic content could be better
-            <!SYNTAX!><!>fun named4(): Int {return 1}
-        <!SYNTAX!>else<!>
-            fun named5() = 1
+    <!INVALID_IF_AS_EXPRESSION!>if<!> (1 == 1)
+    // TODO: Diagnostic content could be better
+    <!SYNTAX!><!>fun named4(): Int {return 1}
+    <!SYNTAX!>else<!>
+    fun named5() = 1
 
     val x2 =
-            if (1 == 1) {
-                fun named6(): Int {
-                    return 1
-                }
-            }
-            else
-                <!SYNTAX!><!>fun named7() = 1
+    <!INVALID_IF_AS_EXPRESSION!>if<!> (1 == 1) {
+        fun named6(): Int {
+            return 1
+        }
+    }
+    else
+    <!SYNTAX!><!>fun named7() = 1
 
     val x3 = when (1) {
         0 -> <!EXPECTED_TYPE_MISMATCH!>fun named8(): Int {return 1}<!>
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElse.kt b/compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElse.kt
index 7d02a8b3433..79750663a38 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElse.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElse.kt
@@ -2,7 +2,7 @@ val flag = true
 
 // type of a was checked by txt
 val a/*: () -> Any*/ = l@ {
-    <!INVALID_IF_AS_EXPRESSION!>if (flag) return@l 4<!>
+    <!INVALID_IF_AS_EXPRESSION!>if<!> (flag) return@l 4
 }
 
 val b/*: () -> Int */ = l@ {
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElseWithExplicitType.kt b/compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElseWithExplicitType.kt
index ef1c77c23ba..a300099a0c0 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElseWithExplicitType.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElseWithExplicitType.kt
@@ -1,7 +1,7 @@
 val flag = true
 
 val a: () -> Int = l@ {
-    <!TYPE_MISMATCH, INVALID_IF_AS_EXPRESSION!>if (flag) return@l 4<!>
+    <!TYPE_MISMATCH!><!INVALID_IF_AS_EXPRESSION!>if<!> (flag) return@l 4<!>
 }
 
 val b: () -> Unit = l@ {
@@ -9,7 +9,7 @@ val b: () -> Unit = l@ {
 }
 
 val c: () -> Any = l@ {
-    <!INVALID_IF_AS_EXPRESSION!>if (flag) return@l 4<!>
+    <!INVALID_IF_AS_EXPRESSION!>if<!> (flag) return@l 4
 }
 
 val d: () -> Int = l@ {
diff --git a/compiler/testData/diagnostics/testsWithStdLib/implicitCastToAny.kt b/compiler/testData/diagnostics/testsWithStdLib/implicitCastToAny.kt
index f684795dbf8..2770e74780c 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/implicitCastToAny.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/implicitCastToAny.kt
@@ -14,7 +14,7 @@ fun test1(word: String) =
 fun test2(word: String) =
         run {
             if (word.length > 4) {
-                <!INVALID_IF_AS_EXPRESSION!>if (word.startsWith("a")) <!IMPLICIT_CAST_TO_ANY!>longWords++<!><!>
+                <!INVALID_IF_AS_EXPRESSION!>if<!> (word.startsWith("a")) <!IMPLICIT_CAST_TO_ANY!>longWords++<!>
             }
             else {
                 <!IMPLICIT_CAST_TO_ANY!>smallWords.add(word)<!>
diff --git a/idea/testData/checker/FunctionReturnTypes.kt b/idea/testData/checker/FunctionReturnTypes.kt
index 8a969b6d8b2..9be498b02b5 100644
--- a/idea/testData/checker/FunctionReturnTypes.kt
+++ b/idea/testData/checker/FunctionReturnTypes.kt
@@ -65,10 +65,10 @@ fun blockReturnValueTypeMatch1() : Int {
   return if (1 > 2) <error>1.0</error> else <error>2.0</error>
 }
 fun blockReturnValueTypeMatch2() : Int {
-  return <error>if (1 > 2) 1</error>
+    return <error><error>if</error> (1 > 2) 1</error>
 }
 fun blockReturnValueTypeMatch3() : Int {
-  return <error>if (1 > 2) else 1</error>
+    return <error><error>if</error> (1 > 2) else 1</error>
 }
 fun blockReturnValueTypeMatch4() : Int {
   if (1 > 2)
@@ -101,8 +101,7 @@ fun blockReturnValueTypeMatch9() : Int {
     <warning>1.0</warning>
 <error>}</error>
 fun blockReturnValueTypeMatch10() : Int {
-  return <error>if (1 > 2)
-    1</error>
+    return <error><error>if</error> (1 > 2) 1</error>
 }
 fun blockReturnValueTypeMatch11() : Int {
   if (1 > 2)