diff --git a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/CheckersConfiguration.kt b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/CheckersConfiguration.kt new file mode 100644 index 00000000000..632b92fafda --- /dev/null +++ b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/CheckersConfiguration.kt @@ -0,0 +1,60 @@ +/* + * 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.checkers.generator + +import kotlin.reflect.KClass +import kotlin.reflect.full.superclasses + +class CheckersConfiguration( + val aliases: Map, String>, + val additionalCheckers: MutableMap +) { + val parentsMap: Map, List>> + + init { + val parents: MutableMap, List>> = mutableMapOf() + for (firKClass in aliases.keys) { + val directParents = mutableListOf>() + bfs( + firKClass, + childrenExtractor = { it.superclasses } + ) { + if (it in aliases) { + directParents += it + false + } else { + true + } + } + parents[firKClass] = directParents + } + parentsMap = parents + } +} + +private fun bfs(start: T, childrenExtractor: (T) -> Collection, process: (T) -> Boolean) { + val queue = ArrayDeque() + val visited = mutableSetOf() + val levels = mutableMapOf(start to 0) + queue.addLast(start) + var levelToStop: Int? = null + while (queue.isNotEmpty()) { + val element = queue.removeFirst() + if (!visited.add(element)) continue + val level = levels.getValue(element) + if (levelToStop != null && level > levelToStop) continue + val shouldContinue = if (level > 0) process(element) else true + if (shouldContinue) { + val children = childrenExtractor(element) + for (child in children) { + levels[child] = level + 1 + queue.addLast(child) + } + } else { + levelToStop = level + } + } +} diff --git a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/CheckersConfigurator.kt b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/CheckersConfigurator.kt new file mode 100644 index 00000000000..17f93dec424 --- /dev/null +++ b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/CheckersConfigurator.kt @@ -0,0 +1,42 @@ +/* + * 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.checkers.generator + +import org.jetbrains.kotlin.fir.FirElement +import java.io.File +import kotlin.reflect.KClass + +class CheckersConfigurator { + private val registeredAliases: MutableMap, String> = LinkedHashMap() + private val additionalCheckers: MutableMap = LinkedHashMap() + + inline fun alias(name: String) { + alias(T::class, name) + } + + fun alias(kClass: KClass, name: String) { + val realName = name.takeIf { it.startsWith("Fir") } ?: "Fir$name" + registeredAliases[kClass] = realName + } + + fun additional(fieldName: String, classFqn: String) { + additionalCheckers[fieldName] = classFqn + } + + fun build(): CheckersConfiguration { + return CheckersConfiguration(registeredAliases, additionalCheckers) + } +} + +fun generateCheckersComponents( + generationPath: File, + packageName: String, + abstractCheckerName: String, + init: CheckersConfigurator.() -> Unit +) { + val configuration = CheckersConfigurator().apply(init).build() + Generator(configuration, generationPath, packageName, abstractCheckerName).generate() +} diff --git a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Generator.kt b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Generator.kt new file mode 100644 index 00000000000..eb6e99dce5b --- /dev/null +++ b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Generator.kt @@ -0,0 +1,186 @@ +/* + * 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.checkers.generator + +import org.jetbrains.kotlin.fir.tree.generator.printer.* +import java.io.File + +private typealias Alias = String +private typealias Fqn = String + +private const val CHECKERS_COMPONENT_INTERNAL_ANNOTATION = "@CheckersComponentInternal" +private const val CHECKERS_COMPONENT_INTERNAL_FQN = "org.jetbrains.kotlin.fir.analysis.CheckersComponentInternal" + +class Generator( + private val configuration: CheckersConfiguration, + generationPath: File, + private val packageName: String, + private val abstractCheckerName: String +) { + private val generationPath: File + + init { + var path = generationPath + packageName.split(".").forEach { + path = path.resolve(it) + } + path.mkdirs() + this.generationPath = path + } + + private fun generateAliases() { + val filename = "${abstractCheckerName}Aliases.kt" + generationPath.resolve(filename).useSmartPrinter { + printPackageAndCopyright() + printGeneratedMessage() + configuration.aliases.keys + .mapNotNull { it.qualifiedName } + .sorted() + .forEach { println("import $it") } + println() + for ((kClass, alias) in configuration.aliases) { + println("typealias $alias = $abstractCheckerName<${kClass.simpleName}>") + } + } + } + + private fun generateAbstractCheckersComponent() { + val filename = "${checkersComponentName}.kt" + generationPath.resolve(filename).useSmartPrinter { + printPackageAndCopyright() + printImports() + printGeneratedMessage() + + println("abstract class $checkersComponentName {") + withIndent { + println("companion object {") + withIndent { + println("val EMPTY: $checkersComponentName = object : $checkersComponentName() {}") + } + println("}") + println() + + for (alias in configuration.aliases.values) { + println("open ${alias.valDeclaration} = emptySet()") + } + println() + + for ((fieldName, classFqn) in configuration.additionalCheckers) { + val fieldClassName = classFqn.simpleName + println("open val $fieldName: ${fieldClassName.setType} = emptySet()") + } + if (configuration.additionalCheckers.isNotEmpty()) { + println() + } + + for ((kClass, alias) in configuration.aliases) { + print("$CHECKERS_COMPONENT_INTERNAL_ANNOTATION internal val ${alias.allFieldName}: ${alias.setType} get() = ${alias.fieldName}") + for (parent in configuration.parentsMap.getValue(kClass)) { + val parentAlias = configuration.aliases.getValue(parent) + print(" + ${parentAlias.allFieldName}") + } + println() + } + } + println("}") + } + } + + private fun generateComposedComponent() { + val composedComponentName = "Composed$checkersComponentName" + val filename = "${composedComponentName}.kt" + generationPath.resolve(filename).useSmartPrinter { + printPackageAndCopyright() + printImports() + printGeneratedMessage() + println("internal class $composedComponentName : $checkersComponentName() {") + withIndent { + // public overrides + for (alias in configuration.aliases.values) { + println("override ${alias.valDeclaration}") + withIndent { + println("get() = _${alias.fieldName}") + } + } + for ((fieldName, classFqn) in configuration.additionalCheckers) { + println("override val $fieldName: ${classFqn.simpleName.setType}") + withIndent { + println("get() = _$fieldName") + } + } + println() + + // private mutable delegates + for (alias in configuration.aliases.values) { + println("private val _${alias.fieldName}: ${alias.mutableSetType} = mutableSetOf()") + } + for ((fieldName, classFqn) in configuration.additionalCheckers) { + println("private val _$fieldName: ${classFqn.simpleName.mutableSetType} = mutableSetOf()") + } + println() + + // register function + println(CHECKERS_COMPONENT_INTERNAL_ANNOTATION) + println("internal fun register(checkers: $checkersComponentName) {") + withIndent { + for (alias in configuration.aliases.values) { + println("_${alias.fieldName} += checkers.${alias.allFieldName}") + } + for (fieldName in configuration.additionalCheckers.keys) { + println("_$fieldName += checkers.$fieldName") + } + } + println("}") + } + println("}") + } + } + + private fun SmartPrinter.printPackageAndCopyright() { + printCopyright() + println("package $packageName") + println() + } + + @OptIn(ExperimentalStdlibApi::class) + private fun SmartPrinter.printImports() { + val imports = buildList { + addAll(configuration.additionalCheckers.values) + add(CHECKERS_COMPONENT_INTERNAL_FQN) + }.sorted() + + for (fqn in imports) { + println("import $fqn") + } + println() + } + + private val Alias.valDeclaration: String + get() = "val $fieldName: $setType" + + private val Alias.fieldName: String + get() = removePrefix("Fir").decapitalize() + "s" + + private val Alias.allFieldName: String + get() = "all${fieldName.capitalize()}" + + private val Alias.setType: String + get() = "Set<$this>" + + private val Alias.mutableSetType: String + get() = "MutableSet<$this>" + + private val Fqn.simpleName: String + get() = this.split(".").last() + + private val checkersComponentName = abstractCheckerName.removePrefix("Fir") + "s" + + fun generate() { + generateAliases() + generateAbstractCheckersComponent() + generateComposedComponent() + } +} diff --git a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Main.kt b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Main.kt index b06f653b124..db5204e59fb 100644 --- a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Main.kt +++ b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Main.kt @@ -5,4 +5,49 @@ package org.jetbrains.kotlin.fir.checkers.generator -fun main() {} +import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.expressions.FirFunctionCall +import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression +import org.jetbrains.kotlin.fir.expressions.FirStatement +import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment +import java.io.File + +fun main(args: Array) { + val generationPath = args.firstOrNull()?.let { File(it) } ?: File("compiler/fir/checkers/gen").absoluteFile + + val expressionPackage = "org.jetbrains.kotlin.fir.analysis.checkers.expression" + generateCheckersComponents(generationPath, expressionPackage, "FirExpressionChecker") { + alias("BasicExpressionChecker") + alias("QualifiedAccessChecker") + alias("FunctionCallChecker") + alias("VariableAssignmentChecker") + } + + val declarationPackage = "org.jetbrains.kotlin.fir.analysis.checkers.declaration" + generateCheckersComponents(generationPath, declarationPackage, "FirDeclarationChecker") { + alias("BasicDeclarationChecker") + alias("MemberDeclarationChecker") + alias("RegularClassChecker") + alias("ConstructorChecker") + alias("FileChecker") + + additional( + fieldName = "controlFlowAnalyserCheckers", + classFqn = "org.jetbrains.kotlin.fir.analysis.checkers.cfa.FirControlFlowChecker" + ) + + additional( + fieldName = "variableAssignmentCfaBasedCheckers", + classFqn = "org.jetbrains.kotlin.fir.analysis.cfa.AbstractFirPropertyInitializationChecker" + ) + } +} + +/* + * Stages: + * 1. associate aliases with fir statements + * 2. build inheritance hierarchy for all mentioned fir elements + * 3. generate aliases + * 4. generate abstract "DeclarationCheckers" + * 5. generate "ComposedDeclarationCheckers" with OptIn annotation + */ diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/ComposedDeclarationCheckers.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/ComposedDeclarationCheckers.kt new file mode 100644 index 00000000000..9e73df75a4c --- /dev/null +++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/ComposedDeclarationCheckers.kt @@ -0,0 +1,51 @@ +/* + * 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.CheckersComponentInternal +import org.jetbrains.kotlin.fir.analysis.cfa.AbstractFirPropertyInitializationChecker +import org.jetbrains.kotlin.fir.analysis.checkers.cfa.FirControlFlowChecker + +/* + * This file was generated automatically + * DO NOT MODIFY IT MANUALLY + */ + +internal class ComposedDeclarationCheckers : DeclarationCheckers() { + override val basicDeclarationCheckers: Set + get() = _basicDeclarationCheckers + override val memberDeclarationCheckers: Set + get() = _memberDeclarationCheckers + override val regularClassCheckers: Set + get() = _regularClassCheckers + override val constructorCheckers: Set + get() = _constructorCheckers + override val fileCheckers: Set + get() = _fileCheckers + override val controlFlowAnalyserCheckers: Set + get() = _controlFlowAnalyserCheckers + override val variableAssignmentCfaBasedCheckers: Set + get() = _variableAssignmentCfaBasedCheckers + + private val _basicDeclarationCheckers: MutableSet = mutableSetOf() + private val _memberDeclarationCheckers: MutableSet = mutableSetOf() + private val _regularClassCheckers: MutableSet = mutableSetOf() + private val _constructorCheckers: MutableSet = mutableSetOf() + private val _fileCheckers: MutableSet = mutableSetOf() + private val _controlFlowAnalyserCheckers: MutableSet = mutableSetOf() + private val _variableAssignmentCfaBasedCheckers: MutableSet = mutableSetOf() + + @CheckersComponentInternal + internal fun register(checkers: DeclarationCheckers) { + _basicDeclarationCheckers += checkers.allBasicDeclarationCheckers + _memberDeclarationCheckers += checkers.allMemberDeclarationCheckers + _regularClassCheckers += checkers.allRegularClassCheckers + _constructorCheckers += checkers.allConstructorCheckers + _fileCheckers += checkers.allFileCheckers + _controlFlowAnalyserCheckers += checkers.controlFlowAnalyserCheckers + _variableAssignmentCfaBasedCheckers += checkers.variableAssignmentCfaBasedCheckers + } +} diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/DeclarationCheckers.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/DeclarationCheckers.kt new file mode 100644 index 00000000000..34805ab172c --- /dev/null +++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/DeclarationCheckers.kt @@ -0,0 +1,36 @@ +/* + * 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.CheckersComponentInternal +import org.jetbrains.kotlin.fir.analysis.cfa.AbstractFirPropertyInitializationChecker +import org.jetbrains.kotlin.fir.analysis.checkers.cfa.FirControlFlowChecker + +/* + * This file was generated automatically + * DO NOT MODIFY IT MANUALLY + */ + +abstract class DeclarationCheckers { + companion object { + val EMPTY: DeclarationCheckers = object : DeclarationCheckers() {} + } + + open val basicDeclarationCheckers: Set = emptySet() + open val memberDeclarationCheckers: Set = emptySet() + open val regularClassCheckers: Set = emptySet() + open val constructorCheckers: Set = emptySet() + open val fileCheckers: Set = emptySet() + + open val controlFlowAnalyserCheckers: Set = emptySet() + open val variableAssignmentCfaBasedCheckers: Set = emptySet() + + @CheckersComponentInternal internal val allBasicDeclarationCheckers: Set get() = basicDeclarationCheckers + @CheckersComponentInternal internal val allMemberDeclarationCheckers: Set get() = memberDeclarationCheckers + allBasicDeclarationCheckers + @CheckersComponentInternal internal val allRegularClassCheckers: Set get() = regularClassCheckers + allMemberDeclarationCheckers + @CheckersComponentInternal internal val allConstructorCheckers: Set get() = constructorCheckers + allMemberDeclarationCheckers + @CheckersComponentInternal internal val allFileCheckers: Set get() = fileCheckers + allBasicDeclarationCheckers +} diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationCheckerAliases.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationCheckerAliases.kt new file mode 100644 index 00000000000..72d3a5cf709 --- /dev/null +++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationCheckerAliases.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 + +/* + * This file was generated automatically + * DO NOT MODIFY IT MANUALLY + */ + +import org.jetbrains.kotlin.fir.declarations.FirConstructor +import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration +import org.jetbrains.kotlin.fir.declarations.FirRegularClass + +typealias FirBasicDeclarationChecker = FirDeclarationChecker +typealias FirMemberDeclarationChecker = FirDeclarationChecker +typealias FirRegularClassChecker = FirDeclarationChecker +typealias FirConstructorChecker = FirDeclarationChecker +typealias FirFileChecker = FirDeclarationChecker diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ComposedExpressionCheckers.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ComposedExpressionCheckers.kt new file mode 100644 index 00000000000..216ad71593b --- /dev/null +++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ComposedExpressionCheckers.kt @@ -0,0 +1,37 @@ +/* + * 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.expression + +import org.jetbrains.kotlin.fir.analysis.CheckersComponentInternal + +/* + * This file was generated automatically + * DO NOT MODIFY IT MANUALLY + */ + +internal class ComposedExpressionCheckers : ExpressionCheckers() { + override val basicExpressionCheckers: Set + get() = _basicExpressionCheckers + override val qualifiedAccessCheckers: Set + get() = _qualifiedAccessCheckers + override val functionCallCheckers: Set + get() = _functionCallCheckers + override val variableAssignmentCheckers: Set + get() = _variableAssignmentCheckers + + private val _basicExpressionCheckers: MutableSet = mutableSetOf() + private val _qualifiedAccessCheckers: MutableSet = mutableSetOf() + private val _functionCallCheckers: MutableSet = mutableSetOf() + private val _variableAssignmentCheckers: MutableSet = mutableSetOf() + + @CheckersComponentInternal + internal fun register(checkers: ExpressionCheckers) { + _basicExpressionCheckers += checkers.allBasicExpressionCheckers + _qualifiedAccessCheckers += checkers.allQualifiedAccessCheckers + _functionCallCheckers += checkers.allFunctionCallCheckers + _variableAssignmentCheckers += checkers.allVariableAssignmentCheckers + } +} diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ExpressionCheckers.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ExpressionCheckers.kt new file mode 100644 index 00000000000..4b4d617e0b8 --- /dev/null +++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ExpressionCheckers.kt @@ -0,0 +1,29 @@ +/* + * 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.expression + +import org.jetbrains.kotlin.fir.analysis.CheckersComponentInternal + +/* + * This file was generated automatically + * DO NOT MODIFY IT MANUALLY + */ + +abstract class ExpressionCheckers { + companion object { + val EMPTY: ExpressionCheckers = object : ExpressionCheckers() {} + } + + open val basicExpressionCheckers: Set = emptySet() + open val qualifiedAccessCheckers: Set = emptySet() + open val functionCallCheckers: Set = emptySet() + open val variableAssignmentCheckers: Set = emptySet() + + @CheckersComponentInternal internal val allBasicExpressionCheckers: Set get() = basicExpressionCheckers + @CheckersComponentInternal internal val allQualifiedAccessCheckers: Set get() = qualifiedAccessCheckers + allBasicExpressionCheckers + @CheckersComponentInternal internal val allFunctionCallCheckers: Set get() = functionCallCheckers + allQualifiedAccessCheckers + @CheckersComponentInternal internal val allVariableAssignmentCheckers: Set get() = variableAssignmentCheckers + allBasicExpressionCheckers +} diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirExpressionCheckerAliases.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirExpressionCheckerAliases.kt new file mode 100644 index 00000000000..90798945283 --- /dev/null +++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirExpressionCheckerAliases.kt @@ -0,0 +1,21 @@ +/* + * 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.expression + +/* + * This file was generated automatically + * DO NOT MODIFY IT MANUALLY + */ + +import org.jetbrains.kotlin.fir.expressions.FirFunctionCall +import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression +import org.jetbrains.kotlin.fir.expressions.FirStatement +import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment + +typealias FirBasicExpressionChecker = FirExpressionChecker +typealias FirQualifiedAccessChecker = FirExpressionChecker +typealias FirFunctionCallChecker = FirExpressionChecker +typealias FirVariableAssignmentChecker = FirExpressionChecker diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/CheckersComponent.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/CheckersComponent.kt index 4280f8ed3f9..f72c9740ed0 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/CheckersComponent.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/CheckersComponent.kt @@ -8,12 +8,13 @@ package org.jetbrains.kotlin.fir.analysis import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSessionComponent import org.jetbrains.kotlin.fir.SessionConfiguration -import org.jetbrains.kotlin.fir.analysis.cfa.AbstractFirPropertyInitializationChecker -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.* import org.jetbrains.kotlin.fir.analysis.extensions.FirAdditionalCheckersExtension +@RequiresOptIn +annotation class CheckersComponentInternal + class CheckersComponent : FirSessionComponent { val declarationCheckers: DeclarationCheckers get() = _declarationCheckers private val _declarationCheckers = ComposedDeclarationCheckers() @@ -22,11 +23,13 @@ class CheckersComponent : FirSessionComponent { private val _expressionCheckers = ComposedExpressionCheckers() @SessionConfiguration + @OptIn(CheckersComponentInternal::class) fun register(checkers: DeclarationCheckers) { _declarationCheckers.register(checkers) } @SessionConfiguration + @OptIn(CheckersComponentInternal::class) fun register(checkers: ExpressionCheckers) { _expressionCheckers.register(checkers) } @@ -39,61 +42,3 @@ class CheckersComponent : FirSessionComponent { } val FirSession.checkersComponent: CheckersComponent by FirSession.sessionComponentAccessor() - -private class ComposedDeclarationCheckers : DeclarationCheckers() { - override val fileCheckers: List - get() = _fileCheckers - override val declarationCheckers: List - get() = _declarationCheckers - override val memberDeclarationCheckers: List - get() = _memberDeclarationCheckers - override val regularClassCheckers: List - get() = _regularClassCheckers - override val constructorCheckers: List - get() = _constructorCheckers - override val controlFlowAnalyserCheckers: List - get() = _controlFlowAnalyserCheckers - override val variableAssignmentCfaBasedCheckers: List - get() = _variableAssignmentCfaBasedCheckers - - private val _fileCheckers: MutableList = mutableListOf() - private val _declarationCheckers: MutableList = mutableListOf() - private val _memberDeclarationCheckers: MutableList = mutableListOf() - private val _regularClassCheckers: MutableList = mutableListOf() - private val _constructorCheckers: MutableList = mutableListOf() - private val _controlFlowAnalyserCheckers: MutableList = mutableListOf() - private val _variableAssignmentCfaBasedCheckers: MutableList = mutableListOf() - - fun register(checkers: DeclarationCheckers) { - _fileCheckers += checkers.allFileCheckers - _declarationCheckers += checkers.declarationCheckers - _memberDeclarationCheckers += checkers.allMemberDeclarationCheckers - _regularClassCheckers += checkers.allRegularClassCheckers - _constructorCheckers += checkers.allConstructorCheckers - _controlFlowAnalyserCheckers += checkers.controlFlowAnalyserCheckers - _variableAssignmentCfaBasedCheckers += checkers.variableAssignmentCfaBasedCheckers - } -} - -private class ComposedExpressionCheckers : ExpressionCheckers() { - override val expressionCheckers: List - get() = _expressionCheckers - override val qualifiedAccessCheckers: List - get() = _qualifiedAccessCheckers - override val functionCallCheckers: List - get() = _functionCallCheckers - override val variableAssignmentCheckers: List - get() = _variableAssignmentCheckers - - private val _expressionCheckers: MutableList = mutableListOf() - private val _qualifiedAccessCheckers: MutableList = mutableListOf() - private val _functionCallCheckers: MutableList = mutableListOf() - private val _variableAssignmentCheckers: MutableList = mutableListOf() - - fun register(checkers: ExpressionCheckers) { - _expressionCheckers += checkers.allExpressionCheckers - _qualifiedAccessCheckers += checkers.allQualifiedAccessCheckers - _functionCallCheckers += checkers.allFunctionCallCheckers - _variableAssignmentCheckers += checkers.variableAssignmentCheckers - } -} diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/DeclarationCheckers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/DeclarationCheckers.kt deleted file mode 100644 index 09ebff60267..00000000000 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/DeclarationCheckers.kt +++ /dev/null @@ -1,28 +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.declaration - -import org.jetbrains.kotlin.fir.analysis.cfa.AbstractFirPropertyInitializationChecker -import org.jetbrains.kotlin.fir.analysis.checkers.cfa.FirControlFlowChecker - -abstract class DeclarationCheckers { - companion object { - val EMPTY: DeclarationCheckers = object : DeclarationCheckers() {} - } - - open val fileCheckers: List = emptyList() - open val declarationCheckers: List = emptyList() - open val memberDeclarationCheckers: List = emptyList() - open val regularClassCheckers: List = emptyList() - open val constructorCheckers: List = emptyList() - open val controlFlowAnalyserCheckers: List = emptyList() - open val variableAssignmentCfaBasedCheckers: List = emptyList() - - internal val allFileCheckers: List get() = fileCheckers + declarationCheckers - internal val allMemberDeclarationCheckers: List get() = memberDeclarationCheckers + declarationCheckers - internal val allRegularClassCheckers: List get() = regularClassCheckers + allMemberDeclarationCheckers - internal val allConstructorCheckers: List get() = constructorCheckers + allMemberDeclarationCheckers -} diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationChecker.kt index 662a6926f37..d784af5a5d9 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationChecker.kt @@ -12,9 +12,3 @@ import org.jetbrains.kotlin.fir.declarations.* abstract class FirDeclarationChecker { abstract fun check(declaration: D, context: CheckerContext, reporter: DiagnosticReporter) } - -typealias FirFileChecker = FirDeclarationChecker -typealias FirBasicDeclarationChecker = FirDeclarationChecker -typealias FirMemberDeclarationChecker = FirDeclarationChecker -typealias FirRegularClassChecker = FirDeclarationChecker -typealias FirConstructorChecker = FirDeclarationChecker diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/ExpressionCheckers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/ExpressionCheckers.kt deleted file mode 100644 index 315d4f91e0e..00000000000 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/ExpressionCheckers.kt +++ /dev/null @@ -1,21 +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.expression - -abstract class ExpressionCheckers { - companion object { - val EMPTY: ExpressionCheckers = object : ExpressionCheckers() {} - } - - open val expressionCheckers: List = emptyList() - open val qualifiedAccessCheckers: List = emptyList() - open val functionCallCheckers: List = emptyList() - open val variableAssignmentCheckers: List = emptyList() - - internal val allExpressionCheckers get() = expressionCheckers - internal val allQualifiedAccessCheckers get() = qualifiedAccessCheckers + allExpressionCheckers - internal val allFunctionCallCheckers get() = functionCallCheckers + allQualifiedAccessCheckers -} diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirExpressionChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirExpressionChecker.kt index 5d35ffe1411..243c6ffaa05 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirExpressionChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirExpressionChecker.kt @@ -7,16 +7,8 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter -import org.jetbrains.kotlin.fir.expressions.FirFunctionCall -import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.expressions.FirStatement -import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment abstract class FirExpressionChecker { abstract fun check(expression: E, context: CheckerContext, reporter: DiagnosticReporter) } - -typealias FirBasicExpressionChecker = FirExpressionChecker -typealias FirQualifiedAccessChecker = FirExpressionChecker -typealias FirFunctionCallChecker = FirExpressionChecker -typealias FirVariableAssignmentChecker = FirExpressionChecker diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/DeclarationCheckersDiagnosticComponent.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/DeclarationCheckersDiagnosticComponent.kt index 4fef998b84f..b3b5ac9d4f5 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/DeclarationCheckersDiagnosticComponent.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/DeclarationCheckersDiagnosticComponent.kt @@ -42,34 +42,34 @@ class DeclarationCheckersDiagnosticComponent( } override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: CheckerContext) { - checkers.declarationCheckers.check(anonymousFunction, data, reporter) + checkers.basicDeclarationCheckers.check(anonymousFunction, data, reporter) } override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: CheckerContext) { - checkers.declarationCheckers.check(propertyAccessor, data, reporter) + checkers.basicDeclarationCheckers.check(propertyAccessor, data, reporter) } override fun visitValueParameter(valueParameter: FirValueParameter, data: CheckerContext) { - checkers.declarationCheckers.check(valueParameter, data, reporter) + checkers.basicDeclarationCheckers.check(valueParameter, data, reporter) } override fun visitTypeParameter(typeParameter: FirTypeParameter, data: CheckerContext) { - checkers.declarationCheckers.check(typeParameter, data, reporter) + checkers.basicDeclarationCheckers.check(typeParameter, data, reporter) } override fun visitEnumEntry(enumEntry: FirEnumEntry, data: CheckerContext) { - checkers.declarationCheckers.check(enumEntry, data, reporter) + checkers.basicDeclarationCheckers.check(enumEntry, data, reporter) } override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: CheckerContext) { - checkers.declarationCheckers.check(anonymousObject, data, reporter) + checkers.basicDeclarationCheckers.check(anonymousObject, data, reporter) } override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: CheckerContext) { - checkers.declarationCheckers.check(anonymousInitializer, data, reporter) + checkers.basicDeclarationCheckers.check(anonymousInitializer, data, reporter) } - private fun List>.check( + private fun Collection>.check( declaration: D, context: CheckerContext, reporter: DiagnosticReporter diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ExpressionCheckersDiagnosticComponent.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ExpressionCheckersDiagnosticComponent.kt index 5872857cea4..4931bac1e11 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ExpressionCheckersDiagnosticComponent.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ExpressionCheckersDiagnosticComponent.kt @@ -16,15 +16,15 @@ class ExpressionCheckersDiagnosticComponent(collector: AbstractDiagnosticCollect private val checkers = session.checkersComponent.expressionCheckers override fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: CheckerContext) { - checkers.expressionCheckers.check(typeOperatorCall, data, reporter) + checkers.basicExpressionCheckers.check(typeOperatorCall, data, reporter) } override fun visitConstExpression(constExpression: FirConstExpression, data: CheckerContext) { - checkers.expressionCheckers.check(constExpression, data, reporter) + checkers.basicExpressionCheckers.check(constExpression, data, reporter) } override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: CheckerContext) { - checkers.expressionCheckers.check(annotationCall, data, reporter) + checkers.basicExpressionCheckers.check(annotationCall, data, reporter) } override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: CheckerContext) { @@ -40,54 +40,58 @@ class ExpressionCheckersDiagnosticComponent(collector: AbstractDiagnosticCollect } override fun visitThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression, data: CheckerContext) { - checkers.expressionCheckers.check(thisReceiverExpression, data, reporter) + checkers.basicExpressionCheckers.check(thisReceiverExpression, data, reporter) } override fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: CheckerContext) { - checkers.expressionCheckers.check(resolvedQualifier, data, reporter) + checkers.basicExpressionCheckers.check(resolvedQualifier, data, reporter) } override fun visitWhenExpression(whenExpression: FirWhenExpression, data: CheckerContext) { - checkers.expressionCheckers.check(whenExpression, data, reporter) + checkers.basicExpressionCheckers.check(whenExpression, data, reporter) } override fun visitBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, data: CheckerContext) { - checkers.expressionCheckers.check(binaryLogicExpression, data, reporter) + checkers.basicExpressionCheckers.check(binaryLogicExpression, data, reporter) } override fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: CheckerContext) { - checkers.expressionCheckers.check(arrayOfCall, data, reporter) + checkers.basicExpressionCheckers.check(arrayOfCall, data, reporter) } override fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: CheckerContext) { - checkers.expressionCheckers.check(stringConcatenationCall, data, reporter) + checkers.basicExpressionCheckers.check(stringConcatenationCall, data, reporter) } override fun visitCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, data: CheckerContext) { - checkers.expressionCheckers.check(checkNotNullCall, data, reporter) + checkers.basicExpressionCheckers.check(checkNotNullCall, data, reporter) } override fun visitTryExpression(tryExpression: FirTryExpression, data: CheckerContext) { - checkers.expressionCheckers.check(tryExpression, data, reporter) + checkers.basicExpressionCheckers.check(tryExpression, data, reporter) } override fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: CheckerContext) { - checkers.expressionCheckers.check(classReferenceExpression, data, reporter) + checkers.basicExpressionCheckers.check(classReferenceExpression, data, reporter) } override fun visitGetClassCall(getClassCall: FirGetClassCall, data: CheckerContext) { - checkers.expressionCheckers.check(getClassCall, data, reporter) + checkers.basicExpressionCheckers.check(getClassCall, data, reporter) } override fun visitEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, data: CheckerContext) { - checkers.expressionCheckers.check(equalityOperatorCall, data, reporter) + checkers.basicExpressionCheckers.check(equalityOperatorCall, data, reporter) } override fun visitVariableAssignment(variableAssignment: FirVariableAssignment, data: CheckerContext) { checkers.variableAssignmentCheckers.check(variableAssignment, data, reporter) } - private fun List>.check(expression: E, context: CheckerContext, reporter: DiagnosticReporter) { + private fun Collection>.check( + expression: E, + context: CheckerContext, + reporter: DiagnosticReporter + ) { for (checker in this) { checker.check(expression, context, reporter) } diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/CommonDeclarationCheckers.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/CommonDeclarationCheckers.kt index 17be0cdb51b..51f3fe69164 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/CommonDeclarationCheckers.kt +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/CommonDeclarationCheckers.kt @@ -13,9 +13,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.cfa.FirControlFlowChecker import org.jetbrains.kotlin.fir.analysis.checkers.declaration.* object CommonDeclarationCheckers : DeclarationCheckers() { - override val fileCheckers: List = listOf() - - override val declarationCheckers: List = listOf( + override val basicDeclarationCheckers: Set = setOf( FirAnnotationClassDeclarationChecker, FirModifierChecker, FirManyCompanionObjectsChecker, @@ -26,7 +24,7 @@ object CommonDeclarationCheckers : DeclarationCheckers() { FirConflictingProjectionChecker, ) - override val memberDeclarationCheckers: List = listOf( + override val memberDeclarationCheckers: Set = setOf( FirInfixFunctionDeclarationChecker, FirExposedVisibilityDeclarationChecker, FirCommonConstructorDelegationIssuesChecker, @@ -42,20 +40,20 @@ object CommonDeclarationCheckers : DeclarationCheckers() { FirInapplicableLateinitChecker, ) - override val regularClassCheckers: List = listOf( + override val regularClassCheckers: Set = setOf( FirTypeMismatchOnOverrideChecker, ) - override val constructorCheckers: List = listOf( + override val constructorCheckers: Set = setOf( FirConstructorAllowedChecker, ) - override val controlFlowAnalyserCheckers: List = listOf( + override val controlFlowAnalyserCheckers: Set = setOf( FirCallsEffectAnalyzer, - FirReturnsImpliesAnalyzer + FirReturnsImpliesAnalyzer, ) - override val variableAssignmentCfaBasedCheckers: List = listOf( - FirPropertyInitializationAnalyzer + override val variableAssignmentCfaBasedCheckers: Set = setOf( + FirPropertyInitializationAnalyzer, ) } diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/CommonExpressionCheckers.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/CommonExpressionCheckers.kt index 4e4f6434c80..cec00d6bee4 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/CommonExpressionCheckers.kt +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/CommonExpressionCheckers.kt @@ -9,8 +9,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirSealedClassCons import org.jetbrains.kotlin.fir.analysis.checkers.expression.* object CommonExpressionCheckers : ExpressionCheckers() { - override val expressionCheckers: List = listOf() - override val qualifiedAccessCheckers: List = listOf( + override val qualifiedAccessCheckers: Set = setOf( FirSuperNotAvailableChecker, FirNotASupertypeChecker, FirSuperclassNotAccessibleFromInterfaceChecker, @@ -21,5 +20,5 @@ object CommonExpressionCheckers : ExpressionCheckers() { FirTypeArgumentsNotAllowedExpressionChecker, FirSealedClassConstructorCallChecker, ) - override val functionCallCheckers: List = listOf() + override val functionCallCheckers: Set = setOf() } diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/ExtendedDeclarationCheckers.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/ExtendedDeclarationCheckers.kt index bd9ff6339e5..f85347ac3d6 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/ExtendedDeclarationCheckers.kt +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/ExtendedDeclarationCheckers.kt @@ -8,25 +8,29 @@ package org.jetbrains.kotlin.fir.checkers import org.jetbrains.kotlin.fir.analysis.cfa.AbstractFirPropertyInitializationChecker import org.jetbrains.kotlin.fir.analysis.checkers.cfa.FirControlFlowChecker import org.jetbrains.kotlin.fir.analysis.checkers.declaration.DeclarationCheckers +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirDeclarationChecker +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirMemberDeclarationChecker import org.jetbrains.kotlin.fir.analysis.checkers.extended.* +import org.jetbrains.kotlin.fir.declarations.FirDeclaration object ExtendedDeclarationCheckers : DeclarationCheckers() { - override val declarationCheckers = listOf( + override val basicDeclarationCheckers: Set = setOf( RedundantVisibilityModifierChecker, - RedundantReturnUnitType + RedundantReturnUnitType, ) - override val memberDeclarationCheckers = listOf( + override val memberDeclarationCheckers: Set = setOf( RedundantModalityModifierChecker, RedundantExplicitTypeChecker, - RedundantSetterParameterTypeChecker + RedundantSetterParameterTypeChecker, ) - override val variableAssignmentCfaBasedCheckers: List = listOf( + override val variableAssignmentCfaBasedCheckers: Set = setOf( CanBeValChecker, ) - override val controlFlowAnalyserCheckers: List = listOf( - UnusedChecker + override val controlFlowAnalyserCheckers: Set = setOf( + UnusedChecker, ) } diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/ExtendedExpressionCheckers.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/ExtendedExpressionCheckers.kt index cc3b28b83b8..7fba9b8a10e 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/ExtendedExpressionCheckers.kt +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/ExtendedExpressionCheckers.kt @@ -12,18 +12,18 @@ import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirVariableAssignme import org.jetbrains.kotlin.fir.analysis.checkers.extended.* object ExtendedExpressionCheckers : ExpressionCheckers() { - override val expressionCheckers: List = listOf( + override val basicExpressionCheckers: Set = setOf( ArrayEqualityCanBeReplacedWithEquals, RedundantSingleExpressionStringTemplateChecker, - EmptyRangeChecker + EmptyRangeChecker, ) - override val variableAssignmentCheckers: List = listOf( - CanBeReplacedWithOperatorAssignmentChecker + override val variableAssignmentCheckers: Set = setOf( + CanBeReplacedWithOperatorAssignmentChecker, ) - override val qualifiedAccessCheckers: List = listOf( + override val qualifiedAccessCheckers: Set = setOf( RedundantCallOfConversionMethod, - UselessCallOnNotNullChecker + UselessCallOnNotNullChecker, ) } diff --git a/plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllOpenAdditionalCheckers.kt b/plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllOpenAdditionalCheckers.kt index e50c36a97d5..195e26a5bec 100644 --- a/plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllOpenAdditionalCheckers.kt +++ b/plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllOpenAdditionalCheckers.kt @@ -17,6 +17,6 @@ class AllOpenAdditionalCheckers(session: FirSession) : FirAdditionalCheckersExte get() = AllOpenPluginKey override val declarationCheckers: DeclarationCheckers = object : DeclarationCheckers() { - override val memberDeclarationCheckers: List = listOf(DummyNameChecker) + override val memberDeclarationCheckers: Set = setOf(DummyNameChecker) } -} \ No newline at end of file +}