Tests: do not depend on PSI in JvmBackendDiagnosticsHandler

#KT-59586

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/JvmBackendDiagnosticsHandler.kt

@@ -5,15 +5,14 @@
 
 package org.jetbrains.kotlin.test.backend.handlers
 
-import com.intellij.openapi.util.TextRange
 import com.intellij.openapi.util.io.FileUtil
+import org.jetbrains.kotlin.cli.common.fir.SequentialPositionFinder
 import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
 import org.jetbrains.kotlin.codeMetaInfo.model.DiagnosticCodeMetaInfo
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
 import org.jetbrains.kotlin.diagnostics.Severity
 import org.jetbrains.kotlin.diagnostics.impl.BaseDiagnosticsCollector
 import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
-import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.KtDefaultJvmErrorMessages
 import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives
@@ -22,14 +21,13 @@ import org.jetbrains.kotlin.test.frontend.classic.handlers.withNewInferenceModeE
 import org.jetbrains.kotlin.test.frontend.fir.handlers.FirDiagnosticCodeMetaInfo
 import org.jetbrains.kotlin.test.frontend.fir.handlers.toMetaInfos
 import org.jetbrains.kotlin.test.model.BinaryArtifacts
-import org.jetbrains.kotlin.test.model.FrontendKinds
-import org.jetbrains.kotlin.test.model.TestFile
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.assertions
-import org.jetbrains.kotlin.test.services.dependencyProvider
 import org.jetbrains.kotlin.test.services.globalMetadataInfoHandler
+import org.jetbrains.kotlin.test.services.sourceFileProvider
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.toLowerCaseAsciiOnly
+import org.junit.jupiter.api.fail
 import java.io.File
 
 class JvmBackendDiagnosticsHandler(testServices: TestServices) : JvmBinaryArtifactHandler(testServices) {
@@ -41,40 +39,26 @@ class JvmBackendDiagnosticsHandler(testServices: TestServices) : JvmBinaryArtifa
         checkFullDiagnosticRender(module)
     }
 
-    private fun getKtFiles(module: TestModule): Map<TestFile, KtFile> {
-        return when (module.frontendKind) {
-            FrontendKinds.ClassicFrontend -> testServices.dependencyProvider.getArtifact(module, FrontendKinds.ClassicFrontend).ktFiles
-            FrontendKinds.FIR -> testServices.dependencyProvider.getArtifact(module, FrontendKinds.FIR).mainFirFiles.entries
-                .associate { it.key to (it.value.psi as KtFile) }
-            else -> testServices.assertions.fail { "Unknown frontend kind ${module.frontendKind}" }
-        }
-    }
-
     override fun processAfterAllModules(someAssertionWasFailed: Boolean) {}
 
     private fun reportDiagnostics(module: TestModule, info: BinaryArtifacts.Jvm) {
-        val testFileToKtFileMap = getKtFiles(module)
-        val ktFileToTestFileMap = testFileToKtFileMap.entries.associate { it.value to it.key }
-        val generationState = info.classFileFactory.generationState
+        val testFiles = module.files.associateBy { "/${it.name}" }
         val configuration = reporter.createConfiguration(module)
         val withNewInferenceModeEnabled = testServices.withNewInferenceModeEnabled()
 
-        val diagnostics = generationState.collectedExtraJvmDiagnostics.all()
+        val diagnostics = info.classFileFactory.generationState.collectedExtraJvmDiagnostics.all()
         for (diagnostic in diagnostics) {
-            val ktFile = diagnostic.psiFile as? KtFile ?: continue
-            val testFile = ktFileToTestFileMap[ktFile] ?: continue
+            val ktFile = diagnostic.psiFile as? KtFile ?: fail("PSI file is not a KtFile: ${diagnostic.psiFile}")
+            val testFile = testFiles[ktFile.virtualFilePath] ?: fail("Test file for KtFile not found: ${ktFile.virtualFilePath}")
             reporter.reportDiagnostic(diagnostic, module, testFile, configuration, withNewInferenceModeEnabled)
         }
     }
 
     private fun reportKtDiagnostics(module: TestModule, info: BinaryArtifacts.Jvm) {
-        val testFileToKtFileMap = getKtFiles(module)
-        val generationState = info.classFileFactory.generationState
-
-        val ktDiagnosticReporter = generationState.diagnosticReporter as BaseDiagnosticsCollector
+        val ktDiagnosticReporter = info.classFileFactory.generationState.diagnosticReporter as BaseDiagnosticsCollector
         val globalMetadataInfoHandler = testServices.globalMetadataInfoHandler
-        for ((testFile, ktFile) in testFileToKtFileMap.entries) {
-            val ktDiagnostics = ktDiagnosticReporter.diagnosticsByFilePath[ktFile.virtualFilePath] ?: continue
+        for (testFile in module.files) {
+            val ktDiagnostics = ktDiagnosticReporter.diagnosticsByFilePath["/${testFile.name}"] ?: continue
             ktDiagnostics.forEach {
                 val metaInfos =
                     it.toMetaInfos(module, testFile, globalMetadataInfoHandler, false, false)
@@ -86,33 +70,36 @@ class JvmBackendDiagnosticsHandler(testServices: TestServices) : JvmBinaryArtifa
     private fun checkFullDiagnosticRender(module: TestModule) {
         if (DiagnosticsDirectives.RENDER_ALL_DIAGNOSTICS_FULL_TEXT !in module.directives) return
 
-        val testFileToKtFileMap = getKtFiles(module)
-
         val reportedDiagnostics = mutableListOf<String>()
-        for ((testFile, ktFile) in testFileToKtFileMap) {
+        for (testFile in module.files) {
+            val finder =
+                SequentialPositionFinder(testServices.sourceFileProvider.getContentOfSourceFile(testFile).byteInputStream().reader())
             for (metaInfo in testServices.globalMetadataInfoHandler.getReportedMetaInfosForFile(testFile).sortedBy { it.start }) {
                 when (metaInfo) {
                     is DiagnosticCodeMetaInfo -> metaInfo.diagnostic.let {
                         val message = DefaultErrorMessages.render(it)
-                        reportedDiagnostics += renderDiagnosticMessage(ktFile, it.severity, message, it.textRanges)
+                        val position = DiagnosticUtils.getLineAndColumnRange(it.psiFile, it.textRanges).start
+                        reportedDiagnostics +=
+                            renderDiagnosticMessage(it.psiFile.name, it.severity, message, position.line, position.column)
                     }
                     is FirDiagnosticCodeMetaInfo -> metaInfo.diagnostic.let {
                         val message = KtDefaultJvmErrorMessages.MAP[it.factory]?.render(it)
-                        reportedDiagnostics += renderDiagnosticMessage(ktFile, it.severity, message, it.textRanges)
+                        val position = finder.findNextPosition(DiagnosticUtils.firstRange(it.textRanges).startOffset, false)
+                        reportedDiagnostics +=
+                            renderDiagnosticMessage(testFile.relativePath, it.severity, message, position.line, position.column)
                     }
                 }
             }
         }
 
         testServices.assertions.assertEqualsToFile(
-            File(FileUtil.getNameWithoutExtension(testFileToKtFileMap.keys.first().originalFile.absolutePath) + ".diag.txt"),
+            File(FileUtil.getNameWithoutExtension(module.files.first().originalFile.absolutePath) + ".diag.txt"),
             reportedDiagnostics.joinToString(separator = "\n\n", postfix = "\n")
         )
     }
 
-    private fun renderDiagnosticMessage(file: KtFile, severity: Severity, message: String?, textRanges: List<TextRange>): String {
+    private fun renderDiagnosticMessage(fileName: String, severity: Severity, message: String?, line: Int, column: Int): String {
         val severityString = AnalyzerWithCompilerReport.convertSeverity(severity).toString().toLowerCaseAsciiOnly()
-        val position = DiagnosticUtils.getLineAndColumnRange(file, textRanges).start
-        return "/${file.name}:${position.line}:${position.column}: $severityString: $message"
+        return "/${fileName}:$line:$column: $severityString: $message"
     }
 }