[FIR Native] KT-58549: Get rid of the builtin provider

According to
`FirNativeCodegenBoxTestGenerated.testNestedClassesInAnnotations`,
the annotation
`kotlin.internal.PlatformDependent` is
unresolved reference.

^KT-58549 Fixed

compiler/cli/src/org/jetbrains/kotlin/cli/metadata/FirMetadataSerializer.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.cli.metadata
 import com.intellij.openapi.vfs.StandardFileSystems
 import com.intellij.openapi.vfs.VirtualFileManager
 import org.jetbrains.kotlin.analyzer.common.CommonPlatformAnalyzerServices
-import org.jetbrains.kotlin.backend.common.CommonJsKLibResolver
+import org.jetbrains.kotlin.backend.common.CommonKLibResolver
 import org.jetbrains.kotlin.cli.common.*
 import org.jetbrains.kotlin.cli.common.fir.FirDiagnosticsCompilerResultsReporter
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
@@ -78,7 +78,7 @@ internal class FirMetadataSerializer(
             .filterIsInstance<JvmClasspathRoot>()
             .filter { it.file.isDirectory || it.file.extension == "klib" }
             .map { it.file.absolutePath }
-        val resolvedLibraries = CommonJsKLibResolver.resolve(klibFiles, DummyLogger).getFullResolvedList()
+        val resolvedLibraries = CommonKLibResolver.resolve(klibFiles, DummyLogger).getFullResolvedList()
 
         val outputs = if (isLightTree) {
             val projectEnvironment = environment.toAbstractProjectEnvironment() as VfsBasedProjectEnvironment

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirNativeSessionFactory.kt

@@ -14,8 +14,7 @@ import org.jetbrains.kotlin.fir.deserialization.ModuleDataProvider
 import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
 import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
 import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory
-import org.jetbrains.kotlin.fir.resolve.providers.impl.FirBuiltinSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.providers.impl.FirBuiltinSyntheticFunctionInterfaceProvider
-import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirExtensionSyntheticFunctionInterfaceProvider
 import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
 import org.jetbrains.kotlin.fir.scopes.FirPlatformClassMapper
@@ -54,9 +53,8 @@ object FirNativeSessionFactory : FirAbstractSessionFactory() {
                 listOfNotNull(
                     KlibBasedSymbolProvider(session, moduleDataProvider, kotlinScopeProvider, kotlinLibraries),
                     NativeForwardDeclarationsSymbolProvider(session, forwardDeclarationsModuleData, kotlinScopeProvider, kotlinLibraries),
-                    FirBuiltinSymbolProvider(session, builtinsModuleData, kotlinScopeProvider),
+                    FirBuiltinSyntheticFunctionInterfaceProvider(session, builtinsModuleData, kotlinScopeProvider),
                     FirExtensionSyntheticFunctionInterfaceProvider.createIfNeeded(session, builtinsModuleData, kotlinScopeProvider),
-                    FirCloneableSymbolProvider(session, builtinsModuleData, kotlinScopeProvider),
                 )
             })
     }

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/CacheUpdater.kt

@@ -4,7 +4,7 @@
 
 package org.jetbrains.kotlin.ir.backend.js.ic
 
-import org.jetbrains.kotlin.backend.common.CommonJsKLibResolver
+import org.jetbrains.kotlin.backend.common.CommonKLibResolver
 import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
 import org.jetbrains.kotlin.backend.common.serialization.IrInterningService
 import org.jetbrains.kotlin.backend.common.serialization.cityHash64
@@ -96,7 +96,7 @@ class CacheUpdater(
         // libraries in topological order: [stdlib, ..., main]
         val libraryDependencies = stopwatch.measure("Resolving and loading klib dependencies") {
             val zipAccessor = compilerConfiguration.get(JSConfigurationKeys.ZIP_FILE_SYSTEM_ACCESSOR)
-            val allResolvedDependencies = CommonJsKLibResolver.resolve(allModules, compilerConfiguration.resolverLogger, zipAccessor)
+            val allResolvedDependencies = CommonKLibResolver.resolve(allModules, compilerConfiguration.resolverLogger, zipAccessor)
 
             val libraries = allResolvedDependencies.getFullList(TopologicalLibraryOrder).let { resolvedLibraries ->
                 val mainLibraryIndex = resolvedLibraries.indexOfLast {

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/CommonKLibResolver.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.library.metadata.resolver.KotlinLibraryResolver
 import org.jetbrains.kotlin.library.metadata.resolver.impl.libraryResolver
 import org.jetbrains.kotlin.util.Logger
 
-object CommonJsKLibResolver {
+object CommonKLibResolver {
     fun resolve(
         libraries: Collection<String>,
         logger: Logger,

compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/klib.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.KtVirtualFileSourceFile
 import org.jetbrains.kotlin.analyzer.AbstractAnalyzerWithCompilerReport
 import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.analyzer.CompilationErrorException
-import org.jetbrains.kotlin.backend.common.CommonJsKLibResolver
+import org.jetbrains.kotlin.backend.common.CommonKLibResolver
 import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
 import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext
 import org.jetbrains.kotlin.backend.common.extensions.IrPluginContextImpl
@@ -483,7 +483,7 @@ class ModulesStructure(
     friendDependenciesPaths: Collection<String>,
 ) {
 
-    val allDependenciesResolution = CommonJsKLibResolver.resolveWithoutDependencies(
+    val allDependenciesResolution = CommonKLibResolver.resolveWithoutDependencies(
         dependencies,
         compilerConfiguration.resolverLogger,
         compilerConfiguration.get(JSConfigurationKeys.ZIP_FILE_SYSTEM_ACCESSOR)

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

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives
 import org.jetbrains.kotlin.test.directives.model.SimpleDirective
 import org.jetbrains.kotlin.test.directives.model.ValueDirective
 import org.jetbrains.kotlin.test.directives.model.singleOrZeroValue
+import org.jetbrains.kotlin.test.model.DependencyDescription
 import org.jetbrains.kotlin.test.model.ServicesAndDirectivesContainer
 import org.jetbrains.kotlin.test.model.TestModule
 
@@ -51,6 +52,12 @@ abstract class EnvironmentConfigurator(protected val testServices: TestServices)
 
     open fun DirectiveToConfigurationKeyExtractor.provideConfigurationKeys() {}
 
+    fun TestModule.allTransitiveDependencies(): Set<DependencyDescription> {
+        val modules = testServices.moduleStructure.modules
+        return regularDependencies.toSet() +
+                regularDependencies.flatMap { modules.single { module -> module.name == it.moduleName }.allTransitiveDependencies() }
+    }
+
     override fun provideAdditionalAnalysisFlags(
         directives: RegisteredDirectives,
         languageVersion: LanguageVersion

compiler/testData/diagnostics/nativeTests/cloneableInNative.fir.kt

@@ -1,6 +1,6 @@
 // ISSUE: KT-58549
 
 fun main() {
-    val x: kotlin.Cloneable = if (true) intArrayOf(1) else longArrayOf(1)
+    val x: <!UNRESOLVED_REFERENCE!>kotlin.Cloneable<!> = if (true) intArrayOf(1) else longArrayOf(1)
     x
 }

compiler/testData/diagnostics/nativeTests/overridesMemberWithPlatformDependent.kt

@@ -1,5 +1,13 @@
 // FIR_IDENTICAL
 // ISSUE: KT-57858
+
+// FILE: Sub.kt
+package kotlin.internal
+
+@Target(AnnotationTarget.FUNCTION)
+annotation class PlatformDependent
+
+// FILE: Main.kt
 @file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
 
 import kotlin.internal.PlatformDependent

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontendFacade.kt

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.analyzer.common.CommonDependenciesContainer
 import org.jetbrains.kotlin.analyzer.common.CommonPlatformAnalyzerServices
 import org.jetbrains.kotlin.analyzer.common.CommonResolverForModuleFactory
-import org.jetbrains.kotlin.backend.common.CommonJsKLibResolver
+import org.jetbrains.kotlin.backend.common.CommonKLibResolver
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.jvm.JvmBuiltIns
@@ -75,7 +75,7 @@ import org.jetbrains.kotlin.test.model.FrontendKinds
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.*
 import org.jetbrains.kotlin.test.services.configuration.JsEnvironmentConfigurator
-import org.jetbrains.kotlin.test.services.configuration.WasmEnvironmentConfigurator
+import org.jetbrains.kotlin.test.services.configuration.getDependencies
 import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.types.typeUtil.closure
 import org.jetbrains.kotlin.utils.addToStdlib.runIf
@@ -273,7 +273,7 @@ class ClassicFrontendFacade(
     }
 
     private fun loadKlib(names: List<String>, configuration: CompilerConfiguration): List<ModuleDescriptor> {
-        val resolvedLibraries = CommonJsKLibResolver.resolve(
+        val resolvedLibraries = CommonKLibResolver.resolve(
             names,
             configuration.resolverLogger
         ).getFullResolvedList()
@@ -315,8 +315,8 @@ class ClassicFrontendFacade(
     ): AnalysisResult {
         val runtimeKlibsNames = JsEnvironmentConfigurator.getRuntimePathsForModule(module, testServices)
         val runtimeKlibs = loadKlib(runtimeKlibsNames, configuration)
-        val transitiveLibraries = JsEnvironmentConfigurator.getDependencies(module, testServices, DependencyRelation.RegularDependency)
+        val transitiveLibraries = getDependencies(module, testServices, DependencyRelation.RegularDependency)
-        val friendLibraries = JsEnvironmentConfigurator.getDependencies(module, testServices, DependencyRelation.FriendDependency)
+        val friendLibraries = getDependencies(module, testServices, DependencyRelation.FriendDependency)
         val allDependencies = runtimeKlibs + dependencyDescriptors + friendLibraries + friendsDescriptors + transitiveLibraries
 
         val analyzer = AnalyzerWithCompilerReport(configuration)
@@ -357,8 +357,8 @@ class ClassicFrontendFacade(
             }
 
         val runtimeKlibs = loadKlib(runtimeKlibsNames, configuration)
-        val transitiveLibraries = WasmEnvironmentConfigurator.getDependencies(module, testServices, DependencyRelation.RegularDependency)
+        val transitiveLibraries = getDependencies(module, testServices, DependencyRelation.RegularDependency)
-        val friendLibraries = WasmEnvironmentConfigurator.getDependencies(module, testServices, DependencyRelation.FriendDependency)
+        val friendLibraries = getDependencies(module, testServices, DependencyRelation.FriendDependency)
         val allDependencies = runtimeKlibs + dependencyDescriptors + friendLibraries + friendsDescriptors + transitiveLibraries
 
         val builtInModuleDescriptor = allDependencies.firstNotNullOfOrNull { it.builtIns }?.builtInsModule

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrJsResultsConverter.kt

@@ -167,7 +167,7 @@ fun AbstractFirAnalyzerFacade.convertToJsIr(
 ): Fir2IrResult {
     this as FirAnalyzerFacade
     // TODO: consider avoiding repeated libraries resolution
-    val libraries = resolveJsLibraries(module, testServices, configuration)
+    val libraries = resolveLibraries(configuration, getAllJsDependenciesPaths(module, testServices))
     val (dependencies, builtIns) = loadResolvedLibraries(libraries, configuration.languageVersionSettings, testServices)
 
     val fir2IrConfiguration = Fir2IrConfiguration(

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirFrontendFacade.kt

@@ -35,6 +35,7 @@ import org.jetbrains.kotlin.fir.session.FirJvmSessionFactory
 import org.jetbrains.kotlin.fir.session.FirNativeSessionFactory
 import org.jetbrains.kotlin.fir.session.FirSessionConfigurator
 import org.jetbrains.kotlin.fir.session.environment.AbstractProjectEnvironment
+import org.jetbrains.kotlin.test.services.configuration.NativeEnvironmentConfigurator
 import org.jetbrains.kotlin.load.kotlin.PackageAndMetadataPartProvider
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.TargetPlatform
@@ -44,7 +45,6 @@ import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.platform.konan.isNative
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.FirParser
-import org.jetbrains.kotlin.test.TargetBackend
 import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives
 import org.jetbrains.kotlin.test.directives.model.DirectivesContainer
 import org.jetbrains.kotlin.test.directives.model.singleValue
@@ -54,6 +54,7 @@ import org.jetbrains.kotlin.test.model.FrontendKinds
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.runners.lightTreeSyntaxDiagnosticsReporterHolder
 import org.jetbrains.kotlin.test.services.*
+import org.jetbrains.kotlin.test.services.configuration.JsEnvironmentConfigurator
 import java.nio.file.Paths
 
 open class FirFrontendFacade(
@@ -170,13 +171,21 @@ open class FirFrontendFacade(
     ): DependencyListForCliModule {
         return DependencyListForCliModule.build(binaryModuleData) {
             when {
-                targetPlatform.isCommon() || targetPlatform.isJvm() || targetPlatform.isNative() -> {
+                targetPlatform.isCommon() || targetPlatform.isJvm() -> {
                     dependencies(configuration.jvmModularRoots.map { it.toPath() })
                     dependencies(configuration.jvmClasspathRoots.map { it.toPath() })
                     friendDependencies(configuration[JVMConfigurationKeys.FRIEND_PATHS] ?: emptyList())
                 }
                 targetPlatform.isJs() -> {
-                    val (runtimeKlibsPaths, transitiveLibraries, friendLibraries) = getJsDependencies(mainModule, testServices)
+                    val runtimeKlibsPaths = JsEnvironmentConfigurator.getRuntimePathsForModule(mainModule, testServices)
+                    val (transitiveLibraries, friendLibraries) = getTransitivesAndFriends(mainModule, testServices)
+                    dependencies(runtimeKlibsPaths.map { Paths.get(it).toAbsolutePath() })
+                    dependencies(transitiveLibraries.map { it.toPath().toAbsolutePath() })
+                    friendDependencies(friendLibraries.map { it.toPath().toAbsolutePath() })
+                }
+                targetPlatform.isNative() -> {
+                    val runtimeKlibsPaths = NativeEnvironmentConfigurator.getRuntimePathsForModule(mainModule, testServices)
+                    val (transitiveLibraries, friendLibraries) = getTransitivesAndFriends(mainModule, testServices)
                     dependencies(runtimeKlibsPaths.map { Paths.get(it).toAbsolutePath() })
                     dependencies(transitiveLibraries.map { it.toPath().toAbsolutePath() })
                     friendDependencies(friendLibraries.map { it.toPath().toAbsolutePath() })
@@ -251,11 +260,13 @@ open class FirFrontendFacade(
             }
             module.targetPlatform.isNative() -> {
                 projectEnvironment = null
-                FirNativeSessionFactory.createLibrarySession(
+                TestFirNativeSessionFactory.createLibrarySession(
                     moduleName,
-                    listOf(),
+                    module,
+                    testServices,
                     sessionProvider,
                     moduleDataProvider,
+                    configuration,
                     extensionRegistrars,
                     languageVersionSettings,
                     registerExtraComponents = ::registerExtraComponents,

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/SessionFactoryHelpers.kt

@@ -0,0 +1,30 @@
+/*
+ * 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.frontend.fir
+
+import org.jetbrains.kotlin.backend.common.CommonKLibResolver
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.ir.backend.js.resolverLogger
+import org.jetbrains.kotlin.library.metadata.resolver.KotlinResolvedLibrary
+import org.jetbrains.kotlin.test.model.DependencyRelation
+import org.jetbrains.kotlin.test.model.TestModule
+import org.jetbrains.kotlin.test.services.TestServices
+import org.jetbrains.kotlin.test.services.configuration.getKlibDependencies
+import java.io.File
+
+fun resolveLibraries(configuration: CompilerConfiguration, paths: List<String>): List<KotlinResolvedLibrary> {
+    return CommonKLibResolver.resolve(paths, configuration.resolverLogger).getFullResolvedList()
+}
+
+fun getTransitivesAndFriendsPaths(module: TestModule, testServices: TestServices): List<String> {
+    return getTransitivesAndFriends(module, testServices).toList().flatten().map { it.path }
+}
+
+fun getTransitivesAndFriends(module: TestModule, testServices: TestServices): Pair<List<File>, List<File>> {
+    val transitiveLibraries = getKlibDependencies(module, testServices, DependencyRelation.RegularDependency)
+    val friendLibraries = getKlibDependencies(module, testServices, DependencyRelation.FriendDependency)
+    return transitiveLibraries to friendLibraries
+}

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/TestFirJsSessionFactory.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.test.frontend.fir
 
-import org.jetbrains.kotlin.backend.common.CommonJsKLibResolver
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.fir.FirModuleData
@@ -16,14 +15,10 @@ import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
 import org.jetbrains.kotlin.fir.session.FirJsSessionFactory
 import org.jetbrains.kotlin.fir.session.FirSessionConfigurator
 import org.jetbrains.kotlin.incremental.components.LookupTracker
-import org.jetbrains.kotlin.ir.backend.js.resolverLogger
-import org.jetbrains.kotlin.library.metadata.resolver.KotlinResolvedLibrary
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.test.model.DependencyRelation
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.configuration.JsEnvironmentConfigurator
-import java.io.File
 
 object TestFirJsSessionFactory {
     fun createLibrarySession(
@@ -37,9 +32,7 @@ object TestFirJsSessionFactory {
         languageVersionSettings: LanguageVersionSettings,
         registerExtraComponents: ((FirSession) -> Unit),
     ): FirSession {
-        val logger = configuration.resolverLogger
+        val resolvedLibraries = resolveLibraries(configuration, getAllJsDependenciesPaths(module, testServices))
-        val libraries = getAllJsDependenciesPaths(module, testServices)
-        val resolvedLibraries = CommonJsKLibResolver.resolve(libraries, logger).getFullResolvedList()
 
         return FirJsSessionFactory.createLibrarySession(
             mainModuleName,
@@ -70,24 +63,5 @@ object TestFirJsSessionFactory {
         )
 }
 
-fun resolveJsLibraries(
+fun getAllJsDependenciesPaths(module: TestModule, testServices: TestServices) =
-    module: TestModule,
+    JsEnvironmentConfigurator.getRuntimePathsForModule(module, testServices) + getTransitivesAndFriendsPaths(module, testServices)
-    testServices: TestServices,
-    configuration: CompilerConfiguration
-): List<KotlinResolvedLibrary> {
-    val paths = getAllJsDependenciesPaths(module, testServices)
-    val logger = configuration.resolverLogger
-    return CommonJsKLibResolver.resolve(paths, logger).getFullResolvedList()
-}
-
-fun getAllJsDependenciesPaths(module: TestModule, testServices: TestServices): List<String> {
-    val (runtimeKlibsPaths, transitiveLibraries, friendLibraries) = getJsDependencies(module, testServices)
-    return runtimeKlibsPaths + transitiveLibraries.map { it.path } + friendLibraries.map { it.path }
-}
-
-fun getJsDependencies(module: TestModule, testServices: TestServices): Triple<List<String>, List<File>, List<File>> {
-    val runtimeKlibsPaths = JsEnvironmentConfigurator.getRuntimePathsForModule(module, testServices)
-    val transitiveLibraries = JsEnvironmentConfigurator.getKlibDependencies(module, testServices, DependencyRelation.RegularDependency)
-    val friendLibraries = JsEnvironmentConfigurator.getKlibDependencies(module, testServices, DependencyRelation.FriendDependency)
-    return Triple(runtimeKlibsPaths, transitiveLibraries, friendLibraries)
-}

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/TestFirNativeSessionFactory.kt

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2010-2021 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.frontend.fir
+
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.deserialization.ModuleDataProvider
+import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
+import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
+import org.jetbrains.kotlin.fir.session.FirNativeSessionFactory
+import org.jetbrains.kotlin.test.services.configuration.NativeEnvironmentConfigurator
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.test.model.TestModule
+import org.jetbrains.kotlin.test.services.TestServices
+
+object TestFirNativeSessionFactory {
+    fun createLibrarySession(
+        mainModuleName: Name,
+        module: TestModule,
+        testServices: TestServices,
+        sessionProvider: FirProjectSessionProvider,
+        moduleDataProvider: ModuleDataProvider,
+        configuration: CompilerConfiguration,
+        extensionRegistrars: List<FirExtensionRegistrar>,
+        languageVersionSettings: LanguageVersionSettings,
+        registerExtraComponents: (FirSession) -> Unit = {},
+    ): FirSession {
+        val resolvedLibraries = resolveLibraries(configuration, getAllNativeDependenciesPaths(module, testServices))
+
+        return FirNativeSessionFactory.createLibrarySession(
+            mainModuleName,
+            resolvedLibraries,
+            sessionProvider,
+            moduleDataProvider,
+            extensionRegistrars,
+            languageVersionSettings,
+            registerExtraComponents,
+        )
+    }
+}
+
+fun getAllNativeDependenciesPaths(module: TestModule, testServices: TestServices) =
+    NativeEnvironmentConfigurator.getRuntimePathsForModule(module, testServices) + getTransitivesAndFriendsPaths(module, testServices)

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

@@ -0,0 +1,43 @@
+/*
+ * 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.configuration
+
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.test.model.ArtifactKinds
+import org.jetbrains.kotlin.test.model.DependencyKind
+import org.jetbrains.kotlin.test.model.DependencyRelation
+import org.jetbrains.kotlin.test.model.TestModule
+import org.jetbrains.kotlin.test.services.TestServices
+import org.jetbrains.kotlin.test.services.dependencyProvider
+import org.jetbrains.kotlin.test.services.jsLibraryProvider
+import java.io.File
+
+fun getKlibDependencies(module: TestModule, testServices: TestServices, kind: DependencyRelation): List<File> {
+    val visited = mutableSetOf<TestModule>()
+    fun getRecursive(module: TestModule, relation: DependencyRelation) {
+        val dependencies = if (relation == DependencyRelation.FriendDependency) {
+            module.friendDependencies
+        } else {
+            module.regularDependencies
+        }
+        dependencies
+            // See: `dependencyKind =` in AbstractJsBlackBoxCodegenTestBase.kt
+            .filter { it.kind != DependencyKind.Source }
+            .map { testServices.dependencyProvider.getTestModule(it.moduleName) }.forEach {
+                if (it !in visited) {
+                    visited += it
+                    getRecursive(it, relation)
+                }
+            }
+    }
+    getRecursive(module, kind)
+    return visited.map { testServices.dependencyProvider.getArtifact(it, ArtifactKinds.KLib).outputFile }
+}
+
+fun getDependencies(module: TestModule, testServices: TestServices, kind: DependencyRelation): List<ModuleDescriptor> {
+    return getKlibDependencies(module, testServices, kind)
+        .map { testServices.jsLibraryProvider.getDescriptorByPath(it.absolutePath) }
+}

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

@@ -161,33 +161,6 @@ class JsEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigu
             return result
         }
 
-        fun getKlibDependencies(module: TestModule, testServices: TestServices, kind: DependencyRelation): List<File> {
-            val visited = mutableSetOf<TestModule>()
-            fun getRecursive(module: TestModule, relation: DependencyRelation) {
-                val dependencies = if (relation == DependencyRelation.FriendDependency) {
-                    module.friendDependencies
-                } else {
-                    module.regularDependencies
-                }
-                dependencies
-                    // See: `dependencyKind =` in AbstractJsBlackBoxCodegenTestBase.kt
-                    .filter { it.kind != DependencyKind.Source }
-                    .map { testServices.dependencyProvider.getTestModule(it.moduleName) }.forEach {
-                        if (it !in visited) {
-                            visited += it
-                            getRecursive(it, relation)
-                        }
-                    }
-            }
-            getRecursive(module, kind)
-            return visited.map { testServices.dependencyProvider.getArtifact(it, ArtifactKinds.KLib).outputFile }
-        }
-
-        fun getDependencies(module: TestModule, testServices: TestServices, kind: DependencyRelation): List<ModuleDescriptor> {
-            return getKlibDependencies(module, testServices, kind)
-                .map { testServices.jsLibraryProvider.getDescriptorByPath(it.absolutePath) }
-        }
-
         fun getMainCallParametersForModule(module: TestModule): MainCallParameters {
             return when (JsEnvironmentConfigurationDirectives.CALL_MAIN) {
                 in module.directives -> MainCallParameters.mainWithArguments(listOf())
@@ -235,13 +208,6 @@ class JsEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigu
         }
     }
 
-
-    private fun TestModule.allTransitiveDependencies(): Set<DependencyDescription> {
-        val modules = testServices.moduleStructure.modules
-        return regularDependencies.toSet() +
-                regularDependencies.flatMap { modules.single { module -> module.name == it.moduleName }.allTransitiveDependencies() }
-    }
-
     override fun provideAdditionalAnalysisFlags(
         directives: RegisteredDirectives,
         languageVersion: LanguageVersion

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

@@ -0,0 +1,35 @@
+/*
+ * 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.configuration
+
+import org.jetbrains.kotlin.test.directives.ConfigurationDirectives
+import org.jetbrains.kotlin.test.model.TestModule
+import org.jetbrains.kotlin.test.services.EnvironmentConfigurator
+import org.jetbrains.kotlin.test.services.TestServices
+import org.jetbrains.kotlin.test.services.runtimeClasspathProviders
+import java.io.File
+
+class NativeEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigurator(testServices) {
+    companion object {
+        private val nativeHome
+            get() = System.getProperty("kotlin.internal.native.test.nativeHome")
+                ?: error("No nativeHome provided. Are you sure the test are executed within :native:native.tests?")
+
+        fun getRuntimePathsForModule(module: TestModule, testServices: TestServices): List<String> {
+            val result = mutableListOf<String>()
+
+            if (ConfigurationDirectives.WITH_STDLIB in module.directives) {
+                result += File("$nativeHome/klib/common/stdlib").absolutePath
+            }
+
+            testServices.runtimeClasspathProviders
+                .flatMap { it.runtimeClassPaths(module) }
+                .mapTo(result) { it.absolutePath }
+
+            return result
+        }
+    }
+}

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

@@ -34,37 +34,6 @@ class WasmEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfi
     override val directiveContainers: List<DirectivesContainer>
         get() = listOf(JsEnvironmentConfigurationDirectives)
 
-    companion object {
-        private fun getKlibDependencies(module: TestModule, testServices: TestServices, kind: DependencyRelation): List<File> {
-            val visited = mutableSetOf<TestModule>()
-            fun getRecursive(module: TestModule, relation: DependencyRelation) {
-                val dependencies = if (relation == DependencyRelation.FriendDependency) {
-                    module.friendDependencies
-                } else {
-                    module.regularDependencies
-                }
-                dependencies
-                    // See: `dependencyKind =` in AbstractJsBlackBoxCodegenTestBase.kt
-                    .filter { it.kind != DependencyKind.Source }
-                    .map { testServices.dependencyProvider.getTestModule(it.moduleName) }.forEach {
-                        if (it !in visited) {
-                            visited += it
-                            getRecursive(it, relation)
-                        }
-                    }
-            }
-            getRecursive(module, kind)
-            return visited.map { testServices.dependencyProvider.getArtifact(it, ArtifactKinds.KLib).outputFile }
-        }
-
-        fun getDependencies(module: TestModule, testServices: TestServices, kind: DependencyRelation): List<ModuleDescriptor> {
-            return getKlibDependencies(module, testServices, kind)
-                .map { testServices.jsLibraryProvider.getDescriptorByPath(it.absolutePath) }
-        }
-
-    }
-
-
     override fun provideAdditionalAnalysisFlags(
         directives: RegisteredDirectives,
         languageVersion: LanguageVersion

compiler/tests-common/tests/org/jetbrains/kotlin/klib/AbstractKlibIrTextTestCase.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.klib
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
 import junit.framework.TestCase
-import org.jetbrains.kotlin.backend.common.CommonJsKLibResolver
+import org.jetbrains.kotlin.backend.common.CommonKLibResolver
 import org.jetbrains.kotlin.backend.common.linkage.issues.checkNoUnboundSymbols
 import org.jetbrains.kotlin.backend.common.linkage.partial.PartialLinkageSupportForLinker
 import org.jetbrains.kotlin.backend.common.serialization.CompatibilityMode
@@ -236,7 +236,7 @@ abstract class AbstractKlibIrTextTestCase : CodegenTestCase() {
     }
 
     private fun loadKlibFromPath(paths: List<String>): List<KotlinLibrary> {
-        val result = CommonJsKLibResolver.resolve(paths, DummyLogger)
+        val result = CommonKLibResolver.resolve(paths, DummyLogger)
         return result.getFullList(TopologicalLibraryOrder)
     }
 

compiler/tests-for-compiler-generator/tests/org/jetbrains/kotlin/test/generators/GenerateJUnit5CompilerTests.kt

@@ -58,10 +58,6 @@ fun generateJUnit5CompilerTests(args: Array<String>) {
                 )
             }
 
-            testClass<AbstractDiagnosticsNativeTest> {
-                model("diagnostics/nativeTests", excludedPattern = excludedCustomTestdataPattern)
-            }
-
             testClass<AbstractDiagnosticsWithMultiplatformCompositeAnalysisTest> {
                 model(
                     "diagnostics/testsWithMultiplatformCompositeAnalysis",
@@ -266,18 +262,6 @@ fun generateJUnit5CompilerTests(args: Array<String>) {
                 model("diagnostics/foreignAnnotationsTests/java8Tests", excludedPattern = excludedCustomTestdataPattern)
                 model("diagnostics/foreignAnnotationsTests/java11Tests", excludedPattern = excludedCustomTestdataPattern)
             }
-
-            testClass<AbstractFirPsiNativeDiagnosticsTest>(
-                suiteTestClassName = "FirPsiOldFrontendNativeDiagnosticsTestGenerated"
-            ) {
-                model("diagnostics/nativeTests", excludedPattern = excludedCustomTestdataPattern)
-            }
-
-            testClass<AbstractFirLightTreeNativeDiagnosticsTest>(
-                suiteTestClassName = "FirLightTreeOldFrontendNativeDiagnosticsTestGenerated"
-            ) {
-                model("diagnostics/nativeTests", excludedPattern = excludedCustomTestdataPattern)
-            }
         }
 
         testGroup("compiler/fir/analysis-tests/tests-gen", "compiler/testData") {

compiler/tests/org/jetbrains/kotlin/klib/FilePathsInKlibTest.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.klib
 import com.intellij.openapi.vfs.StandardFileSystems
 import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.psi.PsiManager
-import org.jetbrains.kotlin.backend.common.CommonJsKLibResolver
+import org.jetbrains.kotlin.backend.common.CommonKLibResolver
 import org.jetbrains.kotlin.backend.common.serialization.codedInputStream
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrFile
 import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
@@ -103,7 +103,7 @@ class FilePathsInKlibTest : CodegenTestCase() {
     private fun File.md5(): Long = readBytes().md5()
 
     private fun File.loadKlibFilePaths(): List<String> {
-        val libs = CommonJsKLibResolver.resolve(listOf(runtimeKlibPath, canonicalPath), DummyLogger).getFullList()
+        val libs = CommonKLibResolver.resolve(listOf(runtimeKlibPath, canonicalPath), DummyLogger).getFullList()
         val lib = libs.last()
         val fileSize = lib.fileCount()
         val extReg = ExtensionRegistryLite.newInstance()

js/js.tests/test/org/jetbrains/kotlin/js/test/converters/FirJsKlibBackendFacade.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.js.test.converters
 
-import org.jetbrains.kotlin.backend.common.CommonJsKLibResolver
+import org.jetbrains.kotlin.backend.common.CommonKLibResolver
 import org.jetbrains.kotlin.backend.common.actualizer.IrActualizer
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.LanguageFeature
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.test.backend.ir.IrBackendInput
 import org.jetbrains.kotlin.test.frontend.classic.ModuleDescriptorProvider
 import org.jetbrains.kotlin.test.frontend.classic.moduleDescriptorProvider
 import org.jetbrains.kotlin.test.frontend.fir.getAllJsDependenciesPaths
-import org.jetbrains.kotlin.test.frontend.fir.resolveJsLibraries
+import org.jetbrains.kotlin.test.frontend.fir.resolveLibraries
 import org.jetbrains.kotlin.test.model.ArtifactKinds
 import org.jetbrains.kotlin.test.model.BinaryArtifacts
 import org.jetbrains.kotlin.test.model.FrontendKinds
@@ -39,12 +39,12 @@ import java.io.File
 class FirJsKlibBackendFacade(
     testServices: TestServices,
     private val firstTimeCompilation: Boolean
-) : IrBackendFacade<BinaryArtifacts.KLib>(testServices, ArtifactKinds.KLib)  {
+) : IrBackendFacade<BinaryArtifacts.KLib>(testServices, ArtifactKinds.KLib) {
 
     override val additionalServices: List<ServiceRegistrationData>
         get() = listOf(service(::JsIrIncrementalDataProvider), service(::ModuleDescriptorProvider))
 
-    constructor(testServices: TestServices): this(testServices, firstTimeCompilation = true)
+    constructor(testServices: TestServices) : this(testServices, firstTimeCompilation = true)
 
     override fun shouldRunAnalysis(module: TestModule): Boolean {
         return module.backendKind == inputKind
@@ -59,7 +59,7 @@ class FirJsKlibBackendFacade(
         val outputFile = JsEnvironmentConfigurator.getJsKlibArtifactPath(testServices, module.name)
 
         // TODO: consider avoiding repeated libraries resolution
-        val libraries = resolveJsLibraries(module, testServices, configuration)
+        val libraries = resolveLibraries(configuration, getAllJsDependenciesPaths(module, testServices))
 
         // TODO: find out how to pass diagnostics to the test infra in this case
         val diagnosticReporter = DiagnosticReporterFactory.createReporter()
@@ -98,7 +98,7 @@ class FirJsKlibBackendFacade(
         }
 
         // TODO: consider avoiding repeated libraries resolution
-        val lib = CommonJsKLibResolver.resolve(
+        val lib = CommonKLibResolver.resolve(
             getAllJsDependenciesPaths(module, testServices) + listOf(outputFile),
             configuration.resolverLogger
         ).getFullResolvedList().last().library

js/js.tests/test/org/jetbrains/kotlin/js/test/converters/JsIrBackendFacade.kt

@@ -43,6 +43,7 @@ import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.compilerConfigurationProvider
 import org.jetbrains.kotlin.test.services.configuration.JsEnvironmentConfigurator
 import org.jetbrains.kotlin.test.services.configuration.JsEnvironmentConfigurator.Companion.getJsArtifactSimpleName
+import org.jetbrains.kotlin.test.services.configuration.getDependencies
 import org.jetbrains.kotlin.test.services.jsLibraryProvider
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue
 import org.jetbrains.kotlin.utils.addToStdlib.runIf
@@ -210,7 +211,7 @@ class JsIrBackendFacade(
 
         val moduleDescriptor = testServices.moduleDescriptorProvider.getModuleDescriptor(module)
         val mainModuleLib = testServices.jsLibraryProvider.getCompiledLibraryByDescriptor(moduleDescriptor)
-        val friendLibraries = JsEnvironmentConfigurator.getDependencies(module, testServices, DependencyRelation.FriendDependency)
+        val friendLibraries = getDependencies(module, testServices, DependencyRelation.FriendDependency)
             .map { testServices.jsLibraryProvider.getCompiledLibraryByDescriptor(it) }
         val friendModules = mapOf(mainModuleLib.uniqueName to friendLibraries.map { it.uniqueName })
 

js/js.tests/test/org/jetbrains/kotlin/js/test/converters/JsKlibBackendFacade.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.js.test.converters
 
-import org.jetbrains.kotlin.backend.common.CommonJsKLibResolver
+import org.jetbrains.kotlin.backend.common.CommonKLibResolver
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.incremental.components.LookupTracker
@@ -68,7 +68,7 @@ class JsKlibBackendFacade(
         }
 
         val dependencies = JsEnvironmentConfigurator.getAllRecursiveDependenciesFor(module, testServices).toList()
-        val lib = CommonJsKLibResolver.resolve(
+        val lib = CommonKLibResolver.resolve(
             dependencies.map { testServices.jsLibraryProvider.getPathByDescriptor(it) } + listOf(outputFile),
             configuration.resolverLogger
         ).getFullResolvedList().last().library

native/native.tests/tests-gen/org/jetbrains/kotlin/konan/diagnostics/DiagnosticsNativeTestGenerated.java

@@ -3,10 +3,12 @@
  * 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.runners;
+package org.jetbrains.kotlin.konan.diagnostics;
 
 import com.intellij.testFramework.TestDataPath;
 import org.jetbrains.kotlin.test.util.KtTestUtil;
+import org.junit.jupiter.api.Tag;
+import org.jetbrains.kotlin.konan.blackboxtest.support.group.FirPipeline;
 import org.jetbrains.kotlin.test.TestMetadata;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
@@ -14,10 +16,12 @@ import org.junit.jupiter.api.Test;
 import java.io.File;
 import java.util.regex.Pattern;
 
-/** This class is generated by {@link org.jetbrains.kotlin.test.generators.GenerateCompilerTestsKt}. DO NOT MODIFY MANUALLY */
+/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.GenerateNativeTestsKt}. DO NOT MODIFY MANUALLY */
 @SuppressWarnings("all")
 @TestMetadata("compiler/testData/diagnostics/nativeTests")
 @TestDataPath("$PROJECT_ROOT")
+@Tag("frontend-fir")
+@FirPipeline()
 public class DiagnosticsNativeTestGenerated extends AbstractDiagnosticsNativeTest {
     @Test
     public void testAllFilesPresentInNativeTests() throws Exception {

native/native.tests/tests-gen/org/jetbrains/kotlin/konan/diagnostics/FirLightTreeOldFrontendNativeDiagnosticsTestGenerated.java

@@ -3,10 +3,12 @@
  * 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.runners;
+package org.jetbrains.kotlin.konan.diagnostics;
 
 import com.intellij.testFramework.TestDataPath;
 import org.jetbrains.kotlin.test.util.KtTestUtil;
+import org.junit.jupiter.api.Tag;
+import org.jetbrains.kotlin.konan.blackboxtest.support.group.FirPipeline;
 import org.jetbrains.kotlin.test.TestMetadata;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
@@ -14,10 +16,12 @@ import org.junit.jupiter.api.Test;
 import java.io.File;
 import java.util.regex.Pattern;
 
-/** This class is generated by {@link org.jetbrains.kotlin.test.generators.GenerateCompilerTestsKt}. DO NOT MODIFY MANUALLY */
+/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.GenerateNativeTestsKt}. DO NOT MODIFY MANUALLY */
 @SuppressWarnings("all")
 @TestMetadata("compiler/testData/diagnostics/nativeTests")
 @TestDataPath("$PROJECT_ROOT")
+@Tag("frontend-fir")
+@FirPipeline()
 public class FirLightTreeOldFrontendNativeDiagnosticsTestGenerated extends AbstractFirLightTreeNativeDiagnosticsTest {
     @Test
     public void testAllFilesPresentInNativeTests() throws Exception {

native/native.tests/tests-gen/org/jetbrains/kotlin/konan/diagnostics/FirPsiOldFrontendNativeDiagnosticsTestGenerated.java

@@ -3,10 +3,12 @@
  * 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.runners;
+package org.jetbrains.kotlin.konan.diagnostics;
 
 import com.intellij.testFramework.TestDataPath;
 import org.jetbrains.kotlin.test.util.KtTestUtil;
+import org.junit.jupiter.api.Tag;
+import org.jetbrains.kotlin.konan.blackboxtest.support.group.FirPipeline;
 import org.jetbrains.kotlin.test.TestMetadata;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
@@ -14,10 +16,12 @@ import org.junit.jupiter.api.Test;
 import java.io.File;
 import java.util.regex.Pattern;
 
-/** This class is generated by {@link org.jetbrains.kotlin.test.generators.GenerateCompilerTestsKt}. DO NOT MODIFY MANUALLY */
+/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.GenerateNativeTestsKt}. DO NOT MODIFY MANUALLY */
 @SuppressWarnings("all")
 @TestMetadata("compiler/testData/diagnostics/nativeTests")
 @TestDataPath("$PROJECT_ROOT")
+@Tag("frontend-fir")
+@FirPipeline()
 public class FirPsiOldFrontendNativeDiagnosticsTestGenerated extends AbstractFirPsiNativeDiagnosticsTest {
     @Test
     public void testAllFilesPresentInNativeTests() throws Exception {

native/native.tests/tests/org/jetbrains/kotlin/generators/tests/GenerateNativeTests.kt

@@ -17,11 +17,16 @@ import org.jetbrains.kotlin.konan.blackboxtest.support.group.*
 import org.jetbrains.kotlin.konan.blackboxtest.support.group.DisabledTestsIfProperty
 import org.jetbrains.kotlin.konan.blackboxtest.support.group.FirPipeline
 import org.jetbrains.kotlin.konan.blackboxtest.support.group.UsePartialLinkage
+import org.jetbrains.kotlin.konan.diagnostics.AbstractDiagnosticsNativeTest
+import org.jetbrains.kotlin.konan.diagnostics.AbstractFirLightTreeNativeDiagnosticsTest
+import org.jetbrains.kotlin.konan.diagnostics.AbstractFirPsiNativeDiagnosticsTest
 import org.jetbrains.kotlin.test.TargetBackend
+import org.jetbrains.kotlin.test.utils.CUSTOM_TEST_DATA_EXTENSION_PATTERN
 import org.junit.jupiter.api.Tag
 
 fun main() {
     System.setProperty("java.awt.headless", "true")
+    val excludedCustomTestdataPattern = CUSTOM_TEST_DATA_EXTENSION_PATTERN
 
     generateTestGroupSuiteWithJUnit5 {
         // Codegen box tests.
@@ -216,6 +221,29 @@ fun main() {
                 model("lldb")
             }
         }
+
+        // New frontend test infrastructure tests
+        testGroup(testsRoot = "native/native.tests/tests-gen", testDataRoot = "compiler/testData") {
+            testClass<AbstractDiagnosticsNativeTest>(
+                annotations = listOf(*frontendFir()),
+            ) {
+                model("diagnostics/nativeTests", excludedPattern = excludedCustomTestdataPattern)
+            }
+
+            testClass<AbstractFirPsiNativeDiagnosticsTest>(
+                suiteTestClassName = "FirPsiOldFrontendNativeDiagnosticsTestGenerated",
+                annotations = listOf(*frontendFir()),
+            ) {
+                model("diagnostics/nativeTests", excludedPattern = excludedCustomTestdataPattern)
+            }
+
+            testClass<AbstractFirLightTreeNativeDiagnosticsTest>(
+                suiteTestClassName = "FirLightTreeOldFrontendNativeDiagnosticsTestGenerated",
+                annotations = listOf(*frontendFir()),
+            ) {
+                model("diagnostics/nativeTests", excludedPattern = excludedCustomTestdataPattern)
+            }
+        }
     }
 }
 

native/native.tests/tests/org/jetbrains/kotlin/konan/diagnostics/AbstractDiagnosticsNativeTest.kt

@@ -1,9 +1,9 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * 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.runners
+package org.jetbrains.kotlin.konan.diagnostics
 
 import org.jetbrains.kotlin.platform.konan.NativePlatforms
 import org.jetbrains.kotlin.test.Constructor
@@ -21,7 +21,11 @@ import org.jetbrains.kotlin.test.frontend.fir.FirFrontendFacade
 import org.jetbrains.kotlin.test.frontend.fir.FirOutputArtifact
 import org.jetbrains.kotlin.test.frontend.fir.handlers.*
 import org.jetbrains.kotlin.test.model.*
+import org.jetbrains.kotlin.test.runners.AbstractKotlinCompilerTest
+import org.jetbrains.kotlin.test.runners.configurationForClassicAndFirTestsAlongside
+import org.jetbrains.kotlin.test.runners.enableLazyResolvePhaseChecking
 import org.jetbrains.kotlin.test.services.configuration.CommonEnvironmentConfigurator
+import org.jetbrains.kotlin.test.services.configuration.NativeEnvironmentConfigurator
 import org.jetbrains.kotlin.test.services.sourceProviders.AdditionalDiagnosticsSourceFilesProvider
 import org.jetbrains.kotlin.test.services.sourceProviders.CoroutineHelpersSourceFilesProvider
 
@@ -43,7 +47,10 @@ abstract class AbstractDiagnosticsNativeTestBase<R : ResultingArtifact.FrontendO
 
         enableMetaInfoHandler()
 
-        useConfigurators(::CommonEnvironmentConfigurator)
+        useConfigurators(
+            ::CommonEnvironmentConfigurator,
+            ::NativeEnvironmentConfigurator,
+        )
 
         useMetaInfoProcessors(::OldNewInferenceMetaInfoProcessor)
         useAdditionalSourceProviders(
@@ -121,5 +128,3 @@ abstract class AbstractFirNativeDiagnosticsTestBase(val parser: FirParser) : Abs
 
 abstract class AbstractFirPsiNativeDiagnosticsTest : AbstractFirNativeDiagnosticsTestBase(FirParser.Psi)
 abstract class AbstractFirLightTreeNativeDiagnosticsTest : AbstractFirNativeDiagnosticsTestBase(FirParser.LightTree)
-
-