From 68d271fc91fccf8d9929c506636a644071eda27d Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Wed, 2 Dec 2020 12:14:51 +0300 Subject: [PATCH] Move FirModifierList inside FirModifierChecker to reduce its scope --- .../fir/analysis/checkers/FirModifierList.kt | 77 --------------- .../declaration/FirModifierChecker.kt | 93 ++++++++++++++++--- 2 files changed, 78 insertions(+), 92 deletions(-) delete mode 100644 compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirModifierList.kt diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirModifierList.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirModifierList.kt deleted file mode 100644 index 750b2aaa930..00000000000 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirModifierList.kt +++ /dev/null @@ -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> -} - -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 - get() = modifierList.node.getChildren(MODIFIER_KEYWORD_SET).map { node -> - FirPsiModifier(node, node.elementType as KtModifierKeywordToken) - } - -} - -class FirLightModifierList(val modifierList: LighterASTNode, val tree: FlyweightCapableTreeStructure) : FirModifierList() { - override val modifiers: List - 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(val node: Node, val token: KtModifierKeywordToken) - -class FirPsiModifier( - node: ASTNode, - token: KtModifierKeywordToken -) : FirModifier(node, token) - -class FirLightModifier( - node: LighterASTNode, - token: KtModifierKeywordToken, - val tree: FlyweightCapableTreeStructure -) : FirModifier(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) - } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirModifierChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirModifierChecker.kt index a2ef26e346c..1f0920854e2 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirModifierChecker.kt +++ b/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.analysis.checkers.FirModifier -import org.jetbrains.kotlin.fir.analysis.checkers.FirModifierList +import org.jetbrains.kotlin.fir.* +import org.jetbrains.kotlin.fir.analysis.checkers.* 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 - source?.let { report(FirErrors.REPEATED_MODIFIER.on(it, keyword)) } + report(FirErrors.REPEATED_MODIFIER.on(modifier.source, keyword)) } private fun DiagnosticReporter.reportRedundantModifier( modifier: FirModifier<*>, firstKeyword: KtModifierKeywordToken, secondKeyword: KtModifierKeywordToken ) { - val source = modifier.source - source?.let { report(FirErrors.REDUNDANT_MODIFIER.on(it, firstKeyword, secondKeyword)) } + report(FirErrors.REDUNDANT_MODIFIER.on(modifier.source, firstKeyword, secondKeyword)) } private fun DiagnosticReporter.reportDeprecatedModifierPair( modifier: FirModifier<*>, firstKeyword: KtModifierKeywordToken, secondKeyword: KtModifierKeywordToken ) { - val source = modifier.source - source?.let { report(FirErrors.DEPRECATED_MODIFIER_PAIR.on(it, firstKeyword, secondKeyword)) } + report(FirErrors.DEPRECATED_MODIFIER_PAIR.on(modifier.source, firstKeyword, secondKeyword)) } private fun DiagnosticReporter.reportIncompatibleModifiers( modifier: FirModifier<*>, firstKeyword: KtModifierKeywordToken, secondKeyword: KtModifierKeywordToken ) { - val source = modifier.source - source?.let { report(FirErrors.INCOMPATIBLE_MODIFIERS.on(it, firstKeyword, secondKeyword)) } + report(FirErrors.INCOMPATIBLE_MODIFIERS.on(modifier.source, firstKeyword, secondKeyword)) + } + + private sealed class FirModifierList { + abstract val modifiers: List> + + class FirPsiModifierList(val modifierList: KtModifierList) : FirModifierList() { + override val modifiers: List + get() = modifierList.node.getChildren(MODIFIER_KEYWORD_SET).map { node -> + FirModifier.FirPsiModifier(node, node.elementType as KtModifierKeywordToken) + } + + } + + class FirLightModifierList( + val modifierList: LighterASTNode, + val tree: FlyweightCapableTreeStructure + ) : FirModifierList() { + override val modifiers: List + 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(val node: Node, val token: KtModifierKeywordToken) { + + class FirPsiModifier( + node: ASTNode, + token: KtModifierKeywordToken + ) : FirModifier(node, token) { + override val source: FirSourceElement + get() = node.psi.toFirPsiSourceElement() + } + + class FirLightModifier( + node: LighterASTNode, + token: KtModifierKeywordToken, + val tree: FlyweightCapableTreeStructure + ) : FirModifier(node, token) { + override val source: FirSourceElement + get() = node.toFirLightSourceElement(tree) + } + + abstract val source: FirSourceElement } }