[FIR] Replace lists with Long in Modifier, refactor Modifier and derived classes

compiler/fir/analysis-tests/testData/resolve/diagnostics/incompatibleModifiers.fir.txt

@@ -1,10 +1,4 @@
 FILE: incompatibleModifiers.kt
-    public final class A<out T> : R|kotlin/Any| {
-        public constructor<out T>(): R|A<T>| {
-            super<R|kotlin/Any|>()
-        }
-
-    }
     private final class B : R|kotlin/Any| {
         public constructor(): R|B| {
             super<R|kotlin/Any|>()

compiler/fir/analysis-tests/testData/resolve/diagnostics/incompatibleModifiers.kt

@@ -1,5 +1,3 @@
-class A<<!INCOMPATIBLE_MODIFIERS!>in<!> <!INCOMPATIBLE_MODIFIERS!>out<!> T> {  }
-
 <!INCOMPATIBLE_MODIFIERS!>private<!> <!INCOMPATIBLE_MODIFIERS!>public<!> class B
 <!INCOMPATIBLE_MODIFIERS!>protected<!> <!INCOMPATIBLE_MODIFIERS!>internal<!> class C
 

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<TypeModifier>.hasSuspend() = any { it.hasSuspend }
+    private fun Collection<TypeModifier>.hasSuspend() = any { it.hasSuspend() }
 
     /**
      * @see org.jetbrains.kotlin.parsing.KotlinParsing.parseTypeRefContents

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(
+open class Modifier(var modifiers: Long = ModifierFlag.NONE.value) {
-    private val classModifiers: MutableList<ClassModifier> = mutableListOf(),
-    private val memberModifiers: MutableList<MemberModifier> = mutableListOf(),
-    private val visibilityModifiers: MutableList<VisibilityModifier> = mutableListOf(),
-    private val functionModifiers: MutableList<FunctionModifier> = mutableListOf(),
-    private var propertyModifier: PropertyModifier? = null,
-    private val inheritanceModifiers: MutableList<InheritanceModifier> = mutableListOf(),
-    private val parameterModifiers: MutableList<ParameterModifier> = mutableListOf(),
-    private val platformModifiers: MutableList<PlatformModifier> = mutableListOf()
-) {
     val annotations: MutableList<FirAnnotationCall> = mutableListOf()
 
     fun addModifier(modifier: LighterASTNode, isInClass: Boolean = false) {
-        val tokenType = modifier.tokenType
+        when (val tokenType = modifier.tokenType) {
-        if (tokenType == KtTokens.CONST_KEYWORD) {
+            KtTokens.CONST_KEYWORD -> {
-            // Specific case because CONST may exist both on parameter and property
+                // Specific case because CONST may exist both on parameter and property
-            propertyModifier = PropertyModifier.CONST
+                setFlag(ModifierFlag.PROPERTY_CONST)
-            parameterModifiers += ParameterModifier.CONST
+                setFlag(ModifierFlag.PARAMETER_CONST)
-            return
+            }
-        }
+            KtTokens.INLINE_KEYWORD -> {
-        val upperCasedModifier = modifier.toString().uppercase()
+                setFlag(if (isInClass) ModifierFlag.CLASS_INLINE else ModifierFlag.FUNCTION_INLINE)
-        when (ModifierSets.ModifierKinds[tokenType]) {
-            ModifierKind.INLINE -> {
-                if (isInClass)
-                    this.classModifiers += ClassModifier.valueOf(upperCasedModifier)
-                else
-                    this.functionModifiers += FunctionModifier.valueOf(upperCasedModifier)
             }
-            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 {
+    fun isEnum(): Boolean = hasFlag(ModifierFlag.CLASS_ENUM)
-        return classModifiers.contains(ClassModifier.ENUM)
-    }
 
-    fun isAnnotation(): Boolean {
+    fun isAnnotation(): Boolean = hasFlag(ModifierFlag.CLASS_ANNOTATION)
-        return classModifiers.contains(ClassModifier.ANNOTATION)
-    }
 
-    fun isDataClass(): Boolean {
+    fun isDataClass(): Boolean = hasFlag(ModifierFlag.CLASS_DATA)
-        return classModifiers.contains(ClassModifier.DATA)
-    }
 
-    fun isInlineClass(): Boolean {
+    fun isInlineClass(): Boolean = hasFlag(ModifierFlag.CLASS_INLINE)
-        return classModifiers.contains(ClassModifier.INLINE)
-    }
 
-    fun isInner(): Boolean {
+    fun isInner(): Boolean = hasFlag(ModifierFlag.CLASS_INNER)
-        return classModifiers.contains(ClassModifier.INNER)
-    }
 
-    fun isCompanion(): Boolean {
+    fun isCompanion(): Boolean = hasFlag(ModifierFlag.CLASS_COMPANION)
-        return classModifiers.contains(ClassModifier.COMPANION)
-    }
 
-    fun isFunctionalInterface(): Boolean {
+    fun isFunctionalInterface(): Boolean = hasFlag(ModifierFlag.CLASS_FUN)
-        return classModifiers.contains(ClassModifier.FUN)
-    }
 
-    fun hasOverride(): Boolean {
+    fun hasOverride(): Boolean = hasFlag(ModifierFlag.MEMBER_OVERRIDE)
-        return memberModifiers.contains(MemberModifier.OVERRIDE)
-    }
 
-    fun hasLateinit(): Boolean {
+    fun hasLateinit(): Boolean = hasFlag(ModifierFlag.MEMBER_LATEINIT)
-        return memberModifiers.contains(MemberModifier.LATEINIT)
-    }
 
     fun getVisibility(): Visibility {
         return when {
-            visibilityModifiers.contains(VisibilityModifier.PRIVATE) -> Visibilities.Private
+            hasFlag(ModifierFlag.VISIBILITY_PRIVATE) -> Visibilities.Private
-            visibilityModifiers.contains(VisibilityModifier.PUBLIC) -> Visibilities.Public
+            hasFlag(ModifierFlag.VISIBILITY_PUBLIC) -> Visibilities.Public
-            visibilityModifiers.contains(VisibilityModifier.PROTECTED) -> Visibilities.Protected
+            hasFlag(ModifierFlag.VISIBILITY_PROTECTED) -> Visibilities.Protected
-            visibilityModifiers.contains(VisibilityModifier.INTERNAL) -> Visibilities.Internal
+            hasFlag(ModifierFlag.VISIBILITY_INTERNAL) -> Visibilities.Internal
             else -> Visibilities.Unknown
         }
     }
 
-    fun hasTailrec(): Boolean {
+    fun hasTailrec(): Boolean = hasFlag(ModifierFlag.FUNCTION_TAILREC)
-        return functionModifiers.contains(FunctionModifier.TAILREC)
-    }
 
-    fun hasOperator(): Boolean {
+    fun hasOperator(): Boolean = hasFlag(ModifierFlag.FUNCTION_OPERATOR)
-        return functionModifiers.contains(FunctionModifier.OPERATOR)
-    }
 
-    fun hasInfix(): Boolean {
+    fun hasInfix(): Boolean = hasFlag(ModifierFlag.FUNCTION_INFIX)
-        return functionModifiers.contains(FunctionModifier.INFIX)
-    }
 
-    fun hasInline(): Boolean {
+    fun hasInline(): Boolean = hasFlag(ModifierFlag.FUNCTION_INLINE)
-        return functionModifiers.contains(FunctionModifier.INLINE)
-    }
 
-    fun hasExternal(): Boolean {
+    fun hasExternal(): Boolean = hasFlag(ModifierFlag.FUNCTION_EXTERNAL)
-        return functionModifiers.contains(FunctionModifier.EXTERNAL)
-    }
 
-    fun hasSuspend(): Boolean {
+    fun hasSuspend(): Boolean = hasFlag(ModifierFlag.FUNCTION_SUSPEND)
-        return functionModifiers.contains(FunctionModifier.SUSPEND)
-    }
 
-    fun isConst(): Boolean {
+    fun isConst(): Boolean = hasFlag(ModifierFlag.PROPERTY_CONST)
-        return propertyModifier == PropertyModifier.CONST
-    }
 
     fun hasModality(modality: Modality): Boolean {
         return when {
-            modality == Modality.FINAL && inheritanceModifiers.contains(InheritanceModifier.FINAL) -> true
+            modality == Modality.FINAL && hasFlag(ModifierFlag.INHERITANCE_FINAL) -> true
-            modality == Modality.SEALED && inheritanceModifiers.contains(InheritanceModifier.SEALED) -> true
+            modality == Modality.SEALED && hasFlag(ModifierFlag.INHERITANCE_SEALED) -> true
-            modality == Modality.ABSTRACT && inheritanceModifiers.contains(InheritanceModifier.ABSTRACT) -> true
+            modality == Modality.ABSTRACT && hasFlag(ModifierFlag.INHERITANCE_ABSTRACT) -> true
-            modality == Modality.OPEN && inheritanceModifiers.contains(InheritanceModifier.OPEN) -> true
+            modality == Modality.OPEN && hasFlag(ModifierFlag.INHERITANCE_OPEN) -> true
             else -> false
         }
     }
 
     fun getModality(isClassOrObject: Boolean): Modality? {
         return when {
-            inheritanceModifiers.contains(InheritanceModifier.FINAL) -> Modality.FINAL
+            hasFlag(ModifierFlag.INHERITANCE_FINAL) -> Modality.FINAL
-            inheritanceModifiers.contains(InheritanceModifier.SEALED) -> if (isClassOrObject) Modality.SEALED else null
+            hasFlag(ModifierFlag.INHERITANCE_SEALED) -> if (isClassOrObject) Modality.SEALED else null
-            inheritanceModifiers.contains(InheritanceModifier.ABSTRACT) -> Modality.ABSTRACT
+            hasFlag(ModifierFlag.INHERITANCE_ABSTRACT) -> Modality.ABSTRACT
-            inheritanceModifiers.contains(InheritanceModifier.OPEN) -> Modality.OPEN
+            hasFlag(ModifierFlag.INHERITANCE_OPEN) -> Modality.OPEN
             else -> null
         }
     }
 
-    fun hasVararg(): Boolean {
+    fun getVariance(): Variance {
-        return parameterModifiers.contains(ParameterModifier.VARARG)
+        return when {
+            hasFlag(ModifierFlag.VARIANCE_IN) -> Variance.IN_VARIANCE
+            hasFlag(ModifierFlag.VARIANCE_OUT) -> Variance.OUT_VARIANCE
+            else -> Variance.INVARIANT
+        }
     }
 
-    fun hasNoinline(): Boolean {
+    fun hasVararg(): Boolean = hasFlag(ModifierFlag.PARAMETER_VARARG)
-        return parameterModifiers.contains(ParameterModifier.NOINLINE)
+
+    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 {
+    override fun toString(): String {
-        return parameterModifiers.contains(ParameterModifier.CROSSINLINE)
+        val result = StringBuilder()
-    }
+        var firstAppend = true
-
+        for (value in ModifierFlag.Values) {
-    fun hasExpect(): Boolean {
+            if (hasFlag(value) && value != ModifierFlag.NONE) {
-        return platformModifiers.contains(PlatformModifier.EXPECT) || platformModifiers.contains(PlatformModifier.HEADER)
+                if (firstAppend) {
-    }
+                    firstAppend = false
-
+                } else {
-    fun hasActual(): Boolean {
+                    result.append(" ")
-        return platformModifiers.contains(PlatformModifier.ACTUAL) || platformModifiers.contains(PlatformModifier.IMPL)
+                }
-    }
+                result.append(value.name)
-
+            }
-    fun hasConst(): Boolean {
+        }
-        return parameterModifiers.contains(ParameterModifier.CONST)
+        return result.toString()
     }
 }

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<IElementType, ModifierFlag> = 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,
+        )
+    }
+}

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/ModifierKind.kt

@@ -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
-}

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/ModifierSets.kt

@@ -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<IElementType, ModifierKind> = let {
-        val result = mutableMapOf<IElementType, ModifierKind>()
-
-        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
-    }
-}

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/ModifiersEnumSet.kt

@@ -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
-}

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
+class TypeModifier(suspendModifier: Long = ModifierFlag.NONE.value) : Modifier(suspendModifier) {
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+    fun hasNoAnnotations(): Boolean = annotations.isEmpty()
-import org.jetbrains.kotlin.lexer.KtTokens
-
-class TypeModifier(var hasSuspend: Boolean = false) {
-    val annotations: MutableList<FirAnnotationCall> = mutableListOf()
-
-    fun addModifier(modifier: LighterASTNode) {
-        when (modifier.tokenType) {
-            KtTokens.SUSPEND_KEYWORD -> this.hasSuspend = true
-        }
-    }
-
-    fun hasNoAnnotations(): Boolean {
-        return annotations.isEmpty()
-    }
 }

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
+class TypeParameterModifier(varianceOrReificationModifiers: Long = ModifierFlag.NONE.value) : Modifier(varianceOrReificationModifiers) {
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+    fun hasReified(): Boolean = hasFlag(ModifierFlag.REIFICATION_REIFIED)
-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<VarianceModifier> = mutableListOf(),
-    private var reificationModifier: ReificationModifier? = null
-) {
-    val annotations: MutableList<FirAnnotationCall> = 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
-    }
 }

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(
+class TypeProjectionModifier(val source: FirSourceElement? = null, varianceModifiers: Long = ModifierFlag.NONE.value) :
-    val source: FirSourceElement? = null,
+    Modifier(varianceModifiers) {
-    private val varianceModifiers: MutableList<VarianceModifier> = mutableListOf()
-) {
-    val annotations: MutableList<FirAnnotationCall> = 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
-        }
-    }
 }

compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.fir.kt

@@ -1,7 +1,6 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE
 
 interface Foo<T>
-interface Foo1<<!INCOMPATIBLE_MODIFIERS!>in<!> <!INCOMPATIBLE_MODIFIERS!>out<!> T>
 interface Foo2<in <!REPEATED_MODIFIER!>in<!> T>
 
 fun test1(foo: Foo<in out Int>) = foo

compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.kt

@@ -1,7 +1,6 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE
 
 interface Foo<T>
-interface Foo1<<!INCOMPATIBLE_MODIFIERS!>in<!> <!INCOMPATIBLE_MODIFIERS!>out<!> T>
 interface Foo2<in <!REPEATED_MODIFIER!>in<!> T>
 
 fun test1(foo: Foo<<!INCOMPATIBLE_MODIFIERS!>in<!> <!INCOMPATIBLE_MODIFIERS!>out<!> Int>) = foo

compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.txt

@@ -19,14 +19,9 @@ public interface Foo</*0*/ T> {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-public interface Foo1</*0*/ out T> {
-    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</*0*/ in T> {
     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
 }
+