From 94809075148351caf10cf2238a068fda358c54ad Mon Sep 17 00:00:00 2001
From: Svetlana Isakova <svetlana.isakova@jetbrains.com>
Date: Thu, 12 Jun 2014 12:58:57 +0400
Subject: [PATCH] Mark some expressions after processing their components  when
 it's semantically correct

Expressions: calls, 'for' loops, elvis operators
It's significant for reporting 'unreachable code' correctly
---
 .../jet/lang/cfg/JetControlFlowProcessor.java | 22 +++--
 .../BasicExpressionTypingVisitor.java         |  2 +-
 .../basic/IfWithUninitialized.instructions    |  6 +-
 .../basic/UsageInFunctionLiteral.instructions | 12 +--
 .../basic/VariablesUsage.instructions         |  8 +-
 ...eferenceToPropertyInitializer.instructions | 10 +--
 .../bugs/varInitializationInIf.instructions   |  6 +-
 .../varInitializationInIfInCycle.instructions | 16 ++--
 .../lexicalScopes/doWhileScope.instructions   |  2 +-
 .../lexicalScopes/forScope.instructions       |  8 +-
 .../functionLiteralScope.instructions         |  6 +-
 .../localFunctionScope.instructions           |  6 +-
 ...localFunctionScopeWithoutBody.instructions |  6 +-
 .../lexicalScopes/whileScope.instructions     |  2 +-
 .../cfg/arrays/ArrayAccess.instructions       |  4 +-
 .../cfg/arrays/ArrayOfFunctions.instructions  |  3 +-
 .../arrays/arrayAccessExpression.instructions |  3 +-
 .../testData/cfg/arrays/arrayInc.instructions |  3 +-
 .../arrays/arraySetPlusAssign.instructions    |  3 +-
 .../testData/cfg/basic/Basic.instructions     | 12 +--
 .../cfg/bugs/jumpToOuterScope.instructions    |  4 +-
 .../controlStructures/Finally.instructions    | 80 +++++++++----------
 .../FinallyTestCopy.instructions              | 16 ++--
 .../cfg/controlStructures/For.instructions    |  8 +-
 .../cfg/controlStructures/If.instructions     | 16 ++--
 .../OnlyWhileInFunctionBody.instructions      | 10 +--
 .../cfg/conventions/equals.instructions       |  2 +-
 .../incrementAtTheEnd.instructions            |  2 +-
 .../cfg/conventions/invoke.instructions       |  2 +-
 .../cfg/conventions/notEqual.instructions     |  2 +-
 .../cfg/deadCode/returnInElvis.instructions   |  1 +
 .../local/ObjectExpression.instructions       |  2 +-
 ...backingFieldQualifiedWithThis.instructions |  2 +-
 .../cfg/expressions/Assignments.instructions  |  4 +-
 .../chainedQualifiedExpression.instructions   | 48 +++++------
 .../expressionAsFunction.instructions         |  2 +-
 .../cfg/expressions/nothingExpr.instructions  |  4 +-
 .../expressions/unresolvedCall.instructions   |  2 +-
 .../testData/cfg/tailCalls/sum.instructions   | 12 +--
 39 files changed, 181 insertions(+), 178 deletions(-)

diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
index 7379e15f149..1cc0a9090fb 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
@@ -16,7 +16,6 @@
 
 package org.jetbrains.jet.lang.cfg;
 
-import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.tree.IElementType;
@@ -333,9 +332,6 @@ public class JetControlFlowProcessor {
         public void visitBinaryExpressionVoid(@NotNull JetBinaryExpression expression, CFPContext context) {
             JetSimpleNameExpression operationReference = expression.getOperationReference();
             IElementType operationType = operationReference.getReferencedNameElementType();
-            if (!ImmutableSet.of(ANDAND, OROR, EQ, ELVIS).contains(operationType)) {
-                mark(expression);
-            }
 
             JetExpression left = expression.getLeft();
             JetExpression right = expression.getRight();
@@ -385,11 +381,12 @@ public class JetControlFlowProcessor {
                     }
                 }
                 else {
-                    generateBothArguments(expression);
+                    generateBothArgumentsAndMark(expression);
                 }
             }
             else if (operationType == ELVIS) {
                 generateInstructions(left, NOT_IN_CONDITION);
+                mark(expression);
                 Label afterElvis = builder.createUnboundLabel();
                 builder.jumpOnTrue(afterElvis, expression, builder.getBoundValue(left));
                 if (right != null) {
@@ -400,7 +397,7 @@ public class JetControlFlowProcessor {
             }
             else {
                 if (!generateCall(expression, operationReference)) {
-                    generateBothArguments(expression);
+                    generateBothArgumentsAndMark(expression);
                 }
             }
         }
@@ -430,7 +427,7 @@ public class JetControlFlowProcessor {
             );
         }
 
-        private void generateBothArguments(JetBinaryExpression expression) {
+        private void generateBothArgumentsAndMark(JetBinaryExpression expression) {
             JetExpression left = JetPsiUtil.deparenthesize(expression.getLeft());
             if (left != null) {
                 generateInstructions(left, NOT_IN_CONDITION);
@@ -439,8 +436,8 @@ public class JetControlFlowProcessor {
             if (right != null) {
                 generateInstructions(right, NOT_IN_CONDITION);
             }
-
             createNonSyntheticValue(expression, left, right);
+            mark(expression);
         }
 
         private void visitAssignment(JetExpression lhs, @NotNull Function0<PseudoValue> rhsDeferredValue, JetExpression parentExpression) {
@@ -592,7 +589,6 @@ public class JetControlFlowProcessor {
 
         @Override
         public void visitUnaryExpressionVoid(@NotNull JetUnaryExpression expression, CFPContext context) {
-            mark(expression);
             JetSimpleNameExpression operationSign = expression.getOperationReference();
             IElementType operationType = operationSign.getReferencedNameElementType();
             JetExpression baseExpression = expression.getBaseExpression();
@@ -795,7 +791,6 @@ public class JetControlFlowProcessor {
 
         @Override
         public void visitWhileExpressionVoid(@NotNull JetWhileExpression expression, CFPContext context) {
-            mark(expression);
             LoopInfo loopInfo = builder.enterLoop(expression, null, null);
 
             builder.bindLabel(loopInfo.getConditionEntryPoint());
@@ -803,6 +798,7 @@ public class JetControlFlowProcessor {
             if (condition != null) {
                 generateInstructions(condition, IN_CONDITION);
             }
+            mark(expression);
             boolean conditionIsTrueConstant = CompileTimeConstantUtils.canBeReducedToBooleanConstant(condition, trace, true);
             if (!conditionIsTrueConstant) {
                 builder.jumpOnFalse(loopInfo.getExitPoint(), expression, builder.getBoundValue(condition));
@@ -843,7 +839,6 @@ public class JetControlFlowProcessor {
         @Override
         public void visitForExpressionVoid(@NotNull JetForExpression expression, CFPContext context) {
             builder.enterLexicalScope(expression);
-            mark(expression);
 
             JetExpression loopRange = expression.getLoopRange();
             if (loopRange != null) {
@@ -863,6 +858,7 @@ public class JetControlFlowProcessor {
             builder.bindLabel(loopInfo.getBodyEntryPoint());
             writeLoopParameterAssignment(expression);
 
+            mark(expression);
             JetExpression body = expression.getBody();
             if (body != null) {
                 generateInstructions(body, NOT_IN_CONDITION);
@@ -1070,8 +1066,6 @@ public class JetControlFlowProcessor {
 
         @Override
         public void visitCallExpressionVoid(@NotNull JetCallExpression expression, CFPContext context) {
-            mark(expression);
-
             JetExpression calleeExpression = expression.getCalleeExpression();
             if (!generateCall(expression, calleeExpression)) {
                 List<JetExpression> inputExpressions = new ArrayList<JetExpression>();
@@ -1090,6 +1084,7 @@ public class JetControlFlowProcessor {
                 inputExpressions.add(calleeExpression);
                 inputExpressions.add(generateAndGetReceiverIfAny(expression));
 
+                mark(expression);
                 createNonSyntheticValue(expression, inputExpressions);
             }
         }
@@ -1416,6 +1411,7 @@ public class JetControlFlowProcessor {
                         : "Variable-based call with non-empty argument list: " + resolvedCall.getCall().getCallElement().getText();
                 return builder.readVariable(calleeExpression, callExpression, resolvedCall, receivers);
             }
+            mark(resolvedCall.getCall().getCallElement());
             return builder.call(calleeExpression, callExpression, resolvedCall, receivers, parameterValues);
         }
 
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java
index 9b836f765d3..b15e9a82b6a 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java
@@ -882,7 +882,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
                 context.trace, "trace to resolve 'equals(Any?)' interpreting as of type Any? an expression:", right);
         traceInterpretingRightAsNullableAny.record(EXPRESSION_TYPE, right, KotlinBuiltIns.getInstance().getNullableAnyType());
 
-        Call call = CallMaker.makeCallWithExpressions(operationSign, receiver, null, operationSign, Collections.singletonList(right));
+        Call call = CallMaker.makeCallWithExpressions(expression, receiver, null, operationSign, Collections.singletonList(right));
         ExpressionTypingContext newContext = context.replaceBindingTrace(traceInterpretingRightAsNullableAny);
         OverloadResolutionResults<FunctionDescriptor> resolutionResults =
                 components.callResolver.resolveCallWithGivenName(newContext, call, operationSign, OperatorConventions.EQUALS);
diff --git a/compiler/testData/cfg-variables/basic/IfWithUninitialized.instructions b/compiler/testData/cfg-variables/basic/IfWithUninitialized.instructions
index 2afa0f4bfc8..bc3499991b5 100644
--- a/compiler/testData/cfg-variables/basic/IfWithUninitialized.instructions
+++ b/compiler/testData/cfg-variables/basic/IfWithUninitialized.instructions
@@ -14,14 +14,14 @@ L0:
   2 mark({ val b: Boolean if (1 < 2) { use(b) } else { b = true } })
     v(val b: Boolean)                                                   INIT: in: {} out: {b=D}
     mark(if (1 < 2) { use(b) } else { b = true })                       INIT: in: {b=D} out: {b=D}
-    mark(1 < 2)
     r(1) -> <v0>
     r(2) -> <v1>
+    mark(1 < 2)
     call(<, compareTo|<v0>, <v1>) -> <v2>
     jf(L2|<v2>)
-  3 mark({ use(b) })
-    mark(use(b))                                                                                       USE: in: {b=READ} out: {b=READ}
+  3 mark({ use(b) })                                                                                   USE: in: {b=READ} out: {b=READ}
     r(b) -> <v3>                                                                                       USE: in: {} out: {b=READ}
+    mark(use(b))
     call(use, use|<v3>) -> <v4>
   2 jmp(L3)                                                                                            USE: in: {} out: {}
 L2:
diff --git a/compiler/testData/cfg-variables/basic/UsageInFunctionLiteral.instructions b/compiler/testData/cfg-variables/basic/UsageInFunctionLiteral.instructions
index da8b9a71781..c1df1eb55e0 100644
--- a/compiler/testData/cfg-variables/basic/UsageInFunctionLiteral.instructions
+++ b/compiler/testData/cfg-variables/basic/UsageInFunctionLiteral.instructions
@@ -39,14 +39,14 @@ L3:
     magic(x: Int) -> <v0>               INIT: in: {x=D} out: {x=D}
     w(x|<v0>)                           INIT: in: {x=D} out: {x=ID}
   4 mark(val y = x + a use(a))          INIT: in: {x=ID} out: {x=ID}
-    v(val y = x + a)                    INIT: in: {x=ID} out: {x=ID, y=D}
-    mark(x + a)                         INIT: in: {x=ID, y=D} out: {x=ID, y=D}      USE: in: {a=READ, x=READ} out: {a=READ, x=READ}
-    r(x) -> <v1>                                                                    USE: in: {a=READ} out: {a=READ, x=READ}
+    v(val y = x + a)                    INIT: in: {x=ID} out: {x=ID, y=D}           USE: in: {a=READ, x=READ} out: {a=READ, x=READ}
+    r(x) -> <v1>                        INIT: in: {x=ID, y=D} out: {x=ID, y=D}      USE: in: {a=READ} out: {a=READ, x=READ}
     r(a) -> <v2>
+    mark(x + a)
     call(+, plus|<v1>, <v2>) -> <v3>
-    w(y|<v3>)                           INIT: in: {x=ID, y=D} out: {x=ID, y=ID}
-    mark(use(a))                        INIT: in: {x=ID, y=ID} out: {x=ID, y=ID}    USE: in: {a=READ} out: {a=READ}
-    r(a) -> <v4>                                                                    USE: in: {} out: {a=READ}
+    w(y|<v3>)                           INIT: in: {x=ID, y=D} out: {x=ID, y=ID}     USE: in: {a=READ} out: {a=READ}
+    r(a) -> <v4>                        INIT: in: {x=ID, y=ID} out: {x=ID, y=ID}    USE: in: {} out: {a=READ}
+    mark(use(a))
     call(use, use|<v4>) -> <v5>
 L4:
   3 <END>                               INIT: in: {x=ID} out: {x=ID}
diff --git a/compiler/testData/cfg-variables/basic/VariablesUsage.instructions b/compiler/testData/cfg-variables/basic/VariablesUsage.instructions
index c4b90e6cd19..e7ef96d159d 100644
--- a/compiler/testData/cfg-variables/basic/VariablesUsage.instructions
+++ b/compiler/testData/cfg-variables/basic/VariablesUsage.instructions
@@ -11,14 +11,14 @@ L0:
   2 mark({ var a = 1 use(a) a = 2 use(a) })
     v(var a = 1)                               INIT: in: {} out: {a=D}
     r(1) -> <v0>                               INIT: in: {a=D} out: {a=D}
-    w(a|<v0>)                                  INIT: in: {a=D} out: {a=ID}
-    mark(use(a))                               INIT: in: {a=ID} out: {a=ID}    USE: in: {a=READ} out: {a=READ}
-    r(a) -> <v1>                                                               USE: in: {a=WRITTEN_AFTER_READ} out: {a=READ}
+    w(a|<v0>)                                  INIT: in: {a=D} out: {a=ID}     USE: in: {a=READ} out: {a=READ}
+    r(a) -> <v1>                               INIT: in: {a=ID} out: {a=ID}    USE: in: {a=WRITTEN_AFTER_READ} out: {a=READ}
+    mark(use(a))
     call(use, use|<v1>) -> <v2>
     r(2) -> <v3>                                                               USE: in: {a=WRITTEN_AFTER_READ} out: {a=WRITTEN_AFTER_READ}
     w(a|<v3>)                                                                  USE: in: {a=READ} out: {a=WRITTEN_AFTER_READ}
-    mark(use(a))                                                               USE: in: {a=READ} out: {a=READ}
     r(a) -> <v4>                                                               USE: in: {} out: {a=READ}
+    mark(use(a))
     call(use, use|<v4>) -> <v5>
 L1:
   1 <END>                                      INIT: in: {} out: {}
diff --git a/compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.instructions b/compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.instructions
index fe4512be268..ff2efa51a56 100644
--- a/compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.instructions
+++ b/compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.instructions
@@ -32,16 +32,16 @@ L3:
     magic(x: Int) -> <v0>                   INIT: in: {x=D} out: {x=D}
     w(x|<v0>)                               INIT: in: {x=D} out: {x=ID}
   3 mark(sum(x - 1) + x)                    INIT: in: {x=ID} out: {x=ID}
-    mark(sum(x - 1) + x)
-    mark(sum(x - 1))
     magic(sum) -> <v1>                                                      USE: in: {sum=READ, x=READ} out: {sum=READ, x=READ}
     r(sum|<v1>) -> <v2>                                                     USE: in: {x=READ} out: {sum=READ, x=READ}
-    mark(x - 1)
     r(x) -> <v3>
     r(1) -> <v4>
+    mark(x - 1)
     call(-, minus|<v3>, <v4>) -> <v5>
+    mark(sum(x - 1))
     call(sum, invoke|<v2>, <v5>) -> <v6>                                    USE: in: {x=READ} out: {x=READ}
     r(x) -> <v7>                                                            USE: in: {} out: {x=READ}
+    mark(sum(x - 1) + x)
     call(+, plus|<v6>, <v7>) -> <v8>
 L4:
   2 <END>
@@ -127,10 +127,10 @@ class TestOther {
 L0:
   1 <START>                             INIT: in: {} out: {}
     v(val x: Int = x + 1)               INIT: in: {} out: {x=D}
-    mark(x + 1)                         INIT: in: {x=D} out: {x=D}
-    magic(x) -> <v0>                                                    USE: in: {x=READ} out: {x=READ}
+    magic(x) -> <v0>                    INIT: in: {x=D} out: {x=D}      USE: in: {x=READ} out: {x=READ}
     r(x|<v0>) -> <v1>                                                   USE: in: {} out: {x=READ}
     r(1) -> <v2>
+    mark(x + 1)
     call(+, plus|<v1>, <v2>) -> <v3>
     w(x|<v3>)                           INIT: in: {x=D} out: {x=ID}
 L1:
diff --git a/compiler/testData/cfg-variables/bugs/varInitializationInIf.instructions b/compiler/testData/cfg-variables/bugs/varInitializationInIf.instructions
index 96d9c9a1284..c21437571e3 100644
--- a/compiler/testData/cfg-variables/bugs/varInitializationInIf.instructions
+++ b/compiler/testData/cfg-variables/bugs/varInitializationInIf.instructions
@@ -15,9 +15,9 @@ L0:
   2 mark({ val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) })
     v(val b: Boolean)                                                             INIT: in: {} out: {b=D}
     mark(if (1 < 2) { b = false } else { b = true })                              INIT: in: {b=D} out: {b=D}
-    mark(1 < 2)
     r(1) -> <v0>
     r(2) -> <v1>
+    mark(1 < 2)
     call(<, compareTo|<v0>, <v1>) -> <v2>
     jf(L2|<v2>)
   3 mark({ b = false })
@@ -29,10 +29,10 @@ L2:
     r(true) -> <v4>                                                                                               USE: in: {b=WRITTEN_AFTER_READ} out: {b=WRITTEN_AFTER_READ}
     w(b|<v4>)                                                                     INIT: in: {b=D} out: {b=ID}     USE: in: {b=READ} out: {b=WRITTEN_AFTER_READ}
 L3:
-  2 mark(use(b))                                                                  INIT: in: {b=ID} out: {b=ID}
-    error(use, No resolved call)                                                                                  USE: in: {b=READ} out: {b=READ}
+  2 error(use, No resolved call)                                                  INIT: in: {b=ID} out: {b=ID}    USE: in: {b=READ} out: {b=READ}
     r(b) -> <v5>                                                                                                  USE: in: {} out: {b=READ}
     error(use, No resolved call)
+    mark(use(b))
     magic(use(b)|<v5>) -> <v6>
 L1:
   1 <END>                                                                         INIT: in: {} out: {}
diff --git a/compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.instructions b/compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.instructions
index aaa804160de..6c56fdbdd94 100644
--- a/compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.instructions
+++ b/compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.instructions
@@ -18,22 +18,22 @@ L0:
     v(numbers: Collection<Int>)                                                                                   INIT: in: {} out: {numbers=D}
     magic(numbers: Collection<Int>) -> <v0>                                                                       INIT: in: {numbers=D} out: {numbers=D}
     w(numbers|<v0>)                                                                                               INIT: in: {numbers=D} out: {numbers=ID}
-  2 mark({ for (i in numbers) { val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) continue } })    INIT: in: {numbers=ID} out: {numbers=ID}
-  3 mark(for (i in numbers) { val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) continue })                                                                            USE: in: {numbers=READ} out: {numbers=READ}
-    r(numbers) -> <v1>                                                                                                                                                                USE: in: {} out: {numbers=READ}
+  2 mark({ for (i in numbers) { val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) continue } })    INIT: in: {numbers=ID} out: {numbers=ID}                            USE: in: {numbers=READ} out: {numbers=READ}
+  3 r(numbers) -> <v1>                                                                                                                                                                USE: in: {} out: {numbers=READ}
     v(i)                                                                                                          INIT: in: {numbers=ID} out: {i=D, numbers=ID}
 L3:
     jmp?(L2)                                                                                                      INIT: in: {i=D, numbers=ID} out: {i=D, numbers=ID}
 L4 [loop entry point]:
 L5 [body entry point]:
     magic(numbers|<v1>) -> <v2>
-    w(i|<v2>)                                                                                                     INIT: in: {i=D, numbers=ID} out: {i=ID, numbers=ID}                 USE: in: {} out: {}
-  4 mark({ val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) continue })                           INIT: in: {i=ID, numbers=ID} out: {i=ID, numbers=ID}
+    w(i|<v2>)                                                                                                     INIT: in: {i=D, numbers=ID} out: {i=ID, numbers=ID}
+    mark(for (i in numbers) { val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) continue })        INIT: in: {i=ID, numbers=ID} out: {i=ID, numbers=ID}                USE: in: {} out: {}
+  4 mark({ val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) continue })
     v(val b: Boolean)                                                                                             INIT: in: {i=ID, numbers=ID} out: {b=D, i=ID, numbers=ID}
     mark(if (1 < 2) { b = false } else { b = true })                                                              INIT: in: {b=D, i=ID, numbers=ID} out: {b=D, i=ID, numbers=ID}
-    mark(1 < 2)
     r(1) -> <v3>
     r(2) -> <v4>
+    mark(1 < 2)
     call(<, compareTo|<v3>, <v4>) -> <v5>
     jf(L6|<v5>)
   5 mark({ b = false })
@@ -45,8 +45,8 @@ L6:
     r(true) -> <v7>                                                                                                                                                                   USE: in: {b=WRITTEN_AFTER_READ} out: {b=WRITTEN_AFTER_READ}
     w(b|<v7>)                                                                                                     INIT: in: {b=D, i=ID, numbers=ID} out: {b=ID, i=ID, numbers=ID}     USE: in: {b=READ} out: {b=WRITTEN_AFTER_READ}
 L7:
-  4 mark(use(b))                                                                                                  INIT: in: {b=ID, i=ID, numbers=ID} out: {b=ID, i=ID, numbers=ID}    USE: in: {b=READ} out: {b=READ}
-    r(b) -> <v8>                                                                                                                                                                      USE: in: {} out: {b=READ}
+  4 r(b) -> <v8>                                                                                                  INIT: in: {b=ID, i=ID, numbers=ID} out: {b=ID, i=ID, numbers=ID}    USE: in: {} out: {b=READ}
+    mark(use(b))
     call(use, use|<v8>) -> <v9>
     jmp(L4 [loop entry point])                                                                                                                                                        USE: in: {} out: {}
 - 3 jmp?(L4 [loop entry point])
diff --git a/compiler/testData/cfg-variables/lexicalScopes/doWhileScope.instructions b/compiler/testData/cfg-variables/lexicalScopes/doWhileScope.instructions
index 7708be03b46..4825042e39c 100644
--- a/compiler/testData/cfg-variables/lexicalScopes/doWhileScope.instructions
+++ b/compiler/testData/cfg-variables/lexicalScopes/doWhileScope.instructions
@@ -20,9 +20,9 @@ L4 [body entry point]:
     r(2) -> <v1>
     w(a|<v1>)
 L5 [condition entry point]:
-    mark(a > 0)
     r(a) -> <v2>
     r(0) -> <v3>
+    mark(a > 0)
     call(>, compareTo|<v2>, <v3>) -> <v4>
     jt(L2 [loop entry point]|<v4>)                                                               USE: in: {a=READ} out: {a=READ}
 L3 [loop exit point]:
diff --git a/compiler/testData/cfg-variables/lexicalScopes/forScope.instructions b/compiler/testData/cfg-variables/lexicalScopes/forScope.instructions
index c9152b6723d..a061ddc9d89 100644
--- a/compiler/testData/cfg-variables/lexicalScopes/forScope.instructions
+++ b/compiler/testData/cfg-variables/lexicalScopes/forScope.instructions
@@ -12,10 +12,9 @@ L0:
   2 mark({ "before" for (i in 1..10) { val a = i } "after" })
     mark("before")
     r("before") -> <v0>                                                                                     USE: in: {} out: {}
-  3 mark(for (i in 1..10) { val a = i })
-    mark(1..10)
-    r(1) -> <v1>
+  3 r(1) -> <v1>
     r(10) -> <v2>
+    mark(1..10)
     call(.., rangeTo|<v1>, <v2>) -> <v3>
     v(i)                                                         INIT: in: {} out: {i=D}
 L3:
@@ -24,7 +23,8 @@ L4 [loop entry point]:
 L5 [body entry point]:
     magic(1..10|<v3>) -> <v4>
     w(i|<v4>)                                                    INIT: in: {i=D} out: {i=ID}
-  4 mark({ val a = i })                                          INIT: in: {i=ID} out: {i=ID}
+    mark(for (i in 1..10) { val a = i })                         INIT: in: {i=ID} out: {i=ID}
+  4 mark({ val a = i })
     v(val a = i)                                                 INIT: in: {i=ID} out: {a=D, i=ID}
     r(i) -> <v5>                                                 INIT: in: {a=D, i=ID} out: {a=D, i=ID}
     w(a|<v5>)                                                    INIT: in: {a=D, i=ID} out: {a=ID, i=ID}
diff --git a/compiler/testData/cfg-variables/lexicalScopes/functionLiteralScope.instructions b/compiler/testData/cfg-variables/lexicalScopes/functionLiteralScope.instructions
index a9f72bf6857..ad9463aaccc 100644
--- a/compiler/testData/cfg-variables/lexicalScopes/functionLiteralScope.instructions
+++ b/compiler/testData/cfg-variables/lexicalScopes/functionLiteralScope.instructions
@@ -43,10 +43,10 @@ L3:
     magic(x: Int) -> <v0>               INIT: in: {x=D} out: {x=D}
     w(x|<v0>)                           INIT: in: {x=D} out: {x=ID}
   4 mark(val a = x + b)                 INIT: in: {x=ID} out: {x=ID}
-    v(val a = x + b)                    INIT: in: {x=ID} out: {a=D, x=ID}
-    mark(x + b)                         INIT: in: {a=D, x=ID} out: {a=D, x=ID}     USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
-    r(x) -> <v1>                                                                   USE: in: {b=READ} out: {b=READ, x=READ}
+    v(val a = x + b)                    INIT: in: {x=ID} out: {a=D, x=ID}          USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
+    r(x) -> <v1>                        INIT: in: {a=D, x=ID} out: {a=D, x=ID}     USE: in: {b=READ} out: {b=READ, x=READ}
     r(b) -> <v2>                                                                   USE: in: {} out: {b=READ}
+    mark(x + b)
     call(+, plus|<v1>, <v2>) -> <v3>
     w(a|<v3>)                           INIT: in: {a=D, x=ID} out: {a=ID, x=ID}
 L4:
diff --git a/compiler/testData/cfg-variables/lexicalScopes/localFunctionScope.instructions b/compiler/testData/cfg-variables/lexicalScopes/localFunctionScope.instructions
index fec9e2c51c1..e92d11ab224 100644
--- a/compiler/testData/cfg-variables/lexicalScopes/localFunctionScope.instructions
+++ b/compiler/testData/cfg-variables/lexicalScopes/localFunctionScope.instructions
@@ -39,10 +39,10 @@ L3:
     magic(x: Int) -> <v0>               INIT: in: {x=D} out: {x=D}
     w(x|<v0>)                           INIT: in: {x=D} out: {x=ID}
   4 mark({ val a = x + b })             INIT: in: {x=ID} out: {x=ID}
-    v(val a = x + b)                    INIT: in: {x=ID} out: {a=D, x=ID}
-    mark(x + b)                         INIT: in: {a=D, x=ID} out: {a=D, x=ID}     USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
-    r(x) -> <v1>                                                                   USE: in: {b=READ} out: {b=READ, x=READ}
+    v(val a = x + b)                    INIT: in: {x=ID} out: {a=D, x=ID}          USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
+    r(x) -> <v1>                        INIT: in: {a=D, x=ID} out: {a=D, x=ID}     USE: in: {b=READ} out: {b=READ, x=READ}
     r(b) -> <v2>                                                                   USE: in: {} out: {b=READ}
+    mark(x + b)
     call(+, plus|<v1>, <v2>) -> <v3>
     w(a|<v3>)                           INIT: in: {a=D, x=ID} out: {a=ID, x=ID}
 L4:
diff --git a/compiler/testData/cfg-variables/lexicalScopes/localFunctionScopeWithoutBody.instructions b/compiler/testData/cfg-variables/lexicalScopes/localFunctionScopeWithoutBody.instructions
index 38ee650f5a1..6053403f52c 100644
--- a/compiler/testData/cfg-variables/lexicalScopes/localFunctionScopeWithoutBody.instructions
+++ b/compiler/testData/cfg-variables/lexicalScopes/localFunctionScopeWithoutBody.instructions
@@ -33,10 +33,10 @@ L3:
   3 <START>                             INIT: in: {} out: {}
     v(x: Int)                           INIT: in: {} out: {x=D}
     magic(x: Int) -> <v0>               INIT: in: {x=D} out: {x=D}
-    w(x|<v0>)                           INIT: in: {x=D} out: {x=ID}
-    mark(x + b)                         INIT: in: {x=ID} out: {x=ID}    USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
-    r(x) -> <v1>                                                        USE: in: {b=READ} out: {b=READ, x=READ}
+    w(x|<v0>)                           INIT: in: {x=D} out: {x=ID}     USE: in: {b=READ, x=READ} out: {b=READ, x=READ}
+    r(x) -> <v1>                        INIT: in: {x=ID} out: {x=ID}    USE: in: {b=READ} out: {b=READ, x=READ}
     r(b) -> <v2>                                                        USE: in: {} out: {b=READ}
+    mark(x + b)
     call(+, plus|<v1>, <v2>) -> <v3>
 L4:
     <END>
diff --git a/compiler/testData/cfg-variables/lexicalScopes/whileScope.instructions b/compiler/testData/cfg-variables/lexicalScopes/whileScope.instructions
index 50d2a76ed4b..2dec72a8ad3 100644
--- a/compiler/testData/cfg-variables/lexicalScopes/whileScope.instructions
+++ b/compiler/testData/cfg-variables/lexicalScopes/whileScope.instructions
@@ -12,10 +12,10 @@ L0:
   2 mark({ "before" while (true) { val a: Int } "after" })
     mark("before")
     r("before") -> <v0>
-    mark(while (true) { val a: Int })
 L2 [loop entry point]:
 L5 [condition entry point]:
     r(true) -> <v1>
+    mark(while (true) { val a: Int })
 L4 [body entry point]:
   3 mark({ val a: Int })
     v(val a: Int)                                             INIT: in: {} out: {a=D}
diff --git a/compiler/testData/cfg/arrays/ArrayAccess.instructions b/compiler/testData/cfg/arrays/ArrayAccess.instructions
index 67a47d4ca48..0e7994e6ff5 100644
--- a/compiler/testData/cfg/arrays/ArrayAccess.instructions
+++ b/compiler/testData/cfg/arrays/ArrayAccess.instructions
@@ -26,14 +26,16 @@ L0:
     mark(a[10])
     r(a) -> <v7>
     r(10) -> <v8>
+    mark(a[10])
     call(a[10], get|<v7>, <v8>) -> <v9>
     r(100) -> <v10>
-    mark(a[10] += 1)
     mark(a[10])
     r(a) -> <v11>
     r(10) -> <v12>
+    mark(a[10])
     call(a[10], get|<v11>, <v12>) -> <v13>
     r(1) -> <v14>
+    mark(a[10] += 1)
     call(+=, plus|<v13>, <v14>) -> <v15>
     r(a) -> <v16>
     r(10) -> <v17>
diff --git a/compiler/testData/cfg/arrays/ArrayOfFunctions.instructions b/compiler/testData/cfg/arrays/ArrayOfFunctions.instructions
index 4b5c97d2f60..94932e91ba4 100644
--- a/compiler/testData/cfg/arrays/ArrayOfFunctions.instructions
+++ b/compiler/testData/cfg/arrays/ArrayOfFunctions.instructions
@@ -9,12 +9,13 @@ L0:
     magic(array: Array<(Int)->Unit>) -> <v0>
     w(array|<v0>)
   2 mark({ array[11](3) })
-    mark(array[11](3))
     mark(array[11])
     r(array) -> <v1>
     r(11) -> <v2>
+    mark(array[11])
     call(array[11], get|<v1>, <v2>) -> <v3>
     r(3) -> <v4>
+    mark(array[11](3))
     call(array[11], invoke|<v3>, <v4>) -> <v5>
 L1:
   1 <END>                                         NEXT:[<SINK>]
diff --git a/compiler/testData/cfg/arrays/arrayAccessExpression.instructions b/compiler/testData/cfg/arrays/arrayAccessExpression.instructions
index 6ac16f85361..31b610d5143 100644
--- a/compiler/testData/cfg/arrays/arrayAccessExpression.instructions
+++ b/compiler/testData/cfg/arrays/arrayAccessExpression.instructions
@@ -37,10 +37,11 @@ L0:
   2 mark({ ab.getArray()[1] })
     mark(ab.getArray()[1])
     mark(ab.getArray())
-    mark(getArray())
     r(ab) -> <v1>
+    mark(getArray())
     call(getArray, getArray|<v1>) -> <v2>
     r(1) -> <v3>
+    mark(ab.getArray()[1])
     call(ab.getArray()[1], get|<v2>, <v3>) -> <v4>
 L1:
   1 <END>                                             NEXT:[<SINK>]
diff --git a/compiler/testData/cfg/arrays/arrayInc.instructions b/compiler/testData/cfg/arrays/arrayInc.instructions
index 05096066b52..5916a920d52 100644
--- a/compiler/testData/cfg/arrays/arrayInc.instructions
+++ b/compiler/testData/cfg/arrays/arrayInc.instructions
@@ -9,11 +9,12 @@ L0:
     magic(a: Array<Int>) -> <v0>
     w(a|<v0>)
   2 mark({ a[0]++ })
-    mark(a[0]++)
     mark(a[0])
     r(a) -> <v1>
     r(0) -> <v2>
+    mark(a[0])
     call(a[0], get|<v1>, <v2>) -> <v3>
+    mark(a[0]++)
     call(++, inc|<v3>) -> <v4>
     r(a) -> <v5>
     r(0) -> <v6>
diff --git a/compiler/testData/cfg/arrays/arraySetPlusAssign.instructions b/compiler/testData/cfg/arrays/arraySetPlusAssign.instructions
index e5629e1ca6a..4c01b6ae3ed 100644
--- a/compiler/testData/cfg/arrays/arraySetPlusAssign.instructions
+++ b/compiler/testData/cfg/arrays/arraySetPlusAssign.instructions
@@ -9,12 +9,13 @@ L0:
     magic(a: Array<Int>) -> <v0>
     w(a|<v0>)
   2 mark({ a[0] += 1 })
-    mark(a[0] += 1)
     mark(a[0])
     r(a) -> <v1>
     r(0) -> <v2>
+    mark(a[0])
     call(a[0], get|<v1>, <v2>) -> <v3>
     r(1) -> <v4>
+    mark(a[0] += 1)
     call(+=, plus|<v3>, <v4>) -> <v5>
     r(a) -> <v6>
     r(0) -> <v7>
diff --git a/compiler/testData/cfg/basic/Basic.instructions b/compiler/testData/cfg/basic/Basic.instructions
index 1283ba8fa66..6962e4a033a 100644
--- a/compiler/testData/cfg/basic/Basic.instructions
+++ b/compiler/testData/cfg/basic/Basic.instructions
@@ -26,34 +26,34 @@ L0:
     r(1) -> <v1>
     r(a) -> <v2>
     mark(2.toLong())
-    mark(toLong())
     r(2) -> <v3>
+    mark(toLong())
     call(toLong, toLong|<v3>) -> <v4>
-    mark(foo(a, 3))
     r(a) -> <v5>
     r(3) -> <v6>
+    mark(foo(a, 3))
     call(foo, foo|<v5>, <v6>) -> <v7>
     mark(genfun<Any>())
     call(genfun, genfun) -> <v8>
-    mark(flfun {1})
     mark({1})
     jmp?(L2)                                                                                                        NEXT:[r({1}) -> <v9>, d({1})]
     d({1})                                                                                                          NEXT:[<SINK>]
 L2:
     r({1}) -> <v9>                                                                                                  PREV:[jmp?(L2)]
+    mark(flfun {1})
     call(flfun, flfun|<v9>) -> <v10>
     mark(3.equals(4))
-    mark(equals(4))
     r(3) -> <v11>
     r(4) -> <v12>
+    mark(equals(4))
     call(equals, equals|<v11>, <v12>) -> <v13>
-    mark(3 equals 4)
     r(3) -> <v14>
     r(4) -> <v15>
+    mark(3 equals 4)
     call(equals, equals|<v14>, <v15>) -> <v16>
-    mark(1 + 2)
     r(1) -> <v17>
     r(2) -> <v18>
+    mark(1 + 2)
     call(+, plus|<v17>, <v18>) -> <v19>
     r(a) -> <v20>
     jf(L5|<v20>)                                                                                                    NEXT:[magic(a && true|<v20>, <v21>) -> <v22>, r(true) -> <v21>]
diff --git a/compiler/testData/cfg/bugs/jumpToOuterScope.instructions b/compiler/testData/cfg/bugs/jumpToOuterScope.instructions
index b8644228f64..018c604f721 100644
--- a/compiler/testData/cfg/bugs/jumpToOuterScope.instructions
+++ b/compiler/testData/cfg/bugs/jumpToOuterScope.instructions
@@ -13,8 +13,7 @@ L0:
     magic(c: Collection<Int>) -> <v0>
     w(c|<v0>)
   2 mark({ for (e in c) { { break } } })
-  3 mark(for (e in c) { { break } })
-    r(c) -> <v1>
+  3 r(c) -> <v1>
     v(e)
 L3:
     jmp?(L2)                                NEXT:[read (Unit), magic(c|<v1>) -> <v2>]
@@ -22,6 +21,7 @@ L4 [loop entry point]:
 L5 [body entry point]:
     magic(c|<v1>) -> <v2>                   PREV:[jmp?(L2), jmp?(L4 [loop entry point])]
     w(e|<v2>)
+    mark(for (e in c) { { break } })
   4 mark({ { break } })
     mark({ break })
     jmp?(L6)                                NEXT:[r({ break }) -> <v3>, d({ break })]
diff --git a/compiler/testData/cfg/controlStructures/Finally.instructions b/compiler/testData/cfg/controlStructures/Finally.instructions
index 05e80d05c0e..07f32055e00 100644
--- a/compiler/testData/cfg/controlStructures/Finally.instructions
+++ b/compiler/testData/cfg/controlStructures/Finally.instructions
@@ -51,9 +51,9 @@ L0:
   3 mark({ 1 if (2 > 3) { return } })
     r(1) -> <v0>
     mark(if (2 > 3) { return })
-    mark(2 > 3)
     r(2) -> <v1>
     r(3) -> <v2>
+    mark(2 > 3)
     call(>, compareTo|<v1>, <v2>) -> <v3>
     jf(L3|<v3>)                                                NEXT:[read (Unit), mark({ return })]
   4 mark({ return })
@@ -136,9 +136,9 @@ L4:
   4 <START>
   5 mark(if (2 > 3) { return@l })
     mark(if (2 > 3) { return@l })
-    mark(2 > 3)
     r(2) -> <v0>
     r(3) -> <v1>
+    mark(2 > 3)
     call(>, compareTo|<v0>, <v1>) -> <v2>
     jf(L6|<v2>)                              NEXT:[read (Unit), mark({ return@l })]
   6 mark({ return@l })
@@ -204,9 +204,9 @@ L3:
   5 mark({ 1 if (2 > 3) { return@l } })
     r(1) -> <v0>
     mark(if (2 > 3) { return@l })
-    mark(2 > 3)
     r(2) -> <v1>
     r(3) -> <v2>
+    mark(2 > 3)
     call(>, compareTo|<v1>, <v2>) -> <v3>
     jf(L6|<v3>)                                              NEXT:[read (Unit), mark({ return@l })]
   6 mark({ return@l })
@@ -252,10 +252,10 @@ L0:
   1 <START>
   2 mark({ @l while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } } })
     mark(@l while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } })
-    mark(while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } })
 L2 [loop entry point]:
 L5 [condition entry point]:
-    r(true) -> <v0>                                                                 PREV:[mark(while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } }), jmp(L2 [loop entry point])]
+    r(true) -> <v0>                                                                 PREV:[mark(@l while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } }), jmp(L2 [loop entry point])]
+    mark(while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } })
 L4 [body entry point]:
   3 mark({ try { 1 if (2 > 3) { break @l } } finally { 2 } })
     mark(try { 1 if (2 > 3) { break @l } } finally { 2 })
@@ -263,9 +263,9 @@ L4 [body entry point]:
   4 mark({ 1 if (2 > 3) { break @l } })
     r(1) -> <v1>
     mark(if (2 > 3) { break @l })
-    mark(2 > 3)
     r(2) -> <v2>
     r(3) -> <v3>
+    mark(2 > 3)
     call(>, compareTo|<v2>, <v3>) -> <v4>
     jf(L7|<v4>)                                                                     NEXT:[read (Unit), mark({ break @l })]
   5 mark({ break @l })
@@ -318,17 +318,17 @@ L0:
     jmp?(L2 [onExceptionToFinallyBlock])                                              NEXT:[mark({ 2 }), mark({ @l while(true) { 1 if (2 > 3) { break @l } } 5 })]
   3 mark({ @l while(true) { 1 if (2 > 3) { break @l } } 5 })
     mark(@l while(true) { 1 if (2 > 3) { break @l } })
-    mark(while(true) { 1 if (2 > 3) { break @l } })
 L3 [loop entry point]:
 L6 [condition entry point]:
-    r(true) -> <v0>                                                                   PREV:[mark(while(true) { 1 if (2 > 3) { break @l } }), jmp(L3 [loop entry point])]
+    r(true) -> <v0>                                                                   PREV:[mark(@l while(true) { 1 if (2 > 3) { break @l } }), jmp(L3 [loop entry point])]
+    mark(while(true) { 1 if (2 > 3) { break @l } })
 L5 [body entry point]:
   4 mark({ 1 if (2 > 3) { break @l } })
     r(1) -> <v1>
     mark(if (2 > 3) { break @l })
-    mark(2 > 3)
     r(2) -> <v2>
     r(3) -> <v3>
+    mark(2 > 3)
     call(>, compareTo|<v2>, <v3>) -> <v4>
     jf(L7|<v4>)                                                                       NEXT:[read (Unit), mark({ break @l })]
   5 mark({ break @l })
@@ -379,17 +379,17 @@ L0:
     jmp?(L2 [onExceptionToFinallyBlock])                                            NEXT:[mark({ 2 }), mark({ @l while(true) { 1 if (2 > 3) { break @l } } })]
   3 mark({ @l while(true) { 1 if (2 > 3) { break @l } } })
     mark(@l while(true) { 1 if (2 > 3) { break @l } })
-    mark(while(true) { 1 if (2 > 3) { break @l } })
 L3 [loop entry point]:
 L6 [condition entry point]:
-    r(true) -> <v0>                                                                 PREV:[mark(while(true) { 1 if (2 > 3) { break @l } }), jmp(L3 [loop entry point])]
+    r(true) -> <v0>                                                                 PREV:[mark(@l while(true) { 1 if (2 > 3) { break @l } }), jmp(L3 [loop entry point])]
+    mark(while(true) { 1 if (2 > 3) { break @l } })
 L5 [body entry point]:
   4 mark({ 1 if (2 > 3) { break @l } })
     r(1) -> <v1>
     mark(if (2 > 3) { break @l })
-    mark(2 > 3)
     r(2) -> <v2>
     r(3) -> <v3>
+    mark(2 > 3)
     call(>, compareTo|<v2>, <v3>) -> <v4>
     jf(L7|<v4>)                                                                     NEXT:[read (Unit), mark({ break @l })]
   5 mark({ break @l })
@@ -439,10 +439,9 @@ L0:
     w(a|<v0>)
   2 mark({ @l for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } } })
     mark(@l for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } })
-  3 mark(for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } })
-    mark(1..a)
-    r(1) -> <v1>
+  3 r(1) -> <v1>
     r(a) -> <v2>
+    mark(1..a)
     call(.., rangeTo|<v1>, <v2>) -> <v3>
     v(i)
 L3:
@@ -451,15 +450,16 @@ L4 [loop entry point]:
 L5 [body entry point]:
     magic(1..a|<v3>) -> <v4>                                                               PREV:[jmp?(L2), jmp(L4 [loop entry point]), jmp?(L4 [loop entry point])]
     w(i|<v4>)
+    mark(for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } })
   4 mark({ try { 1 if (2 > 3) { continue @l } } finally { 2 } })
     mark(try { 1 if (2 > 3) { continue @l } } finally { 2 })
     jmp?(L6 [onExceptionToFinallyBlock])                                                   NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { continue @l } })]
   5 mark({ 1 if (2 > 3) { continue @l } })
     r(1) -> <v5>
     mark(if (2 > 3) { continue @l })
-    mark(2 > 3)
     r(2) -> <v6>
     r(3) -> <v7>
+    mark(2 > 3)
     call(>, compareTo|<v6>, <v7>) -> <v8>
     jf(L7|<v8>)                                                                            NEXT:[read (Unit), mark({ continue @l })]
   6 mark({ continue @l })
@@ -515,10 +515,9 @@ L0:
     jmp?(L2 [onExceptionToFinallyBlock])                                                     NEXT:[mark({ 2 }), mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 })]
   3 mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 })
     mark(@l for (i in 1..a) { 1 if (2 > 3) { continue @l } })
-  4 mark(for (i in 1..a) { 1 if (2 > 3) { continue @l } })
-    mark(1..a)
-    r(1) -> <v1>
+  4 r(1) -> <v1>
     r(a) -> <v2>
+    mark(1..a)
     call(.., rangeTo|<v1>, <v2>) -> <v3>
     v(i)
 L4:
@@ -527,12 +526,13 @@ L5 [loop entry point]:
 L6 [body entry point]:
     magic(1..a|<v3>) -> <v4>                                                                 PREV:[jmp?(L3), jmp(L5 [loop entry point]), jmp?(L5 [loop entry point])]
     w(i|<v4>)
+    mark(for (i in 1..a) { 1 if (2 > 3) { continue @l } })
   5 mark({ 1 if (2 > 3) { continue @l } })
     r(1) -> <v5>
     mark(if (2 > 3) { continue @l })
-    mark(2 > 3)
     r(2) -> <v6>
     r(3) -> <v7>
+    mark(2 > 3)
     call(>, compareTo|<v6>, <v7>) -> <v8>
     jf(L7|<v8>)                                                                              NEXT:[read (Unit), mark({ continue @l })]
   6 mark({ continue @l })
@@ -586,10 +586,9 @@ L0:
     jmp?(L2 [onExceptionToFinallyBlock])                                                   NEXT:[mark({ 2 }), mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } })]
   3 mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } })
     mark(@l for (i in 1..a) { 1 if (2 > 3) { continue @l } })
-  4 mark(for (i in 1..a) { 1 if (2 > 3) { continue @l } })
-    mark(1..a)
-    r(1) -> <v1>
+  4 r(1) -> <v1>
     r(a) -> <v2>
+    mark(1..a)
     call(.., rangeTo|<v1>, <v2>) -> <v3>
     v(i)
 L4:
@@ -598,12 +597,13 @@ L5 [loop entry point]:
 L6 [body entry point]:
     magic(1..a|<v3>) -> <v4>                                                               PREV:[jmp?(L3), jmp(L5 [loop entry point]), jmp?(L5 [loop entry point])]
     w(i|<v4>)
+    mark(for (i in 1..a) { 1 if (2 > 3) { continue @l } })
   5 mark({ 1 if (2 > 3) { continue @l } })
     r(1) -> <v5>
     mark(if (2 > 3) { continue @l })
-    mark(2 > 3)
     r(2) -> <v6>
     r(3) -> <v7>
+    mark(2 > 3)
     call(>, compareTo|<v6>, <v7>) -> <v8>
     jf(L7|<v8>)                                                                            NEXT:[read (Unit), mark({ continue @l })]
   6 mark({ continue @l })
@@ -691,22 +691,22 @@ L0:
     r(1) -> <v0>
 L3 [start finally]:
   4 mark({ doSmth(3) })
-    mark(doSmth(3))
     r(3) -> <v1>
+    mark(doSmth(3))
     call(doSmth, doSmth|<v1>) -> <v2>
 L4 [finish finally]:
   3 ret(*|<v0>) L1                                      NEXT:[<END>]
 - 2 jmp(L5 [skipFinallyToErrorBlock])                   NEXT:[mark({ doSmth(3) })]                                 PREV:[]
 L2 [onExceptionToFinallyBlock]:
   4 mark({ doSmth(3) })                                 PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
-    mark(doSmth(3))
     r(3) -> <v1>
+    mark(doSmth(3))
     call(doSmth, doSmth|<v1>) -> <v2>
   2 jmp(error)                                          NEXT:[<ERROR>]
 L5 [skipFinallyToErrorBlock]:
 - 4 mark({ doSmth(3) })                                 PREV:[]
--   mark(doSmth(3))                                     PREV:[]
 -   r(3) -> <v1>                                        PREV:[]
+-   mark(doSmth(3))                                     PREV:[]
 -   call(doSmth, doSmth|<v1>) -> <v2>                   PREV:[]
 L1:
   1 <END>                                               NEXT:[<SINK>]                                              PREV:[ret(*|<v0>) L1]
@@ -738,8 +738,8 @@ L0:
     r(1) -> <v0>
 L4 [start finally]:
   4 mark({ doSmth(3) })
-    mark(doSmth(3))
     r(3) -> <v1>
+    mark(doSmth(3))
     call(doSmth, doSmth|<v1>) -> <v2>
 L5 [finish finally]:
   3 ret(*|<v0>) L1                                                                                             NEXT:[<END>]
@@ -749,22 +749,22 @@ L2 [onException]:
     magic(e: UnsupportedOperationException) -> <v3>
     w(e|<v3>)
   4 mark({ doSmth(2) })
-    mark(doSmth(2))
     r(2) -> <v4>
+    mark(doSmth(2))
     call(doSmth, doSmth|<v4>) -> <v5>
   3 jmp(L6 [afterCatches])
 L6 [afterCatches]:
   2 jmp(L7 [skipFinallyToErrorBlock])                                                                          NEXT:[mark({ doSmth(3) })]
 L3 [onExceptionToFinallyBlock]:
   4 mark({ doSmth(3) })                                                                                        PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
-    mark(doSmth(3))
     r(3) -> <v1>
+    mark(doSmth(3))
     call(doSmth, doSmth|<v1>) -> <v2>
   2 jmp(error)                                                                                                 NEXT:[<ERROR>]
 L7 [skipFinallyToErrorBlock]:
   4 mark({ doSmth(3) })                                                                                        PREV:[jmp(L7 [skipFinallyToErrorBlock])]
-    mark(doSmth(3))
     r(3) -> <v1>
+    mark(doSmth(3))
     call(doSmth, doSmth|<v1>) -> <v2>
 L1:
   1 <END>                                                                                                      NEXT:[<SINK>]                                                                                                     PREV:[ret(*|<v0>) L1, call(doSmth, doSmth|<v1>) -> <v2>]
@@ -797,8 +797,8 @@ L2 [onException]:
     magic(e: UnsupportedOperationException) -> <v1>
     w(e|<v1>)
   4 mark({ doSmth(2) })
-    mark(doSmth(2))
     r(2) -> <v2>
+    mark(doSmth(2))
     call(doSmth, doSmth|<v2>) -> <v3>
   3 jmp(L3 [afterCatches])
 L1:
@@ -832,8 +832,8 @@ L0:
     r(1) -> <v0>
 L4 [start finally]:
   4 mark({ doSmth(3) })
-    mark(doSmth(3))
     r(3) -> <v1>
+    mark(doSmth(3))
     call(doSmth, doSmth|<v1>) -> <v2>
 L5 [finish finally]:
   3 ret(*|<v0>) L1                                                                                            NEXT:[<END>]
@@ -845,8 +845,8 @@ L2 [onException]:
   4 mark({ return 2 })
     r(2) -> <v4>
     mark({ doSmth(3) })
-    mark(doSmth(3))
     r(3) -> <v1>
+    mark(doSmth(3))
     call(doSmth, doSmth|<v1>) -> <v2>
     ret(*|<v4>) L1                                                                                            NEXT:[<END>]
 - 3 jmp(L6 [afterCatches])                                                                                    PREV:[]
@@ -854,14 +854,14 @@ L6 [afterCatches]:
 - 2 jmp(L7 [skipFinallyToErrorBlock])                                                                         NEXT:[mark({ doSmth(3) })]                                                                                       PREV:[]
 L3 [onExceptionToFinallyBlock]:
   4 mark({ doSmth(3) })                                                                                       PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
-    mark(doSmth(3))
     r(3) -> <v1>
+    mark(doSmth(3))
     call(doSmth, doSmth|<v1>) -> <v2>
   2 jmp(error)                                                                                                NEXT:[<ERROR>]
 L7 [skipFinallyToErrorBlock]:
 - 4 mark({ doSmth(3) })                                                                                       PREV:[]
--   mark(doSmth(3))                                                                                           PREV:[]
 -   r(3) -> <v1>                                                                                              PREV:[]
+-   mark(doSmth(3))                                                                                           PREV:[]
 -   call(doSmth, doSmth|<v1>) -> <v2>                                                                         PREV:[]
 L1:
   1 <END>                                                                                                     NEXT:[<SINK>]                                                                                                    PREV:[ret(*|<v0>) L1, ret(*|<v4>) L1]
@@ -890,8 +890,8 @@ L0:
     jmp?(L2 [onException])                                                                                     NEXT:[v(e: UnsupportedOperationException), jmp?(L3 [onExceptionToFinallyBlock])]
     jmp?(L3 [onExceptionToFinallyBlock])                                                                       NEXT:[mark({ doSmth(3) }), mark({ doSmth(1) })]
   3 mark({ doSmth(1) })
-    mark(doSmth(1))
     r(1) -> <v0>
+    mark(doSmth(1))
     call(doSmth, doSmth|<v0>) -> <v1>
   2 jmp(L4 [afterCatches])                                                                                     NEXT:[jmp(L7 [skipFinallyToErrorBlock])]
 L2 [onException]:
@@ -902,8 +902,8 @@ L2 [onException]:
     r(2) -> <v3>
 L5 [start finally]:
   5 mark({ doSmth(3) })
-    mark(doSmth(3))
     r(3) -> <v4>
+    mark(doSmth(3))
     call(doSmth, doSmth|<v4>) -> <v5>
 L6 [finish finally]:
   4 ret(*|<v3>) L1                                                                                             NEXT:[<END>]
@@ -912,14 +912,14 @@ L4 [afterCatches]:
   2 jmp(L7 [skipFinallyToErrorBlock])                                                                          NEXT:[mark({ doSmth(3) })]                                                                                        PREV:[jmp(L4 [afterCatches])]
 L3 [onExceptionToFinallyBlock]:
   5 mark({ doSmth(3) })                                                                                        PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
-    mark(doSmth(3))
     r(3) -> <v4>
+    mark(doSmth(3))
     call(doSmth, doSmth|<v4>) -> <v5>
   2 jmp(error)                                                                                                 NEXT:[<ERROR>]
 L7 [skipFinallyToErrorBlock]:
   5 mark({ doSmth(3) })                                                                                        PREV:[jmp(L7 [skipFinallyToErrorBlock])]
-    mark(doSmth(3))
     r(3) -> <v4>
+    mark(doSmth(3))
     call(doSmth, doSmth|<v4>) -> <v5>
 L1:
   1 <END>                                                                                                      NEXT:[<SINK>]                                                                                                     PREV:[ret(*|<v3>) L1, call(doSmth, doSmth|<v4>) -> <v5>]
diff --git a/compiler/testData/cfg/controlStructures/FinallyTestCopy.instructions b/compiler/testData/cfg/controlStructures/FinallyTestCopy.instructions
index 10fc552489d..1fab4a10d8b 100644
--- a/compiler/testData/cfg/controlStructures/FinallyTestCopy.instructions
+++ b/compiler/testData/cfg/controlStructures/FinallyTestCopy.instructions
@@ -140,11 +140,11 @@ fun testCopy2() {
 L0:
   1 <START>
   2 mark({ while (cond()) { try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } } })
-    mark(while (cond()) { try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } })
 L2 [loop entry point]:
 L5 [condition entry point]:
-    mark(cond())                                                                                                                                                                      PREV:[mark(while (cond()) { try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } }), jmp(L2 [loop entry point]), jmp(L2 [loop entry point])]
+    mark(cond())                                                                                                                                                                      PREV:[mark({ while (cond()) { try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } } }), jmp(L2 [loop entry point]), jmp(L2 [loop entry point])]
     call(cond, cond) -> <v0>
+    mark(while (cond()) { try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } })
     jf(L3 [loop exit point]|<v0>)                                                                                                                                                     NEXT:[read (Unit), mark({ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } })]
 L4 [body entry point]:
   3 mark({ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } })
@@ -256,11 +256,11 @@ L4 [afterCatches]:
 L3 [onExceptionToFinallyBlock]:
 L7 [start finally]:
   3 mark({ while (cond()); })                                                                                                                                        PREV:[jmp?(L3 [onExceptionToFinallyBlock])]
-    mark(while (cond()))
 L8 [loop entry point]:
 L11 [condition entry point]:
-    mark(cond())                                                                                                                                                     PREV:[mark(while (cond())), jmp(L8 [loop entry point])]
+    mark(cond())                                                                                                                                                     PREV:[mark({ while (cond()); }), jmp(L8 [loop entry point])]
     call(cond, cond) -> <v5>
+    mark(while (cond()))
     jf(L9 [loop exit point]|<v5>)                                                                                                                                    NEXT:[read (Unit), jmp(L8 [loop entry point])]
 L10 [body entry point]:
     jmp(L8 [loop entry point])                                                                                                                                       NEXT:[mark(cond())]
@@ -270,9 +270,9 @@ L12 [finish finally]:
   2 jmp(error)                                                                                                                                                       NEXT:[<ERROR>]
 L6 [skipFinallyToErrorBlock]:
   3 mark({ while (cond()); })                                                                                                                                        PREV:[jmp(L6 [skipFinallyToErrorBlock])]
-    mark(while (cond()))
-    mark(cond())                                                                                                                                                     PREV:[mark(while (cond())), jmp(copy L8 [loop entry point])]
+    mark(cond())                                                                                                                                                     PREV:[mark({ while (cond()); }), jmp(copy L8 [loop entry point])]
     call(cond, cond) -> <v5>
+    mark(while (cond()))
     jf(copy L9 [loop exit point]|<v5>)                                                                                                                               NEXT:[read (Unit), jmp(copy L8 [loop entry point])]
     jmp(copy L8 [loop entry point])                                                                                                                                  NEXT:[mark(cond())]
     read (Unit)                                                                                                                                                      PREV:[jf(copy L9 [loop exit point]|<v5>)]
@@ -311,9 +311,9 @@ L2 [onExceptionToFinallyBlock]:
 L4 [start finally]:
   3 mark({ if(list != null) { } })                                 PREV:[jmp?(L2 [onExceptionToFinallyBlock])]
     mark(if(list != null) { })
-    mark(list != null)
     r(list) -> <v2>
     r(null) -> <v3>
+    mark(list != null)
     call(!=, equals|<v2>, <v3>) -> <v4>
     jf(L5|<v4>)                                                    NEXT:[read (Unit), mark({ })]
   4 mark({ })
@@ -327,9 +327,9 @@ L7 [finish finally]:
 L3 [skipFinallyToErrorBlock]:
   3 mark({ if(list != null) { } })                                 PREV:[jmp(L3 [skipFinallyToErrorBlock])]
     mark(if(list != null) { })
-    mark(list != null)
     r(list) -> <v2>
     r(null) -> <v3>
+    mark(list != null)
     call(!=, equals|<v2>, <v3>) -> <v4>
     jf(copy L5|<v4>)                                               NEXT:[read (Unit), mark({ })]
   4 mark({ })
diff --git a/compiler/testData/cfg/controlStructures/For.instructions b/compiler/testData/cfg/controlStructures/For.instructions
index 4ef25287833..399d662f15f 100644
--- a/compiler/testData/cfg/controlStructures/For.instructions
+++ b/compiler/testData/cfg/controlStructures/For.instructions
@@ -8,10 +8,9 @@ fun t1() {
 L0:
   1 <START>
   2 mark({ for (i in 1..2) { doSmth(i) } })
-  3 mark(for (i in 1..2) { doSmth(i) })
-    mark(1..2)
-    r(1) -> <v0>
+  3 r(1) -> <v0>
     r(2) -> <v1>
+    mark(1..2)
     call(.., rangeTo|<v0>, <v1>) -> <v2>
     v(i)
 L3:
@@ -20,9 +19,10 @@ L4 [loop entry point]:
 L5 [body entry point]:
     magic(1..2|<v2>) -> <v3>                   PREV:[jmp?(L2), jmp?(L4 [loop entry point])]
     w(i|<v3>)
+    mark(for (i in 1..2) { doSmth(i) })
   4 mark({ doSmth(i) })
-    mark(doSmth(i))
     r(i) -> <v4>
+    mark(doSmth(i))
     call(doSmth, doSmth|<v4>) -> <v5>
   3 jmp?(L4 [loop entry point])                NEXT:[magic(1..2|<v2>) -> <v3>, read (Unit)]
 L2:
diff --git a/compiler/testData/cfg/controlStructures/If.instructions b/compiler/testData/cfg/controlStructures/If.instructions
index c99cbe8b258..3393470ce8a 100644
--- a/compiler/testData/cfg/controlStructures/If.instructions
+++ b/compiler/testData/cfg/controlStructures/If.instructions
@@ -30,12 +30,12 @@ L0:
     mark("s")
     r("s") -> <v2>
     w(u|<v2>)
-  2 jmp(L3)                                                                                                             NEXT:[mark(doSmth(u))]
+  2 jmp(L3)                                                                                                             NEXT:[r(u) -> <v3>]
 L2:
     read (Unit)                                                                                                         PREV:[jf(L2|<v1>)]
 L3:
-    mark(doSmth(u))                                                                                                     PREV:[jmp(L3), read (Unit)]
-    r(u) -> <v3>
+    r(u) -> <v3>                                                                                                        PREV:[jmp(L3), read (Unit)]
+    mark(doSmth(u))
     call(doSmth, doSmth|<v3>) -> <v4>
     v(var r: String)
     mark(if (b) { r = "s" } else { r = "t" })
@@ -45,15 +45,15 @@ L3:
     mark("s")
     r("s") -> <v6>
     w(r|<v6>)
-  2 jmp(L5)                                                                                                             NEXT:[mark(doSmth(r))]
+  2 jmp(L5)                                                                                                             NEXT:[r(r) -> <v8>]
 L4:
   3 mark({ r = "t" })                                                                                                   PREV:[jf(L4|<v5>)]
     mark("t")
     r("t") -> <v7>
     w(r|<v7>)
 L5:
-  2 mark(doSmth(r))                                                                                                     PREV:[jmp(L5), w(r|<v7>)]
-    r(r) -> <v8>
+  2 r(r) -> <v8>                                                                                                        PREV:[jmp(L5), w(r|<v7>)]
+    mark(doSmth(r))
     call(doSmth, doSmth|<v8>) -> <v9>
 L1:
   1 <END>                                                                                                               NEXT:[<SINK>]
@@ -88,12 +88,12 @@ L0:
     jf(L2|<v2>)                                                                   NEXT:[read (Unit), mark({ return; })]
   3 mark({ return; })
     ret L1                                                                        NEXT:[<END>]
-- 2 jmp(L3)                                                                       NEXT:[mark(doSmth(i))]                                                               PREV:[]
+- 2 jmp(L3)                                                                       NEXT:[r(i) -> <v3>]                                                                  PREV:[]
 L2:
     read (Unit)                                                                   PREV:[jf(L2|<v2>)]
 L3:
-    mark(doSmth(i))
     r(i) -> <v3>
+    mark(doSmth(i))
     call(doSmth, doSmth|<v3>) -> <v4>
     mark(if (i is Int) { return; })
     mark(i is Int)
diff --git a/compiler/testData/cfg/controlStructures/OnlyWhileInFunctionBody.instructions b/compiler/testData/cfg/controlStructures/OnlyWhileInFunctionBody.instructions
index 9d727a8c2f8..452cda3860e 100644
--- a/compiler/testData/cfg/controlStructures/OnlyWhileInFunctionBody.instructions
+++ b/compiler/testData/cfg/controlStructures/OnlyWhileInFunctionBody.instructions
@@ -8,18 +8,18 @@ fun main() {
 L0:
   1 <START>
   2 mark({ while(0 > 1) { 2 } })
-    mark(while(0 > 1) { 2 })
 L2 [loop entry point]:
 L5 [condition entry point]:
-    mark(0 > 1)                              PREV:[mark(while(0 > 1) { 2 }), jmp(L2 [loop entry point])]
-    r(0) -> <v0>
+    r(0) -> <v0>                             PREV:[mark({ while(0 > 1) { 2 } }), jmp(L2 [loop entry point])]
     r(1) -> <v1>
+    mark(0 > 1)
     call(>, compareTo|<v0>, <v1>) -> <v2>
+    mark(while(0 > 1) { 2 })
     jf(L3 [loop exit point]|<v2>)            NEXT:[read (Unit), mark({ 2 })]
 L4 [body entry point]:
   3 mark({ 2 })
     r(2) -> <v3>
-  2 jmp(L2 [loop entry point])               NEXT:[mark(0 > 1)]
+  2 jmp(L2 [loop entry point])               NEXT:[r(0) -> <v0>]
 L3 [loop exit point]:
     read (Unit)                              PREV:[jf(L3 [loop exit point]|<v2>)]
 L1:
@@ -44,9 +44,9 @@ L4 [body entry point]:
     mark({return})
     ret L1                                   NEXT:[<END>]
 L5 [condition entry point]:
--   mark(0 > 1)                              PREV:[]
 -   r(0) -> <v0>                             PREV:[]
 -   r(1) -> <v1>                             PREV:[]
+-   mark(0 > 1)                              PREV:[]
 -   call(>, compareTo|<v0>, <v1>) -> <v2>    PREV:[]
 -   jt(L2 [loop entry point]|<v2>)           NEXT:[read (Unit), mark({return})]              PREV:[]
 L3 [loop exit point]:
diff --git a/compiler/testData/cfg/conventions/equals.instructions b/compiler/testData/cfg/conventions/equals.instructions
index 5151be2fd13..d8431a598c6 100644
--- a/compiler/testData/cfg/conventions/equals.instructions
+++ b/compiler/testData/cfg/conventions/equals.instructions
@@ -14,9 +14,9 @@ L0:
     w(b|<v1>)
   2 mark({ if (a == b) { } })
     mark(if (a == b) { })
-    mark(a == b)
     r(a) -> <v2>
     r(b) -> <v3>
+    mark(a == b)
     call(==, equals|<v2>, <v3>) -> <v4>
     jf(L2|<v4>)                            NEXT:[read (Unit), mark({ })]
   3 mark({ })
diff --git a/compiler/testData/cfg/conventions/incrementAtTheEnd.instructions b/compiler/testData/cfg/conventions/incrementAtTheEnd.instructions
index 7ea1808d900..030decbcc89 100644
--- a/compiler/testData/cfg/conventions/incrementAtTheEnd.instructions
+++ b/compiler/testData/cfg/conventions/incrementAtTheEnd.instructions
@@ -10,8 +10,8 @@ L0:
     v(var i = 1)
     r(1) -> <v0>
     w(i|<v0>)
-    mark(i++)
     r(i) -> <v1>
+    mark(i++)
     call(++, inc|<v1>) -> <v2>
     w(i|<v2>)
 L1:
diff --git a/compiler/testData/cfg/conventions/invoke.instructions b/compiler/testData/cfg/conventions/invoke.instructions
index cababa1643f..9c282e0116d 100644
--- a/compiler/testData/cfg/conventions/invoke.instructions
+++ b/compiler/testData/cfg/conventions/invoke.instructions
@@ -9,8 +9,8 @@ L0:
     magic(f: () -> Unit) -> <v0>
     w(f|<v0>)
   2 mark({ f() })
-    mark(f())
     r(f) -> <v1>
+    mark(f())
     call(f, invoke|<v1>) -> <v2>
 L1:
   1 <END>                           NEXT:[<SINK>]
diff --git a/compiler/testData/cfg/conventions/notEqual.instructions b/compiler/testData/cfg/conventions/notEqual.instructions
index 83685976b4b..98d8a17ae84 100644
--- a/compiler/testData/cfg/conventions/notEqual.instructions
+++ b/compiler/testData/cfg/conventions/notEqual.instructions
@@ -13,9 +13,9 @@ L0:
     w(b|<v1>)
   2 mark({ if (a != b) {} })
     mark(if (a != b) {})
-    mark(a != b)
     r(a) -> <v2>
     r(b) -> <v3>
+    mark(a != b)
     call(!=, equals|<v2>, <v3>) -> <v4>
     jf(L2|<v4>)                            NEXT:[read (Unit), mark({})]
   3 mark({})
diff --git a/compiler/testData/cfg/deadCode/returnInElvis.instructions b/compiler/testData/cfg/deadCode/returnInElvis.instructions
index dc75bf6ae3f..a8837e2cd21 100644
--- a/compiler/testData/cfg/deadCode/returnInElvis.instructions
+++ b/compiler/testData/cfg/deadCode/returnInElvis.instructions
@@ -7,6 +7,7 @@ L0:
   1 <START>
   2 mark({ return ?: null })
     ret L1                      NEXT:[<END>]
+-   mark(return ?: null)        PREV:[]
 -   jt(L2)                      NEXT:[r(null) -> <v0>, <END>]      PREV:[]
 -   r(null) -> <v0>             PREV:[]
 L1:
diff --git a/compiler/testData/cfg/declarations/local/ObjectExpression.instructions b/compiler/testData/cfg/declarations/local/ObjectExpression.instructions
index 806b47a8c84..11cf0c848e9 100644
--- a/compiler/testData/cfg/declarations/local/ObjectExpression.instructions
+++ b/compiler/testData/cfg/declarations/local/ObjectExpression.instructions
@@ -70,8 +70,8 @@ L0:
     r(object : A by b {}) -> <v2>
     w(o|<v2>)
     mark(o.foo())
-    mark(foo())
     r(o) -> <v3>
+    mark(foo())
     call(foo, foo|<v3>) -> <v4>
     ret(*|<v4>) L1
 L1:
diff --git a/compiler/testData/cfg/declarations/properties/backingFieldQualifiedWithThis.instructions b/compiler/testData/cfg/declarations/properties/backingFieldQualifiedWithThis.instructions
index 7f0b2a4f09d..2f8dbad732c 100644
--- a/compiler/testData/cfg/declarations/properties/backingFieldQualifiedWithThis.instructions
+++ b/compiler/testData/cfg/declarations/properties/backingFieldQualifiedWithThis.instructions
@@ -19,12 +19,12 @@ fun foo() = "foo" + this.$bar
 ---------------------
 L0:
   1 <START>
-    mark("foo" + this.$bar)
     mark("foo")
     r("foo") -> <v0>
     mark(this.$bar)
     r(this) -> <v1>
     r($bar|<v1>) -> <v2>
+    mark("foo" + this.$bar)
     call(+, plus|<v0>, <v2>) -> <v3>
 L1:
     <END>                               NEXT:[<SINK>]
diff --git a/compiler/testData/cfg/expressions/Assignments.instructions b/compiler/testData/cfg/expressions/Assignments.instructions
index f2c24747477..a9368b3d1f3 100644
--- a/compiler/testData/cfg/expressions/Assignments.instructions
+++ b/compiler/testData/cfg/expressions/Assignments.instructions
@@ -37,9 +37,9 @@ L0:
     w(x|<v0>)
     r(2) -> <v1>
     w(x|<v1>)
-    mark(x += 2)
     r(x) -> <v2>
     r(2) -> <v3>
+    mark(x += 2)
     call(+=, plus|<v2>, <v3>) -> <v4>
     w(x|<v4>)
     mark(if (true) 1 else 2)
@@ -73,11 +73,11 @@ L5:
     r(t) -> <v16>
     r(1) -> <v17>
     w(t.x|<v16>, <v17>)
-    mark(t.x += 1)
     mark(t.x)
     r(t) -> <v18>
     r(x|<v18>) -> <v19>
     r(1) -> <v20>
+    mark(t.x += 1)
     call(+=, plus|<v19>, <v20>) -> <v21>
     r(t) -> <v22>
     w(t.x|<v22>, <v21>)
diff --git a/compiler/testData/cfg/expressions/chainedQualifiedExpression.instructions b/compiler/testData/cfg/expressions/chainedQualifiedExpression.instructions
index dd79aa7acbc..427a9c29ff2 100644
--- a/compiler/testData/cfg/expressions/chainedQualifiedExpression.instructions
+++ b/compiler/testData/cfg/expressions/chainedQualifiedExpression.instructions
@@ -65,158 +65,158 @@ L0:
     r(1.0) -> <v0>
     w(inTopLevel|<v0>)
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel) .add(OBJECT_KEYWORD, unresolvedCode) .registerAll())
-    mark(registerAll())
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel) .add(OBJECT_KEYWORD, unresolvedCode))
-    mark(add(OBJECT_KEYWORD, unresolvedCode))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel))
-    mark(add(OUT_KEYWORD, inTopLevel))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel))
-    mark(add(IN_KEYWORD, inTopLevel, inTopLevel))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel))
-    mark(add(OVERRIDE_KEYWORD, inTopLevel))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel))
-    mark(add(PACKAGE_KEYWORD, inTopLevel))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel))
-    mark(add(IMPORT_KEYWORD, inTopLevel))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
-    mark(add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
-    mark(add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
-    mark(add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
-    mark(add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
-    mark(add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
-    mark(add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
-    mark(add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
-    mark(add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
-    mark(add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel))
-    mark(add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel))
-    mark(add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel))
-    mark(add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel))
-    mark(add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
-    mark(add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
-    mark(add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     mark(BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
-    mark(add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
-    mark(BunchKeywordRegister())
     magic(BunchKeywordRegister()) -> <v1>
+    mark(BunchKeywordRegister())
     call(BunchKeywordRegister, <init>|<v1>) -> <v2>
     r(ABSTRACT_KEYWORD) -> <v3>
     r(inTopLevel) -> <v4>
     r(inTopLevel) -> <v5>
     r(inTopLevel) -> <v6>
+    mark(add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     call(add, add|<v2>, <v3>, <v4>, <v5>, <v6>) -> <v7>
     r(FINAL_KEYWORD) -> <v8>
     r(inTopLevel) -> <v9>
     r(inTopLevel) -> <v10>
     r(inTopLevel) -> <v11>
+    mark(add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     call(add, add|<v7>, <v8>, <v9>, <v10>, <v11>) -> <v12>
     r(OPEN_KEYWORD) -> <v13>
     r(inTopLevel) -> <v14>
     r(inTopLevel) -> <v15>
     r(inTopLevel) -> <v16>
+    mark(add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     call(add, add|<v12>, <v13>, <v14>, <v15>, <v16>) -> <v17>
     r(INTERNAL_KEYWORD) -> <v18>
     r(inTopLevel) -> <v19>
     r(inTopLevel) -> <v20>
     r(inTopLevel) -> <v21>
     r(inTopLevel) -> <v22>
+    mark(add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel))
     call(add, add|<v17>, <v18>, <v19>, <v20>, <v21>, <v22>) -> <v23>
     r(PRIVATE_KEYWORD) -> <v24>
     r(inTopLevel) -> <v25>
     r(inTopLevel) -> <v26>
     r(inTopLevel) -> <v27>
     r(inTopLevel) -> <v28>
+    mark(add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel))
     call(add, add|<v23>, <v24>, <v25>, <v26>, <v27>, <v28>) -> <v29>
     r(PROTECTED_KEYWORD) -> <v30>
     r(inTopLevel) -> <v31>
     r(inTopLevel) -> <v32>
     r(inTopLevel) -> <v33>
     r(inTopLevel) -> <v34>
+    mark(add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel))
     call(add, add|<v29>, <v30>, <v31>, <v32>, <v33>, <v34>) -> <v35>
     r(PUBLIC_KEYWORD) -> <v36>
     r(inTopLevel) -> <v37>
     r(inTopLevel) -> <v38>
     r(inTopLevel) -> <v39>
     r(inTopLevel) -> <v40>
+    mark(add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel))
     call(add, add|<v35>, <v36>, <v37>, <v38>, <v39>, <v40>) -> <v41>
     r(CLASS_KEYWORD) -> <v42>
     r(inTopLevel) -> <v43>
     r(inTopLevel) -> <v44>
     r(inTopLevel) -> <v45>
+    mark(add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     call(add, add|<v41>, <v42>, <v43>, <v44>, <v45>) -> <v46>
     r(ENUM_KEYWORD) -> <v47>
     r(inTopLevel) -> <v48>
     r(inTopLevel) -> <v49>
     r(inTopLevel) -> <v50>
+    mark(add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     call(add, add|<v46>, <v47>, <v48>, <v49>, <v50>) -> <v51>
     r(FUN_KEYWORD) -> <v52>
     r(inTopLevel) -> <v53>
     r(inTopLevel) -> <v54>
     r(inTopLevel) -> <v55>
+    mark(add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     call(add, add|<v51>, <v52>, <v53>, <v54>, <v55>) -> <v56>
     r(GET_KEYWORD) -> <v57>
     r(inTopLevel) -> <v58>
     r(inTopLevel) -> <v59>
     r(inTopLevel) -> <v60>
+    mark(add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     call(add, add|<v56>, <v57>, <v58>, <v59>, <v60>) -> <v61>
     r(SET_KEYWORD) -> <v62>
     r(inTopLevel) -> <v63>
     r(inTopLevel) -> <v64>
     r(inTopLevel) -> <v65>
+    mark(add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     call(add, add|<v61>, <v62>, <v63>, <v64>, <v65>) -> <v66>
     r(TRAIT_KEYWORD) -> <v67>
     r(inTopLevel) -> <v68>
     r(inTopLevel) -> <v69>
     r(inTopLevel) -> <v70>
+    mark(add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     call(add, add|<v66>, <v67>, <v68>, <v69>, <v70>) -> <v71>
     r(VAL_KEYWORD) -> <v72>
     r(inTopLevel) -> <v73>
     r(inTopLevel) -> <v74>
     r(inTopLevel) -> <v75>
+    mark(add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     call(add, add|<v71>, <v72>, <v73>, <v74>, <v75>) -> <v76>
     r(VAR_KEYWORD) -> <v77>
     r(inTopLevel) -> <v78>
     r(inTopLevel) -> <v79>
     r(inTopLevel) -> <v80>
+    mark(add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     call(add, add|<v76>, <v77>, <v78>, <v79>, <v80>) -> <v81>
     r(TYPE_KEYWORD) -> <v82>
     r(inTopLevel) -> <v83>
     r(inTopLevel) -> <v84>
     r(inTopLevel) -> <v85>
+    mark(add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel))
     call(add, add|<v81>, <v82>, <v83>, <v84>, <v85>) -> <v86>
     r(IMPORT_KEYWORD) -> <v87>
     r(inTopLevel) -> <v88>
+    mark(add(IMPORT_KEYWORD, inTopLevel))
     call(add, add|<v86>, <v87>, <v88>) -> <v89>
     r(PACKAGE_KEYWORD) -> <v90>
     r(inTopLevel) -> <v91>
+    mark(add(PACKAGE_KEYWORD, inTopLevel))
     call(add, add|<v89>, <v90>, <v91>) -> <v92>
     r(OVERRIDE_KEYWORD) -> <v93>
     r(inTopLevel) -> <v94>
+    mark(add(OVERRIDE_KEYWORD, inTopLevel))
     call(add, add|<v92>, <v93>, <v94>) -> <v95>
     r(IN_KEYWORD) -> <v96>
     r(inTopLevel) -> <v97>
     r(inTopLevel) -> <v98>
+    mark(add(IN_KEYWORD, inTopLevel, inTopLevel))
     call(add, add|<v95>, <v96>, <v97>, <v98>) -> <v99>
     r(OUT_KEYWORD) -> <v100>
     r(inTopLevel) -> <v101>
+    mark(add(OUT_KEYWORD, inTopLevel))
     call(add, add|<v99>, <v100>, <v101>) -> <v102>
     r(OBJECT_KEYWORD) -> <v103>
     error(unresolvedCode, No resolved call)
     magic(unresolvedCode) -> <v104>
+    mark(add(OBJECT_KEYWORD, unresolvedCode))
     call(add, add|<v102>, <v103>, <v104>) -> <v105>
+    mark(registerAll())
     call(registerAll, registerAll|<v105>) -> <v106>
 L1:
   1 <END>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     NEXT:[<SINK>]
diff --git a/compiler/testData/cfg/expressions/expressionAsFunction.instructions b/compiler/testData/cfg/expressions/expressionAsFunction.instructions
index 44b62d7531e..b83a5ff8b36 100644
--- a/compiler/testData/cfg/expressions/expressionAsFunction.instructions
+++ b/compiler/testData/cfg/expressions/expressionAsFunction.instructions
@@ -9,9 +9,9 @@ L0:
     magic(f: () -> Unit) -> <v0>
     w(f|<v0>)
   2 mark({ (f)() })
-    mark((f)())
     mark((f))
     r(f) -> <v1>
+    mark((f)())
     call((f), invoke|<v1>) -> <v2>
 L1:
   1 <END>                             NEXT:[<SINK>]
diff --git a/compiler/testData/cfg/expressions/nothingExpr.instructions b/compiler/testData/cfg/expressions/nothingExpr.instructions
index ad4f0bf0576..21a743f846e 100644
--- a/compiler/testData/cfg/expressions/nothingExpr.instructions
+++ b/compiler/testData/cfg/expressions/nothingExpr.instructions
@@ -38,16 +38,16 @@ L0:
   1 <START>
   2 mark({ null!!.doSomething() bar().doSomething })
     mark(null!!.doSomething())
-    mark(doSomething())
-    mark(null!!)
     r(null) -> <v0>
     magic(null!!|<v0>) -> <v1>
     jmp(error)                                          NEXT:[<ERROR>]
+-   mark(doSomething())                                 PREV:[]
 -   call(doSomething, doSomething|<v1>) -> <v2>         PREV:[]
 -   mark(bar().doSomething)                             PREV:[]
 -   mark(bar())                                         PREV:[]
 -   call(bar, bar)                                      PREV:[]
 -   jmp(error)                                          NEXT:[<ERROR>]                                             PREV:[]
+-   mark(doSomething)                                   PREV:[]
 -   call(doSomething, doSomething) -> <v3>              PREV:[]
 L1:
   1 <END>                                               NEXT:[<SINK>]                                              PREV:[]
diff --git a/compiler/testData/cfg/expressions/unresolvedCall.instructions b/compiler/testData/cfg/expressions/unresolvedCall.instructions
index 9bf196dff93..3bfc2044c02 100644
--- a/compiler/testData/cfg/expressions/unresolvedCall.instructions
+++ b/compiler/testData/cfg/expressions/unresolvedCall.instructions
@@ -10,10 +10,10 @@ L0:
     w(a|<v0>)
   2 mark({ a.foo() })
     mark(a.foo())
-    mark(foo())
     error(foo, No resolved call)
     error(foo, No resolved call)
     r(a) -> <v1>
+    mark(foo())
     magic(foo()|<v1>) -> <v2>
 L1:
   1 <END>                           NEXT:[<SINK>]
diff --git a/compiler/testData/cfg/tailCalls/sum.instructions b/compiler/testData/cfg/tailCalls/sum.instructions
index 80567d12824..ce457b14d51 100644
--- a/compiler/testData/cfg/tailCalls/sum.instructions
+++ b/compiler/testData/cfg/tailCalls/sum.instructions
@@ -14,29 +14,29 @@ L0:
     w(sum|<v1>)
   2 mark({ if (x == 0.toLong()) return sum return sum(x - 1, sum + x) })
     mark(if (x == 0.toLong()) return sum)
-    mark(x == 0.toLong())
     r(x) -> <v2>
     mark(0.toLong())
-    mark(toLong())
     r(0) -> <v3>
+    mark(toLong())
     call(toLong, toLong|<v3>) -> <v4>
+    mark(x == 0.toLong())
     call(==, equals|<v2>, <v4>) -> <v5>
     jf(L2|<v5>)                                                             NEXT:[read (Unit), r(sum) -> <v6>]
     r(sum) -> <v6>
     ret(*|<v6>) L1                                                          NEXT:[<END>]
--   jmp(L3)                                                                 NEXT:[mark(sum(x - 1, sum + x))]                                               PREV:[]
+-   jmp(L3)                                                                 NEXT:[r(x) -> <v7>]                                                            PREV:[]
 L2:
     read (Unit)                                                             PREV:[jf(L2|<v5>)]
 L3:
-    mark(sum(x - 1, sum + x))
-    mark(x - 1)
     r(x) -> <v7>
     r(1) -> <v8>
+    mark(x - 1)
     call(-, minus|<v7>, <v8>) -> <v9>
-    mark(sum + x)
     r(sum) -> <v10>
     r(x) -> <v11>
+    mark(sum + x)
     call(+, plus|<v10>, <v11>) -> <v12>
+    mark(sum(x - 1, sum + x))
     call(sum, sum|<v9>, <v12>) -> <v13>
     ret(*|<v13>) L1
 L1: