[Test] Add empty platform module for MPP diagnostic test with only one module

After previous commits IrActualizer runs only there are at least two modules
  in backend input. So to check diagnostics from Actualizer all tests
  should contain at least two modules

Diagnostics in test `extendExpectedClassWithAbstractMember.kt` were
  changed because there is an exception from IrActualizer caused by
  errors from frontend (`ABSTRACT_METHOD_NOT_IMPLEMENTED`), which is
  swallowed by this kind of tests

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/resolve/extensions/KtResolveExtensionTestSupport.kt

@@ -18,6 +18,7 @@ import org.jetbrains.kotlin.test.directives.model.DirectiveApplicability
 import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer
 import org.jetbrains.kotlin.test.model.TestFile
 import org.jetbrains.kotlin.test.model.TestModule
+import org.jetbrains.kotlin.test.services.DefaultsProvider
 import org.jetbrains.kotlin.test.services.ModuleStructureTransformer
 import org.jetbrains.kotlin.test.services.TestModuleStructure
 import org.jetbrains.kotlin.test.services.TestServices
@@ -59,7 +60,7 @@ object KtResolveExtensionTestSupport {
     private class ResolveExtensionDirectiveModuleStructureTransformer(
         private val testServices: TestServices,
     ) : ModuleStructureTransformer() {
-        override fun transformModuleStructure(moduleStructure: TestModuleStructure): TestModuleStructure {
+        override fun transformModuleStructure(moduleStructure: TestModuleStructure, defaultsProvider: DefaultsProvider): TestModuleStructure {
             check(Directives.WITH_RESOLVE_EXTENSION in moduleStructure.allDirectives) {
                 "configureResolveExtensions() was called, but no modules specify WITH_RESOLVE_EXTENSION."
             }
@@ -138,4 +139,4 @@ object KtResolveExtensionTestSupport {
         useDirectives(Directives)
         useModuleStructureTransformers(KtResolveExtensionTestSupport::ResolveExtensionDirectiveModuleStructureTransformer)
     }
-}
+}

compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/ModuleStructureTransformer.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.test.TestInfrastructureInternals
 
 @TestInfrastructureInternals
 abstract class ModuleStructureTransformer {
-    abstract fun transformModuleStructure(moduleStructure: TestModuleStructure): TestModuleStructure
+    abstract fun transformModuleStructure(moduleStructure: TestModuleStructure, defaultsProvider: DefaultsProvider): TestModuleStructure
 }
 
 class ExceptionFromModuleStructureTransformer(

compiler/testData/diagnostics/tests/multiplatform/checkNoActualForExpectInLastModule.fir.kt

@@ -1,4 +1,4 @@
 // ISSUE: KT-58483
 // MODULE: jvm
 // FILE: jvm.kt
-<!NO_ACTUAL_FOR_EXPECT!>expect class A<!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect class A<!>

compiler/testData/diagnostics/tests/multiplatform/enum/constructorInHeaderEnum.fir.kt

@@ -1,7 +1,7 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-<!NO_ACTUAL_FOR_EXPECT!>expect enum class En<!EXPECTED_ENUM_CONSTRUCTOR!>(x: Int)<!> {
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect enum class En<!EXPECTED_ENUM_CONSTRUCTOR!>(x: Int)<!> {
     E1,
     E2<!SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS!>(42)<!>,
     ;
@@ -9,6 +9,6 @@
     <!EXPECTED_ENUM_CONSTRUCTOR!>constructor(s: String)<!>
 }<!>
 
-<!NO_ACTUAL_FOR_EXPECT!>expect enum class En2 {
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect enum class En2 {
     E1<!SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS!>()<!>
 }<!>

compiler/testData/diagnostics/tests/multiplatform/enum/enumEntryWithBody.fir.kt

@@ -1,7 +1,7 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-<!NO_ACTUAL_FOR_EXPECT!>expect enum class En {
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect enum class En {
     E1,
     <!EXPECTED_ENUM_ENTRY_WITH_BODY!>E2 {
         <!EXPECTED_DECLARATION_WITH_BODY!>fun foo()<!> = ""

compiler/testData/diagnostics/tests/multiplatform/headerClass/expectClassWithExplicitAbstractMember.fir.kt

@@ -5,7 +5,7 @@ interface Foo {
     fun foo()
 }
 
-<!NO_ACTUAL_FOR_EXPECT!>expect class NonAbstractClass : Foo {
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect class NonAbstractClass : Foo {
     <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS!>abstract<!> fun bar()
 
     <!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val baz: Int
@@ -13,7 +13,7 @@ interface Foo {
     <!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS!>abstract<!> override fun foo()
 }<!>
 
-<!NO_ACTUAL_FOR_EXPECT!>expect abstract class AbstractClass : Foo {
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect abstract class AbstractClass : Foo {
     abstract fun bar()
 
     abstract val baz: Int

compiler/testData/diagnostics/tests/multiplatform/headerClass/explicitConstructorDelegation.fir.kt

@@ -1,12 +1,12 @@
 // MODULE: m1-common
 // FILE: common.kt
-<!NO_ACTUAL_FOR_EXPECT!>expect open class A {
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect open class A {
     constructor(s: String)
 
     constructor(n: Number) : <!EXPECTED_CLASS_CONSTRUCTOR_DELEGATION_CALL!>this<!>("A")
 }<!>
 
-<!NO_ACTUAL_FOR_EXPECT!>expect class B : A {
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect class B : A {
     constructor(i: Int)
 
     constructor() : <!EXPECTED_CLASS_CONSTRUCTOR_DELEGATION_CALL!>super<!>("B")

compiler/testData/diagnostics/tests/multiplatform/headerClass/extendExpectedClassWithAbstractMember.fir.kt

@@ -1,10 +1,10 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-<!NO_ACTUAL_FOR_EXPECT!>expect abstract class BaseA() {
+expect abstract class BaseA() {
     abstract fun foo()
-}<!>
+}
-<!NO_ACTUAL_FOR_EXPECT!>expect open <!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class BaseAImpl<!>() : BaseA<!>
+expect open <!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class BaseAImpl<!>() : BaseA
 
 <!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class DerivedA1<!> : BaseAImpl()
 class DerivedA2 : BaseAImpl() {
@@ -13,10 +13,10 @@ class DerivedA2 : BaseAImpl() {
 
 
 
-<!NO_ACTUAL_FOR_EXPECT!>expect interface BaseB {
+expect interface BaseB {
     fun foo()
-}<!>
+}
-<!NO_ACTUAL_FOR_EXPECT!>expect open <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class BaseBImpl<!>() : BaseB<!>
+expect open <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class BaseBImpl<!>() : BaseB
 
 <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class DerivedB1<!> : BaseBImpl()
 class DerivedB2 : BaseBImpl() {
@@ -25,10 +25,10 @@ class DerivedB2 : BaseBImpl() {
 
 
 
-<!NO_ACTUAL_FOR_EXPECT!>expect interface BaseC {
+expect interface BaseC {
     fun foo()
-}<!>
+}
-<!NO_ACTUAL_FOR_EXPECT!>expect abstract class BaseCImpl() : BaseC<!>
+expect abstract class BaseCImpl() : BaseC
 
 <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class DerivedC1<!> : BaseCImpl()
 class DerivedC2 : BaseCImpl() {
@@ -37,35 +37,35 @@ class DerivedC2 : BaseCImpl() {
 
 
 
-<!NO_ACTUAL_FOR_EXPECT!>expect interface BaseD {
+expect interface BaseD {
     fun foo()
-}<!>
+}
 abstract class BaseDImpl() : BaseD {
     fun bar() = super.<!ABSTRACT_SUPER_CALL!>foo<!>()
 }
 
 
 
-<!NO_ACTUAL_FOR_EXPECT!>expect interface BaseE {
+expect interface BaseE {
     fun foo()
-}<!>
+}
 sealed class BaseEImpl() : BaseE {
     fun bar() = super.<!ABSTRACT_SUPER_CALL!>foo<!>()
 }
 
 
 
-<!NO_ACTUAL_FOR_EXPECT!>expect interface BaseF {
+expect interface BaseF {
     fun foo()
-}<!>
+}
-<!NO_ACTUAL_FOR_EXPECT!>expect <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class BaseFImpl<!>() : BaseF<!>
+expect <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class BaseFImpl<!>() : BaseF
 
 
 
-<!NO_ACTUAL_FOR_EXPECT!>expect abstract class BaseG() {
+expect abstract class BaseG() {
     abstract fun foo()
-}<!>
+}
-<!NO_ACTUAL_FOR_EXPECT!>expect open class BaseGImpl() : BaseG {
+expect open class BaseGImpl() : BaseG {
     override fun foo()
-}<!>
+}
 class DerivedG1 : BaseGImpl()

compiler/testData/diagnostics/tests/multiplatform/headerClass/extendExpectedClassWithAbstractMember.ll.kt

@@ -1,71 +0,0 @@
-// MODULE: m1-common
-// FILE: common.kt
-
-expect abstract class BaseA() {
-    abstract fun foo()
-}
-expect open <!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class BaseAImpl<!>() : BaseA
-
-<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class DerivedA1<!> : BaseAImpl()
-class DerivedA2 : BaseAImpl() {
-    override fun foo() = super.<!ABSTRACT_SUPER_CALL!>foo<!>()
-}
-
-
-
-expect interface BaseB {
-    fun foo()
-}
-expect open <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class BaseBImpl<!>() : BaseB
-
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class DerivedB1<!> : BaseBImpl()
-class DerivedB2 : BaseBImpl() {
-    override fun foo() = super.<!ABSTRACT_SUPER_CALL!>foo<!>()
-}
-
-
-
-expect interface BaseC {
-    fun foo()
-}
-expect abstract class BaseCImpl() : BaseC
-
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class DerivedC1<!> : BaseCImpl()
-class DerivedC2 : BaseCImpl() {
-    override fun foo() = super.<!ABSTRACT_SUPER_CALL!>foo<!>()
-}
-
-
-
-expect interface BaseD {
-    fun foo()
-}
-abstract class BaseDImpl() : BaseD {
-    fun bar() = super.<!ABSTRACT_SUPER_CALL!>foo<!>()
-}
-
-
-
-expect interface BaseE {
-    fun foo()
-}
-sealed class BaseEImpl() : BaseE {
-    fun bar() = super.<!ABSTRACT_SUPER_CALL!>foo<!>()
-}
-
-
-
-expect interface BaseF {
-    fun foo()
-}
-expect <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class BaseFImpl<!>() : BaseF
-
-
-
-expect abstract class BaseG() {
-    abstract fun foo()
-}
-expect open class BaseGImpl() : BaseG {
-    override fun foo()
-}
-class DerivedG1 : BaseGImpl()

compiler/testData/diagnostics/tests/multiplatform/headerClass/headerClassWithFunctionBody.fir.kt

@@ -1,6 +1,6 @@
 // MODULE: m1-common
 // FILE: common.kt
-<!NO_ACTUAL_FOR_EXPECT!>expect class Foo {
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect class Foo {
     <!EXPECTED_DECLARATION_WITH_BODY!>init<!> {
         "no"
     }

compiler/testData/diagnostics/tests/multiplatform/headerClass/inheritanceByDelegationInExpectClass.fir.kt

@@ -4,6 +4,6 @@
 interface A
 
 class B : A
-<!NO_ACTUAL_FOR_EXPECT!>expect class Foo(b: B) : <!IMPLEMENTATION_BY_DELEGATION_IN_EXPECT_CLASS!>A by b<!><!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect class Foo(b: B) : <!IMPLEMENTATION_BY_DELEGATION_IN_EXPECT_CLASS!>A by b<!><!>
 
-<!NO_ACTUAL_FOR_EXPECT!>expect class Bar : <!IMPLEMENTATION_BY_DELEGATION_IN_EXPECT_CLASS!>A by B()<!><!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect class Bar : <!IMPLEMENTATION_BY_DELEGATION_IN_EXPECT_CLASS!>A by B()<!><!>

compiler/testData/diagnostics/tests/multiplatform/headerClass/memberPropertyKinds.fir.kt

@@ -1,7 +1,7 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-<!NO_ACTUAL_FOR_EXPECT!>expect class Foo {
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect class Foo {
     val justVal: String
     var justVar: String
 

compiler/testData/diagnostics/tests/multiplatform/headerClass/smartCastOnExpectClass.fir.kt

@@ -1,7 +1,7 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-<!NO_ACTUAL_FOR_EXPECT!>expect class Foo { // also, it's important that Foo doesn't override equals
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect class Foo { // also, it's important that Foo doesn't override equals
     fun foo()
 }<!>
 

compiler/testData/diagnostics/tests/multiplatform/incompatibles.fir.kt

@@ -1,12 +1,12 @@
 
-<!NO_ACTUAL_FOR_EXPECT!><!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>impl<!> class <!ACTUAL_WITHOUT_EXPECT!>First<!><!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!><!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>impl<!> class <!ACTUAL_WITHOUT_EXPECT!>First<!><!>
 
-<!NO_ACTUAL_FOR_EXPECT!><!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>expect<!> class Second<!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!><!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>expect<!> class Second<!>
 
-<!NO_ACTUAL_FOR_EXPECT!><!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class <!ACTUAL_WITHOUT_EXPECT!>Third<!><!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!><!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class <!ACTUAL_WITHOUT_EXPECT!>Third<!><!>
 
-<!NO_ACTUAL_FOR_EXPECT!><!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>impl<!> <!INCOMPATIBLE_MODIFIERS!>expect<!> class <!ACTUAL_WITHOUT_EXPECT!>Fourth<!><!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!><!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>impl<!> <!INCOMPATIBLE_MODIFIERS!>expect<!> class <!ACTUAL_WITHOUT_EXPECT!>Fourth<!><!>
 
 <!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>impl<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class <!ACTUAL_WITHOUT_EXPECT!>Fifth<!>
 
-<!NO_ACTUAL_FOR_EXPECT!><!INCOMPATIBLE_MODIFIERS!>expect<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class <!ACTUAL_WITHOUT_EXPECT!>Sixth<!><!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!><!INCOMPATIBLE_MODIFIERS!>expect<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class <!ACTUAL_WITHOUT_EXPECT!>Sixth<!><!>

compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingHeaderDeclarations.fir.kt

@@ -1,7 +1,7 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-<!CONFLICTING_OVERLOADS, NO_ACTUAL_FOR_EXPECT!>expect fun foo()<!>
+<!CONFLICTING_OVERLOADS, NO_ACTUAL_FOR_EXPECT{JVM}!>expect fun foo()<!>
-<!CONFLICTING_OVERLOADS, NO_ACTUAL_FOR_EXPECT!>expect fun foo()<!>
+<!CONFLICTING_OVERLOADS, NO_ACTUAL_FOR_EXPECT{JVM}!>expect fun foo()<!>
 
-<!NO_ACTUAL_FOR_EXPECT!>expect fun foo(x: Int)<!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect fun foo(x: Int)<!>

compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerDeclarationWithBody.fir.kt

@@ -1,8 +1,8 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-<!CONFLICTING_OVERLOADS, NO_ACTUAL_FOR_EXPECT!>expect fun foo()<!>
+<!CONFLICTING_OVERLOADS, NO_ACTUAL_FOR_EXPECT{JVM}!>expect fun foo()<!>
 
-<!NO_ACTUAL_FOR_EXPECT!><!CONFLICTING_OVERLOADS, EXPECTED_DECLARATION_WITH_BODY!>expect fun foo()<!> {}<!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!><!CONFLICTING_OVERLOADS, EXPECTED_DECLARATION_WITH_BODY!>expect fun foo()<!> {}<!>
 
-<!NO_ACTUAL_FOR_EXPECT!><!EXPECTED_DECLARATION_WITH_BODY!>expect fun bar()<!> {}<!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!><!EXPECTED_DECLARATION_WITH_BODY!>expect fun bar()<!> {}<!>

compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerWithoutImpl.fir.kt

@@ -1,4 +1,4 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-<!NO_ACTUAL_FOR_EXPECT!>expect fun foo()<!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect fun foo()<!>

compiler/testData/diagnostics/tests/multiplatform/topLevelProperty/differentKindsOfProperties.fir.kt

@@ -2,35 +2,35 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-<!NO_ACTUAL_FOR_EXPECT!>expect val justVal: String<!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect val justVal: String<!>
-<!NO_ACTUAL_FOR_EXPECT!>expect var justVar: String<!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect var justVar: String<!>
 
-<!NO_ACTUAL_FOR_EXPECT!>expect val String.extensionVal: Unit<!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect val String.extensionVal: Unit<!>
-<!NO_ACTUAL_FOR_EXPECT!>expect var <T> T.genericExtensionVar: T<!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect var <T> T.genericExtensionVar: T<!>
 
-<!NO_ACTUAL_FOR_EXPECT!>expect val valWithGet: String
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect val valWithGet: String
     get<!>
-<!NO_ACTUAL_FOR_EXPECT!>expect var varWithGetSet: String
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect var varWithGetSet: String
     get set<!>
 
-<!NO_ACTUAL_FOR_EXPECT!>expect var varWithPlatformGetSet: String
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect var varWithPlatformGetSet: String
     <!WRONG_MODIFIER_TARGET!>expect<!> get
     <!WRONG_MODIFIER_TARGET!>expect<!> set<!>
 
-<!NO_ACTUAL_FOR_EXPECT!>expect val backingFieldVal: String = <!EXPECTED_PROPERTY_INITIALIZER!>"no"<!><!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect val backingFieldVal: String = <!EXPECTED_PROPERTY_INITIALIZER!>"no"<!><!>
-<!NO_ACTUAL_FOR_EXPECT!>expect var backingFieldVar: String = <!EXPECTED_PROPERTY_INITIALIZER!>"no"<!><!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect var backingFieldVar: String = <!EXPECTED_PROPERTY_INITIALIZER!>"no"<!><!>
 
-<!NO_ACTUAL_FOR_EXPECT!>expect val customAccessorVal: String
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect val customAccessorVal: String
     get() = "no"<!>
-<!NO_ACTUAL_FOR_EXPECT!>expect var customAccessorVar: String
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect var customAccessorVar: String
     get() = "no"
     set(value) {}<!>
 
-<!NO_ACTUAL_FOR_EXPECT!>expect <!CONST_VAL_WITHOUT_INITIALIZER!>const<!> val constVal: Int<!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect <!CONST_VAL_WITHOUT_INITIALIZER!>const<!> val constVal: Int<!>
 
-<!NO_ACTUAL_FOR_EXPECT!>expect <!EXPECTED_LATEINIT_PROPERTY!>lateinit<!> var lateinitVar: String<!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect <!EXPECTED_LATEINIT_PROPERTY!>lateinit<!> var lateinitVar: String<!>
 
-<!NO_ACTUAL_FOR_EXPECT!>expect val delegated: String by <!EXPECTED_DELEGATED_PROPERTY!>Delegate<!><!>
+<!NO_ACTUAL_FOR_EXPECT{JVM}!>expect val delegated: String by <!EXPECTED_DELEGATED_PROPERTY!>Delegate<!><!>
 object Delegate { operator fun getValue(x: Any?, y: Any?): String = "" }
 
 fun test(): String {

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractFirDiagnosticTest.kt

@@ -34,14 +34,11 @@ import org.jetbrains.kotlin.test.model.AfterAnalysisChecker
 import org.jetbrains.kotlin.test.model.DependencyKind
 import org.jetbrains.kotlin.test.model.FrontendFacade
 import org.jetbrains.kotlin.test.model.FrontendKinds
-import org.jetbrains.kotlin.test.services.LibraryProvider
+import org.jetbrains.kotlin.test.services.*
-import org.jetbrains.kotlin.test.services.TestService
-import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.configuration.CommonEnvironmentConfigurator
 import org.jetbrains.kotlin.test.services.configuration.JvmEnvironmentConfigurator
 import org.jetbrains.kotlin.test.services.configuration.ScriptingEnvironmentConfigurator
 import org.jetbrains.kotlin.test.services.fir.FirOldFrontendMetaConfigurator
-import org.jetbrains.kotlin.test.services.service
 import org.jetbrains.kotlin.test.services.sourceProviders.AdditionalDiagnosticsSourceFilesProvider
 import org.jetbrains.kotlin.test.services.sourceProviders.CoroutineHelpersSourceFilesProvider
 
@@ -111,7 +108,7 @@ abstract class AbstractFirWithActualizerDiagnosticsTest(val parser: FirParser) :
         useAdditionalService(::LibraryProvider)
 
         @OptIn(TestInfrastructureInternals::class)
-        useModuleStructureTransformers(DuplicateFileNameChecker)
+        useModuleStructureTransformers(DuplicateFileNameChecker, PlatformModuleProvider)
     }
 }
 

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/DuplicateFileNameChecker.kt

@@ -6,13 +6,14 @@
 package org.jetbrains.kotlin.test.runners
 
 import org.jetbrains.kotlin.test.TestInfrastructureInternals
+import org.jetbrains.kotlin.test.services.DefaultsProvider
 import org.jetbrains.kotlin.test.services.ModuleStructureTransformer
 import org.jetbrains.kotlin.test.services.TestModuleStructure
 
 // TODO remove when duplicate files names are supported by prefix their path with the module name KT-63252
 @OptIn(TestInfrastructureInternals::class)
 object DuplicateFileNameChecker : ModuleStructureTransformer() {
-    override fun transformModuleStructure(moduleStructure: TestModuleStructure): TestModuleStructure {
+    override fun transformModuleStructure(moduleStructure: TestModuleStructure, defaultsProvider: DefaultsProvider): TestModuleStructure {
         val files = mutableSetOf<String>()
 
         for (module in moduleStructure.modules) {
@@ -25,4 +26,4 @@ object DuplicateFileNameChecker : ModuleStructureTransformer() {
 
         return moduleStructure
     }
-}
+}

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/ModuleTransformerForSwitchingBackend.kt

@@ -19,7 +19,7 @@ class ModuleTransformerForSwitchingBackend(
     val backendForLib: TargetBackend,
     val backendForMain: TargetBackend
 ) : ModuleStructureTransformer() {
-    override fun transformModuleStructure(moduleStructure: TestModuleStructure): TestModuleStructure {
+    override fun transformModuleStructure(moduleStructure: TestModuleStructure, defaultsProvider: DefaultsProvider): TestModuleStructure {
         if (moduleStructure.modules.size != 2) error("Test should contain only one module")
         val (first, second) = moduleStructure.modules
 

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/PlatformModuleProvider.kt

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2010-2023 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.test.services
+
+import org.jetbrains.kotlin.test.TestInfrastructureInternals
+import org.jetbrains.kotlin.test.model.DependencyDescription
+import org.jetbrains.kotlin.test.model.DependencyRelation
+import org.jetbrains.kotlin.test.services.impl.TestModuleStructureImpl
+
+/**
+ * This provider adds additional empty module platform module if there is only one module in the module structure with common platform
+ *
+ * ```
+ * // MODULE: some
+ * ```
+ * converted to
+ * ```
+ * // MODULE: some
+ * ...
+ * // MODULE: platform()()(some)
+ * ```
+ *
+ * This is needed for MPP diagnostic tests, which sometimes omit specifying platform module, which causes Fir2Ir facade skip
+ *   IR actualizer, since there is only one module at all
+ */
+@OptIn(TestInfrastructureInternals::class)
+object PlatformModuleProvider : ModuleStructureTransformer() {
+    override fun transformModuleStructure(moduleStructure: TestModuleStructure, defaultsProvider: DefaultsProvider): TestModuleStructure {
+        val module = moduleStructure.modules.singleOrNull() ?: return moduleStructure
+        val dependency = DependencyDescription(module.name, defaultsProvider.defaultDependencyKind, DependencyRelation.DependsOnDependency)
+        val platformModule = module.copy(
+            name = "${module.name}-platform",
+            targetPlatform = defaultsProvider.defaultPlatform,
+            allDependencies = listOf(dependency),
+            files = emptyList()
+        )
+        return TestModuleStructureImpl(listOf(module, platformModule), moduleStructure.originalTestDataFiles)
+    }
+}

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/SplittingModuleTransformerForBoxTests.kt

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.test.services.impl.TestModuleStructureImpl
  */
 @TestInfrastructureInternals
 class SplittingModuleTransformerForBoxTests : ModuleStructureTransformer() {
-    override fun transformModuleStructure(moduleStructure: TestModuleStructure): TestModuleStructure {
+    override fun transformModuleStructure(moduleStructure: TestModuleStructure, defaultsProvider: DefaultsProvider): TestModuleStructure {
         if (moduleStructure.modules.size > 1) {
             // The test is already multimodule, no need to split it into modules further.
             return moduleStructure

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/impl/ModuleStructureExtractorImpl.kt

@@ -65,7 +65,7 @@ class ModuleStructureExtractorImpl(
         var result = extractor.splitTestDataByModules()
         for (transformer in moduleStructureTransformers) {
             result = try {
-                transformer.transformModuleStructure(result)
+                transformer.transformModuleStructure(result, testServices.defaultsProvider)
             } catch (e: Throwable) {
                 throw ExceptionFromModuleStructureTransformer(e, result)
             }
@@ -73,7 +73,7 @@ class ModuleStructureExtractorImpl(
         return result
     }
 
-    private inner class ModuleStructureExtractorWorker constructor(
+    private inner class ModuleStructureExtractorWorker(
         private val testDataFiles: List<File>,
         private val directivesContainer: DirectivesContainer,
     ) {