Exhaustive whens without else and 'Nothing' as the result are considered 'implicit exhaustive'

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.java

@@ -145,10 +145,11 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
             }
         }
 
+        boolean isExhaustive = WhenChecker.isWhenExhaustive(expression, context.trace);
         if (commonDataFlowInfo == null) {
             commonDataFlowInfo = context.dataFlowInfo;
         }
-        else if (expression.getElseExpression() == null && !WhenChecker.isWhenExhaustive(expression, context.trace)) {
+        else if (expression.getElseExpression() == null && !isExhaustive) {
             // Without else expression in non-exhaustive when, we *must* take initial data flow info into account,
             // because data flow can bypass all when branches in this case
             commonDataFlowInfo = commonDataFlowInfo.or(context.dataFlowInfo);
@@ -158,6 +159,9 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor {
         if (resultType != null) {
             DataFlowValue resultValue = DataFlowValueFactory.createDataFlowValue(expression, resultType, context);
             commonDataFlowInfo = commonDataFlowInfo.assign(resultValue, whenValue);
+            if (isExhaustive && expression.getElseExpression() == null && KotlinBuiltIns.isNothing(resultType)) {
+                context.trace.record(BindingContext.IMPLICIT_EXHAUSTIVE_WHEN, expression);
+            }
         }
         return TypeInfoFactoryKt.createTypeInfo(expressionTypes.isEmpty() ? null : components.dataFlowAnalyzer.checkType(
                                                              components.dataFlowAnalyzer.checkImplicitCast(

compiler/testData/diagnostics/tests/enum/enumStarImport.kt

@@ -13,8 +13,8 @@ import enum.HappyEnum
 import enum.HappyEnum.*
 
 fun f(e: HappyEnum) {
-    when (e) {
+    <!DEBUG_INFO_IMPLICIT_EXHAUSTIVE!>when (e) {
         CASE1 -> throw UnsupportedOperationException() // unresolved reference
         CASE2 -> throw UnsupportedOperationException() // unresolved references
-    }
+    }<!>
 }

compiler/testData/diagnostics/tests/sealed/TreeWhen.kt

@@ -4,10 +4,10 @@ sealed class Tree {
     class Node(val left: Tree, val right: Tree): Tree()
 
     fun max(): Int {
-        when(this) {
+        <!DEBUG_INFO_IMPLICIT_EXHAUSTIVE!>when(this) {
             is Empty -> return -1
             is Leaf -> return <!DEBUG_INFO_SMARTCAST!>this<!>.x
             is Node -> return <!DEBUG_INFO_SMARTCAST!>this<!>.left.max()
-        }
+        }<!>
     }
 }

compiler/testData/diagnostics/tests/when/ExhaustiveBreakContinue.kt

@@ -2,11 +2,11 @@ enum class Color { RED, GREEN, BLUE }
 
 fun foo(arr: Array<Color>): Color {
     loop@ for (color in arr) {
-        when (color) {
+        <!DEBUG_INFO_IMPLICIT_EXHAUSTIVE!>when (color) {
             Color.RED -> return color
             Color.GREEN -> break@loop
             Color.BLUE -> if (arr.size == 1) return color else continue@loop
-        }
+        }<!>
         // Unreachable
         <!UNREACHABLE_CODE!>return Color.BLUE<!>
     }

compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumStatement.kt

@@ -13,8 +13,8 @@ public enum J {
 // FILE: K.kt
 
 fun foo(): Int {
-    when (<!WHEN_ENUM_CAN_BE_NULL_IN_JAVA!>J.create()<!>) {
+    <!DEBUG_INFO_IMPLICIT_EXHAUSTIVE!>when (<!WHEN_ENUM_CAN_BE_NULL_IN_JAVA!>J.create()<!>) {
         J.A -> return 1
         J.B -> return 2
-    }
+    }<!>
 }

compiler/testData/diagnostics/tests/when/ExhaustiveReturn.kt

@@ -3,11 +3,11 @@ enum class Direction {
 }
 
 fun foo(dir: Direction): Int {
-    when (dir) {
+    <!DEBUG_INFO_IMPLICIT_EXHAUSTIVE!>when (dir) {
         Direction.NORTH -> return 1
         Direction.SOUTH -> return 2
         Direction.WEST  -> return 3
         Direction.EAST  -> return 4
-    }
+    }<!>
     // See KT-1882: no return is needed at the end
 }

compiler/testData/diagnostics/tests/when/ExhaustiveReturnThrow.kt

@@ -3,12 +3,12 @@ enum class Direction {
 }
 
 fun foo(dir: Direction): Int {
-    when (dir) {
+    <!DEBUG_INFO_IMPLICIT_EXHAUSTIVE!>when (dir) {
         Direction.NORTH -> return 1
         Direction.SOUTH -> throw AssertionError("!!!")
         Direction.WEST  -> return 3
         Direction.EAST  -> return 4
-    }
+    }<!>
     // Error: Unreachable code. Return is not required.
     <!UNREACHABLE_CODE!>if (dir == Direction.SOUTH) return 2<!>
 }