From 4697822b5af7499a1da4b0b46280f6fa1eb3f0bd Mon Sep 17 00:00:00 2001
From: Dmitriy Novozhilov <dmitriy.novozhilov@jetbrains.com>
Date: Thu, 22 Aug 2019 15:58:40 +0300
Subject: [PATCH] [FIR] Fix setting return type for `when` and `try` with non
 applicable candidates

---
 .../transformers/FirBodyResolveTransformer.kt |  7 +++--
 .../recursiveCallOnWhenWithSealedClass.txt    |  2 +-
 .../testData/resolve/whenAsReceiver.kt        | 12 +++++++++
 .../testData/resolve/whenAsReceiver.txt       | 26 +++++++++++++++++++
 .../fir/FirResolveTestCaseGenerated.java      |  5 ++++
 5 files changed, 49 insertions(+), 3 deletions(-)
 create mode 100644 compiler/fir/resolve/testData/resolve/whenAsReceiver.kt
 create mode 100644 compiler/fir/resolve/testData/resolve/whenAsReceiver.txt

diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt
index 8a372c145c8..769406bafe7 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt
@@ -400,7 +400,10 @@ open class FirBodyResolveTransformer(
         tryExpression.transformCatches(this, null)
 
         @Suppress("NAME_SHADOWING")
-        val tryExpression = syntheticCallGenerator.generateCalleeForTryExpression(tryExpression) ?: return tryExpression.compose()
+        val tryExpression = syntheticCallGenerator.generateCalleeForTryExpression(tryExpression) ?: run {
+            tryExpression.resultType = FirErrorTypeRefImpl(null, "Inapplicable when expression")
+            return tryExpression.compose()
+        }
         val expectedTypeRef = data as FirTypeRef?
         val result = callCompleter.completeCall(tryExpression, expectedTypeRef)
 
@@ -482,7 +485,7 @@ open class FirBodyResolveTransformer(
 
             @Suppress("NAME_SHADOWING")
             val whenExpression = syntheticCallGenerator.generateCalleeForWhenExpression(whenExpression) ?: run {
-                // TODO: bodies will be unresolved. Maybe run usual transform without completer?
+                whenExpression.resultType = FirErrorTypeRefImpl(null, "Inapplicable when expression")
                 return@with whenExpression.compose()
             }
 
diff --git a/compiler/fir/resolve/testData/resolve/recursiveCallOnWhenWithSealedClass.txt b/compiler/fir/resolve/testData/resolve/recursiveCallOnWhenWithSealedClass.txt
index 534ebc2c1c7..8045f6676a5 100644
--- a/compiler/fir/resolve/testData/resolve/recursiveCallOnWhenWithSealedClass.txt
+++ b/compiler/fir/resolve/testData/resolve/recursiveCallOnWhenWithSealedClass.txt
@@ -27,7 +27,7 @@ FILE: recursiveCallOnWhenWithSealedClass.kt
 
         }
 
-        public final fun unwrap(): <ERROR TYPE REF: No type for block> {
+        public final fun unwrap(): <ERROR TYPE REF: Inapplicable when expression> {
             ^unwrap when (this#) {
                 ($subj$ is R|Maybe.Nope|) ->  {
                     throw R|java/lang/Exception.Exception|(String())
diff --git a/compiler/fir/resolve/testData/resolve/whenAsReceiver.kt b/compiler/fir/resolve/testData/resolve/whenAsReceiver.kt
new file mode 100644
index 00000000000..860ba609ef7
--- /dev/null
+++ b/compiler/fir/resolve/testData/resolve/whenAsReceiver.kt
@@ -0,0 +1,12 @@
+fun <T, R> T.also(block: () -> R): R {
+    null!!
+}
+
+fun foo(b: Boolean) {
+    val x = when (b) {
+        true -> a
+        else -> null
+    }?.also {
+        1
+    }
+}
\ No newline at end of file
diff --git a/compiler/fir/resolve/testData/resolve/whenAsReceiver.txt b/compiler/fir/resolve/testData/resolve/whenAsReceiver.txt
new file mode 100644
index 00000000000..44cc5930a8f
--- /dev/null
+++ b/compiler/fir/resolve/testData/resolve/whenAsReceiver.txt
@@ -0,0 +1,26 @@
+FILE: whenAsReceiver.kt
+    public final fun <T, R> R|T|.also(block: R|kotlin/Function0<R>|): R|R| {
+        when (lval <bangbang>: R|kotlin/Nothing?| = Null(null)) {
+            ==($subj$, Null(null)) ->  {
+                throw <Unresolved name: KotlinNullPointerException>#()
+            }
+            else ->  {
+                R|<local>/<bangbang>|!
+            }
+        }
+
+    }
+    public final fun foo(b: R|kotlin/Boolean|): R|kotlin/Unit| {
+        lval x: <ERROR TYPE REF: Inapplicable(WRONG_RECEIVER): [/also]> = when (R|<local>/b|) {
+            ==($subj$, Boolean(true)) ->  {
+                <Unresolved name: a>#
+            }
+            else ->  {
+                Null(null)
+            }
+        }
+        ?.<Inapplicable(WRONG_RECEIVER): [/also]>#(<L> = also@fun <implicit>.<anonymous>(): <implicit> {
+            Int(1)
+        }
+        )
+    }
diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveTestCaseGenerated.java b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveTestCaseGenerated.java
index f7fb3263f31..5efc03531f4 100644
--- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveTestCaseGenerated.java
+++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveTestCaseGenerated.java
@@ -179,6 +179,11 @@ public class FirResolveTestCaseGenerated extends AbstractFirResolveTestCase {
         runTest("compiler/fir/resolve/testData/resolve/typeParameterVsNested.kt");
     }
 
+    @TestMetadata("whenAsReceiver.kt")
+    public void testWhenAsReceiver() throws Exception {
+        runTest("compiler/fir/resolve/testData/resolve/whenAsReceiver.kt");
+    }
+
     @TestMetadata("whenInference.kt")
     public void testWhenInference() throws Exception {
         runTest("compiler/fir/resolve/testData/resolve/whenInference.kt");