FIR: introduce DSL to generate diagnostics list

this is needed to generate diagnostic list for IDE

compiler/fir/checkers/checkers-component-generator/build.gradle.kts

@@ -9,6 +9,14 @@ dependencies {
     implementation(project(":compiler:fir:tree:tree-generator"))
     implementation(project(":kotlin-reflect"))
     implementation(project(":kotlin-reflect-api"))
+
+    /*
+     We do not need guava in the generator, but because of a bug in the IJ project importing, we need to have a dependency on intellijCoreDep
+     the same as it is in `:fir:tree:tree-generator` module to the project be imported correctly
+    */
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core", "guava", rootProject = rootProject) }
+
+    implementation(project(":compiler:psi"))
 }
 
 val writeCopyright by task<tasks.WriteCopyrightToFile> {

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Generator.kt

@@ -20,16 +20,7 @@ class Generator(
     private val packageName: String,
     private val abstractCheckerName: String
 ) {
-    private val generationPath: File
+    private val generationPath: File = getGenerationPath(generationPath, packageName)
-
-    init {
-        var path = generationPath
-        packageName.split(".").forEach {
-            path = path.resolve(it)
-        }
-        path.mkdirs()
-        this.generationPath = path
-    }
 
     private fun generateAliases() {
         val filename = "${abstractCheckerName}Aliases.kt"

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/ImportPrinter.kt

@@ -0,0 +1,33 @@
+/*
+ * 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.fir.checkers.generator
+
+import org.jetbrains.kotlin.fir.tree.generator.printer.SmartPrinter
+
+private object ImportPrinter {
+   fun SmartPrinter.printImports(imports: Collection<String>) {
+       val importsToPrint = imports.filterNot { it.isDefaultImport() }.distinct().sorted()
+       for (import in importsToPrint) {
+           println("import $import")
+       }
+   }
+
+   private fun String.isDefaultImport() = substringBeforeLast('.') in defaultImportedPackages
+
+   private val defaultImportedPackages = setOf(
+       "kotlin",
+       "kotlin.annotation",
+       "kotlin.collections",
+       "kotlin.ranges",
+       "kotlin.sequences",
+       "kotlin.text",
+       "kotlin.io",
+   )
+}
+
+fun SmartPrinter.printImports(imports: Collection<String>) {
+    with(ImportPrinter) { printImports(imports) }
+}

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Main.kt

@@ -5,6 +5,8 @@
 
 package org.jetbrains.kotlin.fir.checkers.generator
 
+import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.DIAGNOSTICS_LIST
+import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.generateDiagnostics
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.*
 import java.io.File
@@ -43,6 +45,9 @@ fun main(args: Array<String>) {
             classFqn = "org.jetbrains.kotlin.fir.analysis.cfa.AbstractFirPropertyInitializationChecker"
         )
     }
+
+    val diagnosticsPackage = "org.jetbrains.kotlin.fir.analysis.diagnostics"
+    generateDiagnostics(generationPath, diagnosticsPackage, DIAGNOSTICS_LIST)
 }
 
 /*

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

@@ -0,0 +1,93 @@
+/*
+ * 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.fir.checkers.generator.diagnostics
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.diagnostics.Severity
+import org.jetbrains.kotlin.fir.FirSourceElement
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+
+data class Diagnostic(
+    val severity: Severity,
+    val name: String,
+    val sourceElementType: KType,
+    val psiType: KType,
+    val parameters: List<DiagnosticParameter>,
+    val positioningStrategy: PositioningStrategy,
+)
+
+data class DiagnosticParameter(
+    val name: String,
+    val type: KType
+)
+
+enum class PositioningStrategy(val expressionToCreate: String, val import: String) {
+    DEFAULT(
+        "SourceElementPositioningStrategies.DEFAULT",
+        positioningStrategiesImport
+    ),
+
+    VAL_OR_VAR_NODE(
+        "SourceElementPositioningStrategies.VAL_OR_VAR_NODE",
+        positioningStrategiesImport
+    ),
+
+    SECONDARY_CONSTRUCTOR_DELEGATION_CALL(
+        "SourceElementPositioningStrategies.SECONDARY_CONSTRUCTOR_DELEGATION_CALL",
+        positioningStrategiesImport
+    ),
+
+    DECLARATION_NAME(
+        "SourceElementPositioningStrategies.DECLARATION_NAME",
+        positioningStrategiesImport
+    ),
+
+    DECLARATION_SIGNATURE(
+        "SourceElementPositioningStrategies.DECLARATION_SIGNATURE",
+        positioningStrategiesImport
+    ),
+
+    DECLARATION_SIGNATURE_OR_DEFAULT(
+        "SourceElementPositioningStrategies.DECLARATION_SIGNATURE_OR_DEFAULT",
+        positioningStrategiesImport
+    ),
+
+    VISIBILITY_MODIFIER(
+        "SourceElementPositioningStrategies.VISIBILITY_MODIFIER",
+        positioningStrategiesImport
+    ),
+
+    MODALITY_MODIFIER(
+        "SourceElementPositioningStrategies.MODALITY_MODIFIER",
+        positioningStrategiesImport
+    ),
+
+    OPERATOR(
+        "SourceElementPositioningStrategies.OPERATOR",
+        positioningStrategiesImport
+    ),
+
+    PARAMETER_DEFAULT_VALUE(
+        "SourceElementPositioningStrategies.PARAMETER_DEFAULT_VALUE",
+        positioningStrategiesImport
+    ),
+
+    PARAMETER_VARARG_MODIFIER(
+        "SourceElementPositioningStrategies.PARAMETER_VARARG_MODIFIER",
+        positioningStrategiesImport
+    ),
+}
+
+private const val positioningStrategiesImport = "org.jetbrains.kotlin.fir.analysis.diagnostics.SourceElementPositioningStrategies"
+
+
+fun Diagnostic.hasDefaultPositioningStrategy(): Boolean =
+    positioningStrategy == PositioningStrategy.DEFAULT
+
+data class DiagnosticList(
+    val diagnostics: List<Diagnostic>,
+)

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

@@ -0,0 +1,96 @@
+/*
+ * 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.fir.checkers.generator.diagnostics
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.diagnostics.Severity
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.PrivateForInline
+import kotlin.properties.PropertyDelegateProvider
+import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+class DiagnosticListBuilder private constructor() {
+    @PrivateForInline
+    val diagnostics = mutableListOf<Diagnostic>()
+
+    @OptIn(PrivateForInline::class)
+    inline fun <reified E : FirSourceElement, reified P : PsiElement> error(
+        positioningStrategy: PositioningStrategy = PositioningStrategy.DEFAULT,
+        crossinline init: DiagnosticBuilder.() -> Unit = {}
+    ) = diagnosticDelegateProvider<E, P>(Severity.ERROR, positioningStrategy, init)
+
+
+    @OptIn(PrivateForInline::class)
+    inline fun <reified E : FirSourceElement, reified P : PsiElement> warning(
+        positioningStrategy: PositioningStrategy = PositioningStrategy.DEFAULT,
+        crossinline init: DiagnosticBuilder.() -> Unit = {}
+    ) = diagnosticDelegateProvider<E, P>(Severity.WARNING, positioningStrategy, init)
+
+    @PrivateForInline
+    @OptIn(ExperimentalStdlibApi::class)
+    inline fun <reified E : FirSourceElement, reified P : PsiElement> diagnosticDelegateProvider(
+        severity: Severity,
+        positioningStrategy: PositioningStrategy,
+        crossinline init: DiagnosticBuilder.() -> Unit = {}
+    ) = PropertyDelegateProvider<Any?, AlwaysReturningUnitPropertyDelegate> { _, property ->
+        diagnostics += DiagnosticBuilder(
+            severity,
+            name = property.name,
+            sourceElementType = typeOf<E>(),
+            psiType = typeOf<P>(),
+            positioningStrategy,
+        ).apply(init).build()
+        AlwaysReturningUnitPropertyDelegate
+    }
+
+    @PrivateForInline
+    object AlwaysReturningUnitPropertyDelegate : ReadOnlyProperty<Any?, Unit> {
+        override fun getValue(thisRef: Any?, property: KProperty<*>) = Unit
+    }
+
+    @OptIn(PrivateForInline::class)
+    private fun build() = DiagnosticList(diagnostics)
+
+    companion object {
+        fun buildDiagnosticList(init: DiagnosticListBuilder.() -> Unit) =
+            DiagnosticListBuilder().apply(init).build()
+    }
+}
+
+class DiagnosticBuilder(
+    private val severity: Severity,
+    private val name: String,
+    private val sourceElementType: KType,
+    private val psiType: KType,
+    private val positioningStrategy: PositioningStrategy
+) {
+    @PrivateForInline
+    val parameters = mutableListOf<DiagnosticParameter>()
+
+    @OptIn(PrivateForInline::class, ExperimentalStdlibApi::class)
+    inline fun <reified T> parameter(name: String) {
+        if (parameters.size == 3) {
+            error("Diagnostic cannot have more than 3 parameters")
+        }
+        parameters += DiagnosticParameter(
+            name = name,
+            type = typeOf<T>()
+        )
+    }
+
+    @OptIn(PrivateForInline::class)
+    fun build() = Diagnostic(
+        severity,
+        name,
+        sourceElementType,
+        psiType,
+        parameters,
+        positioningStrategy,
+    )
+}

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

@@ -0,0 +1,14 @@
+/*
+ * 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.fir.checkers.generator.diagnostics
+
+import org.jetbrains.kotlin.fir.checkers.generator.getGenerationPath
+import java.io.File
+
+fun generateDiagnostics(rootPath: File, packageName: String, diagnosticList: DiagnosticList) {
+    val generationPath = getGenerationPath(rootPath, packageName)
+    ErrorListDiagnosticListRenderer.render(generationPath.resolve("FirErrors.kt"), diagnosticList, packageName)
+}

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

@@ -0,0 +1,12 @@
+/*
+ * 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.fir.checkers.generator.diagnostics
+
+import java.io.File
+
+abstract class DiagnosticListRenderer {
+    abstract fun render(file: File, diagnosticList: DiagnosticList, packageName: String)
+}

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

@@ -0,0 +1,124 @@
+/*
+ * 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.fir.checkers.generator.diagnostics
+
+import org.jetbrains.kotlin.fir.checkers.generator.*
+import org.jetbrains.kotlin.fir.tree.generator.printer.SmartPrinter
+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.printer.useSmartPrinter
+import java.io.File
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlin.reflect.KTypeProjection
+
+object ErrorListDiagnosticListRenderer : DiagnosticListRenderer() {
+    override fun render(file: File, diagnosticList: DiagnosticList, packageName: String) {
+        file.useSmartPrinter {
+            render(diagnosticList, packageName)
+        }
+    }
+
+    private fun SmartPrinter.render(diagnosticList: DiagnosticList, packageName: String) {
+        printCopyright()
+        println("package $packageName")
+        println()
+        collectAndPrintImports(diagnosticList)
+        printGeneratedMessage()
+        printErrorsObject(diagnosticList)
+    }
+
+    private fun SmartPrinter.printErrorsObject(diagnosticList: DiagnosticList) {
+        inBracketsWithIndent("object FirErrors") {
+            for (it in diagnosticList.diagnostics) {
+                printDiagnostic(it)
+            }
+        }
+    }
+
+    private fun SmartPrinter.printDiagnostic(diagnostic: Diagnostic) {
+        print("val ${diagnostic.name} by ${diagnostic.getFactoryFunction()}")
+        printTypeArguments(diagnostic.getAllTypeArguments())
+        printPositioningStrategy(diagnostic)
+        println()
+    }
+
+    private fun SmartPrinter.printPositioningStrategy(diagnostic: Diagnostic) {
+        print("(")
+        if (!diagnostic.hasDefaultPositioningStrategy()) {
+            print(diagnostic.positioningStrategy.expressionToCreate)
+        }
+        print(")")
+    }
+
+
+    @OptIn(ExperimentalStdlibApi::class)
+    private fun Diagnostic.getAllTypeArguments(): List<KType> = buildList {
+        add(sourceElementType)
+        add(psiType)
+        parameters.mapTo(this) { it.type }
+    }
+
+    private fun SmartPrinter.printTypeArguments(typeArguments: List<KType>) {
+        print("<")
+        printSeparatedWithComma(typeArguments) { typeArgument ->
+            printType(typeArgument)
+        }
+        print(">")
+    }
+
+    private fun SmartPrinter.printType(type: KType) {
+        print(type.kClass.simpleName!!)
+        if (type.arguments.isNotEmpty()) {
+            print("<")
+            printSeparatedWithComma(type.arguments) { typeArgument ->
+                printTypeArgument(typeArgument)
+            }
+            print(">")
+        }
+    }
+
+    private fun SmartPrinter.printTypeArgument(typeArgument: KTypeProjection) {
+        val typeArgumentType = typeArgument.type
+        if (typeArgumentType == null) {
+            print("*")
+        } else {
+            printType(typeArgumentType)
+        }
+    }
+
+    private fun SmartPrinter.collectAndPrintImports(diagnosticList: DiagnosticList) {
+        val imports = collectImports(diagnosticList)
+        printImports(imports)
+        println()
+    }
+
+    @OptIn(ExperimentalStdlibApi::class)
+    private fun collectImports(diagnosticList: DiagnosticList): Collection<String> = buildSet {
+        diagnosticList.diagnostics.forEach { diagnostic ->
+            diagnostic.getAllTypeArguments().mapTo(this) { it.kClass.qualifiedName!! }
+            if (!diagnostic.hasDefaultPositioningStrategy()) {
+                add(diagnostic.positioningStrategy.import)
+            }
+        }
+    }
+
+
+    private val KType.kClass: KClass<*>
+        get() = classifier as KClass<*>
+
+    private fun Diagnostic.getFactoryFunction(): String =
+        severity.name.toLowerCase() + parameters.size
+}
+
+private inline fun <T> SmartPrinter.printSeparatedWithComma(list: List<T>, printItem: (T) -> Unit) {
+    list.forEachIndexed { index, element ->
+        printItem(element)
+        if (index != list.lastIndex) {
+            print(", ")
+        }
+    }
+}

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

@@ -0,0 +1,324 @@
+/*
+ * 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.fir.checkers.generator.diagnostics
+
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiTypeElement
+import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
+import org.jetbrains.kotlin.fir.FirEffectiveVisibility
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.PrivateForInline
+import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
+import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.*
+
+
+@Suppress("UNUSED_VARIABLE", "LocalVariableName")
+@OptIn(PrivateForInline::class)
+val DIAGNOSTICS_LIST = DiagnosticListBuilder.buildDiagnosticList {
+    // Miscellaneous
+    val SYNTAX by error<FirSourceElement, PsiElement>()
+    val OTHER_ERROR by error<FirSourceElement, PsiElement>()
+
+    // General syntax
+    val ILLEGAL_CONST_EXPRESSION by error<FirSourceElement, PsiElement>()
+    val ILLEGAL_UNDERSCORE by error<FirSourceElement, PsiElement>()
+    val EXPRESSION_REQUIRED by error<FirSourceElement, PsiElement>()
+    val BREAK_OR_CONTINUE_OUTSIDE_A_LOOP by error<FirSourceElement, PsiElement>()
+    val NOT_A_LOOP_LABEL by error<FirSourceElement, PsiElement>()
+    val VARIABLE_EXPECTED by error<FirSourceElement, PsiElement>()
+    val RETURN_NOT_ALLOWED by error<FirSourceElement, PsiElement>()
+    val DELEGATION_IN_INTERFACE by error<FirSourceElement, PsiElement>()
+
+    // Unresolved
+    val HIDDEN by error<FirSourceElement, PsiElement> {
+        parameter<AbstractFirBasedSymbol<*>>("hidden")
+    }
+    val UNRESOLVED_REFERENCE by error<FirSourceElement, PsiElement> {
+        parameter<String>("reference")
+    }
+    val UNRESOLVED_LABEL by error<FirSourceElement, PsiElement>()
+    val DESERIALIZATION_ERROR by error<FirSourceElement, PsiElement>()
+    val ERROR_FROM_JAVA_RESOLUTION by error<FirSourceElement, PsiElement>()
+    val UNKNOWN_CALLABLE_KIND by error<FirSourceElement, PsiElement>()
+    val MISSING_STDLIB_CLASS by error<FirSourceElement, PsiElement>()
+    val NO_THIS by error<FirSourceElement, PsiElement>()
+
+    // Super
+    val SUPER_IS_NOT_AN_EXPRESSION by error<FirSourceElement, PsiElement>()
+    val SUPER_NOT_AVAILABLE by error<FirSourceElement, PsiElement>()
+    val ABSTRACT_SUPER_CALL by error<FirSourceElement, PsiElement>()
+    val INSTANCE_ACCESS_BEFORE_SUPER_CALL by error<FirSourceElement, PsiElement>() {
+        parameter<String>("target")
+    }
+
+    // Supertypes
+    val TYPE_PARAMETER_AS_SUPERTYPE by error<FirSourceElement, PsiElement>()
+    val ENUM_AS_SUPERTYPE by error<FirSourceElement, PsiElement>()
+    val RECURSION_IN_SUPERTYPES by error<FirSourceElement, PsiElement>()
+    val NOT_A_SUPERTYPE by error<FirSourceElement, PsiElement>()
+    val SUPERCLASS_NOT_ACCESSIBLE_FROM_INTERFACE by error<FirSourceElement, PsiElement>()
+    val QUALIFIED_SUPERTYPE_EXTENDED_BY_OTHER_SUPERTYPE by error<FirSourceElement, PsiElement>() {
+        parameter<FirClass<*>>("otherSuperType")
+    }
+    val SUPERTYPE_INITIALIZED_IN_INTERFACE by error<FirSourceElement, PsiElement>()
+    val INTERFACE_WITH_SUPERCLASS by error<FirSourceElement, PsiElement>()
+    val CLASS_IN_SUPERTYPE_FOR_ENUM by error<FirSourceElement, PsiElement>()
+    val SEALED_SUPERTYPE by error<FirSourceElement, PsiElement>()
+    val SEALED_SUPERTYPE_IN_LOCAL_CLASS by error<FirSourceElement, PsiElement>()
+
+    // Constructor problems
+    val CONSTRUCTOR_IN_OBJECT by error<FirSourceElement, KtDeclaration>(PositioningStrategy.DECLARATION_SIGNATURE)
+    val CONSTRUCTOR_IN_INTERFACE by error<FirSourceElement, KtDeclaration>(PositioningStrategy.DECLARATION_SIGNATURE)
+    val NON_PRIVATE_CONSTRUCTOR_IN_ENUM by error<FirSourceElement, PsiElement>()
+    val NON_PRIVATE_CONSTRUCTOR_IN_SEALED by error<FirSourceElement, PsiElement>()
+    val CYCLIC_CONSTRUCTOR_DELEGATION_CALL by warning<FirSourceElement, PsiElement>()
+    val PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED by warning<FirSourceElement, PsiElement>(PositioningStrategy.SECONDARY_CONSTRUCTOR_DELEGATION_CALL)
+    val SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR by warning<FirSourceElement, PsiElement>()
+    val DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR by warning<FirSourceElement, PsiElement>()
+    val PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS by warning<FirSourceElement, PsiElement>()
+    val EXPLICIT_DELEGATION_CALL_REQUIRED by warning<FirSourceElement, PsiElement>(PositioningStrategy.SECONDARY_CONSTRUCTOR_DELEGATION_CALL)
+    val SEALED_CLASS_CONSTRUCTOR_CALL by error<FirSourceElement, PsiElement>()
+
+    // Annotations
+    val ANNOTATION_ARGUMENT_KCLASS_LITERAL_OF_TYPE_PARAMETER_ERROR by error<FirSourceElement, KtExpression>()
+    val ANNOTATION_ARGUMENT_MUST_BE_CONST by error<FirSourceElement, KtExpression>()
+    val ANNOTATION_ARGUMENT_MUST_BE_ENUM_CONST by error<FirSourceElement, KtExpression>()
+    val ANNOTATION_ARGUMENT_MUST_BE_KCLASS_LITERAL by error<FirSourceElement, KtExpression>()
+    val ANNOTATION_CLASS_MEMBER by error<FirSourceElement, PsiElement>()
+    val ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT by error<FirSourceElement, KtExpression>()
+    val INVALID_TYPE_OF_ANNOTATION_MEMBER by error<FirSourceElement, KtTypeReference>()
+    val LOCAL_ANNOTATION_CLASS_ERROR by error<FirSourceElement, KtClassOrObject>()
+    val MISSING_VAL_ON_ANNOTATION_PARAMETER by error<FirSourceElement, KtParameter>()
+    val NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION by error<FirSourceElement, KtExpression>()
+    val NOT_AN_ANNOTATION_CLASS by error<FirSourceElement, PsiElement> {
+        parameter<String>("annotationName")
+    }
+    val NULLABLE_TYPE_OF_ANNOTATION_MEMBER by error<FirSourceElement, KtTypeReference>()
+    val VAR_ANNOTATION_PARAMETER by error<FirSourceElement, KtParameter>(PositioningStrategy.VAL_OR_VAR_NODE)
+
+    // Exposed visibility group
+    val EXPOSED_TYPEALIAS_EXPANDED_TYPE by exposedVisibilityError<KtNamedDeclaration>(PositioningStrategy.DECLARATION_NAME)
+    val EXPOSED_FUNCTION_RETURN_TYPE by exposedVisibilityError<KtNamedDeclaration>(PositioningStrategy.DECLARATION_NAME)
+
+    val EXPOSED_RECEIVER_TYPE by exposedVisibilityError<KtTypeReference>()
+    val EXPOSED_PROPERTY_TYPE by exposedVisibilityError<KtNamedDeclaration>(PositioningStrategy.DECLARATION_NAME)
+    val EXPOSED_PARAMETER_TYPE by exposedVisibilityError<KtParameter>(/* // NB: for parameter FE 1.0 reports not on a name for some reason */)
+    val EXPOSED_SUPER_INTERFACE by exposedVisibilityError<KtTypeReference>()
+    val EXPOSED_SUPER_CLASS by exposedVisibilityError< KtTypeReference>()
+    val EXPOSED_TYPE_PARAMETER_BOUND by exposedVisibilityError<KtTypeReference>()
+
+    // Modifiers
+    val INAPPLICABLE_INFIX_MODIFIER by error<FirSourceElement, PsiElement> {
+        parameter<String>("modifier") // TODO or it should be a message?
+    }
+    val REPEATED_MODIFIER by error<FirSourceElement, PsiElement> {
+        parameter<KtModifierKeywordToken>("modifier")
+    }
+    val REDUNDANT_MODIFIER by error<FirSourceElement, PsiElement> {
+        parameter<KtModifierKeywordToken>("redundantModifier")
+        parameter<KtModifierKeywordToken>("conflictingModifier")
+    }
+    val DEPRECATED_MODIFIER_PAIR by error<FirSourceElement, PsiElement>  {
+        parameter<KtModifierKeywordToken>("deprecatedModifier")
+        parameter<KtModifierKeywordToken>("conflictingModifier")
+    }
+    val INCOMPATIBLE_MODIFIERS by error<FirSourceElement, PsiElement> {
+        parameter<KtModifierKeywordToken>("modifier1")
+        parameter<KtModifierKeywordToken>("modifier2")
+    }
+    val REDUNDANT_OPEN_IN_INTERFACE by warning<FirSourceElement, KtModifierListOwner>(PositioningStrategy.MODALITY_MODIFIER)
+
+    // Applicability
+    val NONE_APPLICABLE by error<FirSourceElement, PsiElement> {
+        parameter<Collection<AbstractFirBasedSymbol<*>>>("candidates")
+    }
+
+    val INAPPLICABLE_CANDIDATE by error<FirSourceElement, PsiElement>  {
+        parameter<AbstractFirBasedSymbol<*>>("candidate")
+    }
+    val INAPPLICABLE_LATEINIT_MODIFIER by error<FirSourceElement, PsiElement>()  {
+        parameter<String>("reason")
+    }
+
+    // Ambiguity
+    val AMBIGUITY by error<FirSourceElement, PsiElement> {
+        parameter<Collection<AbstractFirBasedSymbol<*>>>("candidates")
+    }
+    val ASSIGN_OPERATOR_AMBIGUITY by error<FirSourceElement, PsiElement> {
+        parameter<Collection<AbstractFirBasedSymbol<*>>>("candidates")
+    }
+
+    // Types & type parameters
+    val TYPE_MISMATCH by error<FirSourceElement, PsiElement>{
+        parameter<ConeKotlinType>("expectedType")
+        parameter<ConeKotlinType>("actualType")
+    }
+    val RECURSION_IN_IMPLICIT_TYPES by error<FirSourceElement, PsiElement>()
+    val INFERENCE_ERROR by error<FirSourceElement, PsiElement>()
+    val PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT by error<FirSourceElement, PsiElement>()
+    val UPPER_BOUND_VIOLATED by error<FirSourceElement, PsiElement> {
+        parameter<FirTypeParameterSymbol>("typeParameter")
+        parameter<ConeKotlinType>("violatedType")
+    }
+    val TYPE_ARGUMENTS_NOT_ALLOWED by error<FirSourceElement, PsiElement>()
+    val WRONG_NUMBER_OF_TYPE_ARGUMENTS by error<FirSourceElement, PsiElement> {
+        parameter<Int>("expectedCount")
+        parameter<FirClassLikeSymbol<*>>("classifier")
+    }
+    val NO_TYPE_FOR_TYPE_PARAMETER by error<FirSourceElement, PsiElement>()
+    val TYPE_PARAMETERS_IN_OBJECT by error<FirSourceElement, PsiElement>()
+    val ILLEGAL_PROJECTION_USAGE by error<FirSourceElement, PsiElement>()
+    val TYPE_PARAMETERS_IN_ENUM by error<FirSourceElement, PsiElement>()
+    val CONFLICTING_PROJECTION by error<FirSourceElement, PsiElement> {
+        parameter<String>("type") // TODO use ConeType instead of String
+    }
+    val VARIANCE_ON_TYPE_PARAMETER_NOT_ALLOWED by error<FirSourceElement, PsiElement>()
+    val RETURN_TYPE_MISMATCH_ON_OVERRIDE by error<FirSourceElement, PsiElement> {
+        parameter<String>("returnType") // TODO use ConeType instead of String
+        parameter<FirMemberDeclaration>("superFunction")
+    }
+    val PROPERTY_TYPE_MISMATCH_ON_OVERRIDE by error<FirSourceElement, PsiElement>  {
+        parameter<String>("propertyType") // TODO use ConeType instead of String
+        parameter<FirMemberDeclaration>("targetProperty")
+    }
+    val VAR_TYPE_MISMATCH_ON_OVERRIDE by error<FirSourceElement, PsiElement> {
+        parameter<String>("variableType") // TODO use ConeType instead of String
+        parameter<FirMemberDeclaration>("targetVariable")
+    }
+
+    // Redeclarations
+    val MANY_COMPANION_OBJECTS by error<FirSourceElement, PsiElement>()
+    val CONFLICTING_OVERLOADS by error<FirSourceElement, PsiElement>(PositioningStrategy.DECLARATION_SIGNATURE_OR_DEFAULT) {
+        parameter<String>("conflictingOverloads") // TODO use Collection<Symbol> instead of String
+    }
+    val REDECLARATION by error<FirSourceElement, PsiElement>() {
+        parameter<String>("conflictingDeclaration") // TODO use Collection<Symbol> instead of String
+    }
+    val ANY_METHOD_IMPLEMENTED_IN_INTERFACE by error<FirSourceElement, PsiElement>()
+
+    // Invalid local declarations
+    val LOCAL_OBJECT_NOT_ALLOWED by error<FirSourceElement, KtNamedDeclaration>(PositioningStrategy.DECLARATION_NAME) {
+        parameter<Name>("objectName")
+    }
+    val LOCAL_INTERFACE_NOT_ALLOWED by error<FirSourceElement, KtNamedDeclaration>(PositioningStrategy.DECLARATION_NAME) {
+        parameter<Name>("interfaceName")
+    }
+
+    // Functions
+    val ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS by error<FirSourceElement, KtFunction>(PositioningStrategy.MODALITY_MODIFIER) {
+        parameter<FirMemberDeclaration>("function")
+        parameter<FirMemberDeclaration>("containingClass") // TODO use FirClass instead of FirMemberDeclaration
+    }
+    val ABSTRACT_FUNCTION_WITH_BODY by error<FirSourceElement, KtFunction>(PositioningStrategy.MODALITY_MODIFIER) {
+        parameter<FirMemberDeclaration>("function")
+    }
+    val NON_ABSTRACT_FUNCTION_WITH_NO_BODY by error<FirSourceElement, KtFunction>(PositioningStrategy.DECLARATION_SIGNATURE) {
+        parameter<FirMemberDeclaration>("function")
+    }
+    val PRIVATE_FUNCTION_WITH_NO_BODY by error<FirSourceElement, KtFunction>(PositioningStrategy.VISIBILITY_MODIFIER) {
+        parameter<FirMemberDeclaration>("function")
+    }
+
+    val NON_MEMBER_FUNCTION_NO_BODY by error<FirSourceElement, KtFunction>(PositioningStrategy.DECLARATION_SIGNATURE)  {
+        parameter<FirMemberDeclaration>("function")
+    }
+
+
+    val FUNCTION_DECLARATION_WITH_NO_NAME by error<FirSourceElement, KtFunction>(PositioningStrategy.DECLARATION_SIGNATURE)
+
+    // TODO: val ANONYMOUS_FUNCTION_WITH_NAME by error1<FirSourceElement, PsiElement, Name>(SourceElementPositioningStrategies.DECLARATION_NAME)
+    val ANONYMOUS_FUNCTION_PARAMETER_WITH_DEFAULT_VALUE by error<FirSourceElement, KtParameter>(PositioningStrategy.PARAMETER_DEFAULT_VALUE)
+    val USELESS_VARARG_ON_PARAMETER by warning<FirSourceElement, KtParameter>()
+
+
+    // Properties & accessors
+    val ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS by error<FirSourceElement, KtModifierListOwner>(PositioningStrategy.MODALITY_MODIFIER) {
+        parameter<FirMemberDeclaration>("property")
+        parameter<FirMemberDeclaration>("containingClass") // TODO use FirClass instead of FirMemberDeclaration
+    }
+    val PRIVATE_PROPERTY_IN_INTERFACE by error<FirSourceElement, KtProperty>(PositioningStrategy.VISIBILITY_MODIFIER)
+
+    val ABSTRACT_PROPERTY_WITH_INITIALIZER by error<FirSourceElement, KtExpression>()
+    val PROPERTY_INITIALIZER_IN_INTERFACE by error<FirSourceElement, KtExpression>()
+    val PROPERTY_WITH_NO_TYPE_NO_INITIALIZER by error<FirSourceElement, KtProperty>(PositioningStrategy.DECLARATION_SIGNATURE)
+
+    val ABSTRACT_DELEGATED_PROPERTY by error<FirSourceElement, KtPropertyDelegate>()
+    val DELEGATED_PROPERTY_IN_INTERFACE by error<FirSourceElement, KtPropertyDelegate>()
+    // TODO: val ACCESSOR_FOR_DELEGATED_PROPERTY by error1<FirSourceElement, PsiElement, FirPropertyAccessorSymbol>()
+
+    val ABSTRACT_PROPERTY_WITH_GETTER by error<FirSourceElement, KtPropertyAccessor>()
+    val ABSTRACT_PROPERTY_WITH_SETTER by error<FirSourceElement, KtPropertyAccessor>()
+    val PRIVATE_SETTER_FOR_ABSTRACT_PROPERTY by error<FirSourceElement, PsiElement>()
+    val PRIVATE_SETTER_FOR_OPEN_PROPERTY by error<FirSourceElement, PsiElement>()
+    val EXPECTED_PRIVATE_DECLARATION by error<FirSourceElement, KtModifierListOwner>(PositioningStrategy.VISIBILITY_MODIFIER)
+
+    // Multi-platform projects
+    val EXPECTED_DECLARATION_WITH_BODY by error<FirSourceElement, KtDeclaration>(PositioningStrategy.DECLARATION_SIGNATURE)
+    val EXPECTED_PROPERTY_INITIALIZER by error<FirSourceElement, KtExpression>()
+    // TODO: need to cover `by` as well as delegate expression
+    val EXPECTED_DELEGATED_PROPERTY by error<FirSourceElement, KtPropertyDelegate>()
+
+
+    // Destructuring declaration
+    val INITIALIZER_REQUIRED_FOR_DESTRUCTURING_DECLARATION by error<FirSourceElement, KtDestructuringDeclaration>()
+    val COMPONENT_FUNCTION_MISSING by error<FirSourceElement, PsiElement> {
+        parameter<Name>("missingFunctionName")
+        parameter<FirTypeRef>("destructingType")
+    }
+    val COMPONENT_FUNCTION_AMBIGUITY by error<FirSourceElement, PsiElement> {
+        parameter<Name>("functionWithAmbiguityName")
+        parameter<Collection<AbstractFirBasedSymbol<*>>>("candidates")
+    }
+    // TODO: val COMPONENT_FUNCTION_ON_NULLABLE by ...
+    // TODO: val COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH by ...
+
+    // Control flow diagnostics
+    val UNINITIALIZED_VARIABLE by error<FirSourceElement, PsiElement> {
+        parameter<FirPropertySymbol>("variable")
+    }
+    val WRONG_INVOCATION_KIND by warning<FirSourceElement, PsiElement> {
+        parameter< AbstractFirBasedSymbol<*>>("declaration")
+        parameter<EventOccurrencesRange>("requiredRange")
+        parameter<EventOccurrencesRange>("actualRange")
+    }
+    val LEAKED_IN_PLACE_LAMBDA by error<FirSourceElement, PsiElement> {
+        parameter<AbstractFirBasedSymbol<*>>("lambda")
+    }
+    val WRONG_IMPLIES_CONDITION by warning<FirSourceElement, PsiElement>()
+
+    // Extended checkers group
+    val REDUNDANT_VISIBILITY_MODIFIER by warning<FirSourceElement, KtModifierListOwner>(PositioningStrategy.VISIBILITY_MODIFIER)
+    val REDUNDANT_MODALITY_MODIFIER by warning<FirSourceElement, KtModifierListOwner>(PositioningStrategy.MODALITY_MODIFIER)
+    val REDUNDANT_RETURN_UNIT_TYPE by warning<FirSourceElement, PsiTypeElement>()
+    val REDUNDANT_EXPLICIT_TYPE by warning<FirSourceElement, PsiElement>()
+    val REDUNDANT_SINGLE_EXPRESSION_STRING_TEMPLATE by warning<FirSourceElement, PsiElement>()
+    val CAN_BE_VAL by warning<FirSourceElement, KtDeclaration>(PositioningStrategy.VAL_OR_VAR_NODE)
+    val CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT by warning<FirSourceElement, KtExpression>(PositioningStrategy.OPERATOR)
+    val REDUNDANT_CALL_OF_CONVERSION_METHOD by warning<FirSourceElement, PsiElement>()
+    val ARRAY_EQUALITY_OPERATOR_CAN_BE_REPLACED_WITH_EQUALS by warning<FirSourceElement, KtExpression>(PositioningStrategy.OPERATOR)
+    val EMPTY_RANGE by warning<FirSourceElement, PsiElement>()
+    val REDUNDANT_SETTER_PARAMETER_TYPE by warning<FirSourceElement, PsiElement>()
+    val UNUSED_VARIABLE by warning<FirSourceElement, KtNamedDeclaration>(PositioningStrategy.DECLARATION_NAME)
+    val ASSIGNED_VALUE_IS_NEVER_READ by warning<FirSourceElement, PsiElement>()
+    val VARIABLE_INITIALIZER_IS_REDUNDANT by warning<FirSourceElement, PsiElement>()
+    val VARIABLE_NEVER_READ by warning<FirSourceElement, KtNamedDeclaration>(PositioningStrategy.DECLARATION_NAME)
+    val USELESS_CALL_ON_NOT_NULL by warning<FirSourceElement, PsiElement>()
+}
+
+private inline fun <reified P : PsiElement> DiagnosticListBuilder.exposedVisibilityError(
+    positioningStrategy: PositioningStrategy = PositioningStrategy.DEFAULT
+) = error<FirSourceElement, P>(positioningStrategy) {
+    parameter<FirEffectiveVisibility>("elementVisibility")
+    parameter<FirMemberDeclaration>("restrictingDeclaration")
+    parameter<FirEffectiveVisibility>("restrictingVisibility")
+}

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/smartPrinterUtils.kt

@@ -0,0 +1,15 @@
+/*
+ * 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.fir.checkers.generator
+
+import org.jetbrains.kotlin.fir.tree.generator.printer.SmartPrinter
+import org.jetbrains.kotlin.fir.tree.generator.printer.withIndent
+
+inline fun SmartPrinter.inBracketsWithIndent(header: String = "", body: () -> Unit) {
+    println("$header {")
+    withIndent(body)
+    println("}")
+}

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/utils.kt

@@ -0,0 +1,14 @@
+/*
+ * 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.fir.checkers.generator
+
+import java.io.File
+
+fun getGenerationPath(rootPath: File, packageName: String): File =
+    packageName
+        .split(".")
+        .fold(rootPath, File::resolve)
+        .apply { mkdirs() }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * 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.
  */
 
@@ -8,28 +8,40 @@ package org.jetbrains.kotlin.fir.analysis.diagnostics
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiTypeElement
 import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
-import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirEffectiveVisibility
 import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
+import org.jetbrains.kotlin.fir.analysis.diagnostics.SourceElementPositioningStrategies
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
-import org.jetbrains.kotlin.fir.expressions.WhenMissingCase
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtDestructuringDeclaration
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtFunction
+import org.jetbrains.kotlin.psi.KtModifierListOwner
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
+import org.jetbrains.kotlin.psi.KtParameter
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtPropertyAccessor
+import org.jetbrains.kotlin.psi.KtPropertyDelegate
+import org.jetbrains.kotlin.psi.KtTypeReference
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
 
 object FirErrors {
-    // Miscellaneous
     val SYNTAX by error0<FirSourceElement, PsiElement>()
     val OTHER_ERROR by error0<FirSourceElement, PsiElement>()
-
-    // General syntax
     val ILLEGAL_CONST_EXPRESSION by error0<FirSourceElement, PsiElement>()
     val ILLEGAL_UNDERSCORE by error0<FirSourceElement, PsiElement>()
     val EXPRESSION_REQUIRED by error0<FirSourceElement, PsiElement>()
@@ -38,8 +50,6 @@ object FirErrors {
     val VARIABLE_EXPECTED by error0<FirSourceElement, PsiElement>()
     val RETURN_NOT_ALLOWED by error0<FirSourceElement, PsiElement>()
     val DELEGATION_IN_INTERFACE by error0<FirSourceElement, PsiElement>()
-
-    // Unresolved
     val HIDDEN by error1<FirSourceElement, PsiElement, AbstractFirBasedSymbol<*>>()
     val UNRESOLVED_REFERENCE by error1<FirSourceElement, PsiElement, String>()
     val UNRESOLVED_LABEL by error0<FirSourceElement, PsiElement>()
@@ -48,14 +58,10 @@ object FirErrors {
     val UNKNOWN_CALLABLE_KIND by error0<FirSourceElement, PsiElement>()
     val MISSING_STDLIB_CLASS by error0<FirSourceElement, PsiElement>()
     val NO_THIS by error0<FirSourceElement, PsiElement>()
-
-    // Super
     val SUPER_IS_NOT_AN_EXPRESSION by error0<FirSourceElement, PsiElement>()
     val SUPER_NOT_AVAILABLE by error0<FirSourceElement, PsiElement>()
     val ABSTRACT_SUPER_CALL by error0<FirSourceElement, PsiElement>()
     val INSTANCE_ACCESS_BEFORE_SUPER_CALL by error1<FirSourceElement, PsiElement, String>()
-
-    // Supertypes
     val TYPE_PARAMETER_AS_SUPERTYPE by error0<FirSourceElement, PsiElement>()
     val ENUM_AS_SUPERTYPE by error0<FirSourceElement, PsiElement>()
     val RECURSION_IN_SUPERTYPES by error0<FirSourceElement, PsiElement>()
@@ -67,12 +73,10 @@ object FirErrors {
     val CLASS_IN_SUPERTYPE_FOR_ENUM by error0<FirSourceElement, PsiElement>()
     val SEALED_SUPERTYPE by error0<FirSourceElement, PsiElement>()
     val SEALED_SUPERTYPE_IN_LOCAL_CLASS by error0<FirSourceElement, PsiElement>()
-
-    // Constructor problems
     val CONSTRUCTOR_IN_OBJECT by error0<FirSourceElement, KtDeclaration>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
     val CONSTRUCTOR_IN_INTERFACE by error0<FirSourceElement, KtDeclaration>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
-    val NON_PRIVATE_CONSTRUCTOR_IN_ENUM by existing0<FirSourceElement, PsiElement>()
+    val NON_PRIVATE_CONSTRUCTOR_IN_ENUM by error0<FirSourceElement, PsiElement>()
-    val NON_PRIVATE_CONSTRUCTOR_IN_SEALED by existing0<FirSourceElement, PsiElement>()
+    val NON_PRIVATE_CONSTRUCTOR_IN_SEALED by error0<FirSourceElement, PsiElement>()
     val CYCLIC_CONSTRUCTOR_DELEGATION_CALL by warning0<FirSourceElement, PsiElement>()
     val PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED by warning0<FirSourceElement, PsiElement>(SourceElementPositioningStrategies.SECONDARY_CONSTRUCTOR_DELEGATION_CALL)
     val SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR by warning0<FirSourceElement, PsiElement>()
@@ -80,50 +84,38 @@ object FirErrors {
     val PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS by warning0<FirSourceElement, PsiElement>()
     val EXPLICIT_DELEGATION_CALL_REQUIRED by warning0<FirSourceElement, PsiElement>(SourceElementPositioningStrategies.SECONDARY_CONSTRUCTOR_DELEGATION_CALL)
     val SEALED_CLASS_CONSTRUCTOR_CALL by error0<FirSourceElement, PsiElement>()
-
+    val ANNOTATION_ARGUMENT_KCLASS_LITERAL_OF_TYPE_PARAMETER_ERROR by error0<FirSourceElement, KtExpression>()
-    // Annotations
+    val ANNOTATION_ARGUMENT_MUST_BE_CONST by error0<FirSourceElement, KtExpression>()
-    val ANNOTATION_ARGUMENT_KCLASS_LITERAL_OF_TYPE_PARAMETER_ERROR by existing0<FirSourceElement, KtExpression>()
+    val ANNOTATION_ARGUMENT_MUST_BE_ENUM_CONST by error0<FirSourceElement, KtExpression>()
-    val ANNOTATION_ARGUMENT_MUST_BE_CONST by existing0<FirSourceElement, KtExpression>()
+    val ANNOTATION_ARGUMENT_MUST_BE_KCLASS_LITERAL by error0<FirSourceElement, KtExpression>()
-    val ANNOTATION_ARGUMENT_MUST_BE_ENUM_CONST by existing0<FirSourceElement, KtExpression>()
+    val ANNOTATION_CLASS_MEMBER by error0<FirSourceElement, PsiElement>()
-    val ANNOTATION_ARGUMENT_MUST_BE_KCLASS_LITERAL by existing0<FirSourceElement, KtExpression>()
+    val ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT by error0<FirSourceElement, KtExpression>()
-    val ANNOTATION_CLASS_MEMBER by existing0<FirSourceElement, PsiElement>()
+    val INVALID_TYPE_OF_ANNOTATION_MEMBER by error0<FirSourceElement, KtTypeReference>()
-    val ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT by existing0<FirSourceElement, KtExpression>()
+    val LOCAL_ANNOTATION_CLASS_ERROR by error0<FirSourceElement, KtClassOrObject>()
-    val INVALID_TYPE_OF_ANNOTATION_MEMBER by existing0<FirSourceElement, KtTypeReference>()
+    val MISSING_VAL_ON_ANNOTATION_PARAMETER by error0<FirSourceElement, KtParameter>()
-    val LOCAL_ANNOTATION_CLASS_ERROR by existing0<FirSourceElement, KtClassOrObject>()
+    val NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION by error0<FirSourceElement, KtExpression>()
-    val MISSING_VAL_ON_ANNOTATION_PARAMETER by existing0<FirSourceElement, KtParameter>()
-    val NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION by existing0<FirSourceElement, KtExpression>()
     val NOT_AN_ANNOTATION_CLASS by error1<FirSourceElement, PsiElement, String>()
-    val NULLABLE_TYPE_OF_ANNOTATION_MEMBER by existing0<FirSourceElement, KtTypeReference>()
+    val NULLABLE_TYPE_OF_ANNOTATION_MEMBER by error0<FirSourceElement, KtTypeReference>()
     val VAR_ANNOTATION_PARAMETER by error0<FirSourceElement, KtParameter>(SourceElementPositioningStrategies.VAL_OR_VAR_NODE)
-
-    // Exposed visibility group
     val EXPOSED_TYPEALIAS_EXPANDED_TYPE by error3<FirSourceElement, KtNamedDeclaration, FirEffectiveVisibility, FirMemberDeclaration, FirEffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
     val EXPOSED_FUNCTION_RETURN_TYPE by error3<FirSourceElement, KtNamedDeclaration, FirEffectiveVisibility, FirMemberDeclaration, FirEffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
     val EXPOSED_RECEIVER_TYPE by error3<FirSourceElement, KtTypeReference, FirEffectiveVisibility, FirMemberDeclaration, FirEffectiveVisibility>()
     val EXPOSED_PROPERTY_TYPE by error3<FirSourceElement, KtNamedDeclaration, FirEffectiveVisibility, FirMemberDeclaration, FirEffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
-    val EXPOSED_PARAMETER_TYPE by error3<FirSourceElement, KtParameter, FirEffectiveVisibility, FirMemberDeclaration, FirEffectiveVisibility>(/* // NB: for parameter FE 1.0 reports not on a name for some reason */)
+    val EXPOSED_PARAMETER_TYPE by error3<FirSourceElement, KtParameter, FirEffectiveVisibility, FirMemberDeclaration, FirEffectiveVisibility>()
     val EXPOSED_SUPER_INTERFACE by error3<FirSourceElement, KtTypeReference, FirEffectiveVisibility, FirMemberDeclaration, FirEffectiveVisibility>()
     val EXPOSED_SUPER_CLASS by error3<FirSourceElement, KtTypeReference, FirEffectiveVisibility, FirMemberDeclaration, FirEffectiveVisibility>()
     val EXPOSED_TYPE_PARAMETER_BOUND by error3<FirSourceElement, KtTypeReference, FirEffectiveVisibility, FirMemberDeclaration, FirEffectiveVisibility>()
-
+    val INAPPLICABLE_INFIX_MODIFIER by error1<FirSourceElement, PsiElement, String>()
-    // Modifiers
-    val INAPPLICABLE_INFIX_MODIFIER by error0<FirSourceElement, PsiElement>()
     val REPEATED_MODIFIER by error1<FirSourceElement, PsiElement, KtModifierKeywordToken>()
     val REDUNDANT_MODIFIER by error2<FirSourceElement, PsiElement, KtModifierKeywordToken, KtModifierKeywordToken>()
     val DEPRECATED_MODIFIER_PAIR by error2<FirSourceElement, PsiElement, KtModifierKeywordToken, KtModifierKeywordToken>()
     val INCOMPATIBLE_MODIFIERS by error2<FirSourceElement, PsiElement, KtModifierKeywordToken, KtModifierKeywordToken>()
-    val REDUNDANT_OPEN_IN_INTERFACE by warning0<FirSourceElement, KtModifierListOwner>(SourceElementPositioningStrategies.OPEN_MODIFIER)
+    val REDUNDANT_OPEN_IN_INTERFACE by warning0<FirSourceElement, KtModifierListOwner>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
-
-    // Applicability
     val NONE_APPLICABLE by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>()
     val INAPPLICABLE_CANDIDATE by error1<FirSourceElement, PsiElement, AbstractFirBasedSymbol<*>>()
     val INAPPLICABLE_LATEINIT_MODIFIER by error1<FirSourceElement, PsiElement, String>()
-
-    // Ambiguity
     val AMBIGUITY by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>()
     val ASSIGN_OPERATOR_AMBIGUITY by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>()
-
-    // Types & type parameters
     val TYPE_MISMATCH by error2<FirSourceElement, PsiElement, ConeKotlinType, ConeKotlinType>()
     val RECURSION_IN_IMPLICIT_TYPES by error0<FirSourceElement, PsiElement>()
     val INFERENCE_ERROR by error0<FirSourceElement, PsiElement>()
@@ -136,106 +128,46 @@ object FirErrors {
     val ILLEGAL_PROJECTION_USAGE by error0<FirSourceElement, PsiElement>()
     val TYPE_PARAMETERS_IN_ENUM by error0<FirSourceElement, PsiElement>()
     val CONFLICTING_PROJECTION by error1<FirSourceElement, PsiElement, String>()
-    val VARIANCE_ON_TYPE_PARAMETER_NOT_ALLOWED by error0<FirSourceElement, KtTypeParameter>(SourceElementPositioningStrategies.VARIANCE_MODIFIER)
+    val VARIANCE_ON_TYPE_PARAMETER_NOT_ALLOWED by error0<FirSourceElement, PsiElement>()
-    val CATCH_PARAMETER_WITH_DEFAULT_VALUE by error0<FirSourceElement, PsiElement>()
+    val RETURN_TYPE_MISMATCH_ON_OVERRIDE by error2<FirSourceElement, PsiElement, String, FirMemberDeclaration>()
-    val REIFIED_TYPE_IN_CATCH_CLAUSE by error0<FirSourceElement, PsiElement>()
+    val PROPERTY_TYPE_MISMATCH_ON_OVERRIDE by error2<FirSourceElement, PsiElement, String, FirMemberDeclaration>()
-    val TYPE_PARAMETER_IN_CATCH_CLAUSE by error0<FirSourceElement, PsiElement>()
+    val VAR_TYPE_MISMATCH_ON_OVERRIDE by error2<FirSourceElement, PsiElement, String, FirMemberDeclaration>()
-    val GENERIC_THROWABLE_SUBCLASS by error0<FirSourceElement, KtTypeParameterList>()
-    val INNER_CLASS_OF_GENERIC_THROWABLE_SUBCLASS by error0<FirSourceElement, KtClassOrObject>(SourceElementPositioningStrategies.DECLARATION_NAME)
-
-    // Overrides
-    val NOTHING_TO_OVERRIDE by error1<FirSourceElement, KtModifierListOwner, FirMemberDeclaration>(SourceElementPositioningStrategies.OVERRIDE_MODIFIER)
-    val OVERRIDING_FINAL_MEMBER by error2<FirSourceElement, KtNamedDeclaration, FirCallableDeclaration<*>, Name>(SourceElementPositioningStrategies.OVERRIDE_MODIFIER)
-
-    val CANNOT_WEAKEN_ACCESS_PRIVILEGE by error3<FirSourceElement, KtModifierListOwner, Visibility, FirCallableDeclaration<*>, Name>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
-    val CANNOT_CHANGE_ACCESS_PRIVILEGE by error3<FirSourceElement, KtModifierListOwner, Visibility, FirCallableDeclaration<*>, Name>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
-
-    val RETURN_TYPE_MISMATCH_ON_OVERRIDE by error2<FirSourceElement, KtNamedDeclaration, FirMemberDeclaration, FirMemberDeclaration>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE)
-    val PROPERTY_TYPE_MISMATCH_ON_OVERRIDE by error2<FirSourceElement, KtNamedDeclaration, FirMemberDeclaration, FirMemberDeclaration>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE)
-    val VAR_TYPE_MISMATCH_ON_OVERRIDE by error2<FirSourceElement, KtNamedDeclaration, FirMemberDeclaration, FirMemberDeclaration>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE)
-
-    val VAR_OVERRIDDEN_BY_VAL by error2<FirSourceElement, KtNamedDeclaration, FirMemberDeclaration, FirMemberDeclaration>(SourceElementPositioningStrategies.VAL_OR_VAR_NODE)
-
-    // Redeclarations
     val MANY_COMPANION_OBJECTS by error0<FirSourceElement, PsiElement>()
     val CONFLICTING_OVERLOADS by error1<FirSourceElement, PsiElement, String>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE_OR_DEFAULT)
     val REDECLARATION by error1<FirSourceElement, PsiElement, String>()
     val ANY_METHOD_IMPLEMENTED_IN_INTERFACE by error0<FirSourceElement, PsiElement>()
-
-    // Invalid local declarations
     val LOCAL_OBJECT_NOT_ALLOWED by error1<FirSourceElement, KtNamedDeclaration, Name>(SourceElementPositioningStrategies.DECLARATION_NAME)
     val LOCAL_INTERFACE_NOT_ALLOWED by error1<FirSourceElement, KtNamedDeclaration, Name>(SourceElementPositioningStrategies.DECLARATION_NAME)
-
+    val ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS by error2<FirSourceElement, KtFunction, FirMemberDeclaration, FirMemberDeclaration>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
-    // Functions
+    val ABSTRACT_FUNCTION_WITH_BODY by error1<FirSourceElement, KtFunction, FirMemberDeclaration>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
-    val ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS by error2<FirSourceElement, KtFunction, FirMemberDeclaration, FirMemberDeclaration>(SourceElementPositioningStrategies.ABSTRACT_MODIFIER)
-    val ABSTRACT_FUNCTION_WITH_BODY by error1<FirSourceElement, KtFunction, FirMemberDeclaration>(SourceElementPositioningStrategies.ABSTRACT_MODIFIER)
     val NON_ABSTRACT_FUNCTION_WITH_NO_BODY by error1<FirSourceElement, KtFunction, FirMemberDeclaration>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
-    val PRIVATE_FUNCTION_WITH_NO_BODY by error1<FirSourceElement, KtFunction, FirMemberDeclaration>(SourceElementPositioningStrategies.PRIVATE_MODIFIER)
+    val PRIVATE_FUNCTION_WITH_NO_BODY by error1<FirSourceElement, KtFunction, FirMemberDeclaration>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
     val NON_MEMBER_FUNCTION_NO_BODY by error1<FirSourceElement, KtFunction, FirMemberDeclaration>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
-
     val FUNCTION_DECLARATION_WITH_NO_NAME by error0<FirSourceElement, KtFunction>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
-
-    // TODO: val ANONYMOUS_FUNCTION_WITH_NAME by error1<FirSourceElement, PsiElement, Name>(SourceElementPositioningStrategies.DECLARATION_NAME)
     val ANONYMOUS_FUNCTION_PARAMETER_WITH_DEFAULT_VALUE by error0<FirSourceElement, KtParameter>(SourceElementPositioningStrategies.PARAMETER_DEFAULT_VALUE)
     val USELESS_VARARG_ON_PARAMETER by warning0<FirSourceElement, KtParameter>()
-
+    val ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS by error2<FirSourceElement, KtModifierListOwner, FirMemberDeclaration, FirMemberDeclaration>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
-    // Properties & accessors
+    val PRIVATE_PROPERTY_IN_INTERFACE by error0<FirSourceElement, KtProperty>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
-    val ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS by error2<FirSourceElement, KtModifierListOwner, FirMemberDeclaration, FirMemberDeclaration>(SourceElementPositioningStrategies.ABSTRACT_MODIFIER)
-    val PRIVATE_PROPERTY_IN_INTERFACE by error0<FirSourceElement, KtProperty>(SourceElementPositioningStrategies.PRIVATE_MODIFIER)
-
     val ABSTRACT_PROPERTY_WITH_INITIALIZER by error0<FirSourceElement, KtExpression>()
-    // TODO: val MUST_BE_INITIALIZED by error0<FirSourceElement, KtProperty>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
-    // TODO: val MUST_BE_INITIALIZED_OR_BE_ABSTRACT by error0<FirSourceElement, KtProperty>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
-    // TODO: val EXTENSION_PROPERTY_MUST_HAVE_ACCESSORS_OR_BE_ABSTRACT by error0<FirSourceElement, KtProperty>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
-
-    // TODO: val EXTENSION_PROPERTY_WITH_BACKING_FIELD by error0<FirSourceElement, KtExpression>()
-    // TODO: val PROPERTY_INITIALIZER_NO_BACKING_FIELD by error0<FirSourceElement, KtExpression>()
-
     val PROPERTY_INITIALIZER_IN_INTERFACE by error0<FirSourceElement, KtExpression>()
     val PROPERTY_WITH_NO_TYPE_NO_INITIALIZER by error0<FirSourceElement, KtProperty>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
-    // TODO: val BACKING_FIELD_IN_INTERFACE by error0<FirSourceElement, KtProperty>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
-
     val ABSTRACT_DELEGATED_PROPERTY by error0<FirSourceElement, KtPropertyDelegate>()
     val DELEGATED_PROPERTY_IN_INTERFACE by error0<FirSourceElement, KtPropertyDelegate>()
-    // TODO: val ACCESSOR_FOR_DELEGATED_PROPERTY by error1<FirSourceElement, KtPropertyAccessor, FirPropertyAccessorSymbol>()
-
     val ABSTRACT_PROPERTY_WITH_GETTER by error0<FirSourceElement, KtPropertyAccessor>()
     val ABSTRACT_PROPERTY_WITH_SETTER by error0<FirSourceElement, KtPropertyAccessor>()
     val PRIVATE_SETTER_FOR_ABSTRACT_PROPERTY by error0<FirSourceElement, PsiElement>()
     val PRIVATE_SETTER_FOR_OPEN_PROPERTY by error0<FirSourceElement, PsiElement>()
-
+    val EXPECTED_PRIVATE_DECLARATION by error0<FirSourceElement, KtModifierListOwner>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
-    // Multi-platform projects
     val EXPECTED_DECLARATION_WITH_BODY by error0<FirSourceElement, KtDeclaration>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
     val EXPECTED_PROPERTY_INITIALIZER by error0<FirSourceElement, KtExpression>()
-    // TODO: need to cover `by` as well as delegate expression
     val EXPECTED_DELEGATED_PROPERTY by error0<FirSourceElement, KtPropertyDelegate>()
-    val EXPECTED_PRIVATE_DECLARATION by error0<FirSourceElement, KtModifierListOwner>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
-
-    // Destructuring declaration
     val INITIALIZER_REQUIRED_FOR_DESTRUCTURING_DECLARATION by error0<FirSourceElement, KtDestructuringDeclaration>()
-    val COMPONENT_FUNCTION_MISSING by error2<FirSourceElement, KtExpression, Name, ConeKotlinType>()
+    val COMPONENT_FUNCTION_MISSING by error2<FirSourceElement, PsiElement, Name, FirTypeRef>()
-    val COMPONENT_FUNCTION_AMBIGUITY by error2<FirSourceElement, KtExpression, Name, Collection<AbstractFirBasedSymbol<*>>>()
+    val COMPONENT_FUNCTION_AMBIGUITY by error2<FirSourceElement, PsiElement, Name, Collection<AbstractFirBasedSymbol<*>>>()
-    val COMPONENT_FUNCTION_ON_NULLABLE by error1<FirSourceElement, KtExpression, Name>()
-    // TODO: val COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH by ...
-
-    // Control flow diagnostics
     val UNINITIALIZED_VARIABLE by error1<FirSourceElement, PsiElement, FirPropertySymbol>()
     val WRONG_INVOCATION_KIND by warning3<FirSourceElement, PsiElement, AbstractFirBasedSymbol<*>, EventOccurrencesRange, EventOccurrencesRange>()
     val LEAKED_IN_PLACE_LAMBDA by error1<FirSourceElement, PsiElement, AbstractFirBasedSymbol<*>>()
     val WRONG_IMPLIES_CONDITION by warning0<FirSourceElement, PsiElement>()
-
-    // Nullability
-    val UNSAFE_CALL by error1<FirSourceElement, PsiElement, ConeKotlinType>(SourceElementPositioningStrategies.DOT_BY_SELECTOR)
-    // TODO: val UNSAFE_IMPLICIT_INVOKE_CALL by error1<FirSourceElement, PsiElement, ConeKotlinType>()
-    // TODO: val UNSAFE_INFIX_CALL by ...
-    // TODO: val UNSAFE_OPERATOR_CALL by ...
-    // TODO: val UNEXPECTED_SAFE_CALL by ...
-
-    // When expressions
-    val NO_ELSE_IN_WHEN by error1<FirSourceElement, KtWhenExpression, List<WhenMissingCase>>(SourceElementPositioningStrategies.WHEN_EXPRESSION)
-    val INVALID_IF_AS_EXPRESSION by error0<FirSourceElement, KtIfExpression>(SourceElementPositioningStrategies.IF_EXPRESSION)
-
-    // Extended checkers group
     val REDUNDANT_VISIBILITY_MODIFIER by warning0<FirSourceElement, KtModifierListOwner>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
     val REDUNDANT_MODALITY_MODIFIER by warning0<FirSourceElement, KtModifierListOwner>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
     val REDUNDANT_RETURN_UNIT_TYPE by warning0<FirSourceElement, PsiTypeElement>()

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/SmartPrinter.kt

@@ -38,6 +38,9 @@ class SmartPrinter(appendable: Appendable) {
     fun popIndent() {
         printer.popIndent()
     }
+
+    fun getCurrentIndentInUnits() = printer.currentIndentLengthInUnits
+    fun getIndentUnit() = printer.indentUnitLength
 }
 
 inline fun SmartPrinter.withIndent(block: () -> Unit) {