Simplify RedundantVisibilityModifierChecker

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

@@ -16,33 +16,31 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
+import org.jetbrains.kotlin.fir.analysis.diagnostics.overrideModifier
+import org.jetbrains.kotlin.fir.analysis.diagnostics.visibilityModifier
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
-import org.jetbrains.kotlin.lexer.KtTokens
 
 object RedundantVisibilityModifierChecker : FirBasicDeclarationChecker() {
     override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
-        if (declaration is FirConstructor && declaration.source?.kind is FirFakeSourceElementKind) return
+        val source = declaration.source ?: return
-        if (declaration.source is FirFakeSourceElement<*>) return
+        if (declaration is FirConstructor && source.kind is FirFakeSourceElementKind) return
+        if (source is FirFakeSourceElement<*>) return
         if (
             declaration !is FirMemberDeclaration
             && !(declaration is FirPropertyAccessor && declaration.visibility == context.containingPropertyVisibility)
         ) return
 
-        val modifiers = declaration.source.getModifierList()
+        val visibilityModifier = source.treeStructure.visibilityModifier(source.lighterASTNode)
-        val visibilityModifier = when (modifiers) {
+        val explicitVisibility = (visibilityModifier?.tokenType as? KtModifierKeywordToken)?.toVisibilityOrNull()
-            is FirPsiModifierList -> modifiers.modifierList.getVisibility()
-            is FirLightModifierList -> modifiers.modifiers.visibilityOrNull()
-            else -> null
-        } ?: return
         val implicitVisibility = declaration.implicitVisibility(context)
         val containingMemberDeclaration = context.findClosest<FirMemberDeclaration>()
 
         val redundantVisibility = when {
-            visibilityModifier == implicitVisibility -> implicitVisibility
+            explicitVisibility == implicitVisibility -> implicitVisibility
-            modifiers?.modifiers.hasModifier(KtTokens.INTERNAL_KEYWORD) &&
+            explicitVisibility == Visibilities.Internal &&
                     containingMemberDeclaration.let { decl ->
-                        decl != null && (decl.isLocalMember || modifiers?.modifiers.hasModifier(KtTokens.PRIVATE_KEYWORD))
+                        decl != null && decl.isLocalMember
                     } -> Visibilities.Internal
             else -> return
         }
@@ -50,12 +48,12 @@ object RedundantVisibilityModifierChecker : FirBasicDeclarationChecker() {
         if (
             redundantVisibility == Visibilities.Public
             && declaration is FirProperty
-            && modifiers?.modifiers.hasModifier(KtTokens.OVERRIDE_KEYWORD)
+            && source.treeStructure.overrideModifier(source.lighterASTNode) != null
             && declaration.isVar
             && declaration.setter?.visibility == Visibilities.Public
         ) return
 
-        reporter.report(declaration.source, FirErrors.REDUNDANT_VISIBILITY_MODIFIER)
+        reporter.report(source, FirErrors.REDUNDANT_VISIBILITY_MODIFIER)
     }
 
     private fun FirDeclaration.implicitVisibility(context: CheckerContext): Visibility {
@@ -125,10 +123,4 @@ object RedundantVisibilityModifierChecker : FirBasicDeclarationChecker() {
 
     private val CheckerContext.containingPropertyVisibility
         get() = (this.containingDeclarations.last() as? FirProperty)?.visibility
-
-    private fun List<FirLightModifier>.visibilityOrNull() =
-        firstOrNull { it.token.toVisibilityOrNull() != null }?.token?.toVisibilityOrNull()
-
-    private fun List<FirModifier<*>>?.hasModifier(token: KtModifierKeywordToken) = this != null && any { it.token == token }
-
 }