[FE 1.0] Add compiler flag for rendering internal diagnostic names in error messages

compiler/cli/src/org/jetbrains/kotlin/cli/common/CLIConfigurationKeys.java

@@ -36,6 +36,9 @@ public class CLIConfigurationKeys {
     public static final CompilerConfigurationKey<MessageCollector> ORIGINAL_MESSAGE_COLLECTOR_KEY =
             CompilerConfigurationKey.create("original message collector");
 
+    public static final CompilerConfigurationKey<Boolean> RENDER_DIAGNOSTIC_INTERNAL_NAME =
+            CompilerConfigurationKey.create("render diagnostic internal name");
+
     public static final CompilerConfigurationKey<Boolean> ALLOW_KOTLIN_PACKAGE =
             CompilerConfigurationKey.create("allow kotlin package");
     public static final CompilerConfigurationKey<CommonCompilerPerformanceManager> PERF_MANAGER =

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/AnalyzerWithCompilerReport.kt

@@ -38,7 +38,8 @@ import org.jetbrains.kotlin.resolve.jvm.JvmBindingContextSlices
 
 class AnalyzerWithCompilerReport(
     private val messageCollector: MessageCollector,
-    private val languageVersionSettings: LanguageVersionSettings
+    private val languageVersionSettings: LanguageVersionSettings,
+    private val renderDiagnosticName: Boolean
 ) : AbstractAnalyzerWithCompilerReport {
     override val targetEnvironment: TargetEnvironment
         get() = CompilerEnvironment
@@ -47,7 +48,8 @@ class AnalyzerWithCompilerReport(
 
     constructor(configuration: CompilerConfiguration) : this(
         configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY) ?: MessageCollector.NONE,
-        configuration.languageVersionSettings
+        configuration.languageVersionSettings,
+        configuration.getBoolean(CLIConfigurationKeys.RENDER_DIAGNOSTIC_INTERNAL_NAME)
     )
 
     private fun reportIncompleteHierarchies() {
@@ -117,7 +119,7 @@ class AnalyzerWithCompilerReport(
             reportWarning = { message -> messageCollector.report(WARNING, message) }
         )
         reportSyntaxErrors(files)
-        reportDiagnostics(analysisResult.bindingContext.diagnostics, messageCollector)
+        reportDiagnostics(analysisResult.bindingContext.diagnostics, messageCollector, renderDiagnosticName)
         reportIncompleteHierarchies()
         reportAlternativeSignatureErrors()
     }
@@ -140,29 +142,43 @@ class AnalyzerWithCompilerReport(
 
         private val SYNTAX_ERROR_FACTORY = DiagnosticFactory0.create<PsiErrorElement>(Severity.ERROR)
 
-        private fun reportDiagnostic(diagnostic: Diagnostic, reporter: DiagnosticMessageReporter): Boolean {
+        private fun reportDiagnostic(diagnostic: Diagnostic, reporter: DiagnosticMessageReporter, renderDiagnosticName: Boolean): Boolean {
             if (!diagnostic.isValid) return false
 
+            val message = (diagnostic as? MyDiagnostic<*>)?.message ?: DefaultErrorMessages.render(diagnostic)
+            val textToRender = when (renderDiagnosticName) {
+                true -> "[${diagnostic.factoryName}] $message"
+                false -> message
+            }
+
             reporter.report(
                 diagnostic,
                 diagnostic.psiFile,
-                (diagnostic as? MyDiagnostic<*>)?.message ?: DefaultErrorMessages.render(diagnostic)
+                textToRender
             )
 
             return diagnostic.severity == Severity.ERROR
         }
 
-        fun reportDiagnostics(unsortedDiagnostics: GenericDiagnostics<*>, reporter: DiagnosticMessageReporter): Boolean {
+        fun reportDiagnostics(
+            unsortedDiagnostics: GenericDiagnostics<*>,
+            reporter: DiagnosticMessageReporter,
+            renderDiagnosticName: Boolean
+        ): Boolean {
             var hasErrors = false
             val diagnostics = sortedDiagnostics(unsortedDiagnostics.all().filterIsInstance<Diagnostic>())
             for (diagnostic in diagnostics) {
-                hasErrors = hasErrors or reportDiagnostic(diagnostic, reporter)
+                hasErrors = hasErrors or reportDiagnostic(diagnostic, reporter, renderDiagnosticName)
             }
             return hasErrors
         }
 
-        fun reportDiagnostics(diagnostics: GenericDiagnostics<*>, messageCollector: MessageCollector): Boolean {
-            val hasErrors = reportDiagnostics(diagnostics, DefaultDiagnosticReporter(messageCollector))
+        fun reportDiagnostics(
+            diagnostics: GenericDiagnostics<*>,
+            messageCollector: MessageCollector,
+            renderInternalDiagnosticName: Boolean
+        ): Boolean {
+            val hasErrors = reportDiagnostics(diagnostics, DefaultDiagnosticReporter(messageCollector), renderInternalDiagnosticName)
 
             if (diagnostics.any { it.factory == Errors.INCOMPATIBLE_CLASS }) {
                 messageCollector.report(
@@ -207,7 +223,7 @@ class AnalyzerWithCompilerReport(
 
                 private fun <E : PsiElement> reportDiagnostic(element: E, factory: DiagnosticFactory0<E>, message: String) {
                     val diagnostic = MyDiagnostic(element, factory, message)
-                    AnalyzerWithCompilerReport.reportDiagnostic(diagnostic, reporter)
+                    AnalyzerWithCompilerReport.reportDiagnostic(diagnostic, reporter, renderDiagnosticName = false)
                     if (allErrorsAtEof && !element.isAtEof()) {
                         allErrorsAtEof = false
                     }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/FirKotlinToJvmBytecodeCompiler.kt

@@ -98,6 +98,7 @@ object FirKotlinToJvmBytecodeCompiler {
                 ),
                 projectEnvironment,
                 messageCollector,
+                moduleConfiguration.getBoolean(CLIConfigurationKeys.RENDER_DIAGNOSTIC_INTERNAL_NAME),
                 moduleConfiguration,
                 performanceManager,
                 targetIds,
@@ -337,7 +338,8 @@ object FirKotlinToJvmBytecodeCompiler {
                 generationState.collectedExtraJvmDiagnostics,
                 dummyBindingContext.diagnostics
             ),
-            messageCollector
+            messageCollector,
+            renderDiagnosticName
         )
         ProgressIndicatorAndCompilationCanceledStatus.checkCanceled()
 
@@ -349,6 +351,7 @@ object FirKotlinToJvmBytecodeCompiler {
         val allSources: List<KtFile>,
         val projectEnvironment: AbstractProjectEnvironment,
         val messageCollector: MessageCollector,
+        val renderDiagnosticName: Boolean,
         val moduleConfiguration: CompilerConfiguration,
         val performanceManager: CommonCompilerPerformanceManager?,
         val targetIds: List<TargetId>?,

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt

@@ -288,7 +288,11 @@ object KotlinToJVMBytecodeCompiler {
             jvmResolveLibraries(klibPaths, collector.toLogger())
         }?.getFullList() ?: emptyList()
 
-        val analyzerWithCompilerReport = AnalyzerWithCompilerReport(collector, environment.configuration.languageVersionSettings)
+        val analyzerWithCompilerReport = AnalyzerWithCompilerReport(
+            collector,
+            environment.configuration.languageVersionSettings,
+            environment.configuration.getBoolean(CLIConfigurationKeys.RENDER_DIAGNOSTIC_INTERNAL_NAME)
+        )
         analyzerWithCompilerReport.analyzeAndReport(sourceFiles) {
             val project = environment.project
             val moduleOutputs = environment.configuration.get(JVMConfigurationKeys.MODULES)?.mapNotNullTo(hashSetOf()) { module ->
@@ -396,7 +400,8 @@ object KotlinToJVMBytecodeCompiler {
                 state.collectedExtraJvmDiagnostics,
                 bindingContext.diagnostics
             ),
-            messageCollector
+            messageCollector,
+            configuration.getBoolean(CLIConfigurationKeys.RENDER_DIAGNOSTIC_INTERNAL_NAME)
         )
         FirDiagnosticsCompilerResultsReporter.reportToMessageCollector(diagnosticsReporter, messageCollector)
 

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/jvmArguments.kt

@@ -311,6 +311,7 @@ fun CompilerConfiguration.configureAdvancedJvmOptions(arguments: K2JVMCompilerAr
     }
 
     put(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE, arguments.allowKotlinPackage)
+    put(CLIConfigurationKeys.RENDER_DIAGNOSTIC_INTERNAL_NAME, arguments.renderInternalDiagnosticNames)
     put(JVMConfigurationKeys.USE_SINGLE_MODULE, arguments.singleModule)
     put(JVMConfigurationKeys.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME, arguments.useOldInlineClassesManglingScheme)
     put(JVMConfigurationKeys.ENABLE_JVM_PREVIEW, arguments.enableJvmPreview)

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

@@ -56,7 +56,11 @@ private fun runCommonAnalysis(
     val files = environment.getSourceFiles()
     val moduleName = Name.special("<${configuration.getNotNull(CommonConfigurationKeys.MODULE_NAME)}>")
 
-    val analyzer = AnalyzerWithCompilerReport(messageCollector, configuration.languageVersionSettings)
+    val analyzer = AnalyzerWithCompilerReport(
+        messageCollector,
+        configuration.languageVersionSettings,
+        configuration.getBoolean(CLIConfigurationKeys.RENDER_DIAGNOSTIC_INTERNAL_NAME)
+    )
 
     analyzer.analyzeAndReport(files) {
         CommonResolverForModuleFactory.analyzeFiles(

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

@@ -75,6 +75,7 @@ class K2MetadataCompiler : CLICompiler<K2MetadataCompilerArguments>() {
         configuration.put(CommonConfigurationKeys.MODULE_NAME, moduleName)
 
         configuration.put(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE, arguments.allowKotlinPackage)
+        configuration.put(CLIConfigurationKeys.RENDER_DIAGNOSTIC_INTERNAL_NAME, arguments.renderInternalDiagnosticNames)
 
         configuration.putIfNotNull(K2MetadataConfigurationKeys.FRIEND_PATHS, arguments.friendPaths?.toList())
         configuration.putIfNotNull(K2MetadataConfigurationKeys.REFINES_PATHS, arguments.refinesPaths?.toList())