Add multiple renderer sources support to new diagnostics infrastructure

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtAbstractFirDiagnostic.kt

@@ -10,10 +10,10 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
 import org.jetbrains.kotlin.analysis.api.diagnostics.KtDiagnosticWithPsi
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.diagnostics.Severity
-import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDefaultErrorMessages
 import org.jetbrains.kotlin.diagnostics.KtDiagnostic
 import org.jetbrains.kotlin.diagnostics.KtPsiDiagnostic
+import org.jetbrains.kotlin.diagnostics.Severity
+import org.jetbrains.kotlin.diagnostics.rendering.RootDiagnosticRendererFactory
 
 internal interface KtAbstractFirDiagnostic<PSI : PsiElement> : KtDiagnosticWithPsi<PSI>, ValidityTokenOwner {
     val firDiagnostic: KtPsiDiagnostic
@@ -25,7 +25,7 @@ internal interface KtAbstractFirDiagnostic<PSI : PsiElement> : KtDiagnosticWithP
         get() = withValidityAssertion {
             val diagnostic = firDiagnostic as KtDiagnostic
 
-            val firDiagnosticRenderer = FirDefaultErrorMessages.getRendererForDiagnostic(diagnostic)
+            val firDiagnosticRenderer = RootDiagnosticRendererFactory(diagnostic)
             return firDiagnosticRenderer.render(diagnostic)
         }
 

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostics/AbstractFirIdeDiagnosticsCollector.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.module
+import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.CheckersComponentInternal
 import org.jetbrains.kotlin.fir.analysis.checkers.*
@@ -16,10 +17,8 @@ import org.jetbrains.kotlin.fir.analysis.checkers.expression.ExpressionCheckers
 import org.jetbrains.kotlin.fir.analysis.checkers.type.TypeCheckers
 import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollector
 import org.jetbrains.kotlin.fir.analysis.collectors.components.*
-import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.jvm.checkers.JvmDeclarationCheckers
 import org.jetbrains.kotlin.fir.analysis.jvm.checkers.JvmExpressionCheckers
-import org.jetbrains.kotlin.fir.analysis.jvm.diagnostics.FirJvmDefaultErrorMessages
 import org.jetbrains.kotlin.fir.moduleData
 import org.jetbrains.kotlin.platform.SimplePlatform
 import org.jetbrains.kotlin.platform.jvm.JvmPlatform
@@ -43,7 +42,6 @@ private object CheckersFactory {
     ): List<AbstractDiagnosticCollectorComponent> {
         val module = session.moduleData.module
         val platform = module.platform.componentPlatforms.first()
-        installPlatformSpecificErrorMessages(platform)
         val declarationCheckers = createDeclarationCheckers(useExtendedCheckers, platform)
         val expressionCheckers = createExpressionCheckers(useExtendedCheckers, platform)
         val typeCheckers = createTypeCheckers(useExtendedCheckers)
@@ -91,14 +89,6 @@ private object CheckersFactory {
         }
     }
 
-    private fun installPlatformSpecificErrorMessages(platform: SimplePlatform) {
-        when (platform) {
-            is JvmPlatform -> FirJvmDefaultErrorMessages.installJvmErrorMessages()
-            else -> {
-            }
-        }
-    }
-
     private fun createTypeCheckers(useExtendedCheckers: Boolean): TypeCheckers? =
         if (useExtendedCheckers) null else CommonTypeCheckers
 

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/LLDiagnosticParameterChecker.kt

@@ -5,7 +5,8 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based
 
-import org.jetbrains.kotlin.fir.analysis.diagnostics.*
+import org.jetbrains.kotlin.diagnostics.*
+import org.jetbrains.kotlin.diagnostics.rendering.RootDiagnosticRendererFactory
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.ConeTypeVariableType
 import org.jetbrains.kotlin.fir.types.contains
@@ -20,39 +21,39 @@ internal class LLDiagnosticParameterChecker(testServices: TestServices) : FirAna
         val diagnostics = info.firAnalyzerFacade.runCheckers().values.flatten()
 
         for (diagnostic in diagnostics) {
-            checkDiagnosticIsSuitableForFirIde(diagnostic)
+            checkDiagnosticIsSuitableForFirIde(diagnostic as KtPsiDiagnostic)
         }
     }
 
-    private fun checkDiagnosticIsSuitableForFirIde(diagnostic: FirDiagnostic) {
+    private fun checkDiagnosticIsSuitableForFirIde(diagnostic: KtPsiDiagnostic) {
         val parameters = diagnostic.allParameters()
         for (parameter in parameters) {
             checkDiagnosticParameter(diagnostic, parameter)
         }
     }
 
-    private fun checkDiagnosticParameter(diagnostic: FirDiagnostic, parameter: Any?) {
+    private fun checkDiagnosticParameter(diagnostic: KtPsiDiagnostic, parameter: Any?) {
         when (parameter) {
-            is ConeKotlinType -> checkType(parameter, diagnostic)
+            is ConeKotlinType -> checkType(parameter, diagnostic as KtDiagnostic)
         }
     }
 
-    private fun checkType(parameter: ConeKotlinType, diagnostic: FirDiagnostic) {
+    private fun checkType(parameter: ConeKotlinType, diagnostic: KtDiagnostic) {
         val containsTypeVariableType = parameter.contains { it is ConeTypeVariableType }
         if (containsTypeVariableType) {
-            val rendered = FirDefaultErrorMessages.getRendererForDiagnostic(diagnostic).render(diagnostic)
+            val rendered = RootDiagnosticRendererFactory(diagnostic).render(diagnostic)
             testServices.assertions.fail {
                 "ConeTypeVariableType should not be exposed from diagnostic. But it was for ${diagnostic.factoryName} $rendered"
             }
         }
     }
 
-    private fun FirDiagnostic.allParameters(): List<Any?> = when (this) {
+    private fun KtPsiDiagnostic.allParameters(): List<Any?> = when (this) {
-        is FirPsiDiagnosticWithParameters1<*> -> listOf(a)
+        is KtPsiDiagnosticWithParameters1<*> -> listOf(a)
-        is FirPsiDiagnosticWithParameters2<*, *> -> listOf(a, b)
+        is KtPsiDiagnosticWithParameters2<*, *> -> listOf(a, b)
-        is FirPsiDiagnosticWithParameters3<*, *, *> -> listOf(a, b, c)
+        is KtPsiDiagnosticWithParameters3<*, *, *> -> listOf(a, b, c)
-        is FirPsiDiagnosticWithParameters4<*, *, *, *> -> listOf(a, b, c, d)
+        is KtPsiDiagnosticWithParameters4<*, *, *, *> -> listOf(a, b, c, d)
-        is FirPsiSimpleDiagnostic -> emptyList()
+        is KtPsiSimpleDiagnostic -> emptyList()
         else -> error("Unexpected diagnostic $this")
     }
 

compiler/cli/src/org/jetbrains/kotlin/cli/common/fir/FirDiagnosticsCompilerResultsReporter.kt

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.messages.MessageUtil
 import org.jetbrains.kotlin.diagnostics.*
 import org.jetbrains.kotlin.diagnostics.impl.BaseDiagnosticReporter
-import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDefaultErrorMessages
+import org.jetbrains.kotlin.diagnostics.rendering.RootDiagnosticRendererFactory
 import java.io.Closeable
 import java.io.File
 import java.io.InputStreamReader
@@ -86,8 +86,7 @@ object FirDiagnosticsCompilerResultsReporter {
         reporter: MessageCollector
     ) {
         val severity = AnalyzerWithCompilerReport.convertSeverity(diagnostic.severity)
-        // TODO: support multiple maps with messages
+        val renderer = RootDiagnosticRendererFactory(diagnostic)
-        val renderer = FirDefaultErrorMessages.getRendererForDiagnostic(diagnostic)
         reporter.report(severity, renderer.render(diagnostic), location)
     }
 

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/model/ErrorListDiagnosticListRenderer.kt

@@ -5,7 +5,9 @@
 
 package org.jetbrains.kotlin.fir.checkers.generator.diagnostics.model
 
-import org.jetbrains.kotlin.fir.checkers.generator.*
+import org.jetbrains.kotlin.fir.checkers.generator.collectClassNamesTo
+import org.jetbrains.kotlin.fir.checkers.generator.inBracketsWithIndent
+import org.jetbrains.kotlin.fir.checkers.generator.printImports
 import org.jetbrains.kotlin.fir.tree.generator.printer.printCopyright
 import org.jetbrains.kotlin.fir.tree.generator.printer.printGeneratedMessage
 import org.jetbrains.kotlin.fir.tree.generator.util.writeToFileUsingSmartPrinterIfFileContentChanged
@@ -40,6 +42,9 @@ object ErrorListDiagnosticListRenderer : DiagnosticListRenderer() {
                 printDiagnosticGroup(group.name, group.diagnostics)
                 println()
             }
+            inBracketsWithIndent("init") {
+                println("RootDiagnosticRendererFactory.registerFactory(${diagnosticList.objectName}DefaultMessages)")
+            }
         }
     }
 
@@ -136,6 +141,7 @@ object ErrorListDiagnosticListRenderer : DiagnosticListRenderer() {
         for (deprecationDiagnostic in diagnosticList.allDiagnostics.filterIsInstance<DeprecationDiagnosticData>()) {
             add("org.jetbrains.kotlin.config.LanguageFeature.${deprecationDiagnostic.featureForError.name}")
         }
+        add("org.jetbrains.kotlin.diagnostics.rendering.RootDiagnosticRendererFactory")
     }
 
 

compiler/fir/checkers/checkers.jvm/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/jvm/FirJvmErrors.kt

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.config.LanguageFeature.ProhibitSpreadOnSignaturePoly
 import org.jetbrains.kotlin.config.LanguageFeature.RepeatableAnnotationContainerConstraints
 import org.jetbrains.kotlin.diagnostics.*
 import org.jetbrains.kotlin.diagnostics.SourceElementPositioningStrategies
+import org.jetbrains.kotlin.diagnostics.rendering.RootDiagnosticRendererFactory
 import org.jetbrains.kotlin.fir.analysis.diagnostics.*
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -125,4 +126,7 @@ object FirJvmErrors {
     val CONCURRENT_HASH_MAP_CONTAINS_OPERATOR by deprecationError0<PsiElement>(ProhibitConcurrentHashMapContains)
     val SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL by deprecationError0<PsiElement>(ProhibitSpreadOnSignaturePolymorphicCall, SourceElementPositioningStrategies.SPREAD_OPERATOR)
 
+    init {
+        RootDiagnosticRendererFactory.registerFactory(FirJvmErrorsDefaultMessages)
+    }
 }

compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/diagnostics/jvm/FirJvmErrorsDefaultMessages.kt

@@ -5,11 +5,12 @@
 
 package org.jetbrains.kotlin.fir.analysis.diagnostics.jvm
 
+import org.jetbrains.kotlin.diagnostics.KtDiagnosticFactoryToRendererMap
+import org.jetbrains.kotlin.diagnostics.KtDiagnosticRenderers.TO_STRING
+import org.jetbrains.kotlin.diagnostics.rendering.BaseDiagnosticRendererFactory
 import org.jetbrains.kotlin.diagnostics.rendering.CommonRenderers.STRING
-import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDefaultErrorMessages
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.RENDER_TYPE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.SYMBOL
-import org.jetbrains.kotlin.diagnostics.KtDiagnosticRenderers.TO_STRING
 import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.CONCURRENT_HASH_MAP_CONTAINS_OPERATOR
 import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.CONFLICTING_JVM_DECLARATIONS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET
@@ -84,9 +85,9 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.VALUE_CLAS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.VOLATILE_ON_DELEGATE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.VOLATILE_ON_VALUE
 
-object FirJvmDefaultErrorMessages {
+object FirJvmErrorsDefaultMessages : BaseDiagnosticRendererFactory() {
-    fun installJvmErrorMessages() {
+
-        FirDefaultErrorMessages.Companion.MAP.also { map ->
+    override val MAP = KtDiagnosticFactoryToRendererMap("FIR").also { map ->
         map.put(CONFLICTING_JVM_DECLARATIONS, "Platform declaration clash")
         map.put(JAVA_TYPE_MISMATCH, "Java type mismatch expected {0} but found {1}. Use explicit cast", RENDER_TYPE, RENDER_TYPE)
         map.put(UPPER_BOUND_CANNOT_BE_ARRAY, "Upper bound of a type parameter cannot be an array")
@@ -289,5 +290,4 @@ object FirJvmDefaultErrorMessages {
             "Spread operator is prohibited for arguments to signature-polymorphic calls"
         )
     }
-    }
 }

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.diagnostics.*
 import org.jetbrains.kotlin.diagnostics.SourceElementPositioningStrategies
 import org.jetbrains.kotlin.diagnostics.WhenMissingCase
+import org.jetbrains.kotlin.diagnostics.rendering.RootDiagnosticRendererFactory
 import org.jetbrains.kotlin.fir.FirModuleData
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.expressions.FirExpression
@@ -711,4 +712,7 @@ object FirErrors {
     // label
     val REDUNDANT_LABEL_WARNING by warning0<KtLabelReferenceExpression>(SourceElementPositioningStrategies.LABEL)
 
+    init {
+        RootDiagnosticRendererFactory.registerFactory(FirErrorsDefaultMessages)
+    }
 }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt

@@ -5,9 +5,7 @@
 
 package org.jetbrains.kotlin.fir.analysis.diagnostics
 
-import org.jetbrains.kotlin.diagnostics.KtDiagnostic
 import org.jetbrains.kotlin.diagnostics.KtDiagnosticFactoryToRendererMap
-import org.jetbrains.kotlin.diagnostics.KtDiagnosticRenderer
 import org.jetbrains.kotlin.diagnostics.rendering.CommonRenderers.CLASS_KIND
 import org.jetbrains.kotlin.diagnostics.rendering.CommonRenderers.RENDER_POSITION_VARIANCE
 import org.jetbrains.kotlin.diagnostics.rendering.CommonRenderers.STRING
@@ -524,21 +522,16 @@ import org.jetbrains.kotlin.diagnostics.KtDiagnosticRenderers.NOT_RENDERED
 import org.jetbrains.kotlin.diagnostics.KtDiagnosticRenderers.NULLABLE_STRING
 import org.jetbrains.kotlin.diagnostics.KtDiagnosticRenderers.TO_STRING
 import org.jetbrains.kotlin.diagnostics.KtDiagnosticRenderers.VISIBILITY
+import org.jetbrains.kotlin.diagnostics.rendering.BaseDiagnosticRendererFactory
 
 @Suppress("unused")
-class FirDefaultErrorMessages {
+object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() {
-    companion object {
-        fun getRendererForDiagnostic(diagnostic: KtDiagnostic): KtDiagnosticRenderer {
-            val factory = diagnostic.factory
-            @Suppress("UNCHECKED_CAST")
-            return (MAP[factory] ?: factory.ktRenderer)
-        }
 
     // * - The old FE reports these diagnostics with additional parameters
     // & - New diagnostic that has no analogues in the old FE
     // + - Better message required
     // # - The new diagnostic differs from the old FE's one
-        val MAP = KtDiagnosticFactoryToRendererMap("FIR").also { map ->
+    override val MAP = KtDiagnosticFactoryToRendererMap("FIR").also { map ->
         // Meta-errors
         map.put(UNSUPPORTED, "Unsupported [{0}]", TO_STRING)
         map.put(UNSUPPORTED_FEATURE, "{0}", LanguageFeatureMessageRenderer(LanguageFeatureMessageRenderer.Type.UNSUPPORTED))
@@ -567,7 +560,13 @@ class FirDefaultErrorMessages {
 
         // Unresolved
         map.put(INVISIBLE_REFERENCE, "Symbol {0} is invisible", SYMBOL)
-            map.put(INVISIBLE_SETTER, "Cannot access ''{0}'': it is {1} in {2}", VARIABLE_NAME, VISIBILITY, NAME_OF_CONTAINING_DECLARATION_OR_FILE)
+        map.put(
+            INVISIBLE_SETTER,
+            "Cannot access ''{0}'': it is {1} in {2}",
+            VARIABLE_NAME,
+            VISIBILITY,
+            NAME_OF_CONTAINING_DECLARATION_OR_FILE
+        )
         map.put(UNRESOLVED_REFERENCE, "Unresolved reference: {0}", NULLABLE_STRING)
         map.put(UNRESOLVED_LABEL, "Unresolved label")
         map.put(DESERIALIZATION_ERROR, "Deserialization error")
@@ -838,10 +837,16 @@ class FirDefaultErrorMessages {
         map.put(NAMED_PARAMETER_NOT_FOUND, "Cannot find a parameter with this name: {0}", TO_STRING)
         map.put(MANY_LAMBDA_EXPRESSION_ARGUMENTS, "Only one lambda expression is allowed outside a parenthesized argument list")
         map.put(SPREAD_OF_NULLABLE, "The spread operator (*foo) may not be applied to an argument of nullable type")
-            map.put(ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION, "Assigning single elements to varargs in named form is forbidden")
+        map.put(
-            map.put(ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION, "Assigning single elements to varargs in named form is forbidden")
+            ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION,
-            map.put(REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION, "Redundant spread (*) operator");
+            "Assigning single elements to varargs in named form is forbidden"
-            map.put(REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_FUNCTION, "Redundant spread (*) operator");
+        )
+        map.put(
+            ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION,
+            "Assigning single elements to varargs in named form is forbidden"
+        )
+        map.put(REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION, "Redundant spread (*) operator")
+        map.put(REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_FUNCTION, "Redundant spread (*) operator")
 
         map.put(TYPE_MISMATCH, "Type mismatch: inferred type is {1} but {0} was expected", TO_STRING, TO_STRING, NOT_RENDERED)
         map.put(THROWABLE_TYPE_MISMATCH, "Throwable type mismatch: actual type is {0}", TO_STRING, NOT_RENDERED)
@@ -853,7 +858,13 @@ class FirDefaultErrorMessages {
             RENDER_TYPE,
             NOT_RENDERED
         )
-            map.put(ASSIGNMENT_TYPE_MISMATCH, "Assignment type mismatch: actual type is {1} but {0} was expected", RENDER_TYPE, RENDER_TYPE, NOT_RENDERED)
+        map.put(
+            ASSIGNMENT_TYPE_MISMATCH,
+            "Assignment type mismatch: actual type is {1} but {0} was expected",
+            RENDER_TYPE,
+            RENDER_TYPE,
+            NOT_RENDERED
+        )
         map.put(
             RESULT_TYPE_MISMATCH,
             "Function return type mismatch: actual type is {1} but {0} was expected",
@@ -867,7 +878,11 @@ class FirDefaultErrorMessages {
         map.put(ITERATOR_AMBIGUITY, "Method ''iterator()'' is ambiguous for this expression: {0}", SYMBOLS)
         map.put(HAS_NEXT_FUNCTION_AMBIGUITY, "Method ''hasNext()'' is ambiguous for this expression: {0}", SYMBOLS)
         map.put(NEXT_AMBIGUITY, "Method ''next()'' is ambiguous for this expression: {0}", SYMBOLS)
-            map.put(UNRESOLVED_REFERENCE_WRONG_RECEIVER, "Unresolved reference. None of the following candidates is applicable because of receiver type mismatch: {0}", SYMBOLS)
+        map.put(
+            UNRESOLVED_REFERENCE_WRONG_RECEIVER,
+            "Unresolved reference. None of the following candidates is applicable because of receiver type mismatch: {0}",
+            SYMBOLS
+        )
 
         // Types & type parameters
         map.put(RECURSION_IN_IMPLICIT_TYPES, "Recursion in implicit types")
@@ -998,7 +1013,14 @@ class FirDefaultErrorMessages {
 
         map.put(NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY, "A 'return' expression required in a function with a block body ('{...}')")
 
-            map.put(RETURN_TYPE_MISMATCH, "Return type mismatch: expected {0}, actual {1}", RENDER_TYPE, RENDER_TYPE, NOT_RENDERED, NOT_RENDERED)
+        map.put(
+            RETURN_TYPE_MISMATCH,
+            "Return type mismatch: expected {0}, actual {1}",
+            RENDER_TYPE,
+            RENDER_TYPE,
+            NOT_RENDERED,
+            NOT_RENDERED
+        )
 
         map.put(CYCLIC_GENERIC_UPPER_BOUND, "Type parameter has cyclic upper bounds")
 
@@ -1043,7 +1065,10 @@ class FirDefaultErrorMessages {
         map.put(INLINE_CLASS_CANNOT_IMPLEMENT_INTERFACE_BY_DELEGATION, "Inline class cannot implement an interface by delegation")
         map.put(INLINE_CLASS_CANNOT_EXTEND_CLASSES, "Inline class cannot extend classes")
         map.put(INLINE_CLASS_CANNOT_BE_RECURSIVE, "Inline class cannot be recursive")
-            map.put(DECLARATION_CANT_BE_INLINED, "'inline' modifier is not allowed on virtual members. Only private or final members can be inlined")
+        map.put(
+            DECLARATION_CANT_BE_INLINED,
+            "'inline' modifier is not allowed on virtual members. Only private or final members can be inlined"
+        )
         map.put(OVERRIDE_BY_INLINE, "Override by an inline function")
         map.put(REIFIED_TYPE_PARAMETER_IN_OVERRIDE, "Override by a function with reified type parameter")
         map.put(INLINE_PROPERTY_WITH_BACKING_FIELD, "Inline property cannot have backing field")
@@ -1261,9 +1286,9 @@ class FirDefaultErrorMessages {
         map.put(VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION, "A type annotation is required on a value parameter")
         map.put(CANNOT_INFER_PARAMETER_TYPE, "cannot infer a type for this parameter. Please specify it explicitly.")
         map.put(NO_TAIL_CALLS_FOUND, "A function is marked as tail-recursive but no tail calls are found.")
-            map.put(TAILREC_ON_VIRTUAL_MEMBER_ERROR, "Tailrec is not allowed on open members");
+        map.put(TAILREC_ON_VIRTUAL_MEMBER_ERROR, "Tailrec is not allowed on open members")
-            map.put(NON_TAIL_RECURSIVE_CALL, "Recursive call is not a tail call");
+        map.put(NON_TAIL_RECURSIVE_CALL, "Recursive call is not a tail call")
-            map.put(TAIL_RECURSION_IN_TRY_IS_NOT_SUPPORTED, "Tail recursion optimization inside try/catch/finally is not supported");
+        map.put(TAIL_RECURSION_IN_TRY_IS_NOT_SUPPORTED, "Tail recursion optimization inside try/catch/finally is not supported")
 
         // Fun interfaces
         map.put(FUN_INTERFACE_CONSTRUCTOR_REFERENCE, "Functional/SAM interface constructor references are prohibited")
@@ -1398,17 +1423,52 @@ class FirDefaultErrorMessages {
         map.put(EXPECTED_PRIVATE_DECLARATION, "Expected declaration cannot be private")
         map.put(IMPLEMENTATION_BY_DELEGATION_IN_EXPECT_CLASS, "Implementation by delegation in expected classes is prohibited")
         map.put(ACTUAL_TYPE_ALIAS_NOT_TO_CLASS, "Right-hand side of actual type alias should be a class, not another type alias")
-            map.put(ACTUAL_TYPE_ALIAS_TO_CLASS_WITH_DECLARATION_SITE_VARIANCE, "Aliased class should not have type parameters with declaration-site variance")
+        map.put(
-            map.put(ACTUAL_TYPE_ALIAS_WITH_USE_SITE_VARIANCE, "Right-hand side of actual type alias cannot contain use-site variance or star projections")
+            ACTUAL_TYPE_ALIAS_TO_CLASS_WITH_DECLARATION_SITE_VARIANCE,
-            map.put(ACTUAL_TYPE_ALIAS_WITH_COMPLEX_SUBSTITUTION, "Type arguments in the right-hand side of actual type alias should be its type parameters in the same order, e.g. 'actual typealias Foo<A, B> = Bar<A, B>'")
+            "Aliased class should not have type parameters with declaration-site variance"
-            map.put(ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS, "Actual function cannot have default argument values, they should be declared in the expected function")
+        )
-            map.put(ACTUAL_ANNOTATION_CONFLICTING_DEFAULT_ARGUMENT_VALUE, "Parameter ''{0}'' has conflicting values in the expected and actual annotation", SYMBOL)
+        map.put(
-            map.put(EXPECTED_FUNCTION_SOURCE_WITH_DEFAULT_ARGUMENTS_NOT_FOUND, "Expected function source is not found, therefore it's impossible to generate default argument values declared there. Please add the corresponding file to compilation sources")
+            ACTUAL_TYPE_ALIAS_WITH_USE_SITE_VARIANCE,
-            map.put(NO_ACTUAL_FOR_EXPECT, "Expected {0} has no actual declaration in module {1}{2}", SYMBOL, MODULE_DATA, FirPlatformIncompatibilityDiagnosticRenderer.TEXT)
+            "Right-hand side of actual type alias cannot contain use-site variance or star projections"
-            map.put(ACTUAL_WITHOUT_EXPECT, "{0} has no corresponding expected declaration{1}", SYMBOL, FirPlatformIncompatibilityDiagnosticRenderer.TEXT)
+        )
+        map.put(
+            ACTUAL_TYPE_ALIAS_WITH_COMPLEX_SUBSTITUTION,
+            "Type arguments in the right-hand side of actual type alias should be its type parameters in the same order, e.g. 'actual typealias Foo<A, B> = Bar<A, B>'"
+        )
+        map.put(
+            ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS,
+            "Actual function cannot have default argument values, they should be declared in the expected function"
+        )
+        map.put(
+            ACTUAL_ANNOTATION_CONFLICTING_DEFAULT_ARGUMENT_VALUE,
+            "Parameter ''{0}'' has conflicting values in the expected and actual annotation",
+            SYMBOL
+        )
+        map.put(
+            EXPECTED_FUNCTION_SOURCE_WITH_DEFAULT_ARGUMENTS_NOT_FOUND,
+            "Expected function source is not found, therefore it's impossible to generate default argument values declared there. Please add the corresponding file to compilation sources"
+        )
+        map.put(
+            NO_ACTUAL_FOR_EXPECT,
+            "Expected {0} has no actual declaration in module {1}{2}",
+            SYMBOL,
+            MODULE_DATA,
+            FirPlatformIncompatibilityDiagnosticRenderer.TEXT
+        )
+        map.put(
+            ACTUAL_WITHOUT_EXPECT,
+            "{0} has no corresponding expected declaration{1}",
+            SYMBOL,
+            FirPlatformIncompatibilityDiagnosticRenderer.TEXT
+        )
         map.put(AMBIGUOUS_ACTUALS, "{0} has several compatible actual declarations in modules {1}", SYMBOL, SYMBOLS)
         map.put(AMBIGUOUS_EXPECTS, "{0} has several compatible expect declarations in modules {1}", SYMBOL, COLLECTION(MODULE_DATA))
-            map.put(NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS, "Actual class ''{0}'' has no corresponding members for expected class members:{1}", SYMBOL, FirIncompatibleExpectedActualClassScopesRenderer.TEXT)
+        map.put(
+            NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS,
+            "Actual class ''{0}'' has no corresponding members for expected class members:{1}",
+            SYMBOL,
+            FirIncompatibleExpectedActualClassScopesRenderer.TEXT
+        )
         map.put(ACTUAL_MISSING, "Declaration must be marked with 'actual'")
 
         // Destructuring declaration
@@ -1784,5 +1844,4 @@ class FirDefaultErrorMessages {
         map.put(VARIABLE_INITIALIZER_IS_REDUNDANT, "Initializer is redundant")
         map.put(VARIABLE_NEVER_READ, "Variable is never read")
     }
-    }
 }

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

@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.fir.analysis.checkers.expression.ExpressionCheckers
 import org.jetbrains.kotlin.fir.analysis.checkers.type.TypeCheckers
 import org.jetbrains.kotlin.fir.analysis.checkersComponent
 import org.jetbrains.kotlin.fir.analysis.extensions.additionalCheckers
-import org.jetbrains.kotlin.fir.analysis.jvm.diagnostics.FirJvmDefaultErrorMessages
 import org.jetbrains.kotlin.fir.checkers.registerCommonCheckers
 import org.jetbrains.kotlin.fir.checkers.registerJvmCheckers
 import org.jetbrains.kotlin.fir.deserialization.ModuleDataProvider
@@ -185,7 +184,6 @@ object FirSessionFactory {
                 dependenciesSymbolProvider
             )
 
-            FirJvmDefaultErrorMessages.installJvmErrorMessages()
             projectEnvironment.registerAsJavaElementFinder(this)
         }
     }

compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticRendererFactory.kt

@@ -0,0 +1,45 @@
+/*
+ * 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.diagnostics.rendering
+
+import org.jetbrains.kotlin.diagnostics.KtDiagnostic
+import org.jetbrains.kotlin.diagnostics.KtDiagnosticFactoryToRendererMap
+import org.jetbrains.kotlin.diagnostics.KtDiagnosticRenderer
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+
+fun interface DiagnosticRendererFactory {
+    operator fun invoke(diagnostic: KtDiagnostic): KtDiagnosticRenderer?
+}
+
+abstract class BaseDiagnosticRendererFactory : DiagnosticRendererFactory {
+    override operator fun invoke(diagnostic: KtDiagnostic): KtDiagnosticRenderer? {
+        val factory = diagnostic.factory
+        @Suppress("UNCHECKED_CAST")
+        return MAP[factory]
+    }
+
+    abstract val MAP: KtDiagnosticFactoryToRendererMap
+}
+
+object RootDiagnosticRendererFactory: DiagnosticRendererFactory {
+    private val factories = linkedSetOf<DiagnosticRendererFactory>()
+    private val lock = ReentrantLock()
+
+    override operator fun invoke(diagnostic: KtDiagnostic): KtDiagnosticRenderer = lock.withLock {
+        for (factory in factories) {
+            val renderer = factory(diagnostic)
+            if (renderer != null) return renderer
+        }
+        diagnostic.factory.ktRenderer
+    }
+
+    fun registerFactory(factory: DiagnosticRendererFactory) {
+        lock.withLock {
+            factories.add(factory)
+        }
+    }
+}

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

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.test.backend.handlers
 
 import org.jetbrains.kotlin.diagnostics.PsiDiagnosticUtils
 import org.jetbrains.kotlin.diagnostics.Severity
-import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDefaultErrorMessages
+import org.jetbrains.kotlin.diagnostics.rendering.RootDiagnosticRendererFactory
 import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.test.directives.CodegenTestDirectives
 import org.jetbrains.kotlin.test.directives.CodegenTestDirectives.IGNORE_FIR_DIAGNOSTICS
@@ -29,7 +29,7 @@ class NoFirCompilationErrorsHandler(testServices: TestServices) : FirAnalysisHan
                 if (diagnostic.severity == Severity.ERROR) {
                     hasError = true
                     if (!ignoreErrors) {
-                        val diagnosticText = FirDefaultErrorMessages.getRendererForDiagnostic(diagnostic).render(diagnostic)
+                        val diagnosticText = RootDiagnosticRendererFactory(diagnostic).render(diagnostic)
                         val range = diagnostic.textRanges.first()
                         val locationText = firFile.source?.psi?.containingFile?.let { psiFile ->
                             PsiDiagnosticUtils.atLocation(psiFile, range)

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

@@ -9,8 +9,8 @@ import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo
 import org.jetbrains.kotlin.codeMetaInfo.renderConfigurations.AbstractCodeMetaInfoRenderConfiguration
 import org.jetbrains.kotlin.diagnostics.AbstractKtDiagnosticWithParametersRenderer
-import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDefaultErrorMessages
 import org.jetbrains.kotlin.diagnostics.KtDiagnostic
+import org.jetbrains.kotlin.diagnostics.rendering.RootDiagnosticRendererFactory
 
 object FirMetaInfoUtils {
     val renderDiagnosticNoArgs = FirDiagnosticCodeMetaRenderConfiguration().apply { renderParams = false }
@@ -63,7 +63,7 @@ class FirDiagnosticCodeMetaRenderConfiguration(
         val diagnostic = codeMetaInfo.diagnostic
 
         @Suppress("UNCHECKED_CAST")
-        val renderer = FirDefaultErrorMessages.getRendererForDiagnostic(diagnostic)
+        val renderer = RootDiagnosticRendererFactory(diagnostic)
         if (renderer is AbstractKtDiagnosticWithParametersRenderer) {
             renderer.renderParameters(diagnostic).mapTo(params, Any?::toString)
         }