Move FirModifierList inside FirModifierChecker to reduce its scope

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

@@ -1,77 +0,0 @@
-/*
- * 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
-
-import com.intellij.lang.ASTNode
-import com.intellij.lang.LighterASTNode
-import com.intellij.psi.PsiElement
-import com.intellij.psi.tree.TokenSet
-import com.intellij.util.diff.FlyweightCapableTreeStructure
-import org.jetbrains.kotlin.KtNodeTypes
-import org.jetbrains.kotlin.fir.*
-import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
-import org.jetbrains.kotlin.lexer.KtTokens
-import org.jetbrains.kotlin.psi.KtModifierList
-import org.jetbrains.kotlin.psi.KtModifierListOwner
-
-sealed class FirModifierList {
-    abstract val modifiers: List<FirModifier<*>>
-}
-
-fun FirSourceElement?.getModifierList(): FirModifierList? {
-    return when (this) {
-        null -> null
-        is FirPsiSourceElement<*> -> (psi as? KtModifierListOwner)?.modifierList?.let { FirPsiModifierList(it) }
-        is FirLightSourceElement -> {
-            val modifierListNode = lighterASTNode.getChildren(treeStructure).find { it?.tokenType == KtNodeTypes.MODIFIER_LIST }
-                ?: return null
-            FirLightModifierList(modifierListNode, treeStructure)
-        }
-    }
-}
-
-private val MODIFIER_KEYWORD_SET = TokenSet.orSet(KtTokens.SOFT_KEYWORDS, TokenSet.create(KtTokens.IN_KEYWORD, KtTokens.FUN_KEYWORD))
-
-class FirPsiModifierList(val modifierList: KtModifierList) : FirModifierList() {
-    override val modifiers: List<FirPsiModifier>
-        get() = modifierList.node.getChildren(MODIFIER_KEYWORD_SET).map { node ->
-            FirPsiModifier(node, node.elementType as KtModifierKeywordToken)
-        }
-
-}
-
-class FirLightModifierList(val modifierList: LighterASTNode, val tree: FlyweightCapableTreeStructure<LighterASTNode>) : FirModifierList() {
-    override val modifiers: List<FirLightModifier>
-        get() {
-            val modifierNodes = modifierList.getChildren(tree)
-            return modifierNodes.filterNotNull()
-                .filter { it.tokenType is KtModifierKeywordToken }
-                .map { FirLightModifier(it, it.tokenType as KtModifierKeywordToken, tree) }
-        }
-}
-
-sealed class FirModifier<Node : Any>(val node: Node, val token: KtModifierKeywordToken)
-
-class FirPsiModifier(
-    node: ASTNode,
-    token: KtModifierKeywordToken
-) : FirModifier<ASTNode>(node, token)
-
-class FirLightModifier(
-    node: LighterASTNode,
-    token: KtModifierKeywordToken,
-    val tree: FlyweightCapableTreeStructure<LighterASTNode>
-) : FirModifier<LighterASTNode>(node, token)
-
-val FirModifier<*>.psi: PsiElement? get() = (this as? FirPsiModifier)?.node?.psi
-
-val FirModifier<*>.lightNode: LighterASTNode? get() = (this as? FirLightModifier)?.node
-
-val FirModifier<*>.source: FirSourceElement?
-    get() = when (this) {
-        is FirPsiModifier -> psi?.toFirPsiSourceElement()
-        is FirLightModifier -> node.toFirLightSourceElement(tree)
-    }

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

@@ -5,19 +5,22 @@
 
 package org.jetbrains.kotlin.fir.analysis.checkers.declaration
 
+import com.intellij.lang.ASTNode
+import com.intellij.lang.LighterASTNode
+import com.intellij.psi.tree.TokenSet
+import com.intellij.util.diff.FlyweightCapableTreeStructure
 import org.jetbrains.kotlin.KtNodeTypes
-import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.*
-import org.jetbrains.kotlin.fir.analysis.checkers.FirModifier
+import org.jetbrains.kotlin.fir.analysis.checkers.*
-import org.jetbrains.kotlin.fir.analysis.checkers.FirModifierList
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
-import org.jetbrains.kotlin.fir.analysis.checkers.getModifierList
-import org.jetbrains.kotlin.fir.analysis.checkers.source
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 import org.jetbrains.kotlin.lexer.KtTokens.*
+import org.jetbrains.kotlin.psi.KtModifierList
+import org.jetbrains.kotlin.psi.KtModifierListOwner
 
 object FirModifierChecker : FirBasicDeclarationChecker() {
 
@@ -112,7 +115,8 @@ object FirModifierChecker : FirBasicDeclarationChecker() {
         val firstToken = firstModifier.token
         val secondToken = secondModifier.token
         when (val compatibilityType = deduceCompatibilityType(firstToken, secondToken)) {
-            CompatibilityType.COMPATIBLE -> {}
+            CompatibilityType.COMPATIBLE -> {
+            }
             CompatibilityType.REPEATED ->
                 if (reportedNodes.add(secondModifier)) reporter.reportRepeatedModifier(secondModifier, secondToken)
             CompatibilityType.REDUNDANT_2_TO_1 ->
@@ -170,35 +174,94 @@ object FirModifierChecker : FirBasicDeclarationChecker() {
         if (!isDeclarationMappedToSourceCorrectly(declaration, source)) return
         if (context.containingDeclarations.last() is FirDefaultPropertyAccessor) return
 
-        val modifierList = source.getModifierList()
+        val modifierList = with(FirModifierList) { source.getModifierList() }
         modifierList?.let { checkModifiers(it, declaration, reporter) }
     }
 
     private fun DiagnosticReporter.reportRepeatedModifier(
         modifier: FirModifier<*>, keyword: KtModifierKeywordToken
     ) {
-        val source = modifier.source
+        report(FirErrors.REPEATED_MODIFIER.on(modifier.source, keyword))
-        source?.let { report(FirErrors.REPEATED_MODIFIER.on(it, keyword)) }
     }
 
     private fun DiagnosticReporter.reportRedundantModifier(
         modifier: FirModifier<*>, firstKeyword: KtModifierKeywordToken, secondKeyword: KtModifierKeywordToken
     ) {
-        val source = modifier.source
+        report(FirErrors.REDUNDANT_MODIFIER.on(modifier.source, firstKeyword, secondKeyword))
-        source?.let { report(FirErrors.REDUNDANT_MODIFIER.on(it, firstKeyword, secondKeyword)) }
     }
 
     private fun DiagnosticReporter.reportDeprecatedModifierPair(
         modifier: FirModifier<*>, firstKeyword: KtModifierKeywordToken, secondKeyword: KtModifierKeywordToken
     ) {
-        val source = modifier.source
+        report(FirErrors.DEPRECATED_MODIFIER_PAIR.on(modifier.source, firstKeyword, secondKeyword))
-        source?.let { report(FirErrors.DEPRECATED_MODIFIER_PAIR.on(it, firstKeyword, secondKeyword)) }
     }
 
     private fun DiagnosticReporter.reportIncompatibleModifiers(
         modifier: FirModifier<*>, firstKeyword: KtModifierKeywordToken, secondKeyword: KtModifierKeywordToken
     ) {
-        val source = modifier.source
+        report(FirErrors.INCOMPATIBLE_MODIFIERS.on(modifier.source, firstKeyword, secondKeyword))
-        source?.let { report(FirErrors.INCOMPATIBLE_MODIFIERS.on(it, firstKeyword, secondKeyword)) }
+    }
+
+    private sealed class FirModifierList {
+        abstract val modifiers: List<FirModifier<*>>
+
+        class FirPsiModifierList(val modifierList: KtModifierList) : FirModifierList() {
+            override val modifiers: List<FirModifier.FirPsiModifier>
+                get() = modifierList.node.getChildren(MODIFIER_KEYWORD_SET).map { node ->
+                    FirModifier.FirPsiModifier(node, node.elementType as KtModifierKeywordToken)
+                }
+
+        }
+
+        class FirLightModifierList(
+            val modifierList: LighterASTNode,
+            val tree: FlyweightCapableTreeStructure<LighterASTNode>
+        ) : FirModifierList() {
+            override val modifiers: List<FirModifier.FirLightModifier>
+                get() {
+                    val modifierNodes = modifierList.getChildren(tree)
+                    return modifierNodes.filterNotNull()
+                        .filter { it.tokenType is KtModifierKeywordToken }
+                        .map { FirModifier.FirLightModifier(it, it.tokenType as KtModifierKeywordToken, tree) }
+                }
+        }
+
+        companion object {
+            fun FirSourceElement?.getModifierList(): FirModifierList? {
+                return when (this) {
+                    null -> null
+                    is FirPsiSourceElement<*> -> (psi as? KtModifierListOwner)?.modifierList?.let { FirPsiModifierList(it) }
+                    is FirLightSourceElement -> {
+                        val modifierListNode = lighterASTNode.getChildren(treeStructure).find { it?.tokenType == KtNodeTypes.MODIFIER_LIST }
+                            ?: return null
+                        FirLightModifierList(modifierListNode, treeStructure)
+                    }
+                }
+            }
+        }
+    }
+
+    private val MODIFIER_KEYWORD_SET = TokenSet.orSet(SOFT_KEYWORDS, TokenSet.create(IN_KEYWORD, FUN_KEYWORD))
+
+    sealed class FirModifier<Node : Any>(val node: Node, val token: KtModifierKeywordToken) {
+
+        class FirPsiModifier(
+            node: ASTNode,
+            token: KtModifierKeywordToken
+        ) : FirModifier<ASTNode>(node, token) {
+            override val source: FirSourceElement
+                get() = node.psi.toFirPsiSourceElement()
+        }
+
+        class FirLightModifier(
+            node: LighterASTNode,
+            token: KtModifierKeywordToken,
+            val tree: FlyweightCapableTreeStructure<LighterASTNode>
+        ) : FirModifier<LighterASTNode>(node, token) {
+            override val source: FirSourceElement
+                get() = node.toFirLightSourceElement(tree)
+        }
+
+        abstract val source: FirSourceElement
     }
 }