[LL API] Introduce converters from plugin defined diagnostics to KtDiagnostics

analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/ArgumentsConverterGenerator.kt

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2010-2022 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.analysis.api.fir.generator
+
+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
+import org.jetbrains.kotlin.util.SmartPrinter
+import org.jetbrains.kotlin.util.withIndent
+import java.io.File
+import kotlin.reflect.KClass
+import kotlin.reflect.full.createType
+
+private const val CONVERT_ARGUMENT = "convertArgument"
+
+object ArgumentsConverterGenerator {
+    fun render(file: File, packageName: String) {
+        val convertArgumentFunctionCallConversion = HLFunctionCallConversion(
+            "$CONVERT_ARGUMENT({0}, firSymbolBuilder)",
+            callType = Any::class.createType(nullable = true)
+        )
+        val convertersMap = FirToKtConversionCreator.getAllConverters(convertArgumentFunctionCallConversion)
+        file.writeToFileUsingSmartPrinterIfFileContentChanged { generate(packageName, convertersMap) }
+    }
+
+    private fun SmartPrinter.generate(packageName: String, convertersMap: Map<KClass<*>, HLParameterConversion>) {
+        printCopyright()
+        println("@file:Suppress(\"UNUSED_PARAMETER\")")
+        println()
+        println("package $packageName")
+        println()
+        collectAndPrintImports(convertersMap)
+        println()
+        printGeneratedMessage()
+
+        generateDispatchingConverter(convertersMap)
+        for ((type, converter) in convertersMap) {
+            generateSingleConverter(type, converter)
+        }
+    }
+
+    private fun SmartPrinter.collectAndPrintImports(convertersMap: Map<KClass<*>, HLParameterConversion>) {
+        val imports = buildList {
+            add("org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder")
+            add("org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession")
+            convertersMap.values.flatMapTo(this) { it.importsToAdd }
+            convertersMap.keys.mapNotNullTo(this) { it.qualifiedName }
+        }
+        printImports(imports)
+    }
+
+    private fun SmartPrinter.generateDispatchingConverter(convertersMap: Map<KClass<*>, HLParameterConversion>) {
+        println("internal fun $CONVERT_ARGUMENT(argument: Any?, analysisSession: KtFirAnalysisSession): Any? {")
+        withIndent {
+            println("return $CONVERT_ARGUMENT(argument, analysisSession.firSymbolBuilder)")
+        }
+        println("}")
+        println()
+
+        println("private fun $CONVERT_ARGUMENT(argument: Any?, firSymbolBuilder: KtSymbolByFirBuilder): Any? {")
+        withIndent {
+            println("return when (argument) {")
+            withIndent {
+                println("null -> null")
+                for (type in convertersMap.keys) {
+                    println("is ${type.typeWithStars} -> $CONVERT_ARGUMENT(argument, firSymbolBuilder)")
+                }
+                println("else -> argument")
+            }
+            println("}")
+        }
+        println("}")
+        println()
+    }
+
+    private fun SmartPrinter.generateSingleConverter(type: KClass<*>, converter: HLParameterConversion) {
+        println("private fun $CONVERT_ARGUMENT(argument: ${type.typeWithStars}, firSymbolBuilder: KtSymbolByFirBuilder): Any? {")
+        withIndent {
+            println("return ${converter.convertExpression("argument", ConversionContext(getCurrentIndentInUnits(), getIndentUnit()))}")
+        }
+        println("}")
+        println()
+    }
+
+    private val KClass<*>.typeWithStars: String
+        get() = buildString {
+            append(simpleName)
+            if (typeParameters.isNotEmpty()) {
+                append(typeParameters.joinToString(", ", "<", ">") { "*" })
+            }
+        }
+}

analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/DiagnosticClassGenerator.kt

@@ -18,5 +18,6 @@ object DiagnosticClassGenerator {
         KtDiagnosticClassRenderer.render(path.resolve("KtFirDiagnostics.kt"), diagnosticList, packageName, emptySet())
         KtDiagnosticClassImplementationRenderer.render(path.resolve("KtFirDiagnosticsImpl.kt"), diagnosticList, packageName, emptySet())
         FirDiagnosticToKtDiagnosticConverterRenderer.render(path.resolve("KtFirDataClassConverters.kt"), diagnosticList, packageName, emptySet())
+        ArgumentsConverterGenerator.render(path.resolve("KtFirArgumentsConverter.kt"), packageName)
     }
 }

analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/HLDiagnosticConverter.kt

@@ -43,7 +43,6 @@ import kotlin.reflect.full.createType
 import kotlin.reflect.full.isSubclassOf
 
 object HLDiagnosticConverter {
-    @OptIn(ExperimentalStdlibApi::class)
     fun convert(diagnosticList: DiagnosticList): HLDiagnosticList {
         return HLDiagnosticList(diagnosticList.allDiagnostics.flatMap(::convertDiagnostic))
     }
@@ -107,8 +106,7 @@ object HLDiagnosticConverter {
 
 }
 
-
-private object FirToKtConversionCreator {
+internal object FirToKtConversionCreator {
     fun createConversion(type: KType): HLParameterConversion {
         val nullable = type.isMarkedNullable
         val kClass = type.classifier as KClass<*>
@@ -119,6 +117,32 @@ private object FirToKtConversionCreator {
             ?: error("Unsupported type $type, consider add corresponding mapping")
     }
 
+    fun getAllConverters(conversionForCollectionValues: HLParameterConversion): Map<KClass<*>, HLParameterConversion> {
+        return buildMap {
+            putAll(typeMapping)
+            put(
+                Map::class,
+                HLMapParameterConversion(
+                    "key",
+                    "value",
+                    conversionForCollectionValues,
+                    conversionForCollectionValues
+                )
+            )
+            put(
+                Collection::class,
+                HLCollectionParameterConversion("value", conversionForCollectionValues)
+            )
+            put(
+                Pair::class,
+                HLPairParameterConversion(
+                    conversionForCollectionValues,
+                    conversionForCollectionValues
+                )
+            )
+        }
+    }
+
     private fun tryMapFirTypeToKtType(kClass: KClass<*>, nullable: Boolean): HLParameterConversion? {
         return if (nullable) {
             nullableTypeMapping[kClass] ?: typeMapping[kClass]
@@ -188,19 +212,7 @@ private object FirToKtConversionCreator {
     )
 
     private val typeMapping: Map<KClass<*>, HLFunctionCallConversion> = mapOf(
-        FirBasedSymbol::class to HLFunctionCallConversion(
-            "firSymbolBuilder.buildSymbol({0})",
-            KtSymbol::class.createType(),
-            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration")
-        ),
-        FirClass::class to HLFunctionCallConversion(
-            "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0}.symbol)",
-            KtClassLikeSymbol::class.createType()
-        ),
-        FirClassSymbol::class to HLFunctionCallConversion(
-            "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0})",
-            KtClassLikeSymbol::class.createType()
-        ),
+        // ------------------ symbols ------------------
         FirRegularClass::class to HLFunctionCallConversion(
             "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0}.symbol) as KtNamedClassOrObjectSymbol",
             KtNamedClassOrObjectSymbol::class.createType(),
@@ -209,27 +221,6 @@ private object FirToKtConversionCreator {
                 "org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol"
             )
         ),
-        FirExpression::class to HLFunctionCallConversion(
-            "{0}.source!!.psi as KtExpression",
-            KtExpression::class.createType(),
-            importsToAdd = listOf(
-                "org.jetbrains.kotlin.psi.KtExpression",
-                "org.jetbrains.kotlin.psi"
-            )
-        ),
-        FirQualifiedAccess::class to HLFunctionCallConversion(
-            "{0}.source!!.psi as KtExpression",
-            KtExpression::class.createType(),
-            importsToAdd = listOf(
-                "org.jetbrains.kotlin.psi.KtExpression",
-                "org.jetbrains.kotlin.psi"
-            )
-        ),
-        FirValueParameter::class to HLFunctionCallConversion(
-            "firSymbolBuilder.buildSymbol({0}.symbol)",
-            KtSymbol::class.createType(),
-            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration")
-        ),
         FirValueParameterSymbol::class to HLFunctionCallConversion(
             "firSymbolBuilder.buildSymbol({0})",
             KtSymbol::class.createType(),
@@ -239,66 +230,58 @@ private object FirToKtConversionCreator {
             "firSymbolBuilder.buildSymbol({0})",
             KtSymbol::class.createType(),
         ),
-        FirClassLikeSymbol::class to HLFunctionCallConversion(
-            "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0})",
-            KtClassLikeSymbol::class.createType(),
-            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirClass")
-        ),
         FirRegularClassSymbol::class to HLFunctionCallConversion(
             "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0})",
-            KtClassLikeSymbol::class.createType(),
-            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirRegularClass")
+            KtClassLikeSymbol::class.createType()
         ),
-        FirMemberDeclaration::class to HLFunctionCallConversion(
-            "firSymbolBuilder.buildSymbol({0} as FirDeclaration)",
-            KtSymbol::class.createType(),
-            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration")
-        ),
-        FirCallableDeclaration::class to HLFunctionCallConversion(
-            "firSymbolBuilder.callableBuilder.buildCallableSymbol({0} as FirCallableDeclaration)",
-            KtCallableSymbol::class.createType(),
-            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration")
-        ),
-        FirCallableSymbol::class to HLFunctionCallConversion(
-            "firSymbolBuilder.callableBuilder.buildCallableSymbol({0})",
-            KtCallableSymbol::class.createType(),
-            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration")
-        ),
-        FirTypeParameterSymbol::class to HLFunctionCallConversion(
-            "firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol({0})",
-            KtTypeParameterSymbol::class.createType(),
-            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirTypeParameter")
-        ),
-        FirTypeParameter::class to HLFunctionCallConversion(
-            "firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol({0})",
-            KtTypeParameterSymbol::class.createType(),
-            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirTypeParameter")
-        ),
-        ConeKotlinType::class to HLFunctionCallConversion(
-            "firSymbolBuilder.typeBuilder.buildKtType({0})",
-            KtType::class.createType()
-        ),
-        FirTypeRef::class to HLFunctionCallConversion(
-            "firSymbolBuilder.typeBuilder.buildKtType({0})",
-            KtType::class.createType()
+        FirNamedFunctionSymbol::class to HLFunctionCallConversion(
+            "firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol({0})",
+            KtFunctionLikeSymbol::class.createType()
         ),
         FirPropertySymbol::class to HLFunctionCallConversion(
             "firSymbolBuilder.variableLikeBuilder.buildVariableSymbol({0})",
-            KtVariableSymbol::class.createType(),
-            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirProperty")
+            KtVariableSymbol::class.createType()
         ),
         FirBackingFieldSymbol::class to HLFunctionCallConversion(
             "firSymbolBuilder.variableLikeBuilder.buildVariableSymbol({0}.fir.propertySymbol)",
-            KtVariableSymbol::class.createType(),
-            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirProperty")
+            KtVariableSymbol::class.createType()
         ),
         FirVariableSymbol::class to HLFunctionCallConversion(
             "firSymbolBuilder.variableLikeBuilder.buildVariableLikeSymbol({0})",
-            KtVariableLikeSymbol::class.createType(),
-            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirVariable")
+            KtVariableLikeSymbol::class.createType()
         ),
-        FirDeclaration::class to HLFunctionCallConversion(
+        FirTypeParameterSymbol::class to HLFunctionCallConversion(
+            "firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol({0})",
+            KtTypeParameterSymbol::class.createType()
+        ),
+        FirCallableSymbol::class to HLFunctionCallConversion(
+            "firSymbolBuilder.callableBuilder.buildCallableSymbol({0})",
+            KtCallableSymbol::class.createType()
+        ),
+        FirClassSymbol::class to HLFunctionCallConversion(
+            "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0})",
+            KtClassLikeSymbol::class.createType()
+        ),
+        FirClassLikeSymbol::class to HLFunctionCallConversion(
+            "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0})",
+            KtClassLikeSymbol::class.createType()
+        ),
+        FirBasedSymbol::class to HLFunctionCallConversion(
             "firSymbolBuilder.buildSymbol({0})",
+            KtSymbol::class.createType()
+        ),
+        // ------------------ FIR elements ------------------
+        FirClass::class to HLFunctionCallConversion(
+            "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0}.symbol)",
+            KtClassLikeSymbol::class.createType()
+        ),
+        FirTypeParameter::class to HLFunctionCallConversion(
+            "firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol({0}.symbol)",
+            KtTypeParameterSymbol::class.createType(),
+            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirTypeParameter")
+        ),
+        FirValueParameter::class to HLFunctionCallConversion(
+            "firSymbolBuilder.buildSymbol({0}.symbol)",
             KtSymbol::class.createType(),
             importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration")
         ),
@@ -307,10 +290,46 @@ private object FirToKtConversionCreator {
             KtSymbol::class.createType(),
             importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirFunction")
         ),
-        FirNamedFunctionSymbol::class to HLFunctionCallConversion(
-            "firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol({0})",
-            KtFunctionLikeSymbol::class.createType(),
-            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirSimpleFunction")
+        FirCallableDeclaration::class to HLFunctionCallConversion(
+            "firSymbolBuilder.callableBuilder.buildCallableSymbol({0}.symbol)",
+            KtCallableSymbol::class.createType(),
+            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration")
+        ),
+        FirMemberDeclaration::class to HLFunctionCallConversion(
+            "firSymbolBuilder.buildSymbol({0} as FirDeclaration)",
+            KtSymbol::class.createType(),
+            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration")
+        ),
+        FirDeclaration::class to HLFunctionCallConversion(
+            "firSymbolBuilder.buildSymbol({0})",
+            KtSymbol::class.createType(),
+            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration")
+        ),
+        FirQualifiedAccess::class to HLFunctionCallConversion(
+            "{0}.source!!.psi as KtExpression",
+            KtExpression::class.createType(),
+            importsToAdd = listOf(
+                "org.jetbrains.kotlin.psi.KtExpression",
+                "org.jetbrains.kotlin.psi"
+            )
+        ),
+        FirExpression::class to HLFunctionCallConversion(
+            "{0}.source!!.psi as KtExpression",
+            KtExpression::class.createType(),
+            importsToAdd = listOf(
+                "org.jetbrains.kotlin.psi.KtExpression",
+                "org.jetbrains.kotlin.psi"
+            )
+        ),
+        // ------------------ other ------------------
+
+        ConeKotlinType::class to HLFunctionCallConversion(
+            "firSymbolBuilder.typeBuilder.buildKtType({0})",
+            KtType::class.createType()
+        ),
+        FirTypeRef::class to HLFunctionCallConversion(
+            "firSymbolBuilder.typeBuilder.buildKtType({0})",
+            KtType::class.createType()
         ),
         KtSourceElement::class to HLFunctionCallConversion(
             "({0} as KtPsiSourceElement).psi",

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2010-2022 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.analysis.api.fir.diagnostics
+
+import com.intellij.psi.PsiElement
+
+abstract class KtCompilerPluginDiagnostic0 : KtFirDiagnostic<PsiElement>(), KtAbstractFirDiagnostic<PsiElement> {
+    final override val diagnosticClass
+        get() = KtCompilerPluginDiagnostic0::class
+}
+
+abstract class KtCompilerPluginDiagnostic1 : KtFirDiagnostic<PsiElement>(), KtAbstractFirDiagnostic<PsiElement> {
+    abstract val parameter1: Any?
+
+    final override val diagnosticClass
+        get() = KtCompilerPluginDiagnostic1::class
+}
+
+abstract class KtCompilerPluginDiagnostic2 : KtFirDiagnostic<PsiElement>(), KtAbstractFirDiagnostic<PsiElement> {
+    abstract val parameter1: Any?
+    abstract val parameter2: Any?
+
+    final override val diagnosticClass
+        get() = KtCompilerPluginDiagnostic2::class
+}
+
+abstract class KtCompilerPluginDiagnostic3 : KtFirDiagnostic<PsiElement>(), KtAbstractFirDiagnostic<PsiElement> {
+    abstract val parameter1: Any?
+    abstract val parameter2: Any?
+    abstract val parameter3: Any?
+
+    final override val diagnosticClass
+        get() = KtCompilerPluginDiagnostic3::class
+}
+
+abstract class KtCompilerPluginDiagnostic4 : KtFirDiagnostic<PsiElement>(), KtAbstractFirDiagnostic<PsiElement> {
+    abstract val parameter1: Any?
+    abstract val parameter2: Any?
+    abstract val parameter3: Any?
+    abstract val parameter4: Any?
+
+    final override val diagnosticClass
+        get() = KtCompilerPluginDiagnostic4::class
+}

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

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2010-2022 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.analysis.api.fir.diagnostics
+
+import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
+import org.jetbrains.kotlin.diagnostics.*
+
+internal class KtCompilerPluginDiagnostic0Impl(
+    override val firDiagnostic: KtPsiSimpleDiagnostic,
+    override val token: KtLifetimeToken
+) : KtCompilerPluginDiagnostic0()
+
+internal class KtCompilerPluginDiagnostic1Impl(
+    override val firDiagnostic: KtPsiDiagnosticWithParameters1<*>,
+    override val token: KtLifetimeToken,
+    override val parameter1: Any?
+) : KtCompilerPluginDiagnostic1()
+
+internal class KtCompilerPluginDiagnostic2Impl(
+    override val firDiagnostic: KtPsiDiagnosticWithParameters2<*, *>,
+    override val token: KtLifetimeToken,
+    override val parameter1: Any?,
+    override val parameter2: Any?
+) : KtCompilerPluginDiagnostic2()
+
+internal class KtCompilerPluginDiagnostic3Impl(
+    override val firDiagnostic: KtPsiDiagnosticWithParameters3<*, *, *>,
+    override val token: KtLifetimeToken,
+    override val parameter1: Any?,
+    override val parameter2: Any?,
+    override val parameter3: Any?
+) : KtCompilerPluginDiagnostic3()
+
+internal class KtCompilerPluginDiagnostic4Impl(
+    override val firDiagnostic: KtPsiDiagnosticWithParameters4<*, *, *, *>,
+    override val token: KtLifetimeToken,
+    override val parameter1: Any?,
+    override val parameter2: Any?,
+    override val parameter3: Any?,
+    override val parameter4: Any?
+) : KtCompilerPluginDiagnostic4()

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

@@ -32,8 +32,7 @@ internal fun interface KtFirDiagnostic4Creator<A, B, C, D> : KtFirDiagnosticCrea
 
 internal class KtDiagnosticConverter(private val conversions: Map<AbstractKtDiagnosticFactory, KtFirDiagnosticCreator>) {
     fun convert(analysisSession: KtFirAnalysisSession, diagnostic: KtDiagnostic): KtFirDiagnostic<*> {
-        val creator = conversions[diagnostic.factory]
-            ?: error("No conversion was found for ${diagnostic.factory}")
+        val creator = conversions[diagnostic.factory] ?: buildCreatorForPluginDiagnostic(diagnostic.factory)
 
         @Suppress("UNCHECKED_CAST")
         return with(analysisSession) {
@@ -57,6 +56,49 @@ internal class KtDiagnosticConverter(private val conversions: Map<AbstractKtDiag
             }
         }
     }
+
+    @Suppress("RemoveExplicitTypeArguments") // See KT-52838
+    private fun buildCreatorForPluginDiagnostic(factory: AbstractKtDiagnosticFactory): KtFirDiagnosticCreator {
+        return when (factory) {
+            is KtDiagnosticFactory0 -> KtFirDiagnostic0Creator {
+                KtCompilerPluginDiagnostic0Impl(it as KtPsiSimpleDiagnostic, token)
+            }
+            is KtDiagnosticFactory1<*> -> KtFirDiagnostic1Creator {
+                KtCompilerPluginDiagnostic1Impl(
+                    it as KtPsiDiagnosticWithParameters1<*>,
+                    token,
+                    convertArgument(it.a, this)
+                )
+            }
+            is KtDiagnosticFactory2<*, *> -> KtFirDiagnostic2Creator<Any?, Any?> {
+                KtCompilerPluginDiagnostic2Impl(
+                    it as KtPsiDiagnosticWithParameters2<*, *>,
+                    token,
+                    convertArgument(it.a, this),
+                    convertArgument(it.b, this)
+                )
+            }
+            is KtDiagnosticFactory3<*, *, *> -> KtFirDiagnostic3Creator<Any?, Any?, Any?> {
+                KtCompilerPluginDiagnostic3Impl(
+                    it as KtPsiDiagnosticWithParameters3<*, *, *>,
+                    token,
+                    convertArgument(it.a, this),
+                    convertArgument(it.b, this),
+                    convertArgument(it.c, this)
+                )
+            }
+            is KtDiagnosticFactory4<*, *, *, *> -> KtFirDiagnostic4Creator<Any?, Any?, Any?, Any?> {
+                KtCompilerPluginDiagnostic4Impl(
+                    it as KtPsiDiagnosticWithParameters4<*, *, *, *>,
+                    token,
+                    convertArgument(it.a, this),
+                    convertArgument(it.b, this),
+                    convertArgument(it.c, this),
+                    convertArgument(it.d, this)
+                )
+            }
+        }
+    }
 }
 
 internal class KtDiagnosticConverterBuilder private constructor() {

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

@@ -0,0 +1,203 @@
+/*
+ * 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.
+ */
+
+@file:Suppress("UNUSED_PARAMETER")
+
+package org.jetbrains.kotlin.analysis.api.fir.diagnostics
+
+import org.jetbrains.kotlin.KtPsiSourceElement
+import org.jetbrains.kotlin.KtSourceElement
+import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
+import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
+import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirFunction
+import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirEnumEntrySymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.psi
+import org.jetbrains.kotlin.psi.KtExpression
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+internal fun convertArgument(argument: Any?, analysisSession: KtFirAnalysisSession): Any? {
+    return convertArgument(argument, analysisSession.firSymbolBuilder)
+}
+
+private fun convertArgument(argument: Any?, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return when (argument) {
+        null -> null
+        is FirRegularClass -> convertArgument(argument, firSymbolBuilder)
+        is FirValueParameterSymbol -> convertArgument(argument, firSymbolBuilder)
+        is FirEnumEntrySymbol -> convertArgument(argument, firSymbolBuilder)
+        is FirRegularClassSymbol -> convertArgument(argument, firSymbolBuilder)
+        is FirNamedFunctionSymbol -> convertArgument(argument, firSymbolBuilder)
+        is FirPropertySymbol -> convertArgument(argument, firSymbolBuilder)
+        is FirBackingFieldSymbol -> convertArgument(argument, firSymbolBuilder)
+        is FirVariableSymbol<*> -> convertArgument(argument, firSymbolBuilder)
+        is FirTypeParameterSymbol -> convertArgument(argument, firSymbolBuilder)
+        is FirCallableSymbol<*> -> convertArgument(argument, firSymbolBuilder)
+        is FirClassSymbol<*> -> convertArgument(argument, firSymbolBuilder)
+        is FirClassLikeSymbol<*> -> convertArgument(argument, firSymbolBuilder)
+        is FirBasedSymbol<*> -> convertArgument(argument, firSymbolBuilder)
+        is FirClass -> convertArgument(argument, firSymbolBuilder)
+        is FirTypeParameter -> convertArgument(argument, firSymbolBuilder)
+        is FirValueParameter -> convertArgument(argument, firSymbolBuilder)
+        is FirFunction -> convertArgument(argument, firSymbolBuilder)
+        is FirCallableDeclaration -> convertArgument(argument, firSymbolBuilder)
+        is FirMemberDeclaration -> convertArgument(argument, firSymbolBuilder)
+        is FirDeclaration -> convertArgument(argument, firSymbolBuilder)
+        is FirQualifiedAccess -> convertArgument(argument, firSymbolBuilder)
+        is FirExpression -> convertArgument(argument, firSymbolBuilder)
+        is ConeKotlinType -> convertArgument(argument, firSymbolBuilder)
+        is FirTypeRef -> convertArgument(argument, firSymbolBuilder)
+        is KtSourceElement -> convertArgument(argument, firSymbolBuilder)
+        is Map<*, *> -> convertArgument(argument, firSymbolBuilder)
+        is Collection<*> -> convertArgument(argument, firSymbolBuilder)
+        is Pair<*, *> -> convertArgument(argument, firSymbolBuilder)
+        else -> argument
+    }
+}
+
+private fun convertArgument(argument: FirRegularClass, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(argument.symbol) as KtNamedClassOrObjectSymbol
+}
+
+private fun convertArgument(argument: FirValueParameterSymbol, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.buildSymbol(argument)
+}
+
+private fun convertArgument(argument: FirEnumEntrySymbol, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.buildSymbol(argument)
+}
+
+private fun convertArgument(argument: FirRegularClassSymbol, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(argument)
+}
+
+private fun convertArgument(argument: FirNamedFunctionSymbol, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol(argument)
+}
+
+private fun convertArgument(argument: FirPropertySymbol, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.variableLikeBuilder.buildVariableSymbol(argument)
+}
+
+private fun convertArgument(argument: FirBackingFieldSymbol, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.variableLikeBuilder.buildVariableSymbol(argument.fir.propertySymbol)
+}
+
+private fun convertArgument(argument: FirVariableSymbol<*>, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.variableLikeBuilder.buildVariableLikeSymbol(argument)
+}
+
+private fun convertArgument(argument: FirTypeParameterSymbol, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol(argument)
+}
+
+private fun convertArgument(argument: FirCallableSymbol<*>, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.callableBuilder.buildCallableSymbol(argument)
+}
+
+private fun convertArgument(argument: FirClassSymbol<*>, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(argument)
+}
+
+private fun convertArgument(argument: FirClassLikeSymbol<*>, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(argument)
+}
+
+private fun convertArgument(argument: FirBasedSymbol<*>, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.buildSymbol(argument)
+}
+
+private fun convertArgument(argument: FirClass, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(argument.symbol)
+}
+
+private fun convertArgument(argument: FirTypeParameter, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol(argument.symbol)
+}
+
+private fun convertArgument(argument: FirValueParameter, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.buildSymbol(argument.symbol)
+}
+
+private fun convertArgument(argument: FirFunction, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.buildSymbol(argument)
+}
+
+private fun convertArgument(argument: FirCallableDeclaration, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.callableBuilder.buildCallableSymbol(argument.symbol)
+}
+
+private fun convertArgument(argument: FirMemberDeclaration, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.buildSymbol(argument as FirDeclaration)
+}
+
+private fun convertArgument(argument: FirDeclaration, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.buildSymbol(argument)
+}
+
+private fun convertArgument(argument: FirQualifiedAccess, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return argument.source!!.psi as KtExpression
+}
+
+private fun convertArgument(argument: FirExpression, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return argument.source!!.psi as KtExpression
+}
+
+private fun convertArgument(argument: ConeKotlinType, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.typeBuilder.buildKtType(argument)
+}
+
+private fun convertArgument(argument: FirTypeRef, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return firSymbolBuilder.typeBuilder.buildKtType(argument)
+}
+
+private fun convertArgument(argument: KtSourceElement, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return (argument as KtPsiSourceElement).psi
+}
+
+private fun convertArgument(argument: Map<*, *>, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return argument.mapKeys { (key, _) ->
+        convertArgument(key, firSymbolBuilder)
+    }.mapValues { (_, value) -> 
+        convertArgument(value, firSymbolBuilder)
+    }
+}
+
+private fun convertArgument(argument: Collection<*>, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return argument.map { value ->
+        convertArgument(value, firSymbolBuilder)
+    }
+}
+
+private fun convertArgument(argument: Pair<*, *>, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
+    return convertArgument(argument.first, firSymbolBuilder) to convertArgument(argument.second, firSymbolBuilder)
+}
+

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

@@ -12,15 +12,8 @@ import org.jetbrains.kotlin.diagnostics.KtPsiDiagnostic
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors
 import org.jetbrains.kotlin.fir.builder.FirSyntaxErrors
-import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFunction
-import org.jetbrains.kotlin.fir.declarations.FirProperty
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
-import org.jetbrains.kotlin.fir.declarations.FirVariable
 import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.psi.KtAnnotationEntry
 import org.jetbrains.kotlin.psi.KtAnonymousInitializer