[FIR] Add specific checkers for each leaf declaration type

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

@@ -43,7 +43,6 @@ fun main(args: Array<String>) {
         alias<FirGetClassCall>("GetClassCallChecker")
         alias<FirSafeCallExpression>("SafeCallExpressionChecker")
         alias<FirEqualityOperatorCall>("EqualityOperatorCallChecker")
-        alias<FirAnonymousFunction>("AnonymousFunctionAsExpressionChecker")
         alias<FirStringConcatenationCall>("StringConcatenationCallChecker")
         alias<FirTypeOperatorCall>("TypeOperatorCallChecker")
         alias<FirResolvedQualifier>("ResolvedQualifierChecker")
@@ -62,6 +61,12 @@ fun main(args: Array<String>) {
         alias<FirTypeParameter>("FirTypeParameterChecker")
         alias<FirAnnotatedDeclaration>("FirAnnotatedDeclarationChecker")
         alias<FirTypeAlias>("TypeAliasChecker")
+        alias<FirAnonymousFunction>("AnonymousFunctionChecker")
+        alias<FirPropertyAccessor>("PropertyAccessorChecker")
+        alias<FirValueParameter>("ValueParameterChecker")
+        alias<FirEnumEntry>("EnumEntryChecker")
+        alias<FirAnonymousObject>("AnonymousObjectChecker")
+        alias<FirAnonymousInitializer>("AnonymousInitializerChecker")
 
         additional(
             fieldName = "controlFlowAnalyserCheckers",

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/ComposedDeclarationCheckers.kt

@@ -37,6 +37,18 @@ class ComposedDeclarationCheckers : DeclarationCheckers() {
         get() = _annotatedDeclarationCheckers
     override val typeAliasCheckers: Set<FirTypeAliasChecker>
         get() = _typeAliasCheckers
+    override val anonymousFunctionCheckers: Set<FirAnonymousFunctionChecker>
+        get() = _anonymousFunctionCheckers
+    override val propertyAccessorCheckers: Set<FirPropertyAccessorChecker>
+        get() = _propertyAccessorCheckers
+    override val valueParameterCheckers: Set<FirValueParameterChecker>
+        get() = _valueParameterCheckers
+    override val enumEntryCheckers: Set<FirEnumEntryChecker>
+        get() = _enumEntryCheckers
+    override val anonymousObjectCheckers: Set<FirAnonymousObjectChecker>
+        get() = _anonymousObjectCheckers
+    override val anonymousInitializerCheckers: Set<FirAnonymousInitializerChecker>
+        get() = _anonymousInitializerCheckers
     override val controlFlowAnalyserCheckers: Set<FirControlFlowChecker>
         get() = _controlFlowAnalyserCheckers
     override val variableAssignmentCfaBasedCheckers: Set<AbstractFirPropertyInitializationChecker>
@@ -53,6 +65,12 @@ class ComposedDeclarationCheckers : DeclarationCheckers() {
     private val _typeParameterCheckers: MutableSet<FirTypeParameterChecker> = mutableSetOf()
     private val _annotatedDeclarationCheckers: MutableSet<FirAnnotatedDeclarationChecker> = mutableSetOf()
     private val _typeAliasCheckers: MutableSet<FirTypeAliasChecker> = mutableSetOf()
+    private val _anonymousFunctionCheckers: MutableSet<FirAnonymousFunctionChecker> = mutableSetOf()
+    private val _propertyAccessorCheckers: MutableSet<FirPropertyAccessorChecker> = mutableSetOf()
+    private val _valueParameterCheckers: MutableSet<FirValueParameterChecker> = mutableSetOf()
+    private val _enumEntryCheckers: MutableSet<FirEnumEntryChecker> = mutableSetOf()
+    private val _anonymousObjectCheckers: MutableSet<FirAnonymousObjectChecker> = mutableSetOf()
+    private val _anonymousInitializerCheckers: MutableSet<FirAnonymousInitializerChecker> = mutableSetOf()
     private val _controlFlowAnalyserCheckers: MutableSet<FirControlFlowChecker> = mutableSetOf()
     private val _variableAssignmentCfaBasedCheckers: MutableSet<AbstractFirPropertyInitializationChecker> = mutableSetOf()
 
@@ -69,6 +87,12 @@ class ComposedDeclarationCheckers : DeclarationCheckers() {
         _typeParameterCheckers += checkers.typeParameterCheckers
         _annotatedDeclarationCheckers += checkers.annotatedDeclarationCheckers
         _typeAliasCheckers += checkers.typeAliasCheckers
+        _anonymousFunctionCheckers += checkers.anonymousFunctionCheckers
+        _propertyAccessorCheckers += checkers.propertyAccessorCheckers
+        _valueParameterCheckers += checkers.valueParameterCheckers
+        _enumEntryCheckers += checkers.enumEntryCheckers
+        _anonymousObjectCheckers += checkers.anonymousObjectCheckers
+        _anonymousInitializerCheckers += checkers.anonymousInitializerCheckers
         _controlFlowAnalyserCheckers += checkers.controlFlowAnalyserCheckers
         _variableAssignmentCfaBasedCheckers += checkers.variableAssignmentCfaBasedCheckers
     }

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/DeclarationCheckers.kt

@@ -30,6 +30,12 @@ abstract class DeclarationCheckers {
     open val typeParameterCheckers: Set<FirTypeParameterChecker> = emptySet()
     open val annotatedDeclarationCheckers: Set<FirAnnotatedDeclarationChecker> = emptySet()
     open val typeAliasCheckers: Set<FirTypeAliasChecker> = emptySet()
+    open val anonymousFunctionCheckers: Set<FirAnonymousFunctionChecker> = emptySet()
+    open val propertyAccessorCheckers: Set<FirPropertyAccessorChecker> = emptySet()
+    open val valueParameterCheckers: Set<FirValueParameterChecker> = emptySet()
+    open val enumEntryCheckers: Set<FirEnumEntryChecker> = emptySet()
+    open val anonymousObjectCheckers: Set<FirAnonymousObjectChecker> = emptySet()
+    open val anonymousInitializerCheckers: Set<FirAnonymousInitializerChecker> = emptySet()
 
     open val controlFlowAnalyserCheckers: Set<FirControlFlowChecker> = emptySet()
     open val variableAssignmentCfaBasedCheckers: Set<AbstractFirPropertyInitializationChecker> = emptySet()
@@ -45,4 +51,10 @@ abstract class DeclarationCheckers {
     @CheckersComponentInternal internal val allTypeParameterCheckers: Set<FirTypeParameterChecker> get() = typeParameterCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers
     @CheckersComponentInternal internal val allAnnotatedDeclarationCheckers: Set<FirAnnotatedDeclarationChecker> get() = annotatedDeclarationCheckers + basicDeclarationCheckers
     @CheckersComponentInternal internal val allTypeAliasCheckers: Set<FirTypeAliasChecker> get() = typeAliasCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers
+    @CheckersComponentInternal internal val allAnonymousFunctionCheckers: Set<FirAnonymousFunctionChecker> get() = anonymousFunctionCheckers + functionCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers
+    @CheckersComponentInternal internal val allPropertyAccessorCheckers: Set<FirPropertyAccessorChecker> get() = propertyAccessorCheckers + functionCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers
+    @CheckersComponentInternal internal val allValueParameterCheckers: Set<FirValueParameterChecker> get() = valueParameterCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers
+    @CheckersComponentInternal internal val allEnumEntryCheckers: Set<FirEnumEntryChecker> get() = enumEntryCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers
+    @CheckersComponentInternal internal val allAnonymousObjectCheckers: Set<FirAnonymousObjectChecker> get() = anonymousObjectCheckers + classCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers
+    @CheckersComponentInternal internal val allAnonymousInitializerCheckers: Set<FirAnonymousInitializerChecker> get() = anonymousInitializerCheckers + basicDeclarationCheckers
 }

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationCheckerAliases.kt

@@ -11,16 +11,22 @@ package org.jetbrains.kotlin.fir.analysis.checkers.declaration
  */
 
 import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
+import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer
+import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirProperty
+import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 
 typealias FirBasicDeclarationChecker = FirDeclarationChecker<FirDeclaration>
 typealias FirFunctionChecker = FirDeclarationChecker<FirFunction>
@@ -33,3 +39,9 @@ typealias FirFileChecker = FirDeclarationChecker<FirFile>
 typealias FirTypeParameterChecker = FirDeclarationChecker<FirTypeParameter>
 typealias FirAnnotatedDeclarationChecker = FirDeclarationChecker<FirAnnotatedDeclaration>
 typealias FirTypeAliasChecker = FirDeclarationChecker<FirTypeAlias>
+typealias FirAnonymousFunctionChecker = FirDeclarationChecker<FirAnonymousFunction>
+typealias FirPropertyAccessorChecker = FirDeclarationChecker<FirPropertyAccessor>
+typealias FirValueParameterChecker = FirDeclarationChecker<FirValueParameter>
+typealias FirEnumEntryChecker = FirDeclarationChecker<FirEnumEntry>
+typealias FirAnonymousObjectChecker = FirDeclarationChecker<FirAnonymousObject>
+typealias FirAnonymousInitializerChecker = FirDeclarationChecker<FirAnonymousInitializer>

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ComposedExpressionCheckers.kt

@@ -47,8 +47,6 @@ class ComposedExpressionCheckers : ExpressionCheckers() {
         get() = _safeCallExpressionCheckers
     override val equalityOperatorCallCheckers: Set<FirEqualityOperatorCallChecker>
         get() = _equalityOperatorCallCheckers
-    override val anonymousFunctionAsExpressionCheckers: Set<FirAnonymousFunctionAsExpressionChecker>
-        get() = _anonymousFunctionAsExpressionCheckers
     override val stringConcatenationCallCheckers: Set<FirStringConcatenationCallChecker>
         get() = _stringConcatenationCallCheckers
     override val typeOperatorCallCheckers: Set<FirTypeOperatorCallChecker>
@@ -73,7 +71,6 @@ class ComposedExpressionCheckers : ExpressionCheckers() {
     private val _getClassCallCheckers: MutableSet<FirGetClassCallChecker> = mutableSetOf()
     private val _safeCallExpressionCheckers: MutableSet<FirSafeCallExpressionChecker> = mutableSetOf()
     private val _equalityOperatorCallCheckers: MutableSet<FirEqualityOperatorCallChecker> = mutableSetOf()
-    private val _anonymousFunctionAsExpressionCheckers: MutableSet<FirAnonymousFunctionAsExpressionChecker> = mutableSetOf()
     private val _stringConcatenationCallCheckers: MutableSet<FirStringConcatenationCallChecker> = mutableSetOf()
     private val _typeOperatorCallCheckers: MutableSet<FirTypeOperatorCallChecker> = mutableSetOf()
     private val _resolvedQualifierCheckers: MutableSet<FirResolvedQualifierChecker> = mutableSetOf()
@@ -97,7 +94,6 @@ class ComposedExpressionCheckers : ExpressionCheckers() {
         _getClassCallCheckers += checkers.getClassCallCheckers
         _safeCallExpressionCheckers += checkers.safeCallExpressionCheckers
         _equalityOperatorCallCheckers += checkers.equalityOperatorCallCheckers
-        _anonymousFunctionAsExpressionCheckers += checkers.anonymousFunctionAsExpressionCheckers
         _stringConcatenationCallCheckers += checkers.stringConcatenationCallCheckers
         _typeOperatorCallCheckers += checkers.typeOperatorCallCheckers
         _resolvedQualifierCheckers += checkers.resolvedQualifierCheckers

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ExpressionCheckers.kt

@@ -34,7 +34,6 @@ abstract class ExpressionCheckers {
     open val getClassCallCheckers: Set<FirGetClassCallChecker> = emptySet()
     open val safeCallExpressionCheckers: Set<FirSafeCallExpressionChecker> = emptySet()
     open val equalityOperatorCallCheckers: Set<FirEqualityOperatorCallChecker> = emptySet()
-    open val anonymousFunctionAsExpressionCheckers: Set<FirAnonymousFunctionAsExpressionChecker> = emptySet()
     open val stringConcatenationCallCheckers: Set<FirStringConcatenationCallChecker> = emptySet()
     open val typeOperatorCallCheckers: Set<FirTypeOperatorCallChecker> = emptySet()
     open val resolvedQualifierCheckers: Set<FirResolvedQualifierChecker> = emptySet()
@@ -56,7 +55,6 @@ abstract class ExpressionCheckers {
     @CheckersComponentInternal internal val allGetClassCallCheckers: Set<FirGetClassCallChecker> get() = getClassCallCheckers + basicExpressionCheckers
     @CheckersComponentInternal internal val allSafeCallExpressionCheckers: Set<FirSafeCallExpressionChecker> get() = safeCallExpressionCheckers + basicExpressionCheckers
     @CheckersComponentInternal internal val allEqualityOperatorCallCheckers: Set<FirEqualityOperatorCallChecker> get() = equalityOperatorCallCheckers + basicExpressionCheckers
-    @CheckersComponentInternal internal val allAnonymousFunctionAsExpressionCheckers: Set<FirAnonymousFunctionAsExpressionChecker> get() = anonymousFunctionAsExpressionCheckers + basicExpressionCheckers
     @CheckersComponentInternal internal val allStringConcatenationCallCheckers: Set<FirStringConcatenationCallChecker> get() = stringConcatenationCallCheckers + basicExpressionCheckers
     @CheckersComponentInternal internal val allTypeOperatorCallCheckers: Set<FirTypeOperatorCallChecker> get() = typeOperatorCallCheckers + basicExpressionCheckers
     @CheckersComponentInternal internal val allResolvedQualifierCheckers: Set<FirResolvedQualifierChecker> get() = resolvedQualifierCheckers + basicExpressionCheckers

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirExpressionCheckerAliases.kt

@@ -10,7 +10,6 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression
  * DO NOT MODIFY IT MANUALLY
  */
 
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBinaryLogicExpression
 import org.jetbrains.kotlin.fir.expressions.FirBlock
@@ -49,7 +48,6 @@ typealias FirElvisExpressionChecker = FirExpressionChecker<FirElvisExpression>
 typealias FirGetClassCallChecker = FirExpressionChecker<FirGetClassCall>
 typealias FirSafeCallExpressionChecker = FirExpressionChecker<FirSafeCallExpression>
 typealias FirEqualityOperatorCallChecker = FirExpressionChecker<FirEqualityOperatorCall>
-typealias FirAnonymousFunctionAsExpressionChecker = FirExpressionChecker<FirAnonymousFunction>
 typealias FirStringConcatenationCallChecker = FirExpressionChecker<FirStringConcatenationCall>
 typealias FirTypeOperatorCallChecker = FirExpressionChecker<FirTypeOperatorCall>
 typealias FirResolvedQualifierChecker = FirExpressionChecker<FirResolvedQualifier>

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt

@@ -11,7 +11,9 @@ import org.jetbrains.kotlin.fir.analysis.cfa.FirPropertyInitializationAnalyzer
 import org.jetbrains.kotlin.fir.analysis.cfa.FirReturnsImpliesAnalyzer
 import org.jetbrains.kotlin.fir.analysis.checkers.cfa.FirControlFlowChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.*
+import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirAnonymousFunctionParametersChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirReservedUnderscoreDeclarationChecker
+import org.jetbrains.kotlin.fir.analysis.checkers.syntax.FirAnonymousFunctionSyntaxChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.syntax.FirDelegationInInterfaceSyntaxChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.syntax.FirFunctionTypeParametersSyntaxChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.syntax.FirTypeParameterSyntaxChecker
@@ -48,7 +50,7 @@ object CommonDeclarationCheckers : DeclarationCheckers() {
             FirInapplicableLateinitChecker,
             FirDestructuringDeclarationChecker,
             FirConstPropertyChecker,
-            FirPropertyAccessorChecker,
+            FirPropertyAccessorsTypesChecker,
             FirPropertyTypeParametersChecker,
             FirInitializerTypeMismatchChecker,
             FirDelegatedPropertyChecker,
@@ -128,4 +130,10 @@ object CommonDeclarationCheckers : DeclarationCheckers() {
         get() = setOf(
             FirTopLevelTypeAliasChecker,
         )
+
+    override val anonymousFunctionCheckers: Set<FirAnonymousFunctionChecker>
+        get() = setOf(
+            FirAnonymousFunctionParametersChecker,
+            FirAnonymousFunctionSyntaxChecker,
+        )
 }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonExpressionCheckers.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.fir.analysis.checkers
 
+import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirAnonymousFunctionChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.expression.*
 import org.jetbrains.kotlin.fir.analysis.checkers.syntax.FirAnonymousFunctionSyntaxChecker
 
@@ -103,12 +104,6 @@ object CommonExpressionCheckers : ExpressionCheckers() {
             FirUnnecessarySafeCallChecker,
         )
 
-    override val anonymousFunctionAsExpressionCheckers: Set<FirAnonymousFunctionAsExpressionChecker>
-        get() = setOf(
-            FirAnonymousFunctionChecker,
-            FirAnonymousFunctionSyntaxChecker,
-        )
-
     override val typeOperatorCallCheckers: Set<FirTypeOperatorCallChecker>
         get() = setOf(
             FirUselessTypeOperationCallChecker,

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirPropertyAccessorChecker.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.types.ConeClassErrorType
 import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.fir.types.isUnit
 
-object FirPropertyAccessorChecker : FirPropertyChecker() {
+object FirPropertyAccessorsTypesChecker : FirPropertyChecker() {
     override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) {
         checkGetter(declaration, context, reporter)
         checkSetter(declaration, context, reporter)

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirAnonymousFunctionParametersChecker.kt

@@ -6,12 +6,15 @@
 package org.jetbrains.kotlin.fir.analysis.checkers.expression
 
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
-import org.jetbrains.kotlin.fir.analysis.diagnostics.*
+import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirAnonymousFunctionChecker
+import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
+import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 
-object FirAnonymousFunctionChecker : FirAnonymousFunctionAsExpressionChecker() {
-    override fun check(expression: FirAnonymousFunction, context: CheckerContext, reporter: DiagnosticReporter) {
-        for (valueParameter in expression.valueParameters) {
+object FirAnonymousFunctionParametersChecker : FirAnonymousFunctionChecker() {
+    override fun check(declaration: FirAnonymousFunction, context: CheckerContext, reporter: DiagnosticReporter) {
+        for (valueParameter in declaration.valueParameters) {
             val source = valueParameter.source ?: continue
             if (valueParameter.defaultValue != null) {
                 reporter.reportOn(source, FirErrors.ANONYMOUS_FUNCTION_PARAMETER_WITH_DEFAULT_VALUE, context)

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/syntax/FirAnonymousFunctionSyntaxChecker.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.typeParametersList
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.psi.KtFunction
 
-object FirAnonymousFunctionSyntaxChecker : FirExpressionSyntaxChecker<FirAnonymousFunction, KtFunction>() {
+object FirAnonymousFunctionSyntaxChecker : FirDeclarationSyntaxChecker<FirAnonymousFunction, KtFunction>() {
     override fun checkPsi(
         element: FirAnonymousFunction,
         source: FirPsiSourceElement,

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/DeclarationCheckersDiagnosticComponent.kt

@@ -50,15 +50,15 @@ class DeclarationCheckersDiagnosticComponent(
     }
 
     override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: CheckerContext) {
-        checkers.allAnnotatedDeclarationCheckers.check(anonymousFunction, data, reporter)
+        checkers.allAnonymousFunctionCheckers.check(anonymousFunction, data, reporter)
     }
 
     override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: CheckerContext) {
-        checkers.allAnnotatedDeclarationCheckers.check(propertyAccessor, data, reporter)
+        checkers.allPropertyAccessorCheckers.check(propertyAccessor, data, reporter)
     }
 
     override fun visitValueParameter(valueParameter: FirValueParameter, data: CheckerContext) {
-        checkers.allAnnotatedDeclarationCheckers.check(valueParameter, data, reporter)
+        checkers.allValueParameterCheckers.check(valueParameter, data, reporter)
     }
 
     override fun visitTypeParameter(typeParameter: FirTypeParameter, data: CheckerContext) {
@@ -66,15 +66,15 @@ class DeclarationCheckersDiagnosticComponent(
     }
 
     override fun visitEnumEntry(enumEntry: FirEnumEntry, data: CheckerContext) {
-        checkers.allBasicDeclarationCheckers.check(enumEntry, data, reporter)
+        checkers.allEnumEntryCheckers.check(enumEntry, data, reporter)
     }
 
     override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: CheckerContext) {
-        checkers.allClassCheckers.check(anonymousObject, data, reporter)
+        checkers.allAnonymousObjectCheckers.check(anonymousObject, data, reporter)
     }
 
     override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: CheckerContext) {
-        checkers.allBasicDeclarationCheckers.check(anonymousInitializer, data, reporter)
+        checkers.allAnonymousInitializerCheckers.check(anonymousInitializer, data, reporter)
     }
 
     private fun <D : FirDeclaration> Collection<FirDeclarationChecker<D>>.check(

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ExpressionCheckersDiagnosticComponent.kt

@@ -21,11 +21,6 @@ class ExpressionCheckersDiagnosticComponent(
     reporter: DiagnosticReporter,
     private val checkers: ExpressionCheckers = session.checkersComponent.expressionCheckers,
 ) : AbstractDiagnosticCollectorComponent(session, reporter) {
-
-    override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: CheckerContext) {
-        checkers.allAnonymousFunctionAsExpressionCheckers.check(anonymousFunction, data, reporter)
-    }
-
     override fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: CheckerContext) {
         checkers.allTypeOperatorCallCheckers.check(typeOperatorCall, data, reporter)
     }