From bc3c05a3bd33758cbac46a0e3d14caa198b007bd Mon Sep 17 00:00:00 2001 From: Ivan Kochurkin Date: Sun, 6 Jun 2021 14:56:28 +0300 Subject: [PATCH] [FIR] Replace lists with Long in Modifier, refactor Modifier and derived classes --- .../diagnostics/incompatibleModifiers.fir.txt | 6 - .../diagnostics/incompatibleModifiers.kt | 2 - .../converter/DeclarationsConverter.kt | 2 +- .../fir/lightTree/fir/modifier/Modifier.kt | 198 +++++++----------- .../lightTree/fir/modifier/ModifierFlag.kt | 104 +++++++++ .../lightTree/fir/modifier/ModifierKind.kt | 20 -- .../lightTree/fir/modifier/ModifierSets.kt | 71 ------- .../fir/modifier/ModifiersEnumSet.kt | 73 ------- .../lightTree/fir/modifier/TypeModifier.kt | 18 +- .../fir/modifier/TypeParameterModifier.kt | 34 +-- .../fir/modifier/TypeProjectionModifier.kt | 25 +-- .../incompatibleVarianceModifiers.fir.kt | 1 - .../incompatibleVarianceModifiers.kt | 1 - .../incompatibleVarianceModifiers.txt | 7 +- 14 files changed, 189 insertions(+), 373 deletions(-) create mode 100644 compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/ModifierFlag.kt delete mode 100644 compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/ModifierKind.kt delete mode 100644 compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/ModifierSets.kt delete mode 100644 compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/ModifiersEnumSet.kt diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/incompatibleModifiers.fir.txt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/incompatibleModifiers.fir.txt index dde4466903e..55e220a6295 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/incompatibleModifiers.fir.txt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/incompatibleModifiers.fir.txt @@ -1,10 +1,4 @@ FILE: incompatibleModifiers.kt - public final class A : R|kotlin/Any| { - public constructor(): R|A| { - super() - } - - } private final class B : R|kotlin/Any| { public constructor(): R|B| { super() diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/incompatibleModifiers.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/incompatibleModifiers.kt index 8ac05486eaf..e7e5dc05b1d 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/incompatibleModifiers.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/incompatibleModifiers.kt @@ -1,5 +1,3 @@ -class A<in out T> { } - private public class B protected internal class C diff --git a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt index ae1ae195cd5..9cf599e809a 100644 --- a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt +++ b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt @@ -1736,7 +1736,7 @@ class DeclarationsConverter( return firType } - private fun Collection.hasSuspend() = any { it.hasSuspend } + private fun Collection.hasSuspend() = any { it.hasSuspend() } /** * @see org.jetbrains.kotlin.parsing.KotlinParsing.parseTypeRefContents diff --git a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/Modifier.kt b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/Modifier.kt index 8c327654392..de70a6c828b 100644 --- a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/Modifier.kt +++ b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/Modifier.kt @@ -10,175 +10,131 @@ import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall -import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.CLASS_MODIFIER -import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.FUNCTION_MODIFIER -import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.INHERITANCE_MODIFIER -import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.INLINE_MODIFIER -import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.MEMBER_MODIFIER -import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.PARAMETER_MODIFIER -import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.PLATFORM_MODIFIER -import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.PROPERTY_MODIFIER -import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.VISIBILITY_MODIFIER import org.jetbrains.kotlin.lexer.KtTokens +import org.jetbrains.kotlin.types.Variance -class Modifier( - private val classModifiers: MutableList = mutableListOf(), - private val memberModifiers: MutableList = mutableListOf(), - private val visibilityModifiers: MutableList = mutableListOf(), - private val functionModifiers: MutableList = mutableListOf(), - private var propertyModifier: PropertyModifier? = null, - private val inheritanceModifiers: MutableList = mutableListOf(), - private val parameterModifiers: MutableList = mutableListOf(), - private val platformModifiers: MutableList = mutableListOf() -) { +open class Modifier(var modifiers: Long = ModifierFlag.NONE.value) { val annotations: MutableList = mutableListOf() fun addModifier(modifier: LighterASTNode, isInClass: Boolean = false) { - val tokenType = modifier.tokenType - if (tokenType == KtTokens.CONST_KEYWORD) { - // Specific case because CONST may exist both on parameter and property - propertyModifier = PropertyModifier.CONST - parameterModifiers += ParameterModifier.CONST - return - } - val upperCasedModifier = modifier.toString().uppercase() - when (ModifierSets.ModifierKinds[tokenType]) { - ModifierKind.INLINE -> { - if (isInClass) - this.classModifiers += ClassModifier.valueOf(upperCasedModifier) - else - this.functionModifiers += FunctionModifier.valueOf(upperCasedModifier) + when (val tokenType = modifier.tokenType) { + KtTokens.CONST_KEYWORD -> { + // Specific case because CONST may exist both on parameter and property + setFlag(ModifierFlag.PROPERTY_CONST) + setFlag(ModifierFlag.PARAMETER_CONST) + } + KtTokens.INLINE_KEYWORD -> { + setFlag(if (isInClass) ModifierFlag.CLASS_INLINE else ModifierFlag.FUNCTION_INLINE) } - ModifierKind.CLASS -> this.classModifiers += ClassModifier.valueOf(upperCasedModifier) - ModifierKind.MEMBER -> this.memberModifiers += MemberModifier.valueOf(upperCasedModifier) - ModifierKind.VISIBILITY -> this.visibilityModifiers += - VisibilityModifier.valueOf(upperCasedModifier) - ModifierKind.FUNCTION -> this.functionModifiers += FunctionModifier.valueOf(upperCasedModifier) - ModifierKind.PROPERTY -> this.propertyModifier = PropertyModifier.valueOf(upperCasedModifier) - ModifierKind.INHERITANCE -> this.inheritanceModifiers += - InheritanceModifier.valueOf(upperCasedModifier) - ModifierKind.PARAMETER -> this.parameterModifiers += ParameterModifier.valueOf(upperCasedModifier) - ModifierKind.PLATFORM -> this.platformModifiers += PlatformModifier.valueOf(upperCasedModifier) else -> { + setFlag(ModifierFlag.ElementTypeToModifierFlagMap[tokenType]) } } } - fun isEnum(): Boolean { - return classModifiers.contains(ClassModifier.ENUM) - } + fun isEnum(): Boolean = hasFlag(ModifierFlag.CLASS_ENUM) - fun isAnnotation(): Boolean { - return classModifiers.contains(ClassModifier.ANNOTATION) - } + fun isAnnotation(): Boolean = hasFlag(ModifierFlag.CLASS_ANNOTATION) - fun isDataClass(): Boolean { - return classModifiers.contains(ClassModifier.DATA) - } + fun isDataClass(): Boolean = hasFlag(ModifierFlag.CLASS_DATA) - fun isInlineClass(): Boolean { - return classModifiers.contains(ClassModifier.INLINE) - } + fun isInlineClass(): Boolean = hasFlag(ModifierFlag.CLASS_INLINE) - fun isInner(): Boolean { - return classModifiers.contains(ClassModifier.INNER) - } + fun isInner(): Boolean = hasFlag(ModifierFlag.CLASS_INNER) - fun isCompanion(): Boolean { - return classModifiers.contains(ClassModifier.COMPANION) - } + fun isCompanion(): Boolean = hasFlag(ModifierFlag.CLASS_COMPANION) - fun isFunctionalInterface(): Boolean { - return classModifiers.contains(ClassModifier.FUN) - } + fun isFunctionalInterface(): Boolean = hasFlag(ModifierFlag.CLASS_FUN) - fun hasOverride(): Boolean { - return memberModifiers.contains(MemberModifier.OVERRIDE) - } + fun hasOverride(): Boolean = hasFlag(ModifierFlag.MEMBER_OVERRIDE) - fun hasLateinit(): Boolean { - return memberModifiers.contains(MemberModifier.LATEINIT) - } + fun hasLateinit(): Boolean = hasFlag(ModifierFlag.MEMBER_LATEINIT) fun getVisibility(): Visibility { return when { - visibilityModifiers.contains(VisibilityModifier.PRIVATE) -> Visibilities.Private - visibilityModifiers.contains(VisibilityModifier.PUBLIC) -> Visibilities.Public - visibilityModifiers.contains(VisibilityModifier.PROTECTED) -> Visibilities.Protected - visibilityModifiers.contains(VisibilityModifier.INTERNAL) -> Visibilities.Internal + hasFlag(ModifierFlag.VISIBILITY_PRIVATE) -> Visibilities.Private + hasFlag(ModifierFlag.VISIBILITY_PUBLIC) -> Visibilities.Public + hasFlag(ModifierFlag.VISIBILITY_PROTECTED) -> Visibilities.Protected + hasFlag(ModifierFlag.VISIBILITY_INTERNAL) -> Visibilities.Internal else -> Visibilities.Unknown } } - fun hasTailrec(): Boolean { - return functionModifiers.contains(FunctionModifier.TAILREC) - } + fun hasTailrec(): Boolean = hasFlag(ModifierFlag.FUNCTION_TAILREC) - fun hasOperator(): Boolean { - return functionModifiers.contains(FunctionModifier.OPERATOR) - } + fun hasOperator(): Boolean = hasFlag(ModifierFlag.FUNCTION_OPERATOR) - fun hasInfix(): Boolean { - return functionModifiers.contains(FunctionModifier.INFIX) - } + fun hasInfix(): Boolean = hasFlag(ModifierFlag.FUNCTION_INFIX) - fun hasInline(): Boolean { - return functionModifiers.contains(FunctionModifier.INLINE) - } + fun hasInline(): Boolean = hasFlag(ModifierFlag.FUNCTION_INLINE) - fun hasExternal(): Boolean { - return functionModifiers.contains(FunctionModifier.EXTERNAL) - } + fun hasExternal(): Boolean = hasFlag(ModifierFlag.FUNCTION_EXTERNAL) - fun hasSuspend(): Boolean { - return functionModifiers.contains(FunctionModifier.SUSPEND) - } + fun hasSuspend(): Boolean = hasFlag(ModifierFlag.FUNCTION_SUSPEND) - fun isConst(): Boolean { - return propertyModifier == PropertyModifier.CONST - } + fun isConst(): Boolean = hasFlag(ModifierFlag.PROPERTY_CONST) fun hasModality(modality: Modality): Boolean { return when { - modality == Modality.FINAL && inheritanceModifiers.contains(InheritanceModifier.FINAL) -> true - modality == Modality.SEALED && inheritanceModifiers.contains(InheritanceModifier.SEALED) -> true - modality == Modality.ABSTRACT && inheritanceModifiers.contains(InheritanceModifier.ABSTRACT) -> true - modality == Modality.OPEN && inheritanceModifiers.contains(InheritanceModifier.OPEN) -> true + modality == Modality.FINAL && hasFlag(ModifierFlag.INHERITANCE_FINAL) -> true + modality == Modality.SEALED && hasFlag(ModifierFlag.INHERITANCE_SEALED) -> true + modality == Modality.ABSTRACT && hasFlag(ModifierFlag.INHERITANCE_ABSTRACT) -> true + modality == Modality.OPEN && hasFlag(ModifierFlag.INHERITANCE_OPEN) -> true else -> false } } fun getModality(isClassOrObject: Boolean): Modality? { return when { - inheritanceModifiers.contains(InheritanceModifier.FINAL) -> Modality.FINAL - inheritanceModifiers.contains(InheritanceModifier.SEALED) -> if (isClassOrObject) Modality.SEALED else null - inheritanceModifiers.contains(InheritanceModifier.ABSTRACT) -> Modality.ABSTRACT - inheritanceModifiers.contains(InheritanceModifier.OPEN) -> Modality.OPEN + hasFlag(ModifierFlag.INHERITANCE_FINAL) -> Modality.FINAL + hasFlag(ModifierFlag.INHERITANCE_SEALED) -> if (isClassOrObject) Modality.SEALED else null + hasFlag(ModifierFlag.INHERITANCE_ABSTRACT) -> Modality.ABSTRACT + hasFlag(ModifierFlag.INHERITANCE_OPEN) -> Modality.OPEN else -> null } } - fun hasVararg(): Boolean { - return parameterModifiers.contains(ParameterModifier.VARARG) + fun getVariance(): Variance { + return when { + hasFlag(ModifierFlag.VARIANCE_IN) -> Variance.IN_VARIANCE + hasFlag(ModifierFlag.VARIANCE_OUT) -> Variance.OUT_VARIANCE + else -> Variance.INVARIANT + } } - fun hasNoinline(): Boolean { - return parameterModifiers.contains(ParameterModifier.NOINLINE) + fun hasVararg(): Boolean = hasFlag(ModifierFlag.PARAMETER_VARARG) + + fun hasNoinline(): Boolean = hasFlag(ModifierFlag.PARAMETER_NOINLINE) + + fun hasCrossinline(): Boolean = hasFlag(ModifierFlag.PARAMETER_CROSSINLINE) + + fun hasExpect(): Boolean = hasFlag(ModifierFlag.PLATFORM_EXPECT) || hasFlag(ModifierFlag.PLATFORM_HEADER) + + fun hasActual(): Boolean = hasFlag(ModifierFlag.PLATFORM_ACTUAL) || hasFlag(ModifierFlag.PLATFORM_IMPL) + + fun hasConst(): Boolean = hasFlag(ModifierFlag.PARAMETER_CONST) + + protected fun hasFlag(flag: ModifierFlag) = (modifiers and flag.value) == flag.value + + protected fun setFlag(flag: ModifierFlag?) { + if (flag != null) { + modifiers = modifiers or flag.value + } } - fun hasCrossinline(): Boolean { - return parameterModifiers.contains(ParameterModifier.CROSSINLINE) - } - - fun hasExpect(): Boolean { - return platformModifiers.contains(PlatformModifier.EXPECT) || platformModifiers.contains(PlatformModifier.HEADER) - } - - fun hasActual(): Boolean { - return platformModifiers.contains(PlatformModifier.ACTUAL) || platformModifiers.contains(PlatformModifier.IMPL) - } - - fun hasConst(): Boolean { - return parameterModifiers.contains(ParameterModifier.CONST) + override fun toString(): String { + val result = StringBuilder() + var firstAppend = true + for (value in ModifierFlag.Values) { + if (hasFlag(value) && value != ModifierFlag.NONE) { + if (firstAppend) { + firstAppend = false + } else { + result.append(" ") + } + result.append(value.name) + } + } + return result.toString() } } diff --git a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/ModifierFlag.kt b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/ModifierFlag.kt new file mode 100644 index 00000000000..aae07204df4 --- /dev/null +++ b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/ModifierFlag.kt @@ -0,0 +1,104 @@ +/* + * Copyright 201L0-201L9 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.lightTree.fir.modifier + +import com.intellij.psi.tree.IElementType +import org.jetbrains.kotlin.lexer.KtTokens + +enum class ModifierFlag(val value: Long) { + NONE(0L), + CLASS_ENUM(1L shl 0), + CLASS_ANNOTATION(1L shl 1), + CLASS_DATA(1L shl 2), + CLASS_INLINE(1L shl 3), + CLASS_INNER(1L shl 4), + CLASS_COMPANION(1L shl 5), + CLASS_FUN(1L shl 6), + MEMBER_OVERRIDE(1L shl 7), + MEMBER_LATEINIT(1L shl 8), + VISIBILITY_PUBLIC(1L shl 9), + VISIBILITY_PRIVATE(1L shl 10), + VISIBILITY_INTERNAL(1L shl 11), + VISIBILITY_PROTECTED(1L shl 12), + VISIBILITY_UNKNOWN(1L shl 13), + FUNCTION_TAILREC(1L shl 14), + FUNCTION_OPERATOR(1L shl 15), + FUNCTION_INFIX(1L shl 16), + FUNCTION_INLINE(1L shl 17), + FUNCTION_EXTERNAL(1L shl 18), + FUNCTION_SUSPEND(1L shl 19), + PROPERTY_CONST(1L shl 20), + INHERITANCE_ABSTRACT(1L shl 21), + INHERITANCE_FINAL(1L shl 22), + INHERITANCE_OPEN(1L shl 23), + INHERITANCE_SEALED(1L shl 24), + PARAMETER_VARARG(1L shl 25), + PARAMETER_NOINLINE(1L shl 26), + PARAMETER_CROSSINLINE(1L shl 27), + PARAMETER_CONST(1L shl 28), + PLATFORM_EXPECT(1L shl 29), + PLATFORM_ACTUAL(1L shl 30), + PLATFORM_HEADER(1L shl 31), + PLATFORM_IMPL(1L shl 32), + VARIANCE_IN(1L shl 33), + VARIANCE_OUT(1L shl 34), + VARIANCE_INVARIANT(1L shl 35), + REIFICATION_REIFIED(1L shl 36); + + companion object { + val Values = values() + val ElementTypeToModifierFlagMap: Map = mutableMapOf( + // Class + KtTokens.ENUM_KEYWORD to CLASS_ENUM, + KtTokens.ANNOTATION_KEYWORD to CLASS_ANNOTATION, + KtTokens.DATA_KEYWORD to CLASS_DATA, + KtTokens.INNER_KEYWORD to CLASS_INNER, + KtTokens.COMPANION_KEYWORD to CLASS_COMPANION, + KtTokens.FUN_KEYWORD to CLASS_FUN, + + // Member + KtTokens.OVERRIDE_KEYWORD to MEMBER_OVERRIDE, + KtTokens.LATEINIT_KEYWORD to MEMBER_LATEINIT, + + // Visibility + KtTokens.PUBLIC_KEYWORD to VISIBILITY_PUBLIC, + KtTokens.PRIVATE_KEYWORD to VISIBILITY_PRIVATE, + KtTokens.INTERNAL_KEYWORD to VISIBILITY_INTERNAL, + KtTokens.PROTECTED_KEYWORD to VISIBILITY_PROTECTED, + + // Function + KtTokens.TAILREC_KEYWORD to FUNCTION_TAILREC, + KtTokens.OPERATOR_KEYWORD to FUNCTION_OPERATOR, + KtTokens.INFIX_KEYWORD to FUNCTION_INFIX, + KtTokens.EXTERNAL_KEYWORD to FUNCTION_EXTERNAL, + KtTokens.SUSPEND_KEYWORD to FUNCTION_SUSPEND, + + // Inheritance + KtTokens.ABSTRACT_KEYWORD to INHERITANCE_ABSTRACT, + KtTokens.FINAL_KEYWORD to INHERITANCE_FINAL, + KtTokens.OPEN_KEYWORD to INHERITANCE_OPEN, + KtTokens.SEALED_KEYWORD to INHERITANCE_SEALED, + + // Parameter + KtTokens.VARARG_KEYWORD to PARAMETER_VARARG, + KtTokens.NOINLINE_KEYWORD to PARAMETER_NOINLINE, + KtTokens.CROSSINLINE_KEYWORD to PARAMETER_CROSSINLINE, + + // Platform + KtTokens.EXPECT_KEYWORD to PLATFORM_EXPECT, + KtTokens.ACTUAL_KEYWORD to PLATFORM_ACTUAL, + KtTokens.HEADER_KEYWORD to PLATFORM_HEADER, + KtTokens.IMPL_KEYWORD to PLATFORM_IMPL, + + // Variance + KtTokens.IN_KEYWORD to VARIANCE_IN, + KtTokens.OUT_KEYWORD to VARIANCE_OUT, + + // Reification + KtTokens.REIFIED_KEYWORD to REIFICATION_REIFIED, + ) + } +} \ No newline at end of file diff --git a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/ModifierKind.kt b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/ModifierKind.kt deleted file mode 100644 index 2b9e649d0f5..00000000000 --- a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/ModifierKind.kt +++ /dev/null @@ -1,20 +0,0 @@ -/* - * Copyright 2010-2021 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.lightTree.fir.modifier - -enum class ModifierKind { - INLINE, - CLASS, - MEMBER, - VISIBILITY, - FUNCTION, - PROPERTY, - INHERITANCE, - PARAMETER, - PLATFORM, - VARIANCE, - REIFICATION -} \ No newline at end of file diff --git a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/ModifierSets.kt b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/ModifierSets.kt deleted file mode 100644 index 048f3e7a6e5..00000000000 --- a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/ModifierSets.kt +++ /dev/null @@ -1,71 +0,0 @@ -/* - * Copyright 2010-2019 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.lightTree.fir.modifier - -import com.intellij.psi.tree.IElementType -import com.intellij.psi.tree.TokenSet -import org.jetbrains.kotlin.lexer.KtTokens.* - -object ModifierSets { - val CLASS_MODIFIER = TokenSet.create( - ENUM_KEYWORD, - ANNOTATION_KEYWORD, - DATA_KEYWORD, - INNER_KEYWORD, - COMPANION_KEYWORD, - FUN_KEYWORD - ) - val MEMBER_MODIFIER = TokenSet.create(OVERRIDE_KEYWORD, LATEINIT_KEYWORD) - val VISIBILITY_MODIFIER = TokenSet.create( - PUBLIC_KEYWORD, - PRIVATE_KEYWORD, - INTERNAL_KEYWORD, - PROTECTED_KEYWORD - ) - val FUNCTION_MODIFIER = TokenSet.create( - TAILREC_KEYWORD, - OPERATOR_KEYWORD, - INFIX_KEYWORD, - EXTERNAL_KEYWORD, - SUSPEND_KEYWORD - ) - val PROPERTY_MODIFIER = TokenSet.create(CONST_KEYWORD) - val INHERITANCE_MODIFIER = TokenSet.create( - ABSTRACT_KEYWORD, - FINAL_KEYWORD, - OPEN_KEYWORD, - SEALED_KEYWORD - ) - val PARAMETER_MODIFIER = TokenSet.create(VARARG_KEYWORD, NOINLINE_KEYWORD, CROSSINLINE_KEYWORD) - val PLATFORM_MODIFIER = TokenSet.create(EXPECT_KEYWORD, ACTUAL_KEYWORD, HEADER_KEYWORD, IMPL_KEYWORD) - val VARIANCE_MODIFIER = TokenSet.create(IN_KEYWORD, OUT_KEYWORD) - val REIFICATION_MODIFIER = TokenSet.create(REIFIED_KEYWORD) - val INLINE_MODIFIER = TokenSet.create(INLINE_KEYWORD) - - val ModifierKinds: Map = let { - val result = mutableMapOf() - - fun initTokenSet(tokenSet: TokenSet, modifierKind: ModifierKind) { - for (modifier in tokenSet.types) { - result[modifier] = modifierKind - } - } - - initTokenSet(CLASS_MODIFIER, ModifierKind.CLASS) - initTokenSet(MEMBER_MODIFIER, ModifierKind.MEMBER) - initTokenSet(VISIBILITY_MODIFIER, ModifierKind.VISIBILITY) - initTokenSet(FUNCTION_MODIFIER, ModifierKind.FUNCTION) - initTokenSet(PROPERTY_MODIFIER, ModifierKind.PROPERTY) - initTokenSet(INHERITANCE_MODIFIER, ModifierKind.INHERITANCE) - initTokenSet(PARAMETER_MODIFIER, ModifierKind.PARAMETER) - initTokenSet(PLATFORM_MODIFIER, ModifierKind.PLATFORM) - initTokenSet(VARIANCE_MODIFIER, ModifierKind.VARIANCE) - initTokenSet(REIFICATION_MODIFIER, ModifierKind.REIFICATION) - initTokenSet(INLINE_MODIFIER, ModifierKind.INLINE) - - result - } -} \ No newline at end of file diff --git a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/ModifiersEnumSet.kt b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/ModifiersEnumSet.kt deleted file mode 100644 index 3700eaa1ef1..00000000000 --- a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/ModifiersEnumSet.kt +++ /dev/null @@ -1,73 +0,0 @@ -/* - * Copyright 2010-2019 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.lightTree.fir.modifier - -enum class ClassModifier { - ENUM, - ANNOTATION, - DATA, - INLINE, - INNER, - COMPANION, - FUN -} - -enum class MemberModifier { - OVERRIDE, - LATEINIT -} - -enum class VisibilityModifier { - PUBLIC, - PRIVATE, - INTERNAL, - PROTECTED, - UNKNOWN -} - -enum class FunctionModifier { - TAILREC, - OPERATOR, - INFIX, - INLINE, - EXTERNAL, - SUSPEND -} - -enum class PropertyModifier { - CONST -} - -enum class InheritanceModifier { - ABSTRACT, - FINAL, - OPEN, - SEALED -} - -enum class ParameterModifier { - VARARG, - NOINLINE, - CROSSINLINE, - CONST -} - -enum class PlatformModifier { - EXPECT, - ACTUAL, - HEADER, - IMPL -} - -enum class VarianceModifier { - IN, - OUT, - INVARIANT -} - -enum class ReificationModifier { - REIFIED -} \ No newline at end of file diff --git a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeModifier.kt b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeModifier.kt index e9e244a2604..4067d9d2cad 100644 --- a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeModifier.kt +++ b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeModifier.kt @@ -5,20 +5,6 @@ package org.jetbrains.kotlin.fir.lightTree.fir.modifier -import com.intellij.lang.LighterASTNode -import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall -import org.jetbrains.kotlin.lexer.KtTokens - -class TypeModifier(var hasSuspend: Boolean = false) { - val annotations: MutableList = mutableListOf() - - fun addModifier(modifier: LighterASTNode) { - when (modifier.tokenType) { - KtTokens.SUSPEND_KEYWORD -> this.hasSuspend = true - } - } - - fun hasNoAnnotations(): Boolean { - return annotations.isEmpty() - } +class TypeModifier(suspendModifier: Long = ModifierFlag.NONE.value) : Modifier(suspendModifier) { + fun hasNoAnnotations(): Boolean = annotations.isEmpty() } diff --git a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeParameterModifier.kt b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeParameterModifier.kt index f4d00d2727a..a8beccdde86 100644 --- a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeParameterModifier.kt +++ b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeParameterModifier.kt @@ -5,36 +5,6 @@ package org.jetbrains.kotlin.fir.lightTree.fir.modifier -import com.intellij.lang.LighterASTNode -import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall -import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.REIFICATION_MODIFIER -import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.VARIANCE_MODIFIER -import org.jetbrains.kotlin.types.Variance - -class TypeParameterModifier( - private val varianceModifiers: MutableList = mutableListOf(), - private var reificationModifier: ReificationModifier? = null -) { - val annotations: MutableList = mutableListOf() - - fun addModifier(modifier: LighterASTNode) { - val tokenType = modifier.tokenType - when { - VARIANCE_MODIFIER.contains(tokenType) -> this.varianceModifiers += VarianceModifier.valueOf(modifier.toString().uppercase()) - REIFICATION_MODIFIER.contains(tokenType) -> this.reificationModifier = - ReificationModifier.valueOf(modifier.toString().uppercase()) - } - } - - fun getVariance(): Variance { - return when { - varianceModifiers.contains(VarianceModifier.OUT) -> Variance.OUT_VARIANCE - varianceModifiers.contains(VarianceModifier.IN) -> Variance.IN_VARIANCE - else -> Variance.INVARIANT - } - } - - fun hasReified(): Boolean { - return reificationModifier == ReificationModifier.REIFIED - } +class TypeParameterModifier(varianceOrReificationModifiers: Long = ModifierFlag.NONE.value) : Modifier(varianceOrReificationModifiers) { + fun hasReified(): Boolean = hasFlag(ModifierFlag.REIFICATION_REIFIED) } diff --git a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeProjectionModifier.kt b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeProjectionModifier.kt index 07b77d8655c..e290df08ae0 100644 --- a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeProjectionModifier.kt +++ b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeProjectionModifier.kt @@ -5,30 +5,9 @@ package org.jetbrains.kotlin.fir.lightTree.fir.modifier -import com.intellij.lang.LighterASTNode import org.jetbrains.kotlin.fir.FirSourceElement -import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall -import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.VARIANCE_MODIFIER import org.jetbrains.kotlin.types.Variance -class TypeProjectionModifier( - val source: FirSourceElement? = null, - private val varianceModifiers: MutableList = mutableListOf() -) { - val annotations: MutableList = mutableListOf() - - fun addModifier(modifier: LighterASTNode) { - val tokenType = modifier.tokenType - when { - VARIANCE_MODIFIER.contains(tokenType) -> this.varianceModifiers += VarianceModifier.valueOf(modifier.toString().uppercase()) - } - } - - fun getVariance(): Variance { - return when { - varianceModifiers.contains(VarianceModifier.IN) -> Variance.IN_VARIANCE - varianceModifiers.contains(VarianceModifier.OUT) -> Variance.OUT_VARIANCE - else -> Variance.INVARIANT - } - } +class TypeProjectionModifier(val source: FirSourceElement? = null, varianceModifiers: Long = ModifierFlag.NONE.value) : + Modifier(varianceModifiers) { } diff --git a/compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.fir.kt b/compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.fir.kt index c2cd96f8f12..7c7ac648f25 100644 --- a/compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.fir.kt +++ b/compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.fir.kt @@ -1,7 +1,6 @@ // !DIAGNOSTICS: -UNUSED_VARIABLE interface Foo -interface Foo1<in out T> interface Foo2in T> fun test1(foo: Foo) = foo diff --git a/compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.kt b/compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.kt index 5c54ddd3a42..3c93fc552b9 100644 --- a/compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.kt +++ b/compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.kt @@ -1,7 +1,6 @@ // !DIAGNOSTICS: -UNUSED_VARIABLE interface Foo -interface Foo1<in out T> interface Foo2in T> fun test1(foo: Foo<in out Int>) = foo diff --git a/compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.txt b/compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.txt index 4969cbe4306..d6c389edfae 100644 --- a/compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.txt +++ b/compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.txt @@ -19,14 +19,9 @@ public interface Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -public interface Foo1 { - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String -} - public interface Foo2 { public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } +