FIR DFA: isolate effects between blocks in try expression

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt

@@ -637,7 +637,9 @@ abstract class FirDataFlowAnalyzer<FLOW : Flow>(
     fun enterTryExpression(tryExpression: FirTryExpression) {
         val (tryExpressionEnterNode, tryMainBlockEnterNode) = graphBuilder.enterTryExpression(tryExpression)
         tryExpressionEnterNode.mergeIncomingFlow()
-        tryMainBlockEnterNode.mergeIncomingFlow()
+        // NB: fork to isolate effects inside the try main block
+        // Otherwise, changes in the try main block could affect the try expression enter node as well as its previous nodes.
+        tryMainBlockEnterNode.mergeIncomingFlow(shouldForkFlow = true)
     }
 
     fun exitTryMainBlock(tryExpression: FirTryExpression) {
@@ -645,7 +647,9 @@ abstract class FirDataFlowAnalyzer<FLOW : Flow>(
     }
 
     fun enterCatchClause(catch: FirCatch) {
-        graphBuilder.enterCatchClause(catch).mergeIncomingFlow(updateReceivers = true)
+        // NB: fork to isolate effects inside the catch clause
+        // Otherwise, changes in the catch clause could affect the previous node: try main block.
+        graphBuilder.enterCatchClause(catch).mergeIncomingFlow(updateReceivers = true, shouldForkFlow = true)
     }
 
     fun exitCatchClause(catch: FirCatch) {
@@ -653,19 +657,20 @@ abstract class FirDataFlowAnalyzer<FLOW : Flow>(
     }
 
     fun enterFinallyBlock() {
-        // TODO
+        // NB: fork to isolate effects inside the finally block
-        graphBuilder.enterFinallyBlock().mergeIncomingFlow()
+        // Otherwise, changes in the finally block could affect the previous nodes: try main block and catch clauses.
+        graphBuilder.enterFinallyBlock().mergeIncomingFlow(shouldForkFlow = true)
     }
 
     fun exitFinallyBlock(tryExpression: FirTryExpression) {
-        // TODO
         graphBuilder.exitFinallyBlock(tryExpression).mergeIncomingFlow()
     }
 
     fun exitTryExpression(callCompleted: Boolean) {
-        // TODO
         val (tryExpressionExitNode, unionNode) = graphBuilder.exitTryExpression(callCompleted)
-        tryExpressionExitNode.mergeIncomingFlow()
+        // NB: fork to prevent effects after the try expression from being flown into the try expression
+        // Otherwise, changes in any following nodes could affect the previous nodes, including try main block and finally block if any.
+        tryExpressionExitNode.mergeIncomingFlow(shouldForkFlow = true)
         unionNode?.let { unionFlowFromArguments(it) }
     }
 

compiler/testData/codegen/box/regressions/kt18779.kt

@@ -1,5 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
-
 sealed class Result {
     class Failure(val exception: Exception) : Result()
     class Success(val message: String) : Result()

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/TryFinally.fir.kt

@@ -14,7 +14,7 @@ fun tryCatchFinally(x: Int?) {
     } catch (e: Exception) {
         x!!
     } finally {
-        checkSubtype<Int>(x)
+        <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
         x!!
     }
     checkSubtype<Int>(x)

compiler/testData/diagnostics/tests/smartCasts/castchecks/castInTryWithCatch.fir.kt

@@ -2,11 +2,11 @@ fun castInTry(s: Any) {
     try {
         s as String // Potential cast exception
     } catch (e: Exception) {
-        s.length // shouldn't be resolved
+        s.<!UNRESOLVED_REFERENCE!>length<!> // shouldn't be resolved
     } finally {
-        s.length // shouldn't be resolved
+        s.<!UNRESOLVED_REFERENCE!>length<!> // shouldn't be resolved
     }
-    s.length // shouldn't be resolved
+    s.<!UNRESOLVED_REFERENCE!>length<!> // shouldn't be resolved
 }
 
 fun castInTryAndCatch(s: Any) {
@@ -15,9 +15,9 @@ fun castInTryAndCatch(s: Any) {
     } catch (e: Exception) {
         s as String // Potential cast exception
     } finally {
-        s.length // shouldn't be resolved
+        s.<!UNRESOLVED_REFERENCE!>length<!> // shouldn't be resolved
     }
-    s.length // should be smartcast
+    s.<!UNRESOLVED_REFERENCE!>length<!> // should be smartcast
 }
 
 fun castAtAll(s: Any) {

compiler/testData/diagnostics/tests/smartCasts/castchecks/castInTryWithoutCatch.fir.kt

@@ -2,9 +2,9 @@ fun castInTry(s: Any) {
     try {
         s as String // Potential cast exception
     } finally {
-        s.length // Shouldn't be resolved
+        s.<!UNRESOLVED_REFERENCE!>length<!> // Shouldn't be resolved
     }
-    s.length // Shouldn't be resolved
+    s.<!UNRESOLVED_REFERENCE!>length<!> // Shouldn't be resolved
 }
 
 fun castInTryAndFinally(s: Any) {

compiler/testData/diagnostics/tests/smartCasts/varnotnull/initInTryReturnInCatch.fir.kt

@@ -37,7 +37,7 @@ fun test3() {
     catch (e: B) {
         return
     }
-    a.hashCode() // a is nullable here
+    a.<!INAPPLICABLE_CANDIDATE!>hashCode<!>() // a is nullable here
 }
 fun test4() {
     var a: Int? = null

compiler/testData/diagnostics/tests/smartCasts/varnotnull/setNotNullInTry.fir.kt

@@ -10,5 +10,5 @@ fun foo() {
     } catch (ex: Exception) {}
     bar(s)
     if (s != null) { }
-    s.hashCode()
+    s.<!INAPPLICABLE_CANDIDATE!>hashCode<!>()
 }

compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/catchExceptionSpilling.fir.kt

@@ -17,5 +17,5 @@ fun testWithCatch(x: Any?) {
         x.length
     } catch (e: java.lang.IllegalArgumentException) { }
 
-    x.length
+    x.<!UNRESOLVED_REFERENCE!>length<!>
 }

compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/throwsEffect.fir.kt

@@ -45,7 +45,7 @@ fun testTryCatch(x: Any?) {
     } catch (e: kotlin.IllegalArgumentException) {
 
     }
-    x.length
+    x.<!UNRESOLVED_REFERENCE!>length<!>
 }
 
 fun testUncertainFlow(x: Any?) {