[JS TESTS] Drop pir tests

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/JsEnvironmentConfigurationDirectives.kt

@@ -86,11 +86,6 @@ object JsEnvironmentConfigurationDirectives : SimpleDirectivesContainer() {
         applicability = DirectiveApplicability.Global
     )
 
-    val SKIP_DCE_DRIVEN by directive(
-        description = "",
-        applicability = DirectiveApplicability.Global
-    )
-
     val SPLIT_PER_MODULE by directive(
         description = "",
         applicability = DirectiveApplicability.Global
@@ -205,11 +200,6 @@ object JsEnvironmentConfigurationDirectives : SimpleDirectivesContainer() {
         applicability = DirectiveApplicability.Global
     )
 
-    val RUN_IR_PIR by directive(
-        description = "Enables pir on IR", // TODO what `pir` stands for?
-        applicability = DirectiveApplicability.Global
-    )
-
     val RUN_IC by directive(
         description = "",
         applicability = DirectiveApplicability.Global

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

@@ -50,7 +50,6 @@ class JsEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigu
         private const val OUTPUT_DIR_NAME = "outputDir"
         private const val OUTPUT_KLIB_DIR_NAME = "outputKlibDir"
         private const val DCE_OUTPUT_DIR_NAME = "dceOutputDir"
-        private const val PIR_OUTPUT_DIR_NAME = "pirOutputDir"
         private const val MINIFICATION_OUTPUT_DIR_NAME = "minOutputDir"
 
         object ExceptionThrowingReporter : JsConfig.Reporter() {
@@ -84,10 +83,6 @@ class JsEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigu
             return getDceJsArtifactsOutputDir(testServices).absolutePath + File.separator + getJsArtifactSimpleName(testServices, moduleName) + "_v5"
         }
 
-        fun getPirJsArtifactPath(testServices: TestServices, moduleName: String): String {
-            return getPirJsArtifactsOutputDir(testServices).absolutePath + File.separator + getJsArtifactSimpleName(testServices, moduleName) + "_v5"
-        }
-
         fun getJsArtifactsOutputDir(testServices: TestServices): File {
             return testServices.temporaryDirectoryManager.getOrCreateTempDirectory(OUTPUT_DIR_NAME)
         }
@@ -100,10 +95,6 @@ class JsEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigu
             return testServices.temporaryDirectoryManager.getOrCreateTempDirectory(DCE_OUTPUT_DIR_NAME)
         }
 
-        fun getPirJsArtifactsOutputDir(testServices: TestServices): File {
-            return testServices.temporaryDirectoryManager.getOrCreateTempDirectory(PIR_OUTPUT_DIR_NAME)
-        }
-
         fun getMinificationJsArtifactsOutputDir(testServices: TestServices): File {
             return testServices.temporaryDirectoryManager.getOrCreateTempDirectory(MINIFICATION_OUTPUT_DIR_NAME)
         }

js/js.tests/build.gradle.kts

@@ -262,7 +262,6 @@ fun Test.setUpBoxTests() {
 
 projectTest(parallel = true, jUnitMode = JUnitMode.JUnit5) {
     setUpJsBoxTests(jsEnabled = true, jsIrEnabled = true)
-    systemProperty("kotlin.js.ir.pir", "false")
     maxHeapSize = "3g"
 
     inputs.dir(rootDir.resolve("compiler/cli/cli-common/resources")) // compiler.xml
@@ -275,21 +274,17 @@ projectTest(parallel = true, jUnitMode = JUnitMode.JUnit5) {
 
     outputs.dir("$buildDir/out")
     outputs.dir("$buildDir/out-min")
-    outputs.dir("$buildDir/out-pir")
 
     configureTestDistribution()
 }
 
 projectTest("jsTest", parallel = true, jUnitMode = JUnitMode.JUnit5) {
-    // PIR temporary disabled
-    systemProperty("kotlin.js.ir.pir", "false")
     setUpJsBoxTests(jsEnabled = true, jsIrEnabled = false)
     maxHeapSize = "3g"
     useJUnitPlatform()
 }
 
 projectTest("jsIrTest", true, jUnitMode = JUnitMode.JUnit5) {
-    systemProperty("kotlin.js.ir.pir", "false")
     setUpJsBoxTests(jsEnabled = false, jsIrEnabled = true)
     maxHeapSize = "3g"
     useJUnitPlatform()

js/js.tests/test/org/jetbrains/kotlin/js/test/BasicBoxTest.kt

@@ -83,7 +83,6 @@ abstract class BasicBoxTest(
     private val pathToRootOutputDir = System.getProperty("kotlin.js.test.root.out.dir") ?: error("'kotlin.js.test.root.out.dir' is not set")
     private val testGroupOutputDirForCompilation = File(pathToRootOutputDir + "out/" + testGroupOutputDirPrefix)
     private val testGroupOutputDirForMinification = File(pathToRootOutputDir + "out-min/" + testGroupOutputDirPrefix)
-    private val testGroupOutputDirForPir = File(pathToRootOutputDir + "out-pir/" + testGroupOutputDirPrefix)
 
     protected open fun getOutputPrefixFile(testFilePath: String): File? = null
     protected open fun getOutputPostfixFile(testFilePath: String): File? = null
@@ -93,7 +92,6 @@ abstract class BasicBoxTest(
 
     protected open val skipRegularMode: Boolean = false
     protected open val runIrDce: Boolean = false
-    protected open val runIrPir: Boolean = false
 
     protected open val incrementalCompilationChecksEnabled = true
 
@@ -129,7 +127,6 @@ abstract class BasicBoxTest(
 
         val outputDir = getOutputDir(file)
         val dceOutputDir = getOutputDir(file, testGroupOutputDirForMinification)
-        val pirOutputDir = getOutputDir(file, testGroupOutputDirForPir)
         val fileContent = KtTestUtil.doLoadFile(file)
 
         val needsFullIrRuntime = KJS_WITH_FULL_RUNTIME.matcher(fileContent).find() || WITH_RUNTIME.matcher(fileContent).find() || WITH_STDLIB.matcher(fileContent).find()
@@ -219,7 +216,6 @@ abstract class BasicBoxTest(
 
                 val outputFileName = module.outputFileName(outputDir) + ".js"
                 val dceOutputFileName = module.outputFileName(dceOutputDir) + ".js"
-                val pirOutputFileName = module.outputFileName(pirOutputDir) + ".js"
                 val abiVersion = module.abiVersion
                 val isMainModule = mainModuleName == module.name
 
@@ -230,7 +226,6 @@ abstract class BasicBoxTest(
                     module,
                     outputFileName,
                     dceOutputFileName,
-                    pirOutputFileName,
                     dependencies,
                     allDependencies,
                     friends,
@@ -350,10 +345,6 @@ abstract class BasicBoxTest(
                         runIrEsmTests(dceOutputDir.getTestDir())
                     }
                 }
-
-                if (runIrPir && !skipDceDriven) {
-                    runIrEsmTests(pirOutputDir.getTestDir())
-                }
             }
 
             if (esModules)
@@ -379,14 +370,6 @@ abstract class BasicBoxTest(
                 )
             } + commonFiles + additionalMainFiles + inputJsFilesAfter
 
-            val pirAllJsFiles = additionalFiles + inputJsFilesBefore + generatedJsFiles.map {
-                it.first.replace(
-                    outputDir.absolutePath,
-                    pirOutputDir.absolutePath
-                )
-            } + commonFiles + additionalMainFiles + inputJsFilesAfter
-
-
             val dontRunGeneratedCode = InTextDirectivesUtils.dontRunGeneratedCode(targetBackend, file)
             if (!dontRunGeneratedCode && generateNodeJsRunner && !SKIP_NODE_JS.matcher(fileContent).find()) {
                 val nodeRunnerName = mainModule.outputFileName(outputDir) + ".node.js"
@@ -403,10 +386,6 @@ abstract class BasicBoxTest(
                         runGeneratedCode(dceAllJsFiles, testModuleName, testPackage, testFunction, expectedResult, withModuleSystem)
                     }
                 }
-
-                if (runIrPir && !skipDceDriven) {
-                    runGeneratedCode(pirAllJsFiles, testModuleName, testPackage, testFunction, expectedResult, withModuleSystem)
-                }
             }
 
             performAdditionalChecks(generatedJsFiles.map { it.first }, outputPrefixFile, outputPostfixFile)
@@ -472,7 +451,6 @@ abstract class BasicBoxTest(
         module: TestModule,
         outputFileName: String,
         dceOutputFileName: String,
-        pirOutputFileName: String,
         dependencies: List<String>,
         allDependencies: List<String>,
         friends: List<String>,
@@ -520,14 +498,12 @@ abstract class BasicBoxTest(
         )
         val outputFile = File(outputFileName)
         val dceOutputFile = File(dceOutputFileName)
-        val pirOutputFile = File(pirOutputFileName)
 
         val incrementalData = IncrementalData()
         translateFiles(
             psiFiles.map(TranslationUnit::SourceFile),
             outputFile,
             dceOutputFile,
-            pirOutputFile,
             config,
             outputPrefixFile,
             outputPostfixFile,
@@ -632,7 +608,6 @@ abstract class BasicBoxTest(
             translationUnits,
             recompiledOutputFile,
             recompiledOutputFile,
-            recompiledOutputFile,
             recompiledConfig,
             outputPrefixFile,
             outputPostfixFile,
@@ -720,7 +695,6 @@ abstract class BasicBoxTest(
         units: List<TranslationUnit>,
         outputFile: File,
         dceOutputFile: File,
-        pirOutputFile: File,
         config: JsConfig,
         outputPrefixFile: File?,
         outputPostfixFile: File?,

js/js.tests/test/org/jetbrains/kotlin/js/test/BasicIrBoxTest.kt

@@ -177,8 +177,6 @@ abstract class BasicIrBoxTest(
 
     override val runIrDce: Boolean = getBoolean("kotlin.js.ir.dce", true)
 
-    override val runIrPir: Boolean = !lowerPerModule && getBoolean("kotlin.js.ir.pir", true)
-
     val perModule: Boolean = getBoolean("kotlin.js.ir.perModule")
 
     // TODO Design incremental compilation for IR and add test support
@@ -200,7 +198,6 @@ abstract class BasicIrBoxTest(
         units: List<TranslationUnit>,
         outputFile: File,
         dceOutputFile: File,
-        pirOutputFile: File,
         config: JsConfig,
         outputPrefixFile: File?,
         outputPostfixFile: File?,
@@ -329,29 +326,6 @@ abstract class BasicIrBoxTest(
                     }
                 }
             }
-
-            if (runIrPir && !skipDceDriven) {
-                val ir = compileToLoweredIr(
-                    config,
-                    outputFile,
-                    klibPath,
-                    allKlibPaths + klibCannonPath,
-                    friendPaths,
-                    testPackage,
-                    testFunction,
-                    propertyLazyInitialization = propertyLazyInitialization,
-                    skipMangleVerification = skipMangleVerification,
-                    safeExternalBoolean = safeExternalBoolean,
-                    safeExternalBooleanDiagnostic = safeExternalBooleanDiagnostic,
-                    dceDriven = true,
-                    granularity,
-                )
-                if (esModules) {
-                    generateEsModules(ir, pirOutputFile.esModulesSubDir, granularity, config, customTestModule, mainArguments)
-                } else {
-                    generateOldModuleSystems(ir.oldIr2Js(granularity, false, mainArguments), pirOutputFile, pirOutputFile, config, units)
-                }
-            }
         }
     }
 
@@ -535,7 +509,6 @@ abstract class BasicIrBoxTest(
 
         val recompiledOutputFile = File(outputFile.parentFile, outputFile.nameWithoutExtension + "-recompiled.js")
         val recompiledMinOutputFile = File(recompiledOutputFile.parentFile, recompiledOutputFile.nameWithoutExtension + "-min.js")
-        val recompiledPirOutputFile = File(recompiledOutputFile.parentFile, recompiledOutputFile.nameWithoutExtension + "-pir.js")
         val recompiledConfig = createConfig(
             sourceDirs,
             module,
@@ -553,7 +526,6 @@ abstract class BasicIrBoxTest(
             dirtyFiles.map { TranslationUnit.SourceFile(createPsiFile(it)) },
             outputFile,
             recompiledMinOutputFile,
-            recompiledPirOutputFile,
             recompiledConfig,
             outputPrefixFile,
             outputPostfixFile,

js/js.tests/test/org/jetbrains/kotlin/js/testNew/AbstractJsIrTest.kt

@@ -51,13 +51,11 @@ abstract class AbstractJsIrTest(
         with(builder) {
             defaultDirectives {
                 val runIc = getBoolean("kotlin.js.ir.icMode")
-                val lowerPerModule = runIc || getBoolean("kotlin.js.ir.lowerPerModule")
                 if (runIc) +JsEnvironmentConfigurationDirectives.RUN_IC
-                if (lowerPerModule) +JsEnvironmentConfigurationDirectives.LOWER_PER_MODULE
+                if (runIc || getBoolean("kotlin.js.ir.lowerPerModule")) +JsEnvironmentConfigurationDirectives.LOWER_PER_MODULE
                 if (getBoolean("kotlin.js.ir.klibMainModule")) +JsEnvironmentConfigurationDirectives.KLIB_MAIN_MODULE
                 if (getBoolean("kotlin.js.ir.perModule")) +JsEnvironmentConfigurationDirectives.PER_MODULE
                 if (getBoolean("kotlin.js.ir.dce", true)) +JsEnvironmentConfigurationDirectives.RUN_IR_DCE
-                if (!lowerPerModule && getBoolean("kotlin.js.ir.pir", true)) +JsEnvironmentConfigurationDirectives.RUN_IR_PIR
             }
 
             configureJsArtifactsHandlersStep {

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

@@ -81,11 +81,9 @@ class JsIrBackendFacade(
 
         val testPackage = extractTestPackage(testServices)
         val lowerPerModule = JsEnvironmentConfigurationDirectives.LOWER_PER_MODULE in module.directives
-        val runIrPir = JsEnvironmentConfigurationDirectives.RUN_IR_PIR in module.directives &&
-                JsEnvironmentConfigurationDirectives.SKIP_DCE_DRIVEN !in module.directives
         val skipRegularMode = JsEnvironmentConfigurationDirectives.SKIP_REGULAR_MODE in module.directives
 
-        if (skipRegularMode && !runIrPir) return null
+        if (skipRegularMode) return null
 
         if (JsEnvironmentConfigurator.incrementalEnabledFor(module, testServices)) {
             val outputFile = if (firstTimeCompilation) {
@@ -110,7 +108,7 @@ class JsIrBackendFacade(
             deserializer,
             PhaseConfig(jsPhases), // TODO debug mode
             exportedDeclarations = setOf(FqName.fromSegments(listOfNotNull(testPackage, TEST_FUNCTION))),
-            dceDriven = runIrPir,
+            dceDriven = false,
             dceRuntimeDiagnostic = null,
             es6mode = false,
             propertyLazyInitialization = JsEnvironmentConfigurationDirectives.PROPERTY_LAZY_INITIALIZATION in module.directives,
@@ -121,13 +119,12 @@ class JsIrBackendFacade(
             granularity = granularity
         )
 
-        return loweredIr2JsArtifact(module, loweredIr, runIrPir, granularity)
+        return loweredIr2JsArtifact(module, loweredIr, granularity)
     }
 
     private fun loweredIr2JsArtifact(
         module: TestModule,
         loweredIr: LoweredIr,
-        runIrPir: Boolean,
         granularity: JsGenerationGranularity,
     ): BinaryArtifacts.Js? {
         val generateDts = JsEnvironmentConfigurationDirectives.GENERATE_DTS in module.directives
@@ -138,14 +135,12 @@ class JsIrBackendFacade(
 
         val outputFile = File(JsEnvironmentConfigurator.getJsModuleArtifactPath(testServices, module.name) + ".js")
         val dceOutputFile = File(JsEnvironmentConfigurator.getDceJsArtifactPath(testServices, module.name) + ".js")
-        val pirOutputFile = File(JsEnvironmentConfigurator.getPirJsArtifactPath(testServices, module.name) + ".js")
-        val dontSkipDceDriven = JsEnvironmentConfigurationDirectives.SKIP_DCE_DRIVEN !in module.directives
         if (!esModules) {
             val transformer = IrModuleToJsTransformer(
                 loweredIr.context,
                 mainArguments,
                 fullJs = true,
-                dceJs = if (runIrPir && dontSkipDceDriven) false else runIrDce,
+                dceJs = runIrDce,
                 multiModule = granularity == JsGenerationGranularity.PER_MODULE,
                 relativeRequirePath = false
             )
@@ -153,21 +148,14 @@ class JsIrBackendFacade(
         }
 
         val options = JsGenerationOptions(generatePackageJson = true, generateTypeScriptDefinitions = generateDts)
-        if (dontSkipDceDriven) {
+        generateEsModules(loweredIr, jsOutputSink(outputFile.parentFile.esModulesSubDir), mainArguments, granularity, options)
-            generateEsModules(loweredIr, jsOutputSink(outputFile.parentFile.esModulesSubDir), mainArguments, granularity, options)
-            if (runIrDce) {
-                eliminateDeadDeclarations(loweredIr.allModules, loweredIr.context)
-                generateEsModules(loweredIr, jsOutputSink(dceOutputFile.parentFile.esModulesSubDir), mainArguments, granularity, options)
-                return BinaryArtifacts.Js.JsEsArtifact(outputFile, dceOutputFile).dump(module)
-            }
-            return BinaryArtifacts.Js.JsEsArtifact(outputFile, null).dump(module)
-        }
 
-        if (runIrPir && dontSkipDceDriven) {
+        if (runIrDce) {
-            generateEsModules(loweredIr, jsOutputSink(pirOutputFile.parentFile.esModulesSubDir), mainArguments, granularity, options)
+            eliminateDeadDeclarations(loweredIr.allModules, loweredIr.context)
-            return BinaryArtifacts.Js.JsEsArtifact(pirOutputFile, null).dump(module)
+            generateEsModules(loweredIr, jsOutputSink(dceOutputFile.parentFile.esModulesSubDir), mainArguments, granularity, options)
+            return BinaryArtifacts.Js.JsEsArtifact(outputFile, dceOutputFile).dump(module)
         }
-        return null
+        return BinaryArtifacts.Js.JsEsArtifact(outputFile, null).dump(module)
     }
 
     private fun loadIrFromKlib(module: TestModule, configuration: CompilerConfiguration): IrModuleInfo {
@@ -252,20 +240,13 @@ class JsIrBackendFacade(
         val moduleId = configuration.getNotNull(CommonConfigurationKeys.MODULE_NAME)
         val moduleKind = configuration.get(JSConfigurationKeys.MODULE_KIND, ModuleKind.PLAIN)
         val outputDceFile = File(JsEnvironmentConfigurator.getDceJsArtifactPath(testServices, module.name) + ".js")
-        val outputPirFile = File(JsEnvironmentConfigurator.getPirJsArtifactPath(testServices, module.name) + ".js")
 
         val generateDts = JsEnvironmentConfigurationDirectives.GENERATE_DTS in module.directives
-        val runIrPir = JsEnvironmentConfigurationDirectives.RUN_IR_PIR in module.directives
-        val dontSkipDceDriven = JsEnvironmentConfigurationDirectives.SKIP_DCE_DRIVEN !in module.directives
         val dontSkipRegularMode = JsEnvironmentConfigurationDirectives.SKIP_REGULAR_MODE !in module.directives
 
         if (dontSkipRegularMode) {
             compilerResult.outputs!!.writeTo(outputFile, moduleId, moduleKind)
             compilerResult.outputsAfterDce?.writeTo(outputDceFile, moduleId, moduleKind)
-        } else if (runIrPir && dontSkipDceDriven) {
-            compilerResult.outputs!!.writeTo(outputPirFile, moduleId, moduleKind)
-        } else {
-            TODO("unreachable")
         }
 
         if (generateDts) {

js/js.tests/test/org/jetbrains/kotlin/js/testNew/handlers/JsArtifactsDumpHandler.kt

@@ -29,16 +29,13 @@ class JsArtifactsDumpHandler(testServices: TestServices) : JsBinaryArtifactHandl
 
         val testGroupOutputDirForCompilation = File(pathToRootOutputDir + "out/" + testGroupOutputDirPrefix)
         val testGroupOutputDirForMinification = File(pathToRootOutputDir + "out-min/" + testGroupOutputDirPrefix)
-        val testGroupOutputDirForPir = File(pathToRootOutputDir + "out-pir/" + testGroupOutputDirPrefix)
 
         val outputDir = getOutputDir(originalFile, testGroupOutputDirForCompilation, stopFile)
         val dceOutputDir = getOutputDir(originalFile, testGroupOutputDirForMinification, stopFile)
-        val pirOutputDir = getOutputDir(originalFile, testGroupOutputDirForPir, stopFile)
         val minOutputDir = File(dceOutputDir, originalFile.nameWithoutExtension)
 
         copy(JsEnvironmentConfigurator.getJsArtifactsOutputDir(testServices), outputDir)
         copy(JsEnvironmentConfigurator.getDceJsArtifactsOutputDir(testServices), dceOutputDir)
-        copy(JsEnvironmentConfigurator.getPirJsArtifactsOutputDir(testServices), pirOutputDir)
         copy(JsEnvironmentConfigurator.getMinificationJsArtifactsOutputDir(testServices), minOutputDir)
     }
 

js/js.tests/test/org/jetbrains/kotlin/js/testNew/handlers/JsBoxRunner.kt

@@ -33,19 +33,17 @@ class JsBoxRunner(testServices: TestServices) : AbstractJsArtifactsCollector(tes
 
         if (dontRunGeneratedCode) return
 
-        val (allJsFiles, dceAllJsFiles, pirAllJsFiles) = getAllFilesForRunner(testServices, modulesToArtifact)
+        val (allJsFiles, dceAllJsFiles) = getAllFilesForRunner(testServices, modulesToArtifact)
 
         val withModuleSystem = testWithModuleSystem(testServices)
         val testModuleName = getTestModuleName(testServices)
         val testPackage = extractTestPackage(testServices)
 
         val dontSkipRegularMode = JsEnvironmentConfigurationDirectives.SKIP_REGULAR_MODE !in globalDirectives
-        val dontSkipDceDriven = JsEnvironmentConfigurationDirectives.SKIP_DCE_DRIVEN !in globalDirectives
         val dontSkipIrIc = JsEnvironmentConfigurationDirectives.SKIP_IR_INCREMENTAL_CHECKS !in globalDirectives
         val recompile = testServices.moduleStructure.modules
             .flatMap { it.files }.any { JsEnvironmentConfigurationDirectives.RECOMPILE in it.directives }
         val runIrDce = JsEnvironmentConfigurationDirectives.RUN_IR_DCE in globalDirectives
-        val runIrPir = JsEnvironmentConfigurationDirectives.RUN_IR_PIR in globalDirectives
         if (dontSkipRegularMode) {
             runGeneratedCode(allJsFiles, testModuleName, testPackage, withModuleSystem)
 
@@ -53,10 +51,6 @@ class JsBoxRunner(testServices: TestServices) : AbstractJsArtifactsCollector(tes
                 runGeneratedCode(dceAllJsFiles, testModuleName, testPackage, withModuleSystem)
             }
         }
-
-        if (runIrPir && dontSkipDceDriven) {
-            runGeneratedCode(pirAllJsFiles, testModuleName, testPackage, withModuleSystem)
-        }
     }
 
     private fun runEsCode() {
@@ -64,22 +58,15 @@ class JsBoxRunner(testServices: TestServices) : AbstractJsArtifactsCollector(tes
 
         val esmOutputDir = JsEnvironmentConfigurator.getJsArtifactsOutputDir(testServices).esModulesSubDir
         val esmDceOutputDir = JsEnvironmentConfigurator.getDceJsArtifactsOutputDir(testServices).esModulesSubDir
-        val esmPirOutputDir = JsEnvironmentConfigurator.getPirJsArtifactsOutputDir(testServices).esModulesSubDir
 
         val dontSkipRegularMode = JsEnvironmentConfigurationDirectives.SKIP_REGULAR_MODE !in globalDirectives
-        val dontSkipDceDriven = JsEnvironmentConfigurationDirectives.SKIP_DCE_DRIVEN !in globalDirectives
         val runIrDce = JsEnvironmentConfigurationDirectives.RUN_IR_DCE in globalDirectives
-        val runIrPir = JsEnvironmentConfigurationDirectives.RUN_IR_PIR in globalDirectives
         if (dontSkipRegularMode) {
             singleRunEsCode(esmOutputDir)
             if (runIrDce) {
                 singleRunEsCode(esmDceOutputDir)
             }
         }
-
-        if (runIrPir && dontSkipDceDriven) {
-            singleRunEsCode(esmPirOutputDir)
-        }
     }
 
     private fun singleRunEsCode(esmOutputDir: File) {

js/js.tests/test/org/jetbrains/kotlin/js/testNew/utils/RunnerUtils.kt

@@ -93,11 +93,10 @@ fun testWithModuleSystem(testServices: TestServices): Boolean {
 
 fun getAllFilesForRunner(
     testServices: TestServices, modulesToArtifact: Map<TestModule, BinaryArtifacts.Js>
-): Triple<List<String>, List<String>, List<String>> {
+): Pair<List<String>, List<String>> {
     val originalFile = testServices.moduleStructure.originalTestDataFiles.first()
     val outputDir = JsEnvironmentConfigurator.getJsArtifactsOutputDir(testServices)
     val dceOutputDir = JsEnvironmentConfigurator.getDceJsArtifactsOutputDir(testServices)
-    val pirOutputDir = JsEnvironmentConfigurator.getPirJsArtifactsOutputDir(testServices)
 
     val commonFiles = JsAdditionalSourceProvider.getAdditionalJsFiles(originalFile.parent).map { it.absolutePath }
     val (inputJsFilesBefore, inputJsFilesAfter) = extractJsFiles(testServices, testServices.moduleStructure.modules)
@@ -113,13 +112,11 @@ fun getAllFilesForRunner(
             }
         } ?: emptyList()
     val dceJsFiles = (klibDependencies + artifactsPaths).map { it.replace(outputDir.absolutePath, dceOutputDir.absolutePath) }
-    val pirJsFiles = (klibDependencies + artifactsPaths).map { it.replace(outputDir.absolutePath, pirOutputDir.absolutePath) }
 
     val allJsFiles = additionalFiles + inputJsFilesBefore + klibDependencies + artifactsPaths + commonFiles + additionalMainFiles + inputJsFilesAfter
     val dceAllJsFiles = additionalFiles + inputJsFilesBefore + dceJsFiles + commonFiles + additionalMainFiles + inputJsFilesAfter
-    val pirAllJsFiles = additionalFiles + inputJsFilesBefore + pirJsFiles + commonFiles + additionalMainFiles + inputJsFilesAfter
 
-    return Triple(allJsFiles, dceAllJsFiles, pirAllJsFiles)
+    return Pair(allJsFiles, dceAllJsFiles)
 }
 
 fun extractAllFilesForEsRunner(testServices: TestServices, esmOutputDir: File): Pair<List<String>, List<String>> {