Add IR equivalent of the WriteFlags test

compiler/testData/writeFlags/callableReference/visibility/functionReference.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class A {
     fun foo() {}
 

compiler/testData/writeFlags/callableReference/visibility/functionReferenceInInlineFunction.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class A {
     fun foo() {}
 

compiler/testData/writeFlags/callableReference/visibility/propertyReference.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class A {
     val foo = ""
 

compiler/testData/writeFlags/callableReference/visibility/propertyReferenceInInlineFunction.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class A {
     val foo = ""
 

compiler/testData/writeFlags/class/accessFlags/mappingWhen.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 
 enum class BigEnum {
     ITEM1,

compiler/testData/writeFlags/class/deprecatedFlag/class.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 @Deprecated("") class MyClass() {
 }
 

compiler/testData/writeFlags/class/deprecatedFlag/classObject.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass {
     @Deprecated("") companion object {
 

compiler/testData/writeFlags/class/deprecatedFlag/enumClass.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 @Deprecated("") enum class MyEnum {
     FIRST
 }

compiler/testData/writeFlags/class/deprecatedFlag/innerClass.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
     @Deprecated("") public class MyInnerClass() {}
 }

compiler/testData/writeFlags/class/deprecatedFlag/trait.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 @Deprecated("") public interface MyTrait {
 }
 

compiler/testData/writeFlags/class/visibility/internal/enum.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 enum class MyClass() {
 }
 

compiler/testData/writeFlags/class/visibility/internal/innerEnum.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Foo {
   enum class MyClass() {
   }

compiler/testData/writeFlags/class/visibility/private/enum.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 private enum class MyClass() {
 }
 

compiler/testData/writeFlags/class/visibility/private/innerEnum.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 // NO_FLAGS because we put enum in companion object of foo. When it will be fixed - MyClass should have ACC_PRIVATE flag
 
 class Foo {

compiler/testData/writeFlags/class/visibility/public/enum.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 public enum class MyClass() {
 }
 

compiler/testData/writeFlags/class/visibility/public/innerEnum.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Foo {
   public enum class MyClass() {
   }

compiler/testData/writeFlags/function/constructors/enum.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 enum class Foo {
     A, B, C
 }

compiler/testData/writeFlags/function/constructors/objectLiteral.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Foo {
   fun a() {
     val s = object { }

compiler/testData/writeFlags/function/deprecatedFlag/getterAnnotationOnProperty.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
     @Deprecated("") val test = ""
 }

compiler/testData/writeFlags/function/deprecatedFlag/setterAnnotationOnProperty.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
     @Deprecated("") var test = ""
 }

compiler/testData/writeFlags/function/withDefaultArguments/funInClass.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
     fun test(s: String = "") {}
 }

compiler/testData/writeFlags/function/withDefaultArguments/funInClassObject.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
     companion object {
         fun test(s: String, x:Int = 10) {}

compiler/testData/writeFlags/function/withDefaultArguments/inlineOnlyFunInClass.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
     @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
     @kotlin.internal.InlineOnly

compiler/testData/writeFlags/function/withDefaultArguments/reifiedFunInClass.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
     inline fun <reified T> test(s: String = "") {}
 }

compiler/testData/writeFlags/function/withDefaultArguments/topLevelFun.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 fun test(s: String = "") {}
 
 // TESTED_OBJECT_KIND: function

compiler/testData/writeFlags/hidden/function.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
     @Deprecated("hidden", level = DeprecationLevel.HIDDEN)
     fun test() {}

compiler/testData/writeFlags/hidden/propertyGetter.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
     @Deprecated("hidden", level = DeprecationLevel.HIDDEN)
     var test: Int

compiler/testData/writeFlags/hidden/propertySetter.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
     @Deprecated("hidden", level = DeprecationLevel.HIDDEN)
     var test: Int

compiler/testData/writeFlags/inline/lostInnerClass.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Introspector {
     inner class SchemaRetriever(val transaction: String) {
         inline fun inSchema(crossinline modifier: (String) -> Unit) =

compiler/testData/writeFlags/inline/lostInnerClass2.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Introspector {
 
     class SchemaRetriever(val transaction: String) {

compiler/testData/writeFlags/inline/lostInnerClass3.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Introspector {
     fun test() {
         class SchemaRetriever(val transaction: String) {

compiler/testData/writeFlags/jvm8/defaults/compatibility/propertyAccessors.kt

@@ -1,4 +1,5 @@
 // !JVM_DEFAULT_MODE: compatibility
+// IGNORE_BACKEND: JVM_IR
 // JVM_TARGET: 1.8
 // WITH_RUNTIME
 

compiler/testData/writeFlags/jvm8/defaults/compatibility/propertyAnnotation.kt

@@ -1,4 +1,5 @@
 // !JVM_DEFAULT_MODE: compatibility
+// IGNORE_BACKEND: JVM_IR
 // JVM_TARGET: 1.8
 // WITH_RUNTIME
 

compiler/testData/writeFlags/jvm8/defaults/defaultMethod.kt

@@ -1,4 +1,5 @@
 // !JVM_DEFAULT_MODE: enable
+// IGNORE_BACKEND: JVM_IR
 // JVM_TARGET: 1.8
 // WITH_RUNTIME
 

compiler/testData/writeFlags/jvm8/defaults/defaultProperty.kt

@@ -1,4 +1,5 @@
 // !JVM_DEFAULT_MODE: enable
+// IGNORE_BACKEND: JVM_IR
 // JVM_TARGET: 1.8
 // WITH_RUNTIME
 

compiler/testData/writeFlags/jvm8/defaults/propertyAnnotation.kt

@@ -1,4 +1,5 @@
 // !JVM_DEFAULT_MODE: enable
+// IGNORE_BACKEND: JVM_IR
 // JVM_TARGET: 1.8
 // WITH_RUNTIME
 

compiler/testData/writeFlags/lambda/lambdaInInlineFunction.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Foo {
     inline fun foo() = { }
 }

compiler/testData/writeFlags/lambda/simpleLambda.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Foo {
     fun foo() = { }
 }

compiler/testData/writeFlags/lateinit/lateinitProperty.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class My {
     lateinit var s: String
         private set

compiler/testData/writeFlags/property/classObject/class/internalVar.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test {
   companion object {
     var prop: Int = 0;

compiler/testData/writeFlags/property/classObject/class/internalVarPrivateSet.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test {
   companion object {
     var prop: Int = 0

compiler/testData/writeFlags/property/classObject/class/protectedVarPrivateSet.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test {
   companion object {
     protected var prop: Int = 0

compiler/testData/writeFlags/property/classObject/class/publicValNonDefault.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test {
   companion object {
     public val prop: Int = 0

compiler/testData/writeFlags/property/classObject/class/publicVar.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test {
   companion object {
     public var prop: Int = 0;

compiler/testData/writeFlags/property/classObject/class/publicVarNonDefault.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test {
   companion object {
     public var prop: Int = 0

compiler/testData/writeFlags/property/classObject/class/publicVarPrivateSet.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test {
   companion object {
     public var prop: Int = 0

compiler/testData/writeFlags/property/classObject/class/publicVarProtectedSet.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test {
   companion object {
     public var prop: Int = 0

compiler/testData/writeFlags/property/classObject/class/publicVarPublicSet.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test {
   companion object {
     public var prop: Int = 0

compiler/testData/writeFlags/property/classObject/rename/constructorAndClassObject.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test(val prop: String) {
 
   companion object {

compiler/testData/writeFlags/property/classObject/rename/delegatedAndDelegated.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 import kotlin.reflect.KProperty
 
 public open class TestDelegate<T: Any>(private val initializer: () -> T) {

compiler/testData/writeFlags/property/classObject/rename/delegatedAndProperty.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 import kotlin.reflect.KProperty
 
 public open class TestDelegate<T: Any>(private val initializer: () -> T) {

compiler/testData/writeFlags/property/classObject/rename/propertyAndProperty.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Test {
 
   public var prop: Int = 0;

compiler/testData/writeFlags/property/classObject/trait/delegatedProtectedVar.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 import kotlin.reflect.KProperty
 
 class TestDelegate() {

compiler/testData/writeFlags/property/classObject/trait/delegatedPublicVal.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 import kotlin.reflect.KProperty
 
 class TestDelegate() {

compiler/testData/writeFlags/property/classObject/trait/internalConstVal.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
   companion object {
     internal const val prop: Int = 0;

compiler/testData/writeFlags/property/classObject/trait/internalVal.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
   companion object {
     internal val prop: Int = 0;

compiler/testData/writeFlags/property/classObject/trait/internalVar.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
   companion object {
     internal var prop: Int = 0;

compiler/testData/writeFlags/property/classObject/trait/internalVarPrivateSet.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
   companion object {
     internal var prop: Int = 0

compiler/testData/writeFlags/property/classObject/trait/privateVal.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
   companion object {
     private val prop = 0;

compiler/testData/writeFlags/property/classObject/trait/privateVar.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
   companion object {
     private var prop = 0;

compiler/testData/writeFlags/property/classObject/trait/protectedConstVal.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
   companion object {
     protected const val prop: Int = 0

compiler/testData/writeFlags/property/classObject/trait/protectedVal.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
   companion object {
     protected val prop: Int = 0

compiler/testData/writeFlags/property/classObject/trait/protectedVarPrivateSet.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
   companion object {
     protected var prop: Int = 0

compiler/testData/writeFlags/property/classObject/trait/publicConstVal.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
   companion object {
     public const val prop: Int = 0;

compiler/testData/writeFlags/property/classObject/trait/publicVal.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
   companion object {
     public val prop: Int = 0;

compiler/testData/writeFlags/property/classObject/trait/publicValNonDefault.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
   companion object {
     public val prop: Int = 0

compiler/testData/writeFlags/property/classObject/trait/publicVar.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
   companion object {
     public var prop: Int = 0

compiler/testData/writeFlags/property/classObject/trait/publicVarNonDefault.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
   companion object {
     public var prop: Int = 0

compiler/testData/writeFlags/property/classObject/trait/publicVarPrivateSet.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
   companion object {
     public var prop: Int = 0

compiler/testData/writeFlags/property/classObject/trait/publicVarProtectedSet.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
   companion object {
     public var prop: Int = 0

compiler/testData/writeFlags/property/classObject/trait/publicVarPublicSet.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 interface Test {
   companion object {
     public var prop: Int = 0

compiler/testData/writeFlags/property/deprecatedFlag/propertyInClass.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class MyClass() {
     @Deprecated("") public val test: Int = 0
 }

compiler/testData/writeFlags/property/deprecatedFlag/topLevelProperty.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 @Deprecated("") val test: Int = 0
 
 // TESTED_OBJECT_KIND: property

compiler/testData/writeFlags/property/syntheticAnnotationsMethod/privateProperty.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Foo {
     annotation class Anno
 

compiler/testData/writeFlags/property/syntheticAnnotationsMethod/protectedProperty.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 open class Foo {
     annotation class Anno
 

compiler/testData/writeFlags/property/syntheticAnnotationsMethod/publicProperty.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 class Foo {
     annotation class Anno
 

compiler/testData/writeFlags/typealias/syntheticAnnotationsMethod/privateTypealias.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 @Target(AnnotationTarget.TYPEALIAS)
 annotation class Anno
 

compiler/testData/writeFlags/typealias/syntheticAnnotationsMethod/publicTypealias.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 @Target(AnnotationTarget.TYPEALIAS)
 annotation class Anno
 

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrWriteFlagsTest.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. 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.codegen.ir
+
+import org.jetbrains.kotlin.codegen.flags.AbstractWriteFlagsTest
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.JVMConfigurationKeys
+import org.jetbrains.kotlin.test.TargetBackend
+
+abstract class AbstractIrWriteFlagsTest : AbstractWriteFlagsTest() {
+    override fun updateConfiguration(configuration: CompilerConfiguration) {
+        configuration.put(JVMConfigurationKeys.IR, true)
+    }
+}

compiler/tests/org/jetbrains/kotlin/codegen/flags/WriteFlagsTestGenerated.java

@@ -22,11 +22,11 @@ import java.util.regex.Pattern;
 @RunWith(JUnit3RunnerWithInners.class)
 public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
     private void runTest(String testDataFilePath) throws Exception {
-        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
     }
 
     public void testAllFilesPresentInWriteFlags() throws Exception {
-        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
     }
 
     @TestMetadata("compiler/testData/writeFlags/callableReference")
@@ -34,11 +34,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
     @RunWith(JUnit3RunnerWithInners.class)
     public static class CallableReference extends AbstractWriteFlagsTest {
         private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
         }
 
         public void testAllFilesPresentInCallableReference() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/callableReference"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/callableReference"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
         }
 
         @TestMetadata("compiler/testData/writeFlags/callableReference/visibility")
@@ -46,11 +46,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Visibility extends AbstractWriteFlagsTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInVisibility() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/callableReference/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/callableReference/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("functionReference.kt")
@@ -80,11 +80,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Class extends AbstractWriteFlagsTest {
         private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
         }
 
         public void testAllFilesPresentInClass() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
         }
 
         @TestMetadata("compiler/testData/writeFlags/class/accessFlags")
@@ -92,11 +92,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
         @RunWith(JUnit3RunnerWithInners.class)
         public static class AccessFlags extends AbstractWriteFlagsTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInAccessFlags() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/accessFlags"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/accessFlags"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("defaultImpls.kt")
@@ -150,11 +150,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
         @RunWith(JUnit3RunnerWithInners.class)
         public static class DeprecatedFlag extends AbstractWriteFlagsTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInDeprecatedFlag() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("class.kt")
@@ -188,11 +188,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Visibility extends AbstractWriteFlagsTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInVisibility() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("compiler/testData/writeFlags/class/visibility/internal")
@@ -200,11 +200,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Internal extends AbstractWriteFlagsTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInInternal() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/internal"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/internal"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                 }
 
                 @TestMetadata("class.kt")
@@ -253,11 +253,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Packageprivate extends AbstractWriteFlagsTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInPackageprivate() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/packageprivate"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/packageprivate"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                 }
 
                 @TestMetadata("enumEntry.kt")
@@ -271,11 +271,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Private extends AbstractWriteFlagsTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInPrivate() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/private"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/private"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                 }
 
                 @TestMetadata("class.kt")
@@ -324,11 +324,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Public extends AbstractWriteFlagsTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInPublic() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/public"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/public"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                 }
 
                 @TestMetadata("class.kt")
@@ -379,11 +379,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
     @RunWith(JUnit3RunnerWithInners.class)
     public static class DelegatedProperty extends AbstractWriteFlagsTest {
         private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
         }
 
         public void testAllFilesPresentInDelegatedProperty() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
         }
 
         @TestMetadata("compiler/testData/writeFlags/delegatedProperty/visibility")
@@ -391,11 +391,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Visibility extends AbstractWriteFlagsTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInVisibility() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/delegatedProperty/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/delegatedProperty/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("privateSet.kt")
@@ -410,11 +410,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Function extends AbstractWriteFlagsTest {
         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("compiler/testData/writeFlags/function"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/function"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
         }
 
         @TestMetadata("compiler/testData/writeFlags/function/classObjectPrivate")
@@ -422,11 +422,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
         @RunWith(JUnit3RunnerWithInners.class)
         public static class ClassObjectPrivate extends AbstractWriteFlagsTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInClassObjectPrivate() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/function/classObjectPrivate"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/function/classObjectPrivate"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("privateFun.kt")
@@ -450,11 +450,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Constructors extends AbstractWriteFlagsTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInConstructors() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/function/constructors"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/function/constructors"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("classObject.kt")
@@ -488,11 +488,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
         @RunWith(JUnit3RunnerWithInners.class)
         public static class DeprecatedFlag extends AbstractWriteFlagsTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInDeprecatedFlag() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/function/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/function/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("emptyGetter.kt")
@@ -561,11 +561,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
         @RunWith(JUnit3RunnerWithInners.class)
         public static class WithDefaultArguments extends AbstractWriteFlagsTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInWithDefaultArguments() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/function/withDefaultArguments"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/function/withDefaultArguments"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("funInClass.kt")
@@ -600,11 +600,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Hidden extends AbstractWriteFlagsTest {
         private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
         }
 
         public void testAllFilesPresentInHidden() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/hidden"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/hidden"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
         }
 
         @TestMetadata("function.kt")
@@ -628,11 +628,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Inline extends AbstractWriteFlagsTest {
         private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
         }
 
         public void testAllFilesPresentInInline() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/inline"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/inline"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
         }
 
         @TestMetadata("lostInnerClass.kt")
@@ -656,11 +656,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
     @RunWith(JUnit3RunnerWithInners.class)
     public static class InnerClass extends AbstractWriteFlagsTest {
         private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
         }
 
         public void testAllFilesPresentInInnerClass() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/innerClass"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/innerClass"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
         }
 
         @TestMetadata("compiler/testData/writeFlags/innerClass/visibility")
@@ -668,11 +668,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Visibility extends AbstractWriteFlagsTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInVisibility() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/innerClass/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/innerClass/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("internal.kt")
@@ -712,11 +712,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Jvm8 extends AbstractWriteFlagsTest {
         private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
         }
 
         public void testAllFilesPresentInJvm8() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/jvm8"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/jvm8"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
         }
 
         @TestMetadata("interfaceMethod.kt")
@@ -734,11 +734,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Defaults extends AbstractWriteFlagsTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInDefaults() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("defaultMethod.kt")
@@ -761,11 +761,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Compatibility extends AbstractWriteFlagsTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInCompatibility() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                 }
 
                 @TestMetadata("propertyAccessors.kt")
@@ -786,11 +786,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Lambda extends AbstractWriteFlagsTest {
         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("compiler/testData/writeFlags/lambda"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/lambda"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
         }
 
         @TestMetadata("lambdaInInlineFunction.kt")
@@ -809,11 +809,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Lateinit extends AbstractWriteFlagsTest {
         private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
         }
 
         public void testAllFilesPresentInLateinit() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/lateinit"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/lateinit"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
         }
 
         @TestMetadata("lateinitGetter.kt")
@@ -837,11 +837,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Property extends AbstractWriteFlagsTest {
         private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
         }
 
         public void testAllFilesPresentInProperty() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
         }
 
         @TestMetadata("compiler/testData/writeFlags/property/classObject")
@@ -849,11 +849,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
         @RunWith(JUnit3RunnerWithInners.class)
         public static class ClassObject extends AbstractWriteFlagsTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInClassObject() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/classObject"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/classObject"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("compiler/testData/writeFlags/property/classObject/class")
@@ -861,11 +861,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Class extends AbstractWriteFlagsTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInClass() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/class"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/class"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                 }
 
                 @TestMetadata("delegatedProtectedVar.kt")
@@ -959,11 +959,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Rename extends AbstractWriteFlagsTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInRename() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/rename"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/rename"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                 }
 
                 @TestMetadata("constructorAndClassObject.kt")
@@ -992,11 +992,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Trait extends AbstractWriteFlagsTest {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInTrait() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/trait"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/trait"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
                 }
 
                 @TestMetadata("delegatedProtectedVar.kt")
@@ -1106,11 +1106,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
         @RunWith(JUnit3RunnerWithInners.class)
         public static class DeprecatedFlag extends AbstractWriteFlagsTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInDeprecatedFlag() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("propertyInClass.kt")
@@ -1129,11 +1129,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
         @RunWith(JUnit3RunnerWithInners.class)
         public static class SyntheticAnnotationsMethod extends AbstractWriteFlagsTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInSyntheticAnnotationsMethod() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/syntheticAnnotationsMethod"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/syntheticAnnotationsMethod"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("privateProperty.kt")
@@ -1157,11 +1157,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Visibility extends AbstractWriteFlagsTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInVisibility() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/property/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("internal.kt")
@@ -1186,11 +1186,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Typealias extends AbstractWriteFlagsTest {
         private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
         }
 
         public void testAllFilesPresentInTypealias() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/typealias"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/typealias"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
         }
 
         @TestMetadata("compiler/testData/writeFlags/typealias/syntheticAnnotationsMethod")
@@ -1198,11 +1198,11 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest {
         @RunWith(JUnit3RunnerWithInners.class)
         public static class SyntheticAnnotationsMethod extends AbstractWriteFlagsTest {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
             }
 
             public void testAllFilesPresentInSyntheticAnnotationsMethod() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/typealias/syntheticAnnotationsMethod"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/writeFlags/typealias/syntheticAnnotationsMethod"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
             }
 
             @TestMetadata("privateTypealias.kt")

compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt

@@ -221,7 +221,7 @@ fun main(args: Array<String>) {
         }
 
         testClass<AbstractWriteFlagsTest> {
-            model("writeFlags")
+            model("writeFlags", targetBackend = TargetBackend.JVM)
         }
 
         testClass<AbstractDefaultArgumentsReflectionTest> {
@@ -373,6 +373,10 @@ fun main(args: Array<String>) {
             model("checkLocalVariablesTable", targetBackend = TargetBackend.JVM_IR)
         }
 
+        testClass<AbstractIrWriteFlagsTest> {
+            model("writeFlags", targetBackend = TargetBackend.JVM_IR)
+        }
+
         testClass<AbstractIrLineNumberTest> {
             model("lineNumber", targetBackend = TargetBackend.JVM_IR)
         }