diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIrIncrementalJvmCompilerRunnerTest.kt b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIrIncrementalJvmCompilerRunnerTest.kt
new file mode 100644
index 00000000000..62c4a918525
--- /dev/null
+++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIrIncrementalJvmCompilerRunnerTest.kt
@@ -0,0 +1,16 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.incremental
+
+import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
+import java.io.File
+
+abstract class AbstractIrIncrementalJvmCompilerRunnerTest : AbstractIncrementalJvmCompilerRunnerTest() {
+    override fun createCompilerArguments(destinationDir: File, testDir: File): K2JVMCompilerArguments =
+        super.createCompilerArguments(destinationDir, testDir).apply {
+            useIR = true
+        }
+}
diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunnerTestGenerated.java
index da0fe4947e2..496a2f48cab 100644
--- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunnerTestGenerated.java
+++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunnerTestGenerated.java
@@ -24,7 +24,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
     @RunWith(JUnit3RunnerWithInners.class)
     public static class PureKotlin extends AbstractIncrementalJvmCompilerRunnerTest {
         private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
         }
 
         @TestMetadata("accessingFunctionsViaPackagePart")
@@ -63,7 +63,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         }
 
         public void testAllFilesPresentInPureKotlin() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, false);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, false);
         }
 
         @TestMetadata("annotations")
@@ -627,11 +627,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
     @RunWith(JUnit3RunnerWithInners.class)
     public static class ClassHierarchyAffected extends AbstractIncrementalJvmCompilerRunnerTest {
         private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
         }
 
         public void testAllFilesPresentInClassHierarchyAffected() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, false);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, false);
         }
 
         @TestMetadata("annotationFlagRemoved")
@@ -835,11 +835,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
     @RunWith(JUnit3RunnerWithInners.class)
     public static class InlineFunCallSite extends AbstractIncrementalJvmCompilerRunnerTest {
         private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
         }
 
         public void testAllFilesPresentInInlineFunCallSite() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
         }
 
         @TestMetadata("classProperty")
@@ -917,11 +917,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class ClassProperty extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInClassProperty() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/classProperty"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/classProperty"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
         }
 
@@ -930,11 +930,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class CompanionObjectProperty extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInCompanionObjectProperty() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/companionObjectProperty"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/companionObjectProperty"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
         }
 
@@ -943,11 +943,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Coroutine extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInCoroutine() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/coroutine"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/coroutine"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
         }
 
@@ -956,11 +956,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Function extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInFunction() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/function"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/function"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
         }
 
@@ -969,11 +969,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Getter extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInGetter() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/getter"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/getter"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
         }
 
@@ -982,11 +982,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Lambda extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInLambda() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/lambda"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/lambda"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
         }
 
@@ -995,11 +995,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class LocalFun extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInLocalFun() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/localFun"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/localFun"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
         }
 
@@ -1008,11 +1008,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Method extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInMethod() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/method"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/method"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
         }
 
@@ -1021,11 +1021,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class ParameterDefaultValue extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInParameterDefaultValue() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/parameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/parameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
         }
 
@@ -1034,11 +1034,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class PrimaryConstructorParameterDefaultValue extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInPrimaryConstructorParameterDefaultValue() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/primaryConstructorParameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/primaryConstructorParameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
         }
 
@@ -1047,11 +1047,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class SuperCall extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInSuperCall() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/superCall"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/superCall"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
         }
 
@@ -1060,11 +1060,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class ThisCall extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInThisCall() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/thisCall"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/thisCall"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
         }
 
@@ -1073,11 +1073,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class TopLevelObjectProperty extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInTopLevelObjectProperty() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/topLevelObjectProperty"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/topLevelObjectProperty"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
         }
 
@@ -1086,11 +1086,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class TopLevelProperty extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInTopLevelProperty() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/topLevelProperty"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/topLevelProperty"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
         }
     }
@@ -1100,11 +1100,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
     @RunWith(JUnit3RunnerWithInners.class)
     public static class WithJava extends AbstractIncrementalJvmCompilerRunnerTest {
         private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
         }
 
         public void testAllFilesPresentInWithJava() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
         }
 
         @TestMetadata("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin")
@@ -1112,11 +1112,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class ConvertBetweenJavaAndKotlin extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInConvertBetweenJavaAndKotlin() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("javaToKotlin")
@@ -1144,11 +1144,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class JavaToKotlin extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInJavaToKotlin() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1157,11 +1157,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class JavaToKotlinAndBack extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInJavaToKotlinAndBack() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndBack"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndBack"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1170,11 +1170,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class JavaToKotlinAndRemove extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInJavaToKotlinAndRemove() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndRemove"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndRemove"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1183,11 +1183,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class KotlinToJava extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInKotlinToJava() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/kotlinToJava"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/kotlinToJava"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
         }
@@ -1197,11 +1197,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class JavaUsedInKotlin extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInJavaUsedInKotlin() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("changeFieldType")
@@ -1304,11 +1304,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ChangeFieldType extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInChangeFieldType() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1317,11 +1317,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ChangeNotUsedSignature extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInChangeNotUsedSignature() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1330,11 +1330,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ChangePropertyOverrideType extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInChangePropertyOverrideType() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1343,11 +1343,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ChangeSignature extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInChangeSignature() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1356,11 +1356,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ChangeSignaturePackagePrivate extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInChangeSignaturePackagePrivate() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1369,11 +1369,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ChangeSignaturePackagePrivateNonRoot extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInChangeSignaturePackagePrivateNonRoot() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivateNonRoot"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivateNonRoot"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1382,11 +1382,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ChangeSignatureStatic extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInChangeSignatureStatic() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1395,11 +1395,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ConstantChanged extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInConstantChanged() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1408,11 +1408,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ConstantUnchanged extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInConstantUnchanged() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1421,11 +1421,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class EnumEntryAdded extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInEnumEntryAdded() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1434,11 +1434,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class EnumEntryRemoved extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInEnumEntryRemoved() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryRemoved"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryRemoved"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1447,11 +1447,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class JavaAndKotlinChangedSimultaneously extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInJavaAndKotlinChangedSimultaneously() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaAndKotlinChangedSimultaneously"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaAndKotlinChangedSimultaneously"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1460,11 +1460,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class JavaFieldNullabilityChanged extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInJavaFieldNullabilityChanged() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaFieldNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaFieldNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1473,11 +1473,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class JavaMethodParamNullabilityChanged extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInJavaMethodParamNullabilityChanged() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodParamNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodParamNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1486,11 +1486,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class JavaMethodReturnTypeNullabilityChanged extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInJavaMethodReturnTypeNullabilityChanged() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodReturnTypeNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodReturnTypeNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1499,11 +1499,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class MethodAddedInSuper extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInMethodAddedInSuper() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1512,11 +1512,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class MethodRenamed extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInMethodRenamed() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodRenamed"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodRenamed"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1525,11 +1525,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class MixedInheritance extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInMixedInheritance() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1538,11 +1538,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class NotChangeSignature extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInNotChangeSignature() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1551,11 +1551,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class SamConversions extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInSamConversions() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
 
                 @TestMetadata("methodAdded")
@@ -1583,11 +1583,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
                 @RunWith(JUnit3RunnerWithInners.class)
                 public static class MethodAdded extends AbstractIncrementalJvmCompilerRunnerTest {
                     private void runTest(String testDataFilePath) throws Exception {
-                        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                        KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                     }
 
                     public void testAllFilesPresentInMethodAdded() throws Exception {
-                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                     }
                 }
 
@@ -1596,11 +1596,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
                 @RunWith(JUnit3RunnerWithInners.class)
                 public static class MethodAddedSamAdapter extends AbstractIncrementalJvmCompilerRunnerTest {
                     private void runTest(String testDataFilePath) throws Exception {
-                        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                        KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                     }
 
                     public void testAllFilesPresentInMethodAddedSamAdapter() throws Exception {
-                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddedSamAdapter"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddedSamAdapter"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                     }
                 }
 
@@ -1609,11 +1609,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
                 @RunWith(JUnit3RunnerWithInners.class)
                 public static class MethodSignatureChanged extends AbstractIncrementalJvmCompilerRunnerTest {
                     private void runTest(String testDataFilePath) throws Exception {
-                        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                        KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                     }
 
                     public void testAllFilesPresentInMethodSignatureChanged() throws Exception {
-                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                     }
                 }
 
@@ -1622,11 +1622,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
                 @RunWith(JUnit3RunnerWithInners.class)
                 public static class MethodSignatureChangedSamAdapter extends AbstractIncrementalJvmCompilerRunnerTest {
                     private void runTest(String testDataFilePath) throws Exception {
-                        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                        KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                     }
 
                     public void testAllFilesPresentInMethodSignatureChangedSamAdapter() throws Exception {
-                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChangedSamAdapter"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChangedSamAdapter"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                     }
                 }
             }
@@ -1637,7 +1637,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class KotlinUsedInJava extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             @TestMetadata("addOptionalParameter")
@@ -1646,7 +1646,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             }
 
             public void testAllFilesPresentInKotlinUsedInJava() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("changeNotUsedSignature")
@@ -1719,11 +1719,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class AddOptionalParameter extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInAddOptionalParameter() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/addOptionalParameter"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/addOptionalParameter"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1732,11 +1732,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ChangeNotUsedSignature extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInChangeNotUsedSignature() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1745,11 +1745,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ChangeSignature extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInChangeSignature() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeSignature"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeSignature"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1758,11 +1758,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ConstantChanged extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInConstantChanged() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1771,11 +1771,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ConstantUnchanged extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInConstantUnchanged() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1784,11 +1784,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class FunRenamed extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInFunRenamed() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/funRenamed"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/funRenamed"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1797,11 +1797,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class JvmFieldChanged extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInJvmFieldChanged() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1810,11 +1810,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class JvmFieldUnchanged extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInJvmFieldUnchanged() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldUnchanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldUnchanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1823,11 +1823,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class MethodAddedInSuper extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInMethodAddedInSuper() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1836,11 +1836,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class NotChangeSignature extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInNotChangeSignature() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1849,11 +1849,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class OnlyTopLevelFunctionInFileRemoved extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInOnlyTopLevelFunctionInFileRemoved() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/onlyTopLevelFunctionInFileRemoved"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/onlyTopLevelFunctionInFileRemoved"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1862,11 +1862,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class PackageFileAdded extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInPackageFileAdded() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/packageFileAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/packageFileAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1875,11 +1875,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class PrivateChanges extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInPrivateChanges() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/privateChanges"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/privateChanges"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -1888,11 +1888,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class PropertyRenamed extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInPropertyRenamed() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/propertyRenamed"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/propertyRenamed"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
         }
@@ -1902,7 +1902,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Other extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             @TestMetadata("accessingFunctionsViaRenamedFileClass")
@@ -1911,7 +1911,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             }
 
             public void testAllFilesPresentInOther() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("allKotlinFilesRemovedThenNewAdded")
@@ -2059,11 +2059,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class AccessingFunctionsViaRenamedFileClass extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInAccessingFunctionsViaRenamedFileClass() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/accessingFunctionsViaRenamedFileClass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/accessingFunctionsViaRenamedFileClass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2072,11 +2072,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class AllKotlinFilesRemovedThenNewAdded extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInAllKotlinFilesRemovedThenNewAdded() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/allKotlinFilesRemovedThenNewAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/allKotlinFilesRemovedThenNewAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2085,11 +2085,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ClassRedeclaration extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInClassRedeclaration() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/classRedeclaration"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/classRedeclaration"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2098,11 +2098,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ClassToPackageFacade extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInClassToPackageFacade() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/classToPackageFacade"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/classToPackageFacade"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2111,11 +2111,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ConflictingPlatformDeclarations extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInConflictingPlatformDeclarations() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/conflictingPlatformDeclarations"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/conflictingPlatformDeclarations"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2124,11 +2124,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class DefaultValueInConstructorAdded extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInDefaultValueInConstructorAdded() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/defaultValueInConstructorAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/defaultValueInConstructorAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2137,11 +2137,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class InlineTopLevelFunctionWithJvmName extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInInlineTopLevelFunctionWithJvmName() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineTopLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineTopLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2150,11 +2150,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class InlineTopLevelValPropertyWithJvmName extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInInlineTopLevelValPropertyWithJvmName() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineTopLevelValPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineTopLevelValPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2163,11 +2163,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class InnerClassNotGeneratedWhenRebuilding extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInInnerClassNotGeneratedWhenRebuilding() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/innerClassNotGeneratedWhenRebuilding"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/innerClassNotGeneratedWhenRebuilding"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2176,11 +2176,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class JvmNameChanged extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInJvmNameChanged() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/jvmNameChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/jvmNameChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2189,11 +2189,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class MainRedeclaration extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInMainRedeclaration() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/mainRedeclaration"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/mainRedeclaration"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2202,11 +2202,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class MultifileClassAddTopLevelFunWithDefault extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInMultifileClassAddTopLevelFunWithDefault() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassAddTopLevelFunWithDefault"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassAddTopLevelFunWithDefault"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2215,11 +2215,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class MultifileClassFileAdded extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInMultifileClassFileAdded() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2228,11 +2228,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class MultifileClassFileChanged extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInMultifileClassFileChanged() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2241,11 +2241,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class MultifileClassFileMovedToAnotherMultifileClass extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInMultifileClassFileMovedToAnotherMultifileClass() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileMovedToAnotherMultifileClass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileMovedToAnotherMultifileClass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2254,11 +2254,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class MultifileClassInlineFunction extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInMultifileClassInlineFunction() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunction"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunction"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2267,11 +2267,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class MultifileClassInlineFunctionAccessingField extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInMultifileClassInlineFunctionAccessingField() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunctionAccessingField"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunctionAccessingField"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2280,11 +2280,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class MultifileClassRecreated extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInMultifileClassRecreated() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRecreated"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRecreated"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2293,11 +2293,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class MultifileClassRecreatedAfterRenaming extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInMultifileClassRecreatedAfterRenaming() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRecreatedAfterRenaming"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRecreatedAfterRenaming"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2306,11 +2306,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class MultifileClassRemoved extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInMultifileClassRemoved() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRemoved"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRemoved"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2319,11 +2319,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class MultifilePackagePartMethodAdded extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInMultifilePackagePartMethodAdded() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifilePackagePartMethodAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifilePackagePartMethodAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2332,11 +2332,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class MultifilePartsWithProperties extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInMultifilePartsWithProperties() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifilePartsWithProperties"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifilePartsWithProperties"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2345,11 +2345,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class OptionalParameter extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInOptionalParameter() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/optionalParameter"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/optionalParameter"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2358,11 +2358,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class PackageFacadeToClass extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInPackageFacadeToClass() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageFacadeToClass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageFacadeToClass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2371,11 +2371,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class PackageMultifileClassOneFileWithPublicChanges extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInPackageMultifileClassOneFileWithPublicChanges() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageMultifileClassOneFileWithPublicChanges"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageMultifileClassOneFileWithPublicChanges"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2384,11 +2384,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class PackageMultifileClassPrivateOnlyChanged extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInPackageMultifileClassPrivateOnlyChanged() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageMultifileClassPrivateOnlyChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageMultifileClassPrivateOnlyChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2397,11 +2397,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class PublicPropertyWithPrivateSetterMultiFileFacade extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInPublicPropertyWithPrivateSetterMultiFileFacade() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/publicPropertyWithPrivateSetterMultiFileFacade"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/publicPropertyWithPrivateSetterMultiFileFacade"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2410,11 +2410,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class TopLevelFunctionWithJvmName extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInTopLevelFunctionWithJvmName() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/topLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/topLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
 
@@ -2423,11 +2423,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
             @RunWith(JUnit3RunnerWithInners.class)
             public static class TopLevelPropertyWithJvmName extends AbstractIncrementalJvmCompilerRunnerTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInTopLevelPropertyWithJvmName() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/topLevelPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/topLevelPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
                 }
             }
         }
@@ -2438,7 +2438,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
     @RunWith(JUnit3RunnerWithInners.class)
     public static class IncrementalJvmCompilerOnly extends AbstractIncrementalJvmCompilerRunnerTest {
         private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
         }
 
         @TestMetadata("addAnnotationToJavaClass")
@@ -2452,7 +2452,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         }
 
         public void testAllFilesPresentInIncrementalJvmCompilerOnly() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
         }
 
         @TestMetadata("changeAnnotationInJavaClass")
@@ -2465,11 +2465,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class AddAnnotationToJavaClass extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInAddAnnotationToJavaClass() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
         }
 
@@ -2478,11 +2478,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class AddNestedClass extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInAddNestedClass() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
         }
 
@@ -2491,11 +2491,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
         @RunWith(JUnit3RunnerWithInners.class)
         public static class ChangeAnnotationInJavaClass extends AbstractIncrementalJvmCompilerRunnerTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInChangeAnnotationInJavaClass() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM, true);
             }
         }
     }
diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IrIncrementalJvmCompilerRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IrIncrementalJvmCompilerRunnerTestGenerated.java
new file mode 100644
index 00000000000..6a1d997f62a
--- /dev/null
+++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IrIncrementalJvmCompilerRunnerTestGenerated.java
@@ -0,0 +1,2502 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.incremental;
+
+import com.intellij.testFramework.TestDataPath;
+import org.jetbrains.kotlin.test.JUnit3RunnerWithInners;
+import org.jetbrains.kotlin.test.KotlinTestUtils;
+import org.jetbrains.kotlin.test.TargetBackend;
+import org.jetbrains.kotlin.test.TestMetadata;
+import org.junit.runner.RunWith;
+
+import java.io.File;
+import java.util.regex.Pattern;
+
+/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */
+@SuppressWarnings("all")
+@RunWith(JUnit3RunnerWithInners.class)
+public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncrementalJvmCompilerRunnerTest {
+    @TestMetadata("jps-plugin/testData/incremental/pureKotlin")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class PureKotlin extends AbstractIrIncrementalJvmCompilerRunnerTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+        }
+
+        @TestMetadata("accessingFunctionsViaPackagePart")
+        public void testAccessingFunctionsViaPackagePart() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/accessingFunctionsViaPackagePart/");
+        }
+
+        @TestMetadata("accessingPropertiesViaField")
+        public void testAccessingPropertiesViaField() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/accessingPropertiesViaField/");
+        }
+
+        @TestMetadata("addClass")
+        public void testAddClass() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/addClass/");
+        }
+
+        @TestMetadata("addFileWithFunctionOverload")
+        public void testAddFileWithFunctionOverload() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/addFileWithFunctionOverload/");
+        }
+
+        @TestMetadata("addMemberTypeAlias")
+        public void testAddMemberTypeAlias() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/addMemberTypeAlias/");
+        }
+
+        @TestMetadata("addTopLevelTypeAlias")
+        public void testAddTopLevelTypeAlias() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/addTopLevelTypeAlias/");
+        }
+
+        @TestMetadata("allConstants")
+        public void testAllConstants() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/allConstants/");
+        }
+
+        public void testAllFilesPresentInPureKotlin() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, false);
+        }
+
+        @TestMetadata("annotations")
+        public void testAnnotations() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/annotations/");
+        }
+
+        @TestMetadata("anonymousObjectChanged")
+        public void testAnonymousObjectChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/anonymousObjectChanged/");
+        }
+
+        @TestMetadata("changeTypeImplicitlyWithCircularDependency")
+        public void testChangeTypeImplicitlyWithCircularDependency() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/changeTypeImplicitlyWithCircularDependency/");
+        }
+
+        @TestMetadata("changeWithRemovingUsage")
+        public void testChangeWithRemovingUsage() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/changeWithRemovingUsage/");
+        }
+
+        @TestMetadata("classInlineFunctionChanged")
+        public void testClassInlineFunctionChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/classInlineFunctionChanged/");
+        }
+
+        @TestMetadata("classObjectConstantChanged")
+        public void testClassObjectConstantChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/classObjectConstantChanged/");
+        }
+
+        @TestMetadata("classRecreated")
+        public void testClassRecreated() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/classRecreated/");
+        }
+
+        @TestMetadata("classRemoved")
+        public void testClassRemoved() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/classRemoved/");
+        }
+
+        @TestMetadata("classSignatureChanged")
+        public void testClassSignatureChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/classSignatureChanged/");
+        }
+
+        @TestMetadata("classSignatureUnchanged")
+        public void testClassSignatureUnchanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/classSignatureUnchanged/");
+        }
+
+        @TestMetadata("compilationErrorThenFixedOtherPackage")
+        public void testCompilationErrorThenFixedOtherPackage() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedOtherPackage/");
+        }
+
+        @TestMetadata("compilationErrorThenFixedSamePackage")
+        public void testCompilationErrorThenFixedSamePackage() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedSamePackage/");
+        }
+
+        @TestMetadata("compilationErrorThenFixedWithPhantomPart")
+        public void testCompilationErrorThenFixedWithPhantomPart() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedWithPhantomPart/");
+        }
+
+        @TestMetadata("compilationErrorThenFixedWithPhantomPart2")
+        public void testCompilationErrorThenFixedWithPhantomPart2() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedWithPhantomPart2/");
+        }
+
+        @TestMetadata("compilationErrorThenFixedWithPhantomPart3")
+        public void testCompilationErrorThenFixedWithPhantomPart3() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedWithPhantomPart3/");
+        }
+
+        @TestMetadata("constantRemoved")
+        public void testConstantRemoved() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/constantRemoved/");
+        }
+
+        @TestMetadata("constantValueChanged")
+        public void testConstantValueChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/constantValueChanged/");
+        }
+
+        @TestMetadata("constantsUnchanged")
+        public void testConstantsUnchanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/constantsUnchanged/");
+        }
+
+        @TestMetadata("defaultArgumentInConstructorAdded")
+        public void testDefaultArgumentInConstructorAdded() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/defaultArgumentInConstructorAdded/");
+        }
+
+        @TestMetadata("defaultArgumentInConstructorRemoved")
+        public void testDefaultArgumentInConstructorRemoved() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/defaultArgumentInConstructorRemoved/");
+        }
+
+        @TestMetadata("defaultValueAdded")
+        public void testDefaultValueAdded() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/defaultValueAdded/");
+        }
+
+        @TestMetadata("defaultValueChanged")
+        public void testDefaultValueChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/defaultValueChanged/");
+        }
+
+        @TestMetadata("defaultValueInConstructorChanged")
+        public void testDefaultValueInConstructorChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/defaultValueInConstructorChanged/");
+        }
+
+        @TestMetadata("defaultValueInConstructorRemoved")
+        public void testDefaultValueInConstructorRemoved() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/defaultValueInConstructorRemoved/");
+        }
+
+        @TestMetadata("defaultValueRemoved1")
+        public void testDefaultValueRemoved1() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/defaultValueRemoved1/");
+        }
+
+        @TestMetadata("defaultValueRemoved2")
+        public void testDefaultValueRemoved2() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/defaultValueRemoved2/");
+        }
+
+        @TestMetadata("delegatedPropertyInlineExtensionAccessor")
+        public void testDelegatedPropertyInlineExtensionAccessor() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/delegatedPropertyInlineExtensionAccessor/");
+        }
+
+        @TestMetadata("delegatedPropertyInlineMethodAccessor")
+        public void testDelegatedPropertyInlineMethodAccessor() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/delegatedPropertyInlineMethodAccessor/");
+        }
+
+        @TestMetadata("dependencyClassReferenced")
+        public void testDependencyClassReferenced() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/dependencyClassReferenced/");
+        }
+
+        @TestMetadata("fileWithConstantRemoved")
+        public void testFileWithConstantRemoved() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/fileWithConstantRemoved/");
+        }
+
+        @TestMetadata("fileWithInlineFunctionRemoved")
+        public void testFileWithInlineFunctionRemoved() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/fileWithInlineFunctionRemoved/");
+        }
+
+        @TestMetadata("filesExchangePackages")
+        public void testFilesExchangePackages() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/filesExchangePackages/");
+        }
+
+        @TestMetadata("funRedeclaration")
+        public void testFunRedeclaration() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/funRedeclaration/");
+        }
+
+        @TestMetadata("funVsConstructorOverloadConflict")
+        public void testFunVsConstructorOverloadConflict() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/funVsConstructorOverloadConflict/");
+        }
+
+        @TestMetadata("functionBecameInline")
+        public void testFunctionBecameInline() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/functionBecameInline/");
+        }
+
+        @TestMetadata("functionReferencingClass")
+        public void testFunctionReferencingClass() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/functionReferencingClass/");
+        }
+
+        @TestMetadata("independentClasses")
+        public void testIndependentClasses() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/independentClasses/");
+        }
+
+        @TestMetadata("inlineFunctionBecomesNonInline")
+        public void testInlineFunctionBecomesNonInline() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/inlineFunctionBecomesNonInline/");
+        }
+
+        @TestMetadata("inlineFunctionUsageAdded")
+        public void testInlineFunctionUsageAdded() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/inlineFunctionUsageAdded/");
+        }
+
+        @TestMetadata("inlineFunctionsCircularDependency")
+        public void testInlineFunctionsCircularDependency() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/inlineFunctionsCircularDependency/");
+        }
+
+        @TestMetadata("inlineFunctionsUnchanged")
+        public void testInlineFunctionsUnchanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/inlineFunctionsUnchanged/");
+        }
+
+        @TestMetadata("inlineLinesChanged")
+        public void testInlineLinesChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/inlineLinesChanged/");
+        }
+
+        @TestMetadata("inlineModifiedWithUsage")
+        public void testInlineModifiedWithUsage() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/inlineModifiedWithUsage/");
+        }
+
+        @TestMetadata("inlinePrivateFunctionAdded")
+        public void testInlinePrivateFunctionAdded() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/inlinePrivateFunctionAdded/");
+        }
+
+        @TestMetadata("inlinePropertyInClass")
+        public void testInlinePropertyInClass() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/inlinePropertyInClass/");
+        }
+
+        @TestMetadata("inlinePropertyOnTopLevel")
+        public void testInlinePropertyOnTopLevel() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/inlinePropertyOnTopLevel/");
+        }
+
+        @TestMetadata("inlineSuspendFunctionChanged")
+        public void testInlineSuspendFunctionChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/inlineSuspendFunctionChanged/");
+        }
+
+        @TestMetadata("inlineTwoFunctionsOneChanged")
+        public void testInlineTwoFunctionsOneChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/inlineTwoFunctionsOneChanged/");
+        }
+
+        @TestMetadata("inlineUsedWhereDeclared")
+        public void testInlineUsedWhereDeclared() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/inlineUsedWhereDeclared/");
+        }
+
+        @TestMetadata("internalClassChanged")
+        public void testInternalClassChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/internalClassChanged/");
+        }
+
+        @TestMetadata("internalMemberInClassChanged")
+        public void testInternalMemberInClassChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/internalMemberInClassChanged/");
+        }
+
+        @TestMetadata("internalTypealias")
+        public void testInternalTypealias() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/internalTypealias/");
+        }
+
+        @TestMetadata("internalTypealiasConstructor")
+        public void testInternalTypealiasConstructor() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/internalTypealiasConstructor/");
+        }
+
+        @TestMetadata("internalTypealiasObject")
+        public void testInternalTypealiasObject() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/internalTypealiasObject/");
+        }
+
+        @TestMetadata("localClassChanged")
+        public void testLocalClassChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/localClassChanged/");
+        }
+
+        @TestMetadata("moveClass")
+        public void testMoveClass() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/moveClass/");
+        }
+
+        @TestMetadata("moveFileWithChangingPackage")
+        public void testMoveFileWithChangingPackage() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/moveFileWithChangingPackage/");
+        }
+
+        @TestMetadata("moveFileWithoutChangingPackage")
+        public void testMoveFileWithoutChangingPackage() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/moveFileWithoutChangingPackage/");
+        }
+
+        @TestMetadata("multiplePackagesModified")
+        public void testMultiplePackagesModified() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/multiplePackagesModified/");
+        }
+
+        @TestMetadata("objectConstantChanged")
+        public void testObjectConstantChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/objectConstantChanged/");
+        }
+
+        @TestMetadata("ourClassReferenced")
+        public void testOurClassReferenced() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/ourClassReferenced/");
+        }
+
+        @TestMetadata("overloadInlined")
+        public void testOverloadInlined() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/overloadInlined/");
+        }
+
+        @TestMetadata("packageConstantChanged")
+        public void testPackageConstantChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/packageConstantChanged/");
+        }
+
+        @TestMetadata("packageFileAdded")
+        public void testPackageFileAdded() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/packageFileAdded/");
+        }
+
+        @TestMetadata("packageFileChangedPackage")
+        public void testPackageFileChangedPackage() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/packageFileChangedPackage/");
+        }
+
+        @TestMetadata("packageFileChangedThenOtherRemoved")
+        public void testPackageFileChangedThenOtherRemoved() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/packageFileChangedThenOtherRemoved/");
+        }
+
+        @TestMetadata("packageFileRemoved")
+        public void testPackageFileRemoved() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/packageFileRemoved/");
+        }
+
+        @TestMetadata("packageFilesChangedInTurn")
+        public void testPackageFilesChangedInTurn() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/packageFilesChangedInTurn/");
+        }
+
+        @TestMetadata("packageInlineFunctionAccessingField")
+        public void testPackageInlineFunctionAccessingField() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/packageInlineFunctionAccessingField/");
+        }
+
+        @TestMetadata("packageInlineFunctionFromOurPackage")
+        public void testPackageInlineFunctionFromOurPackage() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/packageInlineFunctionFromOurPackage/");
+        }
+
+        @TestMetadata("packagePrivateOnlyChanged")
+        public void testPackagePrivateOnlyChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/packagePrivateOnlyChanged/");
+        }
+
+        @TestMetadata("packageRecreated")
+        public void testPackageRecreated() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/packageRecreated/");
+        }
+
+        @TestMetadata("packageRecreatedAfterRenaming")
+        public void testPackageRecreatedAfterRenaming() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/packageRecreatedAfterRenaming/");
+        }
+
+        @TestMetadata("packageRemoved")
+        public void testPackageRemoved() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/packageRemoved/");
+        }
+
+        @TestMetadata("privateConstantsChanged")
+        public void testPrivateConstantsChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/privateConstantsChanged/");
+        }
+
+        @TestMetadata("privateMethodAdded")
+        public void testPrivateMethodAdded() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/privateMethodAdded/");
+        }
+
+        @TestMetadata("privateMethodDeleted")
+        public void testPrivateMethodDeleted() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/privateMethodDeleted/");
+        }
+
+        @TestMetadata("privateMethodSignatureChanged")
+        public void testPrivateMethodSignatureChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/privateMethodSignatureChanged/");
+        }
+
+        @TestMetadata("privateSecondaryConstructorAdded")
+        public void testPrivateSecondaryConstructorAdded() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/privateSecondaryConstructorAdded/");
+        }
+
+        @TestMetadata("privateSecondaryConstructorDeleted")
+        public void testPrivateSecondaryConstructorDeleted() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/privateSecondaryConstructorDeleted/");
+        }
+
+        @TestMetadata("privateValAccessorChanged")
+        public void testPrivateValAccessorChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/privateValAccessorChanged/");
+        }
+
+        @TestMetadata("privateValAdded")
+        public void testPrivateValAdded() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/privateValAdded/");
+        }
+
+        @TestMetadata("privateValDeleted")
+        public void testPrivateValDeleted() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/privateValDeleted/");
+        }
+
+        @TestMetadata("privateValSignatureChanged")
+        public void testPrivateValSignatureChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/privateValSignatureChanged/");
+        }
+
+        @TestMetadata("privateVarAdded")
+        public void testPrivateVarAdded() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/privateVarAdded/");
+        }
+
+        @TestMetadata("privateVarDeleted")
+        public void testPrivateVarDeleted() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/privateVarDeleted/");
+        }
+
+        @TestMetadata("privateVarSignatureChanged")
+        public void testPrivateVarSignatureChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/privateVarSignatureChanged/");
+        }
+
+        @TestMetadata("propertyRedeclaration")
+        public void testPropertyRedeclaration() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/");
+        }
+
+        @TestMetadata("publicPropertyWithPrivateSetter")
+        public void testPublicPropertyWithPrivateSetter() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/publicPropertyWithPrivateSetter/");
+        }
+
+        @TestMetadata("removeAndRestoreCompanion")
+        public void testRemoveAndRestoreCompanion() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/removeAndRestoreCompanion/");
+        }
+
+        @TestMetadata("removeAndRestoreCompanionWithImplicitUsages")
+        public void testRemoveAndRestoreCompanionWithImplicitUsages() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/removeAndRestoreCompanionWithImplicitUsages/");
+        }
+
+        @TestMetadata("removeClass")
+        public void testRemoveClass() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/removeClass/");
+        }
+
+        @TestMetadata("removeClassInDefaultPackage")
+        public void testRemoveClassInDefaultPackage() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/removeClassInDefaultPackage/");
+        }
+
+        @TestMetadata("removeFileWithFunctionOverload")
+        public void testRemoveFileWithFunctionOverload() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/removeFileWithFunctionOverload/");
+        }
+
+        @TestMetadata("removeMemberTypeAlias")
+        public void testRemoveMemberTypeAlias() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/removeMemberTypeAlias/");
+        }
+
+        @TestMetadata("removeTopLevelTypeAlias")
+        public void testRemoveTopLevelTypeAlias() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/removeTopLevelTypeAlias/");
+        }
+
+        @TestMetadata("removeUnusedFile")
+        public void testRemoveUnusedFile() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/removeUnusedFile/");
+        }
+
+        @TestMetadata("renameClass")
+        public void testRenameClass() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/renameClass/");
+        }
+
+        @TestMetadata("renameFileWithFunctionOverload")
+        public void testRenameFileWithFunctionOverload() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/renameFileWithFunctionOverload/");
+        }
+
+        @TestMetadata("returnTypeChanged")
+        public void testReturnTypeChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/returnTypeChanged/");
+        }
+
+        @TestMetadata("secondaryConstructorInlined")
+        public void testSecondaryConstructorInlined() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/secondaryConstructorInlined/");
+        }
+
+        @TestMetadata("simpleClassDependency")
+        public void testSimpleClassDependency() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/simpleClassDependency/");
+        }
+
+        @TestMetadata("soleFileChangesPackage")
+        public void testSoleFileChangesPackage() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/soleFileChangesPackage/");
+        }
+
+        @TestMetadata("subpackage")
+        public void testSubpackage() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/subpackage/");
+        }
+
+        @TestMetadata("suspendWithStateMachine")
+        public void testSuspendWithStateMachine() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/suspendWithStateMachine/");
+        }
+
+        @TestMetadata("topLevelFunctionSameSignature")
+        public void testTopLevelFunctionSameSignature() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/topLevelFunctionSameSignature/");
+        }
+
+        @TestMetadata("topLevelMembersInTwoFiles")
+        public void testTopLevelMembersInTwoFiles() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/topLevelMembersInTwoFiles/");
+        }
+
+        @TestMetadata("topLevelPrivateValUsageAdded")
+        public void testTopLevelPrivateValUsageAdded() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/topLevelPrivateValUsageAdded/");
+        }
+
+        @TestMetadata("traitClassObjectConstantChanged")
+        public void testTraitClassObjectConstantChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/traitClassObjectConstantChanged/");
+        }
+
+        @TestMetadata("valAddCustomAccessor")
+        public void testValAddCustomAccessor() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/valAddCustomAccessor/");
+        }
+
+        @TestMetadata("valRemoveCustomAccessor")
+        public void testValRemoveCustomAccessor() throws Exception {
+            runTest("jps-plugin/testData/incremental/pureKotlin/valRemoveCustomAccessor/");
+        }
+    }
+
+    @TestMetadata("jps-plugin/testData/incremental/classHierarchyAffected")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class ClassHierarchyAffected extends AbstractIrIncrementalJvmCompilerRunnerTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInClassHierarchyAffected() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, false);
+        }
+
+        @TestMetadata("annotationFlagRemoved")
+        public void testAnnotationFlagRemoved() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/annotationFlagRemoved/");
+        }
+
+        @TestMetadata("annotationListChanged")
+        public void testAnnotationListChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/annotationListChanged/");
+        }
+
+        @TestMetadata("bridgeGenerated")
+        public void testBridgeGenerated() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/bridgeGenerated/");
+        }
+
+        @TestMetadata("classBecameFinal")
+        public void testClassBecameFinal() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/classBecameFinal/");
+        }
+
+        @TestMetadata("classBecameInterface")
+        public void testClassBecameInterface() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/classBecameInterface/");
+        }
+
+        @TestMetadata("classBecamePrivate")
+        public void testClassBecamePrivate() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/classBecamePrivate/");
+        }
+
+        @TestMetadata("classMovedIntoOtherClass")
+        public void testClassMovedIntoOtherClass() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/classMovedIntoOtherClass/");
+        }
+
+        @TestMetadata("classRemoved")
+        public void testClassRemoved() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/classRemoved/");
+        }
+
+        @TestMetadata("classRemovedAndRestored")
+        public void testClassRemovedAndRestored() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/classRemovedAndRestored/");
+        }
+
+        @TestMetadata("companionObjectInheritedMemberChanged")
+        public void testCompanionObjectInheritedMemberChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/companionObjectInheritedMemberChanged/");
+        }
+
+        @TestMetadata("companionObjectMemberChanged")
+        public void testCompanionObjectMemberChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/companionObjectMemberChanged/");
+        }
+
+        @TestMetadata("companionObjectNameChanged")
+        public void testCompanionObjectNameChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/companionObjectNameChanged/");
+        }
+
+        @TestMetadata("companionObjectToSimpleObject")
+        public void testCompanionObjectToSimpleObject() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/companionObjectToSimpleObject/");
+        }
+
+        @TestMetadata("constructorVisibilityChanged")
+        public void testConstructorVisibilityChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/constructorVisibilityChanged/");
+        }
+
+        @TestMetadata("enumEntryAdded")
+        public void testEnumEntryAdded() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/enumEntryAdded/");
+        }
+
+        @TestMetadata("enumEntryRemoved")
+        public void testEnumEntryRemoved() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/enumEntryRemoved/");
+        }
+
+        @TestMetadata("enumMemberChanged")
+        public void testEnumMemberChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/enumMemberChanged/");
+        }
+
+        @TestMetadata("flagsAndMemberInDifferentClassesChanged")
+        public void testFlagsAndMemberInDifferentClassesChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/flagsAndMemberInDifferentClassesChanged/");
+        }
+
+        @TestMetadata("flagsAndMemberInSameClassChanged")
+        public void testFlagsAndMemberInSameClassChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/flagsAndMemberInSameClassChanged/");
+        }
+
+        @TestMetadata("implcitUpcast")
+        public void testImplcitUpcast() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/implcitUpcast/");
+        }
+
+        @TestMetadata("inferredTypeArgumentChanged")
+        public void testInferredTypeArgumentChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/inferredTypeArgumentChanged/");
+        }
+
+        @TestMetadata("inferredTypeChanged")
+        public void testInferredTypeChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/inferredTypeChanged/");
+        }
+
+        @TestMetadata("lambdaParameterAffected")
+        public void testLambdaParameterAffected() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/lambdaParameterAffected/");
+        }
+
+        @TestMetadata("methodAdded")
+        public void testMethodAdded() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/methodAdded/");
+        }
+
+        @TestMetadata("methodAnnotationAdded")
+        public void testMethodAnnotationAdded() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/methodAnnotationAdded/");
+        }
+
+        @TestMetadata("methodNullabilityChanged")
+        public void testMethodNullabilityChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/methodNullabilityChanged/");
+        }
+
+        @TestMetadata("methodParameterWithDefaultValueAdded")
+        public void testMethodParameterWithDefaultValueAdded() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/methodParameterWithDefaultValueAdded/");
+        }
+
+        @TestMetadata("methodRemoved")
+        public void testMethodRemoved() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/methodRemoved/");
+        }
+
+        @TestMetadata("overrideExplicit")
+        public void testOverrideExplicit() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/overrideExplicit/");
+        }
+
+        @TestMetadata("overrideImplicit")
+        public void testOverrideImplicit() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/overrideImplicit/");
+        }
+
+        @TestMetadata("propertyNullabilityChanged")
+        public void testPropertyNullabilityChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/propertyNullabilityChanged/");
+        }
+
+        @TestMetadata("sealedClassImplAdded")
+        public void testSealedClassImplAdded() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/sealedClassImplAdded/");
+        }
+
+        @TestMetadata("sealedClassIndirectImplAdded")
+        public void testSealedClassIndirectImplAdded() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/sealedClassIndirectImplAdded/");
+        }
+
+        @TestMetadata("sealedClassNestedImplAdded")
+        public void testSealedClassNestedImplAdded() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/sealedClassNestedImplAdded/");
+        }
+
+        @TestMetadata("secondaryConstructorAdded")
+        public void testSecondaryConstructorAdded() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/secondaryConstructorAdded/");
+        }
+
+        @TestMetadata("starProjectionUpperBoundChanged")
+        public void testStarProjectionUpperBoundChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/starProjectionUpperBoundChanged/");
+        }
+
+        @TestMetadata("supertypesListChanged")
+        public void testSupertypesListChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/supertypesListChanged/");
+        }
+
+        @TestMetadata("typeParameterListChanged")
+        public void testTypeParameterListChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/typeParameterListChanged/");
+        }
+
+        @TestMetadata("varianceChanged")
+        public void testVarianceChanged() throws Exception {
+            runTest("jps-plugin/testData/incremental/classHierarchyAffected/varianceChanged/");
+        }
+    }
+
+    @TestMetadata("jps-plugin/testData/incremental/inlineFunCallSite")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class InlineFunCallSite extends AbstractIrIncrementalJvmCompilerRunnerTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInInlineFunCallSite() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+        }
+
+        @TestMetadata("classProperty")
+        public void testClassProperty() throws Exception {
+            runTest("jps-plugin/testData/incremental/inlineFunCallSite/classProperty/");
+        }
+
+        @TestMetadata("companionObjectProperty")
+        public void testCompanionObjectProperty() throws Exception {
+            runTest("jps-plugin/testData/incremental/inlineFunCallSite/companionObjectProperty/");
+        }
+
+        @TestMetadata("coroutine")
+        public void testCoroutine() throws Exception {
+            runTest("jps-plugin/testData/incremental/inlineFunCallSite/coroutine/");
+        }
+
+        @TestMetadata("function")
+        public void testFunction() throws Exception {
+            runTest("jps-plugin/testData/incremental/inlineFunCallSite/function/");
+        }
+
+        @TestMetadata("getter")
+        public void testGetter() throws Exception {
+            runTest("jps-plugin/testData/incremental/inlineFunCallSite/getter/");
+        }
+
+        @TestMetadata("lambda")
+        public void testLambda() throws Exception {
+            runTest("jps-plugin/testData/incremental/inlineFunCallSite/lambda/");
+        }
+
+        @TestMetadata("localFun")
+        public void testLocalFun() throws Exception {
+            runTest("jps-plugin/testData/incremental/inlineFunCallSite/localFun/");
+        }
+
+        @TestMetadata("method")
+        public void testMethod() throws Exception {
+            runTest("jps-plugin/testData/incremental/inlineFunCallSite/method/");
+        }
+
+        @TestMetadata("parameterDefaultValue")
+        public void testParameterDefaultValue() throws Exception {
+            runTest("jps-plugin/testData/incremental/inlineFunCallSite/parameterDefaultValue/");
+        }
+
+        @TestMetadata("primaryConstructorParameterDefaultValue")
+        public void testPrimaryConstructorParameterDefaultValue() throws Exception {
+            runTest("jps-plugin/testData/incremental/inlineFunCallSite/primaryConstructorParameterDefaultValue/");
+        }
+
+        @TestMetadata("superCall")
+        public void testSuperCall() throws Exception {
+            runTest("jps-plugin/testData/incremental/inlineFunCallSite/superCall/");
+        }
+
+        @TestMetadata("thisCall")
+        public void testThisCall() throws Exception {
+            runTest("jps-plugin/testData/incremental/inlineFunCallSite/thisCall/");
+        }
+
+        @TestMetadata("topLevelObjectProperty")
+        public void testTopLevelObjectProperty() throws Exception {
+            runTest("jps-plugin/testData/incremental/inlineFunCallSite/topLevelObjectProperty/");
+        }
+
+        @TestMetadata("topLevelProperty")
+        public void testTopLevelProperty() throws Exception {
+            runTest("jps-plugin/testData/incremental/inlineFunCallSite/topLevelProperty/");
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/inlineFunCallSite/classProperty")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class ClassProperty extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInClassProperty() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/classProperty"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/inlineFunCallSite/companionObjectProperty")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class CompanionObjectProperty extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInCompanionObjectProperty() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/companionObjectProperty"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/inlineFunCallSite/coroutine")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Coroutine extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInCoroutine() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/coroutine"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/inlineFunCallSite/function")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Function extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInFunction() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/function"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/inlineFunCallSite/getter")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Getter extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInGetter() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/getter"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/inlineFunCallSite/lambda")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Lambda extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInLambda() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/lambda"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/inlineFunCallSite/localFun")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class LocalFun extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInLocalFun() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/localFun"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/inlineFunCallSite/method")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Method extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInMethod() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/method"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/inlineFunCallSite/parameterDefaultValue")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class ParameterDefaultValue extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInParameterDefaultValue() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/parameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/inlineFunCallSite/primaryConstructorParameterDefaultValue")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class PrimaryConstructorParameterDefaultValue extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInPrimaryConstructorParameterDefaultValue() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/primaryConstructorParameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/inlineFunCallSite/superCall")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class SuperCall extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInSuperCall() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/superCall"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/inlineFunCallSite/thisCall")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class ThisCall extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInThisCall() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/thisCall"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/inlineFunCallSite/topLevelObjectProperty")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class TopLevelObjectProperty extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInTopLevelObjectProperty() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/topLevelObjectProperty"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/inlineFunCallSite/topLevelProperty")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class TopLevelProperty extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInTopLevelProperty() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/topLevelProperty"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+        }
+    }
+
+    @TestMetadata("jps-plugin/testData/incremental/withJava")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class WithJava extends AbstractIrIncrementalJvmCompilerRunnerTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInWithJava() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class ConvertBetweenJavaAndKotlin extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInConvertBetweenJavaAndKotlin() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+
+            @TestMetadata("javaToKotlin")
+            public void testJavaToKotlin() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlin/");
+            }
+
+            @TestMetadata("javaToKotlinAndBack")
+            public void testJavaToKotlinAndBack() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndBack/");
+            }
+
+            @TestMetadata("javaToKotlinAndRemove")
+            public void testJavaToKotlinAndRemove() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndRemove/");
+            }
+
+            @TestMetadata("kotlinToJava")
+            public void testKotlinToJava() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/kotlinToJava/");
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlin")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class JavaToKotlin extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInJavaToKotlin() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndBack")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class JavaToKotlinAndBack extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInJavaToKotlinAndBack() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndBack"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndRemove")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class JavaToKotlinAndRemove extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInJavaToKotlinAndRemove() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndRemove"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/kotlinToJava")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class KotlinToJava extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInKotlinToJava() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/kotlinToJava"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class JavaUsedInKotlin extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInJavaUsedInKotlin() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+
+            @TestMetadata("changeFieldType")
+            public void testChangeFieldType() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType/");
+            }
+
+            @TestMetadata("changeNotUsedSignature")
+            public void testChangeNotUsedSignature() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeNotUsedSignature/");
+            }
+
+            @TestMetadata("changePropertyOverrideType")
+            public void testChangePropertyOverrideType() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/");
+            }
+
+            @TestMetadata("changeSignature")
+            public void testChangeSignature() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature/");
+            }
+
+            @TestMetadata("changeSignaturePackagePrivate")
+            public void testChangeSignaturePackagePrivate() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate/");
+            }
+
+            @TestMetadata("changeSignaturePackagePrivateNonRoot")
+            public void testChangeSignaturePackagePrivateNonRoot() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivateNonRoot/");
+            }
+
+            @TestMetadata("changeSignatureStatic")
+            public void testChangeSignatureStatic() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic/");
+            }
+
+            @TestMetadata("constantChanged")
+            public void testConstantChanged() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged/");
+            }
+
+            @TestMetadata("constantUnchanged")
+            public void testConstantUnchanged() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged/");
+            }
+
+            @TestMetadata("enumEntryAdded")
+            public void testEnumEntryAdded() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryAdded/");
+            }
+
+            @TestMetadata("enumEntryRemoved")
+            public void testEnumEntryRemoved() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryRemoved/");
+            }
+
+            @TestMetadata("javaAndKotlinChangedSimultaneously")
+            public void testJavaAndKotlinChangedSimultaneously() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaAndKotlinChangedSimultaneously/");
+            }
+
+            @TestMetadata("javaFieldNullabilityChanged")
+            public void testJavaFieldNullabilityChanged() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaFieldNullabilityChanged/");
+            }
+
+            @TestMetadata("javaMethodParamNullabilityChanged")
+            public void testJavaMethodParamNullabilityChanged() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodParamNullabilityChanged/");
+            }
+
+            @TestMetadata("javaMethodReturnTypeNullabilityChanged")
+            public void testJavaMethodReturnTypeNullabilityChanged() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodReturnTypeNullabilityChanged/");
+            }
+
+            @TestMetadata("methodAddedInSuper")
+            public void testMethodAddedInSuper() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodAddedInSuper/");
+            }
+
+            @TestMetadata("methodRenamed")
+            public void testMethodRenamed() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodRenamed/");
+            }
+
+            @TestMetadata("mixedInheritance")
+            public void testMixedInheritance() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/");
+            }
+
+            @TestMetadata("notChangeSignature")
+            public void testNotChangeSignature() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature/");
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ChangeFieldType extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInChangeFieldType() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeNotUsedSignature")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ChangeNotUsedSignature extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInChangeNotUsedSignature() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ChangePropertyOverrideType extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInChangePropertyOverrideType() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ChangeSignature extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInChangeSignature() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ChangeSignaturePackagePrivate extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInChangeSignaturePackagePrivate() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivateNonRoot")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ChangeSignaturePackagePrivateNonRoot extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInChangeSignaturePackagePrivateNonRoot() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivateNonRoot"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ChangeSignatureStatic extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInChangeSignatureStatic() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ConstantChanged extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInConstantChanged() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ConstantUnchanged extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInConstantUnchanged() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryAdded")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class EnumEntryAdded extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInEnumEntryAdded() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryRemoved")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class EnumEntryRemoved extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInEnumEntryRemoved() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryRemoved"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaAndKotlinChangedSimultaneously")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class JavaAndKotlinChangedSimultaneously extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInJavaAndKotlinChangedSimultaneously() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaAndKotlinChangedSimultaneously"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaFieldNullabilityChanged")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class JavaFieldNullabilityChanged extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInJavaFieldNullabilityChanged() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaFieldNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodParamNullabilityChanged")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class JavaMethodParamNullabilityChanged extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInJavaMethodParamNullabilityChanged() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodParamNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodReturnTypeNullabilityChanged")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class JavaMethodReturnTypeNullabilityChanged extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInJavaMethodReturnTypeNullabilityChanged() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodReturnTypeNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodAddedInSuper")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class MethodAddedInSuper extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInMethodAddedInSuper() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodRenamed")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class MethodRenamed extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInMethodRenamed() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodRenamed"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class MixedInheritance extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInMixedInheritance() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class NotChangeSignature extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInNotChangeSignature() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class SamConversions extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInSamConversions() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+
+                @TestMetadata("methodAdded")
+                public void testMethodAdded() throws Exception {
+                    runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded/");
+                }
+
+                @TestMetadata("methodAddedSamAdapter")
+                public void testMethodAddedSamAdapter() throws Exception {
+                    runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddedSamAdapter/");
+                }
+
+                @TestMetadata("methodSignatureChanged")
+                public void testMethodSignatureChanged() throws Exception {
+                    runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChanged/");
+                }
+
+                @TestMetadata("methodSignatureChangedSamAdapter")
+                public void testMethodSignatureChangedSamAdapter() throws Exception {
+                    runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChangedSamAdapter/");
+                }
+
+                @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded")
+                @TestDataPath("$PROJECT_ROOT")
+                @RunWith(JUnit3RunnerWithInners.class)
+                public static class MethodAdded extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                    private void runTest(String testDataFilePath) throws Exception {
+                        KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                    }
+
+                    public void testAllFilesPresentInMethodAdded() throws Exception {
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                    }
+                }
+
+                @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddedSamAdapter")
+                @TestDataPath("$PROJECT_ROOT")
+                @RunWith(JUnit3RunnerWithInners.class)
+                public static class MethodAddedSamAdapter extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                    private void runTest(String testDataFilePath) throws Exception {
+                        KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                    }
+
+                    public void testAllFilesPresentInMethodAddedSamAdapter() throws Exception {
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddedSamAdapter"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                    }
+                }
+
+                @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChanged")
+                @TestDataPath("$PROJECT_ROOT")
+                @RunWith(JUnit3RunnerWithInners.class)
+                public static class MethodSignatureChanged extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                    private void runTest(String testDataFilePath) throws Exception {
+                        KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                    }
+
+                    public void testAllFilesPresentInMethodSignatureChanged() throws Exception {
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                    }
+                }
+
+                @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChangedSamAdapter")
+                @TestDataPath("$PROJECT_ROOT")
+                @RunWith(JUnit3RunnerWithInners.class)
+                public static class MethodSignatureChangedSamAdapter extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                    private void runTest(String testDataFilePath) throws Exception {
+                        KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                    }
+
+                    public void testAllFilesPresentInMethodSignatureChangedSamAdapter() throws Exception {
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChangedSamAdapter"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                    }
+                }
+            }
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/withJava/kotlinUsedInJava")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class KotlinUsedInJava extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            @TestMetadata("addOptionalParameter")
+            public void testAddOptionalParameter() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/addOptionalParameter/");
+            }
+
+            public void testAllFilesPresentInKotlinUsedInJava() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+
+            @TestMetadata("changeNotUsedSignature")
+            public void testChangeNotUsedSignature() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeNotUsedSignature/");
+            }
+
+            @TestMetadata("changeSignature")
+            public void testChangeSignature() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeSignature/");
+            }
+
+            @TestMetadata("constantChanged")
+            public void testConstantChanged() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantChanged/");
+            }
+
+            @TestMetadata("constantUnchanged")
+            public void testConstantUnchanged() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantUnchanged/");
+            }
+
+            @TestMetadata("funRenamed")
+            public void testFunRenamed() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/funRenamed/");
+            }
+
+            @TestMetadata("jvmFieldChanged")
+            public void testJvmFieldChanged() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldChanged/");
+            }
+
+            @TestMetadata("jvmFieldUnchanged")
+            public void testJvmFieldUnchanged() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldUnchanged/");
+            }
+
+            @TestMetadata("methodAddedInSuper")
+            public void testMethodAddedInSuper() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/methodAddedInSuper/");
+            }
+
+            @TestMetadata("notChangeSignature")
+            public void testNotChangeSignature() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/notChangeSignature/");
+            }
+
+            @TestMetadata("onlyTopLevelFunctionInFileRemoved")
+            public void testOnlyTopLevelFunctionInFileRemoved() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/onlyTopLevelFunctionInFileRemoved/");
+            }
+
+            @TestMetadata("packageFileAdded")
+            public void testPackageFileAdded() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/packageFileAdded/");
+            }
+
+            @TestMetadata("privateChanges")
+            public void testPrivateChanges() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/privateChanges/");
+            }
+
+            @TestMetadata("propertyRenamed")
+            public void testPropertyRenamed() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/propertyRenamed/");
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/addOptionalParameter")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class AddOptionalParameter extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInAddOptionalParameter() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/addOptionalParameter"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeNotUsedSignature")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ChangeNotUsedSignature extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInChangeNotUsedSignature() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeSignature")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ChangeSignature extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInChangeSignature() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeSignature"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantChanged")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ConstantChanged extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInConstantChanged() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantUnchanged")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ConstantUnchanged extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInConstantUnchanged() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/funRenamed")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class FunRenamed extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInFunRenamed() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/funRenamed"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldChanged")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class JvmFieldChanged extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInJvmFieldChanged() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldUnchanged")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class JvmFieldUnchanged extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInJvmFieldUnchanged() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldUnchanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/methodAddedInSuper")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class MethodAddedInSuper extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInMethodAddedInSuper() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/notChangeSignature")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class NotChangeSignature extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInNotChangeSignature() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/onlyTopLevelFunctionInFileRemoved")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class OnlyTopLevelFunctionInFileRemoved extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInOnlyTopLevelFunctionInFileRemoved() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/onlyTopLevelFunctionInFileRemoved"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/packageFileAdded")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class PackageFileAdded extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInPackageFileAdded() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/packageFileAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/privateChanges")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class PrivateChanges extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInPrivateChanges() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/privateChanges"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/propertyRenamed")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class PropertyRenamed extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInPropertyRenamed() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/propertyRenamed"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/withJava/other")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Other extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            @TestMetadata("accessingFunctionsViaRenamedFileClass")
+            public void testAccessingFunctionsViaRenamedFileClass() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/accessingFunctionsViaRenamedFileClass/");
+            }
+
+            public void testAllFilesPresentInOther() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+
+            @TestMetadata("allKotlinFilesRemovedThenNewAdded")
+            public void testAllKotlinFilesRemovedThenNewAdded() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/allKotlinFilesRemovedThenNewAdded/");
+            }
+
+            @TestMetadata("classRedeclaration")
+            public void testClassRedeclaration() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/classRedeclaration/");
+            }
+
+            @TestMetadata("classToPackageFacade")
+            public void testClassToPackageFacade() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/classToPackageFacade/");
+            }
+
+            @TestMetadata("conflictingPlatformDeclarations")
+            public void testConflictingPlatformDeclarations() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/conflictingPlatformDeclarations/");
+            }
+
+            @TestMetadata("defaultValueInConstructorAdded")
+            public void testDefaultValueInConstructorAdded() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/defaultValueInConstructorAdded/");
+            }
+
+            @TestMetadata("inlineTopLevelFunctionWithJvmName")
+            public void testInlineTopLevelFunctionWithJvmName() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/inlineTopLevelFunctionWithJvmName/");
+            }
+
+            @TestMetadata("inlineTopLevelValPropertyWithJvmName")
+            public void testInlineTopLevelValPropertyWithJvmName() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/inlineTopLevelValPropertyWithJvmName/");
+            }
+
+            @TestMetadata("innerClassNotGeneratedWhenRebuilding")
+            public void testInnerClassNotGeneratedWhenRebuilding() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/innerClassNotGeneratedWhenRebuilding/");
+            }
+
+            @TestMetadata("jvmNameChanged")
+            public void testJvmNameChanged() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/jvmNameChanged/");
+            }
+
+            @TestMetadata("mainRedeclaration")
+            public void testMainRedeclaration() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/mainRedeclaration/");
+            }
+
+            @TestMetadata("multifileClassAddTopLevelFunWithDefault")
+            public void testMultifileClassAddTopLevelFunWithDefault() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/multifileClassAddTopLevelFunWithDefault/");
+            }
+
+            @TestMetadata("multifileClassFileAdded")
+            public void testMultifileClassFileAdded() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/multifileClassFileAdded/");
+            }
+
+            @TestMetadata("multifileClassFileChanged")
+            public void testMultifileClassFileChanged() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/multifileClassFileChanged/");
+            }
+
+            @TestMetadata("multifileClassFileMovedToAnotherMultifileClass")
+            public void testMultifileClassFileMovedToAnotherMultifileClass() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/multifileClassFileMovedToAnotherMultifileClass/");
+            }
+
+            @TestMetadata("multifileClassInlineFunction")
+            public void testMultifileClassInlineFunction() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunction/");
+            }
+
+            @TestMetadata("multifileClassInlineFunctionAccessingField")
+            public void testMultifileClassInlineFunctionAccessingField() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunctionAccessingField/");
+            }
+
+            @TestMetadata("multifileClassRecreated")
+            public void testMultifileClassRecreated() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/multifileClassRecreated/");
+            }
+
+            @TestMetadata("multifileClassRecreatedAfterRenaming")
+            public void testMultifileClassRecreatedAfterRenaming() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/multifileClassRecreatedAfterRenaming/");
+            }
+
+            @TestMetadata("multifileClassRemoved")
+            public void testMultifileClassRemoved() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/multifileClassRemoved/");
+            }
+
+            @TestMetadata("multifilePackagePartMethodAdded")
+            public void testMultifilePackagePartMethodAdded() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/multifilePackagePartMethodAdded/");
+            }
+
+            @TestMetadata("multifilePartsWithProperties")
+            public void testMultifilePartsWithProperties() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/multifilePartsWithProperties/");
+            }
+
+            @TestMetadata("optionalParameter")
+            public void testOptionalParameter() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/optionalParameter/");
+            }
+
+            @TestMetadata("packageFacadeToClass")
+            public void testPackageFacadeToClass() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/packageFacadeToClass/");
+            }
+
+            @TestMetadata("packageMultifileClassOneFileWithPublicChanges")
+            public void testPackageMultifileClassOneFileWithPublicChanges() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/packageMultifileClassOneFileWithPublicChanges/");
+            }
+
+            @TestMetadata("packageMultifileClassPrivateOnlyChanged")
+            public void testPackageMultifileClassPrivateOnlyChanged() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/packageMultifileClassPrivateOnlyChanged/");
+            }
+
+            @TestMetadata("publicPropertyWithPrivateSetterMultiFileFacade")
+            public void testPublicPropertyWithPrivateSetterMultiFileFacade() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/publicPropertyWithPrivateSetterMultiFileFacade/");
+            }
+
+            @TestMetadata("topLevelFunctionWithJvmName")
+            public void testTopLevelFunctionWithJvmName() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/topLevelFunctionWithJvmName/");
+            }
+
+            @TestMetadata("topLevelPropertyWithJvmName")
+            public void testTopLevelPropertyWithJvmName() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/other/topLevelPropertyWithJvmName/");
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/accessingFunctionsViaRenamedFileClass")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class AccessingFunctionsViaRenamedFileClass extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInAccessingFunctionsViaRenamedFileClass() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/accessingFunctionsViaRenamedFileClass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/allKotlinFilesRemovedThenNewAdded")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class AllKotlinFilesRemovedThenNewAdded extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInAllKotlinFilesRemovedThenNewAdded() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/allKotlinFilesRemovedThenNewAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/classRedeclaration")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ClassRedeclaration extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInClassRedeclaration() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/classRedeclaration"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/classToPackageFacade")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ClassToPackageFacade extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInClassToPackageFacade() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/classToPackageFacade"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/conflictingPlatformDeclarations")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ConflictingPlatformDeclarations extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInConflictingPlatformDeclarations() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/conflictingPlatformDeclarations"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/defaultValueInConstructorAdded")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class DefaultValueInConstructorAdded extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInDefaultValueInConstructorAdded() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/defaultValueInConstructorAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/inlineTopLevelFunctionWithJvmName")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class InlineTopLevelFunctionWithJvmName extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInInlineTopLevelFunctionWithJvmName() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineTopLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/inlineTopLevelValPropertyWithJvmName")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class InlineTopLevelValPropertyWithJvmName extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInInlineTopLevelValPropertyWithJvmName() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineTopLevelValPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/innerClassNotGeneratedWhenRebuilding")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class InnerClassNotGeneratedWhenRebuilding extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInInnerClassNotGeneratedWhenRebuilding() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/innerClassNotGeneratedWhenRebuilding"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/jvmNameChanged")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class JvmNameChanged extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInJvmNameChanged() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/jvmNameChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/mainRedeclaration")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class MainRedeclaration extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInMainRedeclaration() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/mainRedeclaration"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/multifileClassAddTopLevelFunWithDefault")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class MultifileClassAddTopLevelFunWithDefault extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInMultifileClassAddTopLevelFunWithDefault() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassAddTopLevelFunWithDefault"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/multifileClassFileAdded")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class MultifileClassFileAdded extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInMultifileClassFileAdded() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/multifileClassFileChanged")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class MultifileClassFileChanged extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInMultifileClassFileChanged() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/multifileClassFileMovedToAnotherMultifileClass")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class MultifileClassFileMovedToAnotherMultifileClass extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInMultifileClassFileMovedToAnotherMultifileClass() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileMovedToAnotherMultifileClass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunction")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class MultifileClassInlineFunction extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInMultifileClassInlineFunction() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunction"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunctionAccessingField")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class MultifileClassInlineFunctionAccessingField extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInMultifileClassInlineFunctionAccessingField() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunctionAccessingField"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/multifileClassRecreated")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class MultifileClassRecreated extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInMultifileClassRecreated() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRecreated"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/multifileClassRecreatedAfterRenaming")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class MultifileClassRecreatedAfterRenaming extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInMultifileClassRecreatedAfterRenaming() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRecreatedAfterRenaming"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/multifileClassRemoved")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class MultifileClassRemoved extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInMultifileClassRemoved() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRemoved"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/multifilePackagePartMethodAdded")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class MultifilePackagePartMethodAdded extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInMultifilePackagePartMethodAdded() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifilePackagePartMethodAdded"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/multifilePartsWithProperties")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class MultifilePartsWithProperties extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInMultifilePartsWithProperties() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifilePartsWithProperties"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/optionalParameter")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class OptionalParameter extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInOptionalParameter() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/optionalParameter"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/packageFacadeToClass")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class PackageFacadeToClass extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInPackageFacadeToClass() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageFacadeToClass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/packageMultifileClassOneFileWithPublicChanges")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class PackageMultifileClassOneFileWithPublicChanges extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInPackageMultifileClassOneFileWithPublicChanges() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageMultifileClassOneFileWithPublicChanges"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/packageMultifileClassPrivateOnlyChanged")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class PackageMultifileClassPrivateOnlyChanged extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInPackageMultifileClassPrivateOnlyChanged() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageMultifileClassPrivateOnlyChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/publicPropertyWithPrivateSetterMultiFileFacade")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class PublicPropertyWithPrivateSetterMultiFileFacade extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInPublicPropertyWithPrivateSetterMultiFileFacade() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/publicPropertyWithPrivateSetterMultiFileFacade"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/topLevelFunctionWithJvmName")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class TopLevelFunctionWithJvmName extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInTopLevelFunctionWithJvmName() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/topLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+
+            @TestMetadata("jps-plugin/testData/incremental/withJava/other/topLevelPropertyWithJvmName")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class TopLevelPropertyWithJvmName extends AbstractIrIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInTopLevelPropertyWithJvmName() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/topLevelPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+                }
+            }
+        }
+    }
+
+    @TestMetadata("jps-plugin/testData/incremental/incrementalJvmCompilerOnly")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class IncrementalJvmCompilerOnly extends AbstractIrIncrementalJvmCompilerRunnerTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+        }
+
+        @TestMetadata("addAnnotationToJavaClass")
+        public void testAddAnnotationToJavaClass() throws Exception {
+            runTest("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/");
+        }
+
+        @TestMetadata("addNestedClass")
+        public void testAddNestedClass() throws Exception {
+            runTest("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/");
+        }
+
+        public void testAllFilesPresentInIncrementalJvmCompilerOnly() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+        }
+
+        @TestMetadata("changeAnnotationInJavaClass")
+        public void testChangeAnnotationInJavaClass() throws Exception {
+            runTest("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/");
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class AddAnnotationToJavaClass extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInAddAnnotationToJavaClass() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class AddNestedClass extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInAddNestedClass() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+        }
+
+        @TestMetadata("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class ChangeAnnotationInJavaClass extends AbstractIrIncrementalJvmCompilerRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInChangeAnnotationInJavaClass() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JVM_IR, true);
+            }
+        }
+    }
+}
diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt
index ec69ab66c70..b411a101996 100644
--- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt
+++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt
@@ -156,9 +156,9 @@ import org.jetbrains.kotlin.search.AbstractAnnotatedMembersSearchTest
 import org.jetbrains.kotlin.search.AbstractInheritorsSearchTest
 import org.jetbrains.kotlin.shortenRefs.AbstractShortenRefsTest
 import org.jetbrains.kotlin.test.TargetBackend
+import org.jetbrains.kotlinx.serialization.AbstractSerializationIrBytecodeListingTest
 import org.jetbrains.kotlinx.serialization.AbstractSerializationPluginBytecodeListingTest
 import org.jetbrains.kotlinx.serialization.AbstractSerializationPluginDiagnosticTest
-import org.jetbrains.kotlinx.serialization.AbstractSerializationIrBytecodeListingTest
 
 fun main(args: Array<String>) {
     System.setProperty("java.awt.headless", "true")
@@ -1066,13 +1066,15 @@ fun main(args: Array<String>) {
     }
 
     testGroup("compiler/incremental-compilation-impl/test", "jps-plugin/testData") {
-        testClass<AbstractIncrementalJvmCompilerRunnerTest> {
-            model("incremental/pureKotlin", extension = null, recursive = false)
-            model("incremental/classHierarchyAffected", extension = null, recursive = false)
-            model("incremental/inlineFunCallSite", extension = null, excludeParentDirs = true)
-            model("incremental/withJava", extension = null, excludeParentDirs = true)
-            model("incremental/incrementalJvmCompilerOnly", extension = null, excludeParentDirs = true)
+        fun incrementalJvmTestData(targetBackend: TargetBackend): TestGroup.TestClass.() -> Unit = {
+            model("incremental/pureKotlin", extension = null, recursive = false, targetBackend = targetBackend)
+            model("incremental/classHierarchyAffected", extension = null, recursive = false, targetBackend = targetBackend)
+            model("incremental/inlineFunCallSite", extension = null, excludeParentDirs = true, targetBackend = targetBackend)
+            model("incremental/withJava", extension = null, excludeParentDirs = true, targetBackend = targetBackend)
+            model("incremental/incrementalJvmCompilerOnly", extension = null, excludeParentDirs = true, targetBackend = targetBackend)
         }
+        testClass<AbstractIncrementalJvmCompilerRunnerTest>(init = incrementalJvmTestData(TargetBackend.JVM))
+        testClass<AbstractIrIncrementalJvmCompilerRunnerTest>(init = incrementalJvmTestData(TargetBackend.JVM_IR))
 
         testClass<AbstractIncrementalJsCompilerRunnerTest> {
             model("incremental/pureKotlin", extension = null, recursive = false)
diff --git a/jps-plugin/testData/incremental/inlineFunCallSite/coroutine/directives.txt b/jps-plugin/testData/incremental/inlineFunCallSite/coroutine/directives.txt
new file mode 100644
index 00000000000..5099b2ad971
--- /dev/null
+++ b/jps-plugin/testData/incremental/inlineFunCallSite/coroutine/directives.txt
@@ -0,0 +1 @@
+// IGNORE_BACKEND: JVM_IR
diff --git a/jps-plugin/testData/incremental/pureKotlin/constantValueChanged/directives.txt b/jps-plugin/testData/incremental/pureKotlin/constantValueChanged/directives.txt
new file mode 100644
index 00000000000..5099b2ad971
--- /dev/null
+++ b/jps-plugin/testData/incremental/pureKotlin/constantValueChanged/directives.txt
@@ -0,0 +1 @@
+// IGNORE_BACKEND: JVM_IR
diff --git a/jps-plugin/testData/incremental/pureKotlin/inlinePropertyInClass/directives.txt b/jps-plugin/testData/incremental/pureKotlin/inlinePropertyInClass/directives.txt
new file mode 100644
index 00000000000..5099b2ad971
--- /dev/null
+++ b/jps-plugin/testData/incremental/pureKotlin/inlinePropertyInClass/directives.txt
@@ -0,0 +1 @@
+// IGNORE_BACKEND: JVM_IR
diff --git a/jps-plugin/testData/incremental/pureKotlin/inlinePropertyOnTopLevel/directives.txt b/jps-plugin/testData/incremental/pureKotlin/inlinePropertyOnTopLevel/directives.txt
new file mode 100644
index 00000000000..5099b2ad971
--- /dev/null
+++ b/jps-plugin/testData/incremental/pureKotlin/inlinePropertyOnTopLevel/directives.txt
@@ -0,0 +1 @@
+// IGNORE_BACKEND: JVM_IR
diff --git a/jps-plugin/testData/incremental/pureKotlin/inlineSuspendFunctionChanged/directives.txt b/jps-plugin/testData/incremental/pureKotlin/inlineSuspendFunctionChanged/directives.txt
new file mode 100644
index 00000000000..5099b2ad971
--- /dev/null
+++ b/jps-plugin/testData/incremental/pureKotlin/inlineSuspendFunctionChanged/directives.txt
@@ -0,0 +1 @@
+// IGNORE_BACKEND: JVM_IR
diff --git a/jps-plugin/testData/incremental/withJava/other/conflictingPlatformDeclarations/directives.txt b/jps-plugin/testData/incremental/withJava/other/conflictingPlatformDeclarations/directives.txt
new file mode 100644
index 00000000000..5099b2ad971
--- /dev/null
+++ b/jps-plugin/testData/incremental/withJava/other/conflictingPlatformDeclarations/directives.txt
@@ -0,0 +1 @@
+// IGNORE_BACKEND: JVM_IR
diff --git a/jps-plugin/testData/incremental/withJava/other/inlineTopLevelFunctionWithJvmName/directives.txt b/jps-plugin/testData/incremental/withJava/other/inlineTopLevelFunctionWithJvmName/directives.txt
new file mode 100644
index 00000000000..5099b2ad971
--- /dev/null
+++ b/jps-plugin/testData/incremental/withJava/other/inlineTopLevelFunctionWithJvmName/directives.txt
@@ -0,0 +1 @@
+// IGNORE_BACKEND: JVM_IR
diff --git a/jps-plugin/testData/incremental/withJava/other/inlineTopLevelValPropertyWithJvmName/directives.txt b/jps-plugin/testData/incremental/withJava/other/inlineTopLevelValPropertyWithJvmName/directives.txt
new file mode 100644
index 00000000000..5099b2ad971
--- /dev/null
+++ b/jps-plugin/testData/incremental/withJava/other/inlineTopLevelValPropertyWithJvmName/directives.txt
@@ -0,0 +1 @@
+// IGNORE_BACKEND: JVM_IR
diff --git a/jps-plugin/testData/incremental/withJava/other/innerClassNotGeneratedWhenRebuilding/directives.txt b/jps-plugin/testData/incremental/withJava/other/innerClassNotGeneratedWhenRebuilding/directives.txt
new file mode 100644
index 00000000000..5099b2ad971
--- /dev/null
+++ b/jps-plugin/testData/incremental/withJava/other/innerClassNotGeneratedWhenRebuilding/directives.txt
@@ -0,0 +1 @@
+// IGNORE_BACKEND: JVM_IR
diff --git a/jps-plugin/testData/incremental/withJava/other/multifileClassAddTopLevelFunWithDefault/directives.txt b/jps-plugin/testData/incremental/withJava/other/multifileClassAddTopLevelFunWithDefault/directives.txt
new file mode 100644
index 00000000000..5099b2ad971
--- /dev/null
+++ b/jps-plugin/testData/incremental/withJava/other/multifileClassAddTopLevelFunWithDefault/directives.txt
@@ -0,0 +1 @@
+// IGNORE_BACKEND: JVM_IR
diff --git a/jps-plugin/testData/incremental/withJava/other/multifileClassFileAdded/directives.txt b/jps-plugin/testData/incremental/withJava/other/multifileClassFileAdded/directives.txt
new file mode 100644
index 00000000000..5099b2ad971
--- /dev/null
+++ b/jps-plugin/testData/incremental/withJava/other/multifileClassFileAdded/directives.txt
@@ -0,0 +1 @@
+// IGNORE_BACKEND: JVM_IR
diff --git a/jps-plugin/testData/incremental/withJava/other/multifileClassFileChanged/directives.txt b/jps-plugin/testData/incremental/withJava/other/multifileClassFileChanged/directives.txt
new file mode 100644
index 00000000000..5099b2ad971
--- /dev/null
+++ b/jps-plugin/testData/incremental/withJava/other/multifileClassFileChanged/directives.txt
@@ -0,0 +1 @@
+// IGNORE_BACKEND: JVM_IR
diff --git a/jps-plugin/testData/incremental/withJava/other/multifileClassFileMovedToAnotherMultifileClass/directives.txt b/jps-plugin/testData/incremental/withJava/other/multifileClassFileMovedToAnotherMultifileClass/directives.txt
new file mode 100644
index 00000000000..5099b2ad971
--- /dev/null
+++ b/jps-plugin/testData/incremental/withJava/other/multifileClassFileMovedToAnotherMultifileClass/directives.txt
@@ -0,0 +1 @@
+// IGNORE_BACKEND: JVM_IR
diff --git a/jps-plugin/testData/incremental/withJava/other/multifilePackagePartMethodAdded/directives.txt b/jps-plugin/testData/incremental/withJava/other/multifilePackagePartMethodAdded/directives.txt
new file mode 100644
index 00000000000..5099b2ad971
--- /dev/null
+++ b/jps-plugin/testData/incremental/withJava/other/multifilePackagePartMethodAdded/directives.txt
@@ -0,0 +1 @@
+// IGNORE_BACKEND: JVM_IR
diff --git a/jps-plugin/testData/incremental/withJava/other/multifilePartsWithProperties/directives.txt b/jps-plugin/testData/incremental/withJava/other/multifilePartsWithProperties/directives.txt
new file mode 100644
index 00000000000..5099b2ad971
--- /dev/null
+++ b/jps-plugin/testData/incremental/withJava/other/multifilePartsWithProperties/directives.txt
@@ -0,0 +1 @@
+// IGNORE_BACKEND: JVM_IR
diff --git a/jps-plugin/testData/incremental/withJava/other/packageFacadeToClass/directives.txt b/jps-plugin/testData/incremental/withJava/other/packageFacadeToClass/directives.txt
new file mode 100644
index 00000000000..5099b2ad971
--- /dev/null
+++ b/jps-plugin/testData/incremental/withJava/other/packageFacadeToClass/directives.txt
@@ -0,0 +1 @@
+// IGNORE_BACKEND: JVM_IR