FIR: Update diagnostics list after rebase

2021-02-02 21:17:38 +01:00
parent fe9c0e584f
commit b2d51dc455
14 changed files with 480 additions and 59 deletions
@@ -78,6 +78,31 @@ enum class PositioningStrategy(val expressionToCreate: String, val import: Strin
        "SourceElementPositioningStrategies.PARAMETER_VARARG_MODIFIER",
        positioningStrategiesImport
    ),
+
+    DECLARATION_RETURN_TYPE(
+        "SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE",
+        positioningStrategiesImport
+    ),
+
+    OVERRIDE_MODIFIER(
+        "SourceElementPositioningStrategies.OVERRIDE_MODIFIER",
+        positioningStrategiesImport
+    ),
+
+    DOT_BY_SELECTOR(
+        "SourceElementPositioningStrategies.DOT_BY_SELECTOR",
+        positioningStrategiesImport
+    ),
+
+    OPEN_MODIFIER(
+        "SourceElementPositioningStrategies.OPEN_MODIFIER",
+        positioningStrategiesImport
+    ),
+
+    VARIANCE_MODIFIER(
+        "SourceElementPositioningStrategies.VARIANCE_MODIFIER",
+        positioningStrategiesImport
+    ),
 }

 private const val positioningStrategiesImport = "org.jetbrains.kotlin.fir.analysis.diagnostics.SourceElementPositioningStrategies"
@@ -111,7 +111,9 @@ object ErrorListDiagnosticListRenderer : DiagnosticListRenderer() {
    @OptIn(ExperimentalStdlibApi::class)
    private fun collectImports(diagnosticList: DiagnosticList): Collection<String> = buildSet {
        diagnosticList.diagnostics.forEach { diagnostic ->
-            diagnostic.getAllTypeArguments().mapTo(this) { it.kClass.qualifiedName!! }
+            for (typeArgument in diagnostic.getAllTypeArguments()) {
+                typeArgument.collectClassNamesTo(this)
+            }
            if (!diagnostic.hasDefaultPositioningStrategy()) {
                add(diagnostic.positioningStrategy.import)
            }
@@ -8,11 +8,14 @@ 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.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirEffectiveVisibility
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.PrivateForInline
+import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 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.*
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -126,9 +129,7 @@ val DIAGNOSTICS_LIST = DiagnosticListBuilder.buildDiagnosticList {
    }

    group("Modifiers") {
-        val INAPPLICABLE_INFIX_MODIFIER by error<FirSourceElement, PsiElement> {
-            parameter<String>("modifier") // TODO or it should be a message?
-        }
+        val INAPPLICABLE_INFIX_MODIFIER by error<FirSourceElement, PsiElement>()
        val REPEATED_MODIFIER by error<FirSourceElement, PsiElement> {
            parameter<KtModifierKeywordToken>("modifier")
        }
@@ -144,7 +145,7 @@ val DIAGNOSTICS_LIST = DiagnosticListBuilder.buildDiagnosticList {
            parameter<KtModifierKeywordToken>("modifier1")
            parameter<KtModifierKeywordToken>("modifier2")
        }
-        val REDUNDANT_OPEN_IN_INTERFACE by warning<FirSourceElement, KtModifierListOwner>(PositioningStrategy.MODALITY_MODIFIER)
+        val REDUNDANT_OPEN_IN_INTERFACE by warning<FirSourceElement, KtModifierListOwner>(PositioningStrategy.OPEN_MODIFIER)
    }

    group("Applicability") {
@@ -193,19 +194,54 @@ val DIAGNOSTICS_LIST = DiagnosticListBuilder.buildDiagnosticList {
        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
+        val VARIANCE_ON_TYPE_PARAMETER_NOT_ALLOWED by error<FirSourceElement, KtTypeParameter>(PositioningStrategy.VARIANCE_MODIFIER)
+
+        val CATCH_PARAMETER_WITH_DEFAULT_VALUE by error<FirSourceElement, PsiElement>()
+        val REIFIED_TYPE_IN_CATCH_CLAUSE by error<FirSourceElement, PsiElement>()
+        val TYPE_PARAMETER_IN_CATCH_CLAUSE by error<FirSourceElement, PsiElement>()
+        val GENERIC_THROWABLE_SUBCLASS by error<FirSourceElement, KtTypeParameterList>()
+        val INNER_CLASS_OF_GENERIC_THROWABLE_SUBCLASS by error<FirSourceElement, KtClassOrObject>(PositioningStrategy.DECLARATION_NAME)
+    }
+
+    group("overrides") {
+        val NOTHING_TO_OVERRIDE by error<FirSourceElement, KtModifierListOwner>(PositioningStrategy.OVERRIDE_MODIFIER) {
+            parameter<FirMemberDeclaration>("declaration")
+        }
+
+        val CANNOT_WEAKEN_ACCESS_PRIVILEGE by error<FirSourceElement, KtModifierListOwner>(PositioningStrategy.VISIBILITY_MODIFIER) {
+            parameter<Visibility>("overridingVisibility")
+            parameter<FirCallableDeclaration<*>>("overridden")
+            parameter<Name>("containingClassName")
+        }
+        val CANNOT_CHANGE_ACCESS_PRIVILEGE by error<FirSourceElement, KtModifierListOwner>(PositioningStrategy.VISIBILITY_MODIFIER) {
+            parameter<Visibility>("overridingVisibility")
+            parameter<FirCallableDeclaration<*>>("overridden")
+            parameter<Name>("containingClassName")
+        }
+
+
+        val OVERRIDING_FINAL_MEMBER by error<FirSourceElement, KtNamedDeclaration>(PositioningStrategy.OVERRIDE_MODIFIER) {
+            parameter<FirCallableDeclaration<*>>("overriddenDeclaration")
+            parameter<Name>("containingClassName")
+        }
+
+        val RETURN_TYPE_MISMATCH_ON_OVERRIDE by error<FirSourceElement, KtNamedDeclaration>(PositioningStrategy.DECLARATION_RETURN_TYPE) {
+            parameter<FirMemberDeclaration>("function")
            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 PROPERTY_TYPE_MISMATCH_ON_OVERRIDE by error<FirSourceElement, KtNamedDeclaration>(PositioningStrategy.DECLARATION_RETURN_TYPE) {
+            parameter<FirMemberDeclaration>("property")
+            parameter<FirMemberDeclaration>("superProperty")
        }
-        val VAR_TYPE_MISMATCH_ON_OVERRIDE by error<FirSourceElement, PsiElement> {
-            parameter<String>("variableType") // TODO use ConeType instead of String
-            parameter<FirMemberDeclaration>("targetVariable")
+        val VAR_TYPE_MISMATCH_ON_OVERRIDE by error<FirSourceElement, KtNamedDeclaration>(PositioningStrategy.DECLARATION_RETURN_TYPE) {
+            parameter<FirMemberDeclaration>("variable")
+            parameter<FirMemberDeclaration>("superVariable")
        }
+        val VAR_OVERRIDDEN_BY_VAL by error<FirSourceElement, KtNamedDeclaration>(PositioningStrategy.VAL_OR_VAR_NODE) {
+            parameter<FirMemberDeclaration>("overridingDeclaration")
+            parameter<FirMemberDeclaration>("overriddenDeclaration")
+        }
+
    }

    group("Redeclarations") {
@@ -290,12 +326,17 @@ val DIAGNOSTICS_LIST = DiagnosticListBuilder.buildDiagnosticList {
        val INITIALIZER_REQUIRED_FOR_DESTRUCTURING_DECLARATION by error<FirSourceElement, KtDestructuringDeclaration>()
        val COMPONENT_FUNCTION_MISSING by error<FirSourceElement, PsiElement> {
            parameter<Name>("missingFunctionName")
-            parameter<FirTypeRef>("destructingType")
+            parameter<ConeKotlinType>("destructingType")
        }
        val COMPONENT_FUNCTION_AMBIGUITY by error<FirSourceElement, PsiElement> {
            parameter<Name>("functionWithAmbiguityName")
            parameter<Collection<AbstractFirBasedSymbol<*>>>("candidates")
        }
+
+        val COMPONENT_FUNCTION_ON_NULLABLE by error<FirSourceElement, KtExpression>() {
+            parameter<Name>("componentFunctionName")
+        }
+
        // TODO: val COMPONENT_FUNCTION_ON_NULLABLE by ...
        // TODO: val COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH by ...
    }
@@ -315,7 +356,24 @@ val DIAGNOSTICS_LIST = DiagnosticListBuilder.buildDiagnosticList {
        val WRONG_IMPLIES_CONDITION by warning<FirSourceElement, PsiElement>()
    }

-    group(" Extended checkers") {
+    group("Nullability") {
+        val UNSAFE_CALL by error<FirSourceElement, PsiElement>(PositioningStrategy.DOT_BY_SELECTOR) {
+            parameter<ConeKotlinType>("receiverType")
+        }
+        // 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 ...
+    }
+
+    group("When expressions") {
+        val NO_ELSE_IN_WHEN by error<FirSourceElement, KtWhenExpression>(PositioningStrategy.WHEN_EXPRESSION) {
+            parameter<List<WhenMissingCase>>("missingWhenCases")
+        }
+        val INVALID_IF_AS_EXPRESSION by error<FirSourceElement, KtIfExpression>(PositioningStrategy.IF_EXPRESSION)
+    }
+
+    group("Extended checkers") {
        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>()
@@ -6,9 +6,20 @@
 package org.jetbrains.kotlin.fir.checkers.generator

 import java.io.File
+import kotlin.reflect.KClass
+import kotlin.reflect.KType

 fun getGenerationPath(rootPath: File, packageName: String): File =
    packageName
        .split(".")
        .fold(rootPath, File::resolve)
-        .apply { mkdirs() }
+        .apply { mkdirs() }
+
+
+@OptIn(ExperimentalStdlibApi::class)
+fun KType.collectClassNamesTo(set: MutableSet<String>) {
+    (classifier as? KClass<*>)?.qualifiedName?.let(set::add)
+    for (argument in arguments) {
+        argument.type?.collectClassNamesTo(set)
+    }
+}
@@ -8,17 +8,19 @@ 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.analysis.diagnostics.SourceElementPositioningStrategies
+import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 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.KtClassOrObject
@@ -26,13 +28,17 @@ 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.KtIfExpression
 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.KtTypeParameter
+import org.jetbrains.kotlin.psi.KtTypeParameterList
 import org.jetbrains.kotlin.psi.KtTypeReference
+import org.jetbrains.kotlin.psi.KtWhenExpression

 /*
 * This file was generated automatically
@@ -122,12 +128,12 @@ object FirErrors {
    val EXPOSED_TYPE_PARAMETER_BOUND by error3<FirSourceElement, KtTypeReference, FirEffectiveVisibility, FirMemberDeclaration, FirEffectiveVisibility>()

    // Modifiers
-    val INAPPLICABLE_INFIX_MODIFIER by error1<FirSourceElement, PsiElement, String>()
+    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.MODALITY_MODIFIER)
+    val REDUNDANT_OPEN_IN_INTERFACE by warning0<FirSourceElement, KtModifierListOwner>(SourceElementPositioningStrategies.OPEN_MODIFIER)

    // Applicability
    val NONE_APPLICABLE by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>()
@@ -151,10 +157,22 @@ 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, PsiElement>()
-    val RETURN_TYPE_MISMATCH_ON_OVERRIDE by error2<FirSourceElement, PsiElement, String, FirMemberDeclaration>()
-    val PROPERTY_TYPE_MISMATCH_ON_OVERRIDE by error2<FirSourceElement, PsiElement, String, FirMemberDeclaration>()
-    val VAR_TYPE_MISMATCH_ON_OVERRIDE by error2<FirSourceElement, PsiElement, String, FirMemberDeclaration>()
+    val VARIANCE_ON_TYPE_PARAMETER_NOT_ALLOWED by error0<FirSourceElement, KtTypeParameter>(SourceElementPositioningStrategies.VARIANCE_MODIFIER)
+    val CATCH_PARAMETER_WITH_DEFAULT_VALUE by error0<FirSourceElement, PsiElement>()
+    val REIFIED_TYPE_IN_CATCH_CLAUSE by error0<FirSourceElement, PsiElement>()
+    val TYPE_PARAMETER_IN_CATCH_CLAUSE by error0<FirSourceElement, PsiElement>()
+    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 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 OVERRIDING_FINAL_MEMBER by error2<FirSourceElement, KtNamedDeclaration, FirCallableDeclaration<*>, Name>(SourceElementPositioningStrategies.OVERRIDE_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>()
@@ -197,8 +215,9 @@ object FirErrors {

    // Destructuring declaration
    val INITIALIZER_REQUIRED_FOR_DESTRUCTURING_DECLARATION by error0<FirSourceElement, KtDestructuringDeclaration>()
-    val COMPONENT_FUNCTION_MISSING by error2<FirSourceElement, PsiElement, Name, FirTypeRef>()
+    val COMPONENT_FUNCTION_MISSING by error2<FirSourceElement, PsiElement, Name, ConeKotlinType>()
    val COMPONENT_FUNCTION_AMBIGUITY by error2<FirSourceElement, PsiElement, Name, Collection<AbstractFirBasedSymbol<*>>>()
+    val COMPONENT_FUNCTION_ON_NULLABLE by error1<FirSourceElement, KtExpression, Name>()

    // Control flow diagnostics
    val UNINITIALIZED_VARIABLE by error1<FirSourceElement, PsiElement, FirPropertySymbol>()
@@ -206,7 +225,14 @@ object FirErrors {
    val LEAKED_IN_PLACE_LAMBDA by error1<FirSourceElement, PsiElement, AbstractFirBasedSymbol<*>>()
    val WRONG_IMPLIES_CONDITION by warning0<FirSourceElement, PsiElement>()

-    //  Extended checkers
+    // Nullability
+    val UNSAFE_CALL by error1<FirSourceElement, PsiElement, ConeKotlinType>(SourceElementPositioningStrategies.DOT_BY_SELECTOR)
+
+    // 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
    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>()
@@ -18,6 +18,7 @@ import org.jetbrains.kotlin.fir.expressions.FirErrorLoop
 import org.jetbrains.kotlin.fir.expressions.FirErrorResolvedQualifier
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeAmbiguityError
+import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeInapplicableCandidateError
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedNameError
 import org.jetbrains.kotlin.fir.types.FirErrorTypeRef

@@ -5,20 +5,24 @@

 package org.jetbrains.kotlin.idea.frontend.api.fir.generator

+import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirEffectiveVisibility
 import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.Diagnostic
 import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.DiagnosticList
 import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.DiagnosticParameter
+import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 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.idea.frontend.api.symbols.*
 import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 import org.jetbrains.kotlin.name.Name
@@ -26,8 +30,6 @@ import kotlin.reflect.KClass
 import kotlin.reflect.KType
 import kotlin.reflect.full.createType
 import kotlin.reflect.full.isSubclassOf
-import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.idea.frontend.api.symbols.*

 object HLDiagnosticConverter {
    fun convert(diagnosticList: DiagnosticList): HLDiagnosticList =
@@ -124,6 +126,11 @@ private object FirToKtConversionCreator {
            KtSymbol::class.createType(),
            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration")
        ),
+        FirCallableDeclaration::class to HLFunctionCallConversion(
+            "firSymbolBuilder.buildCallableSymbol({0} as FirCallableDeclaration)",
+            KtCallableSymbol::class.createType(),
+            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration")
+        ),
        FirTypeParameterSymbol::class to HLFunctionCallConversion(
            "firSymbolBuilder.buildTypeParameterSymbol({0}.fir as FirTypeParameter)",
            KtTypeParameterSymbol::class.createType(),
@@ -146,6 +153,11 @@ private object FirToKtConversionCreator {
            KtVariableSymbol::class.createType(),
            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirProperty")
        ),
+        WhenMissingCase::class to HLFunctionCallConversion(
+            """TODO("WhenMissingCase conversion is not supported yet")""",
+            Any::class.createType(),
+            importsToAdd = listOf("org.jetbrains.kotlin.fir.expressions.WhenMissingCase")
+        ),
    )

    private val allowedTypesWithoutTypeParams = setOf(
@@ -154,6 +166,7 @@ private object FirToKtConversionCreator {
        Name::class,
        EventOccurrencesRange::class,
        KtModifierKeywordToken::class,
+        Visibility::class,
    )

    private val KType.kClass: KClass<*>
@@ -9,13 +9,6 @@ import org.jetbrains.kotlin.fir.tree.generator.printer.SmartPrinter
 import kotlin.reflect.KClass
 import kotlin.reflect.KType

-@OptIn(ExperimentalStdlibApi::class)
-internal fun KType.collectClassNamesTo(set: MutableSet<String>) {
-    (classifier as? KClass<*>)?.qualifiedName?.let(set::add)
-    for (argument in arguments) {
-        argument.type?.collectClassNamesTo(set)
-    }
-}

 internal fun SmartPrinter.printTypeWithShortNames(type: KType) {
    print((type.classifier as KClass<*>).simpleName!!)
@@ -5,6 +5,7 @@

 package org.jetbrains.kotlin.idea.frontend.api.fir.generator.rendererrs

+import org.jetbrains.kotlin.fir.checkers.generator.collectClassNamesTo
 import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.DiagnosticList
 import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.DiagnosticListRenderer
 import org.jetbrains.kotlin.fir.checkers.generator.printImports
@@ -15,7 +16,6 @@ import org.jetbrains.kotlin.fir.tree.generator.printer.useSmartPrinter
 import org.jetbrains.kotlin.idea.frontend.api.fir.generator.HLDiagnosticConverter
 import org.jetbrains.kotlin.idea.frontend.api.fir.generator.HLDiagnosticList
 import org.jetbrains.kotlin.idea.frontend.api.fir.generator.HLDiagnosticParameter
-import org.jetbrains.kotlin.idea.frontend.api.fir.generator.collectClassNamesTo
 import java.io.File

 abstract class AbstractDiagnosticsDataClassRenderer : DiagnosticListRenderer() {
@@ -9,9 +9,9 @@ import org.jetbrains.kotlin.fir.checkers.generator.inBracketsWithIndent
 import org.jetbrains.kotlin.fir.tree.generator.printer.SmartPrinter
 import org.jetbrains.kotlin.fir.tree.generator.printer.withIndent
 import org.jetbrains.kotlin.idea.frontend.api.fir.generator.*
-import org.jetbrains.kotlin.idea.frontend.api.fir.generator.collectClassNamesTo
 import org.jetbrains.kotlin.idea.frontend.api.fir.generator.printTypeWithShortNames
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.checkers.generator.collectClassNamesTo

 object KtDiagnosticClassImplementationRenderer : AbstractDiagnosticsDataClassRenderer() {
    override fun SmartPrinter.render(diagnosticList: HLDiagnosticList, packageName: String) {
@@ -5,11 +5,10 @@

 package org.jetbrains.kotlin.idea.frontend.api.fir.generator.rendererrs

+import org.jetbrains.kotlin.fir.checkers.generator.collectClassNamesTo
 import org.jetbrains.kotlin.fir.checkers.generator.inBracketsWithIndent
 import org.jetbrains.kotlin.fir.tree.generator.printer.SmartPrinter
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.idea.frontend.api.fir.generator.*
-import org.jetbrains.kotlin.idea.frontend.api.fir.generator.collectClassNamesTo
 import org.jetbrains.kotlin.idea.frontend.api.fir.generator.printTypeWithShortNames

 object KtDiagnosticClassRenderer : AbstractDiagnosticsDataClassRenderer() {
@@ -9,22 +9,28 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiTypeElement
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirPsiDiagnostic
+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.FirProperty
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.expressions.WhenMissingCase
 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.KtIfExpression
 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.KtTypeParameter
+import org.jetbrains.kotlin.psi.KtTypeParameterList
 import org.jetbrains.kotlin.psi.KtTypeReference
+import org.jetbrains.kotlin.psi.KtWhenExpression

 /*
 * This file was generated automatically
@@ -453,7 +459,6 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
    }
    add(FirErrors.INAPPLICABLE_INFIX_MODIFIER) { firDiagnostic ->
        InapplicableInfixModifierImpl(
-            firDiagnostic.a,
            firDiagnostic as FirPsiDiagnostic<*>,
            token,
        )
@@ -621,9 +626,72 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
            token,
        )
    }
+    add(FirErrors.CATCH_PARAMETER_WITH_DEFAULT_VALUE) { firDiagnostic ->
+        CatchParameterWithDefaultValueImpl(
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.REIFIED_TYPE_IN_CATCH_CLAUSE) { firDiagnostic ->
+        ReifiedTypeInCatchClauseImpl(
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.TYPE_PARAMETER_IN_CATCH_CLAUSE) { firDiagnostic ->
+        TypeParameterInCatchClauseImpl(
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.GENERIC_THROWABLE_SUBCLASS) { firDiagnostic ->
+        GenericThrowableSubclassImpl(
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.INNER_CLASS_OF_GENERIC_THROWABLE_SUBCLASS) { firDiagnostic ->
+        InnerClassOfGenericThrowableSubclassImpl(
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.NOTHING_TO_OVERRIDE) { firDiagnostic ->
+        NothingToOverrideImpl(
+            firSymbolBuilder.buildSymbol(firDiagnostic.a as FirDeclaration),
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.CANNOT_WEAKEN_ACCESS_PRIVILEGE) { firDiagnostic ->
+        CannotWeakenAccessPrivilegeImpl(
+            firDiagnostic.a,
+            firSymbolBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration),
+            firDiagnostic.c,
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.CANNOT_CHANGE_ACCESS_PRIVILEGE) { firDiagnostic ->
+        CannotChangeAccessPrivilegeImpl(
+            firDiagnostic.a,
+            firSymbolBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration),
+            firDiagnostic.c,
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.OVERRIDING_FINAL_MEMBER) { firDiagnostic ->
+        OverridingFinalMemberImpl(
+            firSymbolBuilder.buildCallableSymbol(firDiagnostic.a as FirCallableDeclaration),
+            firDiagnostic.b,
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
    add(FirErrors.RETURN_TYPE_MISMATCH_ON_OVERRIDE) { firDiagnostic ->
        ReturnTypeMismatchOnOverrideImpl(
-            firDiagnostic.a,
+            firSymbolBuilder.buildSymbol(firDiagnostic.a as FirDeclaration),
            firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration),
            firDiagnostic as FirPsiDiagnostic<*>,
            token,
@@ -631,7 +699,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
    }
    add(FirErrors.PROPERTY_TYPE_MISMATCH_ON_OVERRIDE) { firDiagnostic ->
        PropertyTypeMismatchOnOverrideImpl(
-            firDiagnostic.a,
+            firSymbolBuilder.buildSymbol(firDiagnostic.a as FirDeclaration),
            firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration),
            firDiagnostic as FirPsiDiagnostic<*>,
            token,
@@ -639,7 +707,15 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
    }
    add(FirErrors.VAR_TYPE_MISMATCH_ON_OVERRIDE) { firDiagnostic ->
        VarTypeMismatchOnOverrideImpl(
-            firDiagnostic.a,
+            firSymbolBuilder.buildSymbol(firDiagnostic.a as FirDeclaration),
+            firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration),
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.VAR_OVERRIDDEN_BY_VAL) { firDiagnostic ->
+        VarOverriddenByValImpl(
+            firSymbolBuilder.buildSymbol(firDiagnostic.a as FirDeclaration),
            firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration),
            firDiagnostic as FirPsiDiagnostic<*>,
            token,
@@ -855,6 +931,13 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
            token,
        )
    }
+    add(FirErrors.COMPONENT_FUNCTION_ON_NULLABLE) { firDiagnostic ->
+        ComponentFunctionOnNullableImpl(
+            firDiagnostic.a,
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
    add(FirErrors.UNINITIALIZED_VARIABLE) { firDiagnostic ->
        UninitializedVariableImpl(
            firSymbolBuilder.buildVariableSymbol(firDiagnostic.a.fir as FirProperty),
@@ -884,6 +967,28 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
            token,
        )
    }
+    add(FirErrors.UNSAFE_CALL) { firDiagnostic ->
+        UnsafeCallImpl(
+            firSymbolBuilder.buildKtType(firDiagnostic.a),
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.NO_ELSE_IN_WHEN) { firDiagnostic ->
+        NoElseInWhenImpl(
+            firDiagnostic.a.map { whenMissingCase ->
+                TODO("WhenMissingCase conversion is not supported yet")
+            },
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.INVALID_IF_AS_EXPRESSION) { firDiagnostic ->
+        InvalidIfAsExpressionImpl(
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
    add(FirErrors.REDUNDANT_VISIBILITY_MODIFIER) { firDiagnostic ->
        RedundantVisibilityModifierImpl(
            firDiagnostic as FirPsiDiagnostic<*>,
@@ -10,6 +10,7 @@ import com.intellij.psi.PsiTypeElement
 import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.idea.frontend.api.diagnostics.KtDiagnosticWithPsi
+import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtClassLikeSymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtTypeParameterSymbol
@@ -17,19 +18,22 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.KtVariableSymbol
 import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.KtCallableDeclaration
 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.KtIfExpression
 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.KtTypeParameter
+import org.jetbrains.kotlin.psi.KtTypeParameterList
 import org.jetbrains.kotlin.psi.KtTypeReference
+import org.jetbrains.kotlin.psi.KtWhenExpression

 /*
 * This file was generated automatically
@@ -328,7 +332,6 @@ sealed class KtFirDiagnostic<PSI: PsiElement> : KtDiagnosticWithPsi<PSI> {

    abstract class InapplicableInfixModifier : KtFirDiagnostic<PsiElement>() {
        override val diagnosticClass get() = InapplicableInfixModifier::class
-        abstract val modifier: String
    }

    abstract class RepeatedModifier : KtFirDiagnostic<PsiElement>() {
@@ -438,26 +441,77 @@ sealed class KtFirDiagnostic<PSI: PsiElement> : KtDiagnosticWithPsi<PSI> {
        abstract val type: String
    }

-    abstract class VarianceOnTypeParameterNotAllowed : KtFirDiagnostic<PsiElement>() {
+    abstract class VarianceOnTypeParameterNotAllowed : KtFirDiagnostic<KtTypeParameter>() {
        override val diagnosticClass get() = VarianceOnTypeParameterNotAllowed::class
    }

-    abstract class ReturnTypeMismatchOnOverride : KtFirDiagnostic<KtCallableDeclaration>() {
+    abstract class CatchParameterWithDefaultValue : KtFirDiagnostic<PsiElement>() {
+        override val diagnosticClass get() = CatchParameterWithDefaultValue::class
+    }
+
+    abstract class ReifiedTypeInCatchClause : KtFirDiagnostic<PsiElement>() {
+        override val diagnosticClass get() = ReifiedTypeInCatchClause::class
+    }
+
+    abstract class TypeParameterInCatchClause : KtFirDiagnostic<PsiElement>() {
+        override val diagnosticClass get() = TypeParameterInCatchClause::class
+    }
+
+    abstract class GenericThrowableSubclass : KtFirDiagnostic<KtTypeParameterList>() {
+        override val diagnosticClass get() = GenericThrowableSubclass::class
+    }
+
+    abstract class InnerClassOfGenericThrowableSubclass : KtFirDiagnostic<KtClassOrObject>() {
+        override val diagnosticClass get() = InnerClassOfGenericThrowableSubclass::class
+    }
+
+    abstract class NothingToOverride : KtFirDiagnostic<KtModifierListOwner>() {
+        override val diagnosticClass get() = NothingToOverride::class
+        abstract val declaration: KtSymbol
+    }
+
+    abstract class CannotWeakenAccessPrivilege : KtFirDiagnostic<KtModifierListOwner>() {
+        override val diagnosticClass get() = CannotWeakenAccessPrivilege::class
+        abstract val overridingVisibility: Visibility
+        abstract val overridden: KtCallableSymbol
+        abstract val containingClassName: Name
+    }
+
+    abstract class CannotChangeAccessPrivilege : KtFirDiagnostic<KtModifierListOwner>() {
+        override val diagnosticClass get() = CannotChangeAccessPrivilege::class
+        abstract val overridingVisibility: Visibility
+        abstract val overridden: KtCallableSymbol
+        abstract val containingClassName: Name
+    }
+
+    abstract class OverridingFinalMember : KtFirDiagnostic<KtNamedDeclaration>() {
+        override val diagnosticClass get() = OverridingFinalMember::class
+        abstract val overriddenDeclaration: KtCallableSymbol
+        abstract val containingClassName: Name
+    }
+
+    abstract class ReturnTypeMismatchOnOverride : KtFirDiagnostic<KtNamedDeclaration>() {
        override val diagnosticClass get() = ReturnTypeMismatchOnOverride::class
        abstract val function: KtSymbol
        abstract val superFunction: KtSymbol
    }

-    abstract class PropertyTypeMismatchOnOverride : KtFirDiagnostic<KtCallableDeclaration>() {
+    abstract class PropertyTypeMismatchOnOverride : KtFirDiagnostic<KtNamedDeclaration>() {
        override val diagnosticClass get() = PropertyTypeMismatchOnOverride::class
        abstract val property: KtSymbol
-        abstract val targetProperty: KtSymbol
+        abstract val superProperty: KtSymbol
    }

-    abstract class VarTypeMismatchOnOverride : KtFirDiagnostic<KtCallableDeclaration>() {
+    abstract class VarTypeMismatchOnOverride : KtFirDiagnostic<KtNamedDeclaration>() {
        override val diagnosticClass get() = VarTypeMismatchOnOverride::class
        abstract val variable: KtSymbol
-        abstract val targetVariable: KtSymbol
+        abstract val superVariable: KtSymbol
+    }
+
+    abstract class VarOverriddenByVal : KtFirDiagnostic<KtNamedDeclaration>() {
+        override val diagnosticClass get() = VarOverriddenByVal::class
+        abstract val overridingDeclaration: KtSymbol
+        abstract val overriddenDeclaration: KtSymbol
    }

    abstract class ManyCompanionObjects : KtFirDiagnostic<PsiElement>() {
@@ -604,6 +658,11 @@ sealed class KtFirDiagnostic<PSI: PsiElement> : KtDiagnosticWithPsi<PSI> {
        abstract val candidates: List<KtSymbol>
    }

+    abstract class ComponentFunctionOnNullable : KtFirDiagnostic<KtExpression>() {
+        override val diagnosticClass get() = ComponentFunctionOnNullable::class
+        abstract val componentFunctionName: Name
+    }
+
    abstract class UninitializedVariable : KtFirDiagnostic<PsiElement>() {
        override val diagnosticClass get() = UninitializedVariable::class
        abstract val variable: KtVariableSymbol
@@ -625,6 +684,20 @@ sealed class KtFirDiagnostic<PSI: PsiElement> : KtDiagnosticWithPsi<PSI> {
        override val diagnosticClass get() = WrongImpliesCondition::class
    }

+    abstract class UnsafeCall : KtFirDiagnostic<PsiElement>() {
+        override val diagnosticClass get() = UnsafeCall::class
+        abstract val receiverType: KtType
+    }
+
+    abstract class NoElseInWhen : KtFirDiagnostic<KtWhenExpression>() {
+        override val diagnosticClass get() = NoElseInWhen::class
+        abstract val missingWhenCases: List<Any>
+    }
+
+    abstract class InvalidIfAsExpression : KtFirDiagnostic<KtIfExpression>() {
+        override val diagnosticClass get() = InvalidIfAsExpression::class
+    }
+
    abstract class RedundantVisibilityModifier : KtFirDiagnostic<KtModifierListOwner>() {
        override val diagnosticClass get() = RedundantVisibilityModifier::class
    }
@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirPsiDiagnostic
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.weakRef
+import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtClassLikeSymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtTypeParameterSymbol
@@ -19,19 +20,22 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.KtVariableSymbol
 import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.KtCallableDeclaration
 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.KtIfExpression
 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.KtTypeParameter
+import org.jetbrains.kotlin.psi.KtTypeParameterList
 import org.jetbrains.kotlin.psi.KtTypeReference
+import org.jetbrains.kotlin.psi.KtWhenExpression

 /*
 * This file was generated automatically
@@ -523,7 +527,6 @@ internal class ExposedTypeParameterBoundImpl(
 }

 internal class InapplicableInfixModifierImpl(
-    override val modifier: String,
    firDiagnostic: FirPsiDiagnostic<*>,
    override val token: ValidityToken,
 ) : KtFirDiagnostic.InapplicableInfixModifier(), KtAbstractFirDiagnostic<PsiElement> {
@@ -706,7 +709,79 @@ internal class ConflictingProjectionImpl(
 internal class VarianceOnTypeParameterNotAllowedImpl(
    firDiagnostic: FirPsiDiagnostic<*>,
    override val token: ValidityToken,
-) : KtFirDiagnostic.VarianceOnTypeParameterNotAllowed(), KtAbstractFirDiagnostic<PsiElement> {
+) : KtFirDiagnostic.VarianceOnTypeParameterNotAllowed(), KtAbstractFirDiagnostic<KtTypeParameter> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class CatchParameterWithDefaultValueImpl(
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.CatchParameterWithDefaultValue(), KtAbstractFirDiagnostic<PsiElement> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class ReifiedTypeInCatchClauseImpl(
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.ReifiedTypeInCatchClause(), KtAbstractFirDiagnostic<PsiElement> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class TypeParameterInCatchClauseImpl(
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.TypeParameterInCatchClause(), KtAbstractFirDiagnostic<PsiElement> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class GenericThrowableSubclassImpl(
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.GenericThrowableSubclass(), KtAbstractFirDiagnostic<KtTypeParameterList> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class InnerClassOfGenericThrowableSubclassImpl(
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.InnerClassOfGenericThrowableSubclass(), KtAbstractFirDiagnostic<KtClassOrObject> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class NothingToOverrideImpl(
+    override val declaration: KtSymbol,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.NothingToOverride(), KtAbstractFirDiagnostic<KtModifierListOwner> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class CannotWeakenAccessPrivilegeImpl(
+    override val overridingVisibility: Visibility,
+    override val overridden: KtCallableSymbol,
+    override val containingClassName: Name,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.CannotWeakenAccessPrivilege(), KtAbstractFirDiagnostic<KtModifierListOwner> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class CannotChangeAccessPrivilegeImpl(
+    override val overridingVisibility: Visibility,
+    override val overridden: KtCallableSymbol,
+    override val containingClassName: Name,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.CannotChangeAccessPrivilege(), KtAbstractFirDiagnostic<KtModifierListOwner> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class OverridingFinalMemberImpl(
+    override val overriddenDeclaration: KtCallableSymbol,
+    override val containingClassName: Name,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.OverridingFinalMember(), KtAbstractFirDiagnostic<KtNamedDeclaration> {
    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
 }

@@ -715,25 +790,34 @@ internal class ReturnTypeMismatchOnOverrideImpl(
    override val superFunction: KtSymbol,
    firDiagnostic: FirPsiDiagnostic<*>,
    override val token: ValidityToken,
-) : KtFirDiagnostic.ReturnTypeMismatchOnOverride(), KtAbstractFirDiagnostic<KtCallableDeclaration> {
+) : KtFirDiagnostic.ReturnTypeMismatchOnOverride(), KtAbstractFirDiagnostic<KtNamedDeclaration> {
    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
 }

 internal class PropertyTypeMismatchOnOverrideImpl(
    override val property: KtSymbol,
-    override val targetProperty: KtSymbol,
+    override val superProperty: KtSymbol,
    firDiagnostic: FirPsiDiagnostic<*>,
    override val token: ValidityToken,
-) : KtFirDiagnostic.PropertyTypeMismatchOnOverride(), KtAbstractFirDiagnostic<KtCallableDeclaration> {
+) : KtFirDiagnostic.PropertyTypeMismatchOnOverride(), KtAbstractFirDiagnostic<KtNamedDeclaration> {
    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
 }

 internal class VarTypeMismatchOnOverrideImpl(
    override val variable: KtSymbol,
-    override val targetVariable: KtSymbol,
+    override val superVariable: KtSymbol,
    firDiagnostic: FirPsiDiagnostic<*>,
    override val token: ValidityToken,
-) : KtFirDiagnostic.VarTypeMismatchOnOverride(), KtAbstractFirDiagnostic<KtCallableDeclaration> {
+) : KtFirDiagnostic.VarTypeMismatchOnOverride(), KtAbstractFirDiagnostic<KtNamedDeclaration> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class VarOverriddenByValImpl(
+    override val overridingDeclaration: KtSymbol,
+    override val overriddenDeclaration: KtSymbol,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.VarOverriddenByVal(), KtAbstractFirDiagnostic<KtNamedDeclaration> {
    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
 }

@@ -977,6 +1061,14 @@ internal class ComponentFunctionAmbiguityImpl(
    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
 }

+internal class ComponentFunctionOnNullableImpl(
+    override val componentFunctionName: Name,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.ComponentFunctionOnNullable(), KtAbstractFirDiagnostic<KtExpression> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
 internal class UninitializedVariableImpl(
    override val variable: KtVariableSymbol,
    firDiagnostic: FirPsiDiagnostic<*>,
@@ -1010,6 +1102,29 @@ internal class WrongImpliesConditionImpl(
    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
 }

+internal class UnsafeCallImpl(
+    override val receiverType: KtType,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.UnsafeCall(), KtAbstractFirDiagnostic<PsiElement> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class NoElseInWhenImpl(
+    override val missingWhenCases: List<Any>,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.NoElseInWhen(), KtAbstractFirDiagnostic<KtWhenExpression> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class InvalidIfAsExpressionImpl(
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.InvalidIfAsExpression(), KtAbstractFirDiagnostic<KtIfExpression> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
 internal class RedundantVisibilityModifierImpl(
    firDiagnostic: FirPsiDiagnostic<*>,
    override val token: ValidityToken,