[FIR] extended checkers infrastructure refactoring

Removed strange way to enable Extended Checkers and add new way to do it

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

@@ -13,16 +13,12 @@ import org.jetbrains.kotlin.fir.analysis.checkers.extended.RedundantVisibilityMo
 object CommonDeclarationCheckers : DeclarationCheckers() {
     override val declarationCheckers: List<FirBasicDeclarationChecker> = listOf(
         FirAnnotationClassDeclarationChecker,
-        FirModifierChecker,
-        RedundantVisibilityModifierChecker,
-        RedundantReturnUnitType
+        FirModifierChecker
     )
 
     override val memberDeclarationCheckers: List<FirMemberDeclarationChecker> = listOf(
         FirInfixFunctionDeclarationChecker,
-        FirExposedVisibilityChecker,
-        RedundantModalityModifierChecker,
-        RedundantExplicitTypeChecker
+        FirExposedVisibilityChecker
     )
 
     override val constructorCheckers: List<FirConstructorChecker> = listOf(

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

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2010-2020 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.analysis.checkers.declaration
+
+import org.jetbrains.kotlin.fir.analysis.checkers.extended.RedundantExplicitTypeChecker
+import org.jetbrains.kotlin.fir.analysis.checkers.extended.RedundantModalityModifierChecker
+import org.jetbrains.kotlin.fir.analysis.checkers.extended.RedundantReturnUnitType
+import org.jetbrains.kotlin.fir.analysis.checkers.extended.RedundantVisibilityModifierChecker
+
+object ExtendedDeclarationCheckers : DeclarationCheckers() {
+    override val declarationCheckers = listOf(
+        RedundantVisibilityModifierChecker,
+        RedundantReturnUnitType
+    )
+
+    override val memberDeclarationCheckers = listOf(
+        RedundantExplicitTypeChecker,
+        RedundantModalityModifierChecker
+    )
+}

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

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 
 abstract class FirDeclarationChecker<in D : FirDeclaration> {
     abstract fun check(declaration: D, context: CheckerContext, reporter: DiagnosticReporter)
-    open val isExtended = false
+
 }
 
 typealias FirBasicDeclarationChecker = FirDeclarationChecker<FirDeclaration>

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantModalityModifierChecker.kt

@@ -20,8 +20,6 @@ import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.psiUtil.modalityModifier
 
 object RedundantModalityModifierChecker : FirMemberDeclarationChecker() {
-    override val isExtended = true
-
     override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration.source is FirFakeSourceElement<*>) return
 

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantReturnUnitTypeChecker.kt

@@ -15,8 +15,6 @@ import org.jetbrains.kotlin.fir.expressions.impl.FirSingleExpressionBlock
 import org.jetbrains.kotlin.fir.types.isUnit
 
 object RedundantReturnUnitType : FirBasicDeclarationChecker() {
-    override val isExtended = true
-
     override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration !is FirSimpleFunction) return
         if (declaration.body is FirSingleExpressionBlock) return

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantVisibilityModifierChecker.kt

@@ -20,8 +20,6 @@ import org.jetbrains.kotlin.fir.toFirPsiSourceElement
 import org.jetbrains.kotlin.psi.psiUtil.visibilityModifier
 
 object RedundantVisibilityModifierChecker : FirBasicDeclarationChecker() {
-    override val isExtended = true
-
     override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration is FirConstructor && declaration.source is FirFakeSourceElement<*>) return
         if (declaration.source is FirFakeSourceElement<*>) return

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

@@ -196,9 +196,9 @@ abstract class AbstractDiagnosticCollector(
     }
 }
 
-fun AbstractDiagnosticCollector.registerAllComponents(checkExtended: Boolean = false) {
+fun AbstractDiagnosticCollector.registerAllComponents() {
     initializeComponents(
-        DeclarationCheckersDiagnosticComponent(this, checkExtended),
+        DeclarationCheckersDiagnosticComponent(this),
         ExpressionCheckersDiagnosticComponent(this),
         ErrorNodeDiagnosticCollectorComponent(this),
         ControlFlowAnalysisDiagnosticComponent(this),

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

@@ -11,10 +11,10 @@ import org.jetbrains.kotlin.fir.analysis.extensions.additionalCheckers
 import org.jetbrains.kotlin.fir.extensions.extensionService
 
 object FirDiagnosticsCollector {
-    fun create(session: FirSession, checkExtended: Boolean = false): AbstractDiagnosticCollector {
+    fun create(session: FirSession): AbstractDiagnosticCollector {
         session.registerAdditionalCheckers()
         val collector = SimpleDiagnosticsCollector(session)
-        collector.registerAllComponents(checkExtended)
+        collector.registerAllComponents()
         return collector
     }
 

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

@@ -13,8 +13,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.declarations.*
 
 class DeclarationCheckersDiagnosticComponent(
-    collector: AbstractDiagnosticCollector,
-    private val checkExtended: Boolean
+    collector: AbstractDiagnosticCollector
 ) : AbstractDiagnosticCollectorComponent(collector) {
     private val checkers = session.checkersComponent.declarationCheckers
 
@@ -72,9 +71,7 @@ class DeclarationCheckersDiagnosticComponent(
         reporter: DiagnosticReporter
     ) {
         for (checker in this) {
-            if (!checker.isExtended || checkExtended) {
-                checker.check(declaration, context, reporter)
-            }
+            checker.check(declaration, context, reporter)
         }
     }
 }

compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractExtendedFirDiagnosticsTest.kt

@@ -5,6 +5,11 @@
 
 package org.jetbrains.kotlin.fir
 
+import org.jetbrains.kotlin.fir.analysis.checkers.declaration.ExtendedDeclarationCheckers
+import org.jetbrains.kotlin.fir.analysis.checkersComponent
+
 abstract class AbstractExtendedFirDiagnosticsTest : AbstractFirDiagnosticsTest() {
-    override fun useExtendedCheckersIfNeeded(): Boolean = true
+    override fun configureSession(session: FirSession) {
+        session.checkersComponent.register(ExtendedDeclarationCheckers)
+    }
 }

compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticTest.kt

@@ -276,7 +276,7 @@ abstract class AbstractFirDiagnosticsTest : AbstractFirBaseDiagnosticsTest() {
     }
 
     private fun createCollector(session: FirSession): AbstractDiagnosticCollector {
-        return FirDiagnosticsCollector.create(session, useExtendedCheckersIfNeeded())
+        return FirDiagnosticsCollector.create(session)
     }
 
     private fun checkCfgDump(testDataFile: File, firFiles: List<FirFile>) {
@@ -360,5 +360,4 @@ abstract class AbstractFirDiagnosticsTest : AbstractFirBaseDiagnosticsTest() {
 
     }
 
-    internal open fun useExtendedCheckersIfNeeded() = false
 }