[FIR] Make FirDeclaration an abstract class

compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/JavaClassRendering.kt

@@ -23,7 +23,8 @@ fun renderJavaClass(renderer: FirRenderer, javaClass: FirJavaClass, session: Fir
 
     val staticScope = javaClass.scopeProvider.getStaticScope(javaClass, session, ScopeSession())
 
-    renderer.visitMemberDeclaration(javaClass)
+    renderer.renderAnnotations(javaClass)
+    renderer.visitStatusOwner(javaClass)
     renderer.renderSupertypes(javaClass)
     renderer.renderInBraces {
         val renderedDeclarations = mutableListOf<FirDeclaration<*>>()

compiler/fir/analysis-tests/testData/loadCompiledKotlin/typealias/Annotations.txt

@@ -1,6 +1,6 @@
-@R|test/Ann|() @R|test/Ann|() public final typealias A1 = R|kotlin/String|
+@R|test/Ann|() public final typealias A1 = R|kotlin/String|
 
-@R|test/Ann|(value = String(OK)) @R|test/Ann|(value = String(OK)) public final typealias A2 = R|kotlin/String|
+@R|test/Ann|(value = String(OK)) public final typealias A2 = R|kotlin/String|
 
 @R|kotlin/annotation/Target|(allowedTargets = <implicitArrayOf>(R|kotlin/annotation/AnnotationTarget.TYPEALIAS|())) public final annotation class Ann : R|kotlin/Annotation| {
     public final val value: R|kotlin/String|

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Main.kt

@@ -52,7 +52,6 @@ fun main(args: Array<String>) {
     val declarationPackage = "$basePackage.checkers.declaration"
     generateCheckersComponents(generationPath, declarationPackage, "FirDeclarationChecker") {
         alias<FirDeclaration<*>>("BasicDeclarationChecker")
-        alias<FirMemberDeclaration<*>>("MemberDeclarationChecker")
         alias<FirFunction<*>>("FunctionChecker")
         alias<FirSimpleFunction>("SimpleFunctionChecker")
         alias<FirProperty>("PropertyChecker")
@@ -62,6 +61,7 @@ fun main(args: Array<String>) {
         alias<FirFile>("FileChecker")
         alias<FirTypeParameter>("FirTypeParameterChecker")
         alias<FirAnnotatedDeclaration<*>>("FirAnnotatedDeclarationChecker")
+        alias<FirTypeAlias>("TypeAliasChecker")
 
         additional(
             fieldName = "controlFlowAnalyserCheckers",

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt

@@ -554,7 +554,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
 
     val OVERRIDES by object : DiagnosticGroup("overrides") {
         val NOTHING_TO_OVERRIDE by error<KtModifierListOwner>(PositioningStrategy.OVERRIDE_MODIFIER) {
-            parameter<FirMemberDeclaration<*>>("declaration")
+            parameter<FirStatusOwner>("declaration")
         }
 
         val CANNOT_WEAKEN_ACCESS_PRIVILEGE by error<KtModifierListOwner>(PositioningStrategy.VISIBILITY_MODIFIER) {
@@ -607,25 +607,25 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
         }
 
         val RETURN_TYPE_MISMATCH_ON_OVERRIDE by error<KtNamedDeclaration>(PositioningStrategy.DECLARATION_RETURN_TYPE) {
-            parameter<FirMemberDeclaration<*>>("function")
+            parameter<FirStatusOwner>("function")
-            parameter<FirMemberDeclaration<*>>("superFunction")
+            parameter<FirStatusOwner>("superFunction")
         }
         val PROPERTY_TYPE_MISMATCH_ON_OVERRIDE by error<KtNamedDeclaration>(PositioningStrategy.DECLARATION_RETURN_TYPE) {
-            parameter<FirMemberDeclaration<*>>("property")
+            parameter<FirStatusOwner>("property")
-            parameter<FirMemberDeclaration<*>>("superProperty")
+            parameter<FirStatusOwner>("superProperty")
         }
         val VAR_TYPE_MISMATCH_ON_OVERRIDE by error<KtNamedDeclaration>(PositioningStrategy.DECLARATION_RETURN_TYPE) {
-            parameter<FirMemberDeclaration<*>>("variable")
+            parameter<FirStatusOwner>("variable")
-            parameter<FirMemberDeclaration<*>>("superVariable")
+            parameter<FirStatusOwner>("superVariable")
         }
         val VAR_OVERRIDDEN_BY_VAL by error<KtNamedDeclaration>(PositioningStrategy.VAL_OR_VAR_NODE) {
-            parameter<FirMemberDeclaration<*>>("overridingDeclaration")
+            parameter<FirStatusOwner>("overridingDeclaration")
-            parameter<FirMemberDeclaration<*>>("overriddenDeclaration")
+            parameter<FirStatusOwner>("overriddenDeclaration")
         }
         val NON_FINAL_MEMBER_IN_FINAL_CLASS by warning<KtNamedDeclaration>(PositioningStrategy.OPEN_MODIFIER)
         val NON_FINAL_MEMBER_IN_OBJECT by warning<KtNamedDeclaration>(PositioningStrategy.OPEN_MODIFIER)
         val VIRTUAL_MEMBER_HIDDEN by error<KtNamedDeclaration>(PositioningStrategy.DECLARATION_NAME) {
-            parameter<FirMemberDeclaration<*>>("declared")
+            parameter<FirStatusOwner>("declared")
             parameter<FirRegularClass>("overriddenContainer")
         }
     }
@@ -652,21 +652,21 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
 
     val FUNCTIONS by object : DiagnosticGroup("Functions") {
         val ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS by error<KtFunction>(PositioningStrategy.MODALITY_MODIFIER) {
-            parameter<FirMemberDeclaration<*>>("function")
+            parameter<FirStatusOwner>("function")
             parameter<FirClass<*>>("containingClass")
         }
         val ABSTRACT_FUNCTION_WITH_BODY by error<KtFunction>(PositioningStrategy.MODALITY_MODIFIER) {
-            parameter<FirMemberDeclaration<*>>("function")
+            parameter<FirStatusOwner>("function")
         }
         val NON_ABSTRACT_FUNCTION_WITH_NO_BODY by error<KtFunction>(PositioningStrategy.DECLARATION_SIGNATURE) {
-            parameter<FirMemberDeclaration<*>>("function")
+            parameter<FirStatusOwner>("function")
         }
         val PRIVATE_FUNCTION_WITH_NO_BODY by error<KtFunction>(PositioningStrategy.VISIBILITY_MODIFIER) {
-            parameter<FirMemberDeclaration<*>>("function")
+            parameter<FirStatusOwner>("function")
         }
 
         val NON_MEMBER_FUNCTION_NO_BODY by error<KtFunction>(PositioningStrategy.DECLARATION_SIGNATURE) {
-            parameter<FirMemberDeclaration<*>>("function")
+            parameter<FirStatusOwner>("function")
         }
 
         val FUNCTION_DECLARATION_WITH_NO_NAME by error<KtFunction>(PositioningStrategy.DECLARATION_SIGNATURE)
@@ -696,7 +696,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
 
     val PROPERTIES_AND_ACCESSORS by object : DiagnosticGroup("Properties & accessors") {
         val ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS by error<KtModifierListOwner>(PositioningStrategy.MODALITY_MODIFIER) {
-            parameter<FirMemberDeclaration<*>>("property")
+            parameter<FirStatusOwner>("property")
             parameter<FirClass<*>>("containingClass")
         }
         val PRIVATE_PROPERTY_IN_INTERFACE by error<KtProperty>(PositioningStrategy.VISIBILITY_MODIFIER)
@@ -1032,7 +1032,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
 
 private val exposedVisibilityDiagnosticInit: DiagnosticBuilder.() -> Unit = {
     parameter<EffectiveVisibility>("elementVisibility")
-    parameter<FirMemberDeclaration<*>>("restrictingDeclaration")
+    parameter<FirStatusOwner>("restrictingDeclaration")
     parameter<EffectiveVisibility>("restrictingVisibility")
 }
 

compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/JvmDeclarationCheckers.kt

@@ -6,11 +6,11 @@
 package org.jetbrains.kotlin.fir.analysis.jvm.checkers
 
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.DeclarationCheckers
-import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirMemberDeclarationChecker
+import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker
 import org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration.FirJvmExternalDeclarationChecker
 
 object JvmDeclarationCheckers : DeclarationCheckers() {
-    override val memberDeclarationCheckers: Set<FirMemberDeclarationChecker>
+    override val basicDeclarationCheckers: Set<FirBasicDeclarationChecker>
         get() = setOf(
             FirJvmExternalDeclarationChecker,
         )

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

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration
 
 import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
-import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirMemberDeclarationChecker
+import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.getModifier
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
@@ -15,8 +15,9 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.lexer.KtTokens
 
-object FirJvmExternalDeclarationChecker : FirMemberDeclarationChecker() {
+object FirJvmExternalDeclarationChecker : FirBasicDeclarationChecker() {
-    override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+        if (declaration !is FirStatusOwner) return
         if (!declaration.isExternal) return
         val source = declaration.source ?: return
         if (source.kind is FirFakeSourceElementKind) return

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/ComposedDeclarationCheckers.kt

@@ -17,8 +17,6 @@ import org.jetbrains.kotlin.fir.analysis.checkers.cfa.FirControlFlowChecker
 class ComposedDeclarationCheckers : DeclarationCheckers() {
     override val basicDeclarationCheckers: Set<FirBasicDeclarationChecker>
         get() = _basicDeclarationCheckers
-    override val memberDeclarationCheckers: Set<FirMemberDeclarationChecker>
-        get() = _memberDeclarationCheckers
     override val functionCheckers: Set<FirFunctionChecker>
         get() = _functionCheckers
     override val simpleFunctionCheckers: Set<FirSimpleFunctionChecker>
@@ -37,13 +35,14 @@ class ComposedDeclarationCheckers : DeclarationCheckers() {
         get() = _typeParameterCheckers
     override val annotatedDeclarationCheckers: Set<FirAnnotatedDeclarationChecker>
         get() = _annotatedDeclarationCheckers
+    override val typeAliasCheckers: Set<FirTypeAliasChecker>
+        get() = _typeAliasCheckers
     override val controlFlowAnalyserCheckers: Set<FirControlFlowChecker>
         get() = _controlFlowAnalyserCheckers
     override val variableAssignmentCfaBasedCheckers: Set<AbstractFirPropertyInitializationChecker>
         get() = _variableAssignmentCfaBasedCheckers
 
     private val _basicDeclarationCheckers: MutableSet<FirBasicDeclarationChecker> = mutableSetOf()
-    private val _memberDeclarationCheckers: MutableSet<FirMemberDeclarationChecker> = mutableSetOf()
     private val _functionCheckers: MutableSet<FirFunctionChecker> = mutableSetOf()
     private val _simpleFunctionCheckers: MutableSet<FirSimpleFunctionChecker> = mutableSetOf()
     private val _propertyCheckers: MutableSet<FirPropertyChecker> = mutableSetOf()
@@ -53,13 +52,13 @@ class ComposedDeclarationCheckers : DeclarationCheckers() {
     private val _fileCheckers: MutableSet<FirFileChecker> = mutableSetOf()
     private val _typeParameterCheckers: MutableSet<FirTypeParameterChecker> = mutableSetOf()
     private val _annotatedDeclarationCheckers: MutableSet<FirAnnotatedDeclarationChecker> = mutableSetOf()
+    private val _typeAliasCheckers: MutableSet<FirTypeAliasChecker> = mutableSetOf()
     private val _controlFlowAnalyserCheckers: MutableSet<FirControlFlowChecker> = mutableSetOf()
     private val _variableAssignmentCfaBasedCheckers: MutableSet<AbstractFirPropertyInitializationChecker> = mutableSetOf()
 
     @CheckersComponentInternal
     fun register(checkers: DeclarationCheckers) {
         _basicDeclarationCheckers += checkers.basicDeclarationCheckers
-        _memberDeclarationCheckers += checkers.memberDeclarationCheckers
         _functionCheckers += checkers.functionCheckers
         _simpleFunctionCheckers += checkers.simpleFunctionCheckers
         _propertyCheckers += checkers.propertyCheckers
@@ -69,6 +68,7 @@ class ComposedDeclarationCheckers : DeclarationCheckers() {
         _fileCheckers += checkers.fileCheckers
         _typeParameterCheckers += checkers.typeParameterCheckers
         _annotatedDeclarationCheckers += checkers.annotatedDeclarationCheckers
+        _typeAliasCheckers += checkers.typeAliasCheckers
         _controlFlowAnalyserCheckers += checkers.controlFlowAnalyserCheckers
         _variableAssignmentCfaBasedCheckers += checkers.variableAssignmentCfaBasedCheckers
     }

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/DeclarationCheckers.kt

@@ -20,7 +20,6 @@ abstract class DeclarationCheckers {
     }
 
     open val basicDeclarationCheckers: Set<FirBasicDeclarationChecker> = emptySet()
-    open val memberDeclarationCheckers: Set<FirMemberDeclarationChecker> = emptySet()
     open val functionCheckers: Set<FirFunctionChecker> = emptySet()
     open val simpleFunctionCheckers: Set<FirSimpleFunctionChecker> = emptySet()
     open val propertyCheckers: Set<FirPropertyChecker> = emptySet()
@@ -30,19 +29,20 @@ abstract class DeclarationCheckers {
     open val fileCheckers: Set<FirFileChecker> = emptySet()
     open val typeParameterCheckers: Set<FirTypeParameterChecker> = emptySet()
     open val annotatedDeclarationCheckers: Set<FirAnnotatedDeclarationChecker> = emptySet()
+    open val typeAliasCheckers: Set<FirTypeAliasChecker> = emptySet()
 
     open val controlFlowAnalyserCheckers: Set<FirControlFlowChecker> = emptySet()
     open val variableAssignmentCfaBasedCheckers: Set<AbstractFirPropertyInitializationChecker> = emptySet()
 
     @CheckersComponentInternal internal val allBasicDeclarationCheckers: Set<FirBasicDeclarationChecker> get() = basicDeclarationCheckers
-    @CheckersComponentInternal internal val allMemberDeclarationCheckers: Set<FirMemberDeclarationChecker> get() = memberDeclarationCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers
     @CheckersComponentInternal internal val allFunctionCheckers: Set<FirFunctionChecker> get() = functionCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers
-    @CheckersComponentInternal internal val allSimpleFunctionCheckers: Set<FirSimpleFunctionChecker> get() = simpleFunctionCheckers + functionCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers + memberDeclarationCheckers
+    @CheckersComponentInternal internal val allSimpleFunctionCheckers: Set<FirSimpleFunctionChecker> get() = simpleFunctionCheckers + functionCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers
-    @CheckersComponentInternal internal val allPropertyCheckers: Set<FirPropertyChecker> get() = propertyCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers + memberDeclarationCheckers
+    @CheckersComponentInternal internal val allPropertyCheckers: Set<FirPropertyChecker> get() = propertyCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers
     @CheckersComponentInternal internal val allClassCheckers: Set<FirClassChecker> get() = classCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers
-    @CheckersComponentInternal internal val allRegularClassCheckers: Set<FirRegularClassChecker> get() = regularClassCheckers + memberDeclarationCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers + classCheckers
+    @CheckersComponentInternal internal val allRegularClassCheckers: Set<FirRegularClassChecker> get() = regularClassCheckers + classCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers
-    @CheckersComponentInternal internal val allConstructorCheckers: Set<FirConstructorChecker> get() = constructorCheckers + functionCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers + memberDeclarationCheckers
+    @CheckersComponentInternal internal val allConstructorCheckers: Set<FirConstructorChecker> get() = constructorCheckers + functionCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers
     @CheckersComponentInternal internal val allFileCheckers: Set<FirFileChecker> get() = fileCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers
     @CheckersComponentInternal internal val allTypeParameterCheckers: Set<FirTypeParameterChecker> get() = typeParameterCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers
     @CheckersComponentInternal internal val allAnnotatedDeclarationCheckers: Set<FirAnnotatedDeclarationChecker> get() = annotatedDeclarationCheckers + basicDeclarationCheckers
+    @CheckersComponentInternal internal val allTypeAliasCheckers: Set<FirTypeAliasChecker> get() = typeAliasCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers
 }

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationCheckerAliases.kt

@@ -16,14 +16,13 @@ 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.FirFunction
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
+import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 
 typealias FirBasicDeclarationChecker = FirDeclarationChecker<FirDeclaration<*>>
-typealias FirMemberDeclarationChecker = FirDeclarationChecker<FirMemberDeclaration<*>>
 typealias FirFunctionChecker = FirDeclarationChecker<FirFunction<*>>
 typealias FirSimpleFunctionChecker = FirDeclarationChecker<FirSimpleFunction>
 typealias FirPropertyChecker = FirDeclarationChecker<FirProperty>
@@ -33,3 +32,4 @@ typealias FirConstructorChecker = FirDeclarationChecker<FirConstructor>
 typealias FirFileChecker = FirDeclarationChecker<FirFile>
 typealias FirTypeParameterChecker = FirDeclarationChecker<FirTypeParameter>
 typealias FirAnnotatedDeclarationChecker = FirDeclarationChecker<FirAnnotatedDeclaration<*>>
+typealias FirTypeAliasChecker = FirDeclarationChecker<FirTypeAlias>

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt

@@ -18,9 +18,9 @@ import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
+import org.jetbrains.kotlin.fir.declarations.FirStatusOwner
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
@@ -218,15 +218,15 @@ object FirErrors {
     val EXPERIMENTAL_ANNOTATION_WITH_WRONG_RETENTION by error0<KtAnnotationEntry>()
 
     // Exposed visibility
-    val EXPOSED_TYPEALIAS_EXPANDED_TYPE by error3<KtNamedDeclaration, EffectiveVisibility, FirMemberDeclaration<*>, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
+    val EXPOSED_TYPEALIAS_EXPANDED_TYPE by error3<KtNamedDeclaration, EffectiveVisibility, FirStatusOwner, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
-    val EXPOSED_FUNCTION_RETURN_TYPE by error3<KtNamedDeclaration, EffectiveVisibility, FirMemberDeclaration<*>, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
+    val EXPOSED_FUNCTION_RETURN_TYPE by error3<KtNamedDeclaration, EffectiveVisibility, FirStatusOwner, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
-    val EXPOSED_RECEIVER_TYPE by error3<KtTypeReference, EffectiveVisibility, FirMemberDeclaration<*>, EffectiveVisibility>()
+    val EXPOSED_RECEIVER_TYPE by error3<KtTypeReference, EffectiveVisibility, FirStatusOwner, EffectiveVisibility>()
-    val EXPOSED_PROPERTY_TYPE by error3<KtNamedDeclaration, EffectiveVisibility, FirMemberDeclaration<*>, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
+    val EXPOSED_PROPERTY_TYPE by error3<KtNamedDeclaration, EffectiveVisibility, FirStatusOwner, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
-    val EXPOSED_PROPERTY_TYPE_IN_CONSTRUCTOR by warning3<KtNamedDeclaration, EffectiveVisibility, FirMemberDeclaration<*>, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
+    val EXPOSED_PROPERTY_TYPE_IN_CONSTRUCTOR by warning3<KtNamedDeclaration, EffectiveVisibility, FirStatusOwner, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
-    val EXPOSED_PARAMETER_TYPE by error3<KtParameter, EffectiveVisibility, FirMemberDeclaration<*>, EffectiveVisibility>()
+    val EXPOSED_PARAMETER_TYPE by error3<KtParameter, EffectiveVisibility, FirStatusOwner, EffectiveVisibility>()
-    val EXPOSED_SUPER_INTERFACE by error3<KtTypeReference, EffectiveVisibility, FirMemberDeclaration<*>, EffectiveVisibility>()
+    val EXPOSED_SUPER_INTERFACE by error3<KtTypeReference, EffectiveVisibility, FirStatusOwner, EffectiveVisibility>()
-    val EXPOSED_SUPER_CLASS by error3<KtTypeReference, EffectiveVisibility, FirMemberDeclaration<*>, EffectiveVisibility>()
+    val EXPOSED_SUPER_CLASS by error3<KtTypeReference, EffectiveVisibility, FirStatusOwner, EffectiveVisibility>()
-    val EXPOSED_TYPE_PARAMETER_BOUND by error3<KtTypeReference, EffectiveVisibility, FirMemberDeclaration<*>, EffectiveVisibility>()
+    val EXPOSED_TYPE_PARAMETER_BOUND by error3<KtTypeReference, EffectiveVisibility, FirStatusOwner, EffectiveVisibility>()
 
     // Modifiers
     val INAPPLICABLE_INFIX_MODIFIER by error0<PsiElement>()
@@ -338,7 +338,7 @@ object FirErrors {
     val EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS by error1<PsiElement, ConeKotlinType>()
 
     // overrides
-    val NOTHING_TO_OVERRIDE by error1<KtModifierListOwner, FirMemberDeclaration<*>>(SourceElementPositioningStrategies.OVERRIDE_MODIFIER)
+    val NOTHING_TO_OVERRIDE by error1<KtModifierListOwner, FirStatusOwner>(SourceElementPositioningStrategies.OVERRIDE_MODIFIER)
     val CANNOT_WEAKEN_ACCESS_PRIVILEGE by error3<KtModifierListOwner, Visibility, FirCallableDeclaration<*>, Name>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
     val CANNOT_CHANGE_ACCESS_PRIVILEGE by error3<KtModifierListOwner, Visibility, FirCallableDeclaration<*>, Name>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
     val OVERRIDING_FINAL_MEMBER by error2<KtNamedDeclaration, FirCallableDeclaration<*>, Name>(SourceElementPositioningStrategies.OVERRIDE_MODIFIER)
@@ -350,13 +350,13 @@ object FirErrors {
     val MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED by error2<KtClassOrObject, FirClass<*>, FirCallableDeclaration<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
     val OVERRIDING_FINAL_MEMBER_BY_DELEGATION by error2<KtClassOrObject, FirCallableDeclaration<*>, FirCallableDeclaration<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
     val DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE by warning2<KtClassOrObject, FirCallableDeclaration<*>, FirCallableDeclaration<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
-    val RETURN_TYPE_MISMATCH_ON_OVERRIDE by error2<KtNamedDeclaration, FirMemberDeclaration<*>, FirMemberDeclaration<*>>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE)
+    val RETURN_TYPE_MISMATCH_ON_OVERRIDE by error2<KtNamedDeclaration, FirStatusOwner, FirStatusOwner>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE)
-    val PROPERTY_TYPE_MISMATCH_ON_OVERRIDE by error2<KtNamedDeclaration, FirMemberDeclaration<*>, FirMemberDeclaration<*>>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE)
+    val PROPERTY_TYPE_MISMATCH_ON_OVERRIDE by error2<KtNamedDeclaration, FirStatusOwner, FirStatusOwner>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE)
-    val VAR_TYPE_MISMATCH_ON_OVERRIDE by error2<KtNamedDeclaration, FirMemberDeclaration<*>, FirMemberDeclaration<*>>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE)
+    val VAR_TYPE_MISMATCH_ON_OVERRIDE by error2<KtNamedDeclaration, FirStatusOwner, FirStatusOwner>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE)
-    val VAR_OVERRIDDEN_BY_VAL by error2<KtNamedDeclaration, FirMemberDeclaration<*>, FirMemberDeclaration<*>>(SourceElementPositioningStrategies.VAL_OR_VAR_NODE)
+    val VAR_OVERRIDDEN_BY_VAL by error2<KtNamedDeclaration, FirStatusOwner, FirStatusOwner>(SourceElementPositioningStrategies.VAL_OR_VAR_NODE)
     val NON_FINAL_MEMBER_IN_FINAL_CLASS by warning0<KtNamedDeclaration>(SourceElementPositioningStrategies.OPEN_MODIFIER)
     val NON_FINAL_MEMBER_IN_OBJECT by warning0<KtNamedDeclaration>(SourceElementPositioningStrategies.OPEN_MODIFIER)
-    val VIRTUAL_MEMBER_HIDDEN by error2<KtNamedDeclaration, FirMemberDeclaration<*>, FirRegularClass>(SourceElementPositioningStrategies.DECLARATION_NAME)
+    val VIRTUAL_MEMBER_HIDDEN by error2<KtNamedDeclaration, FirStatusOwner, FirRegularClass>(SourceElementPositioningStrategies.DECLARATION_NAME)
 
     // Redeclarations
     val MANY_COMPANION_OBJECTS by error0<KtObjectDeclaration>(SourceElementPositioningStrategies.COMPANION_OBJECT)
@@ -369,11 +369,11 @@ object FirErrors {
     val LOCAL_INTERFACE_NOT_ALLOWED by error1<KtNamedDeclaration, Name>(SourceElementPositioningStrategies.DECLARATION_NAME)
 
     // Functions
-    val ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS by error2<KtFunction, FirMemberDeclaration<*>, FirClass<*>>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
+    val ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS by error2<KtFunction, FirStatusOwner, FirClass<*>>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
-    val ABSTRACT_FUNCTION_WITH_BODY by error1<KtFunction, FirMemberDeclaration<*>>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
+    val ABSTRACT_FUNCTION_WITH_BODY by error1<KtFunction, FirStatusOwner>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
-    val NON_ABSTRACT_FUNCTION_WITH_NO_BODY by error1<KtFunction, FirMemberDeclaration<*>>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
+    val NON_ABSTRACT_FUNCTION_WITH_NO_BODY by error1<KtFunction, FirStatusOwner>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
-    val PRIVATE_FUNCTION_WITH_NO_BODY by error1<KtFunction, FirMemberDeclaration<*>>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
+    val PRIVATE_FUNCTION_WITH_NO_BODY by error1<KtFunction, FirStatusOwner>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
-    val NON_MEMBER_FUNCTION_NO_BODY by error1<KtFunction, FirMemberDeclaration<*>>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
+    val NON_MEMBER_FUNCTION_NO_BODY by error1<KtFunction, FirStatusOwner>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
     val FUNCTION_DECLARATION_WITH_NO_NAME by error0<KtFunction>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
     val ANONYMOUS_FUNCTION_WITH_NAME by error0<KtFunction>()
     val ANONYMOUS_FUNCTION_PARAMETER_WITH_DEFAULT_VALUE by error0<KtParameter>(SourceElementPositioningStrategies.PARAMETER_DEFAULT_VALUE)
@@ -392,7 +392,7 @@ object FirErrors {
     val FUN_INTERFACE_WITH_SUSPEND_FUNCTION by error0<KtDeclaration>(SourceElementPositioningStrategies.FUN_INTERFACE)
 
     // Properties & accessors
-    val ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS by error2<KtModifierListOwner, FirMemberDeclaration<*>, FirClass<*>>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
+    val ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS by error2<KtModifierListOwner, FirStatusOwner, FirClass<*>>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
     val PRIVATE_PROPERTY_IN_INTERFACE by error0<KtProperty>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
     val ABSTRACT_PROPERTY_WITH_INITIALIZER by error0<KtExpression>()
     val PROPERTY_INITIALIZER_IN_INTERFACE by error0<KtExpression>()

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

@@ -24,23 +24,17 @@ object CommonDeclarationCheckers : DeclarationCheckers() {
             FirProjectionRelationChecker,
             FirTypeConstraintsChecker,
             FirReservedUnderscoreDeclarationChecker,
-            FirUpperBoundViolatedDeclarationChecker
+            FirUpperBoundViolatedDeclarationChecker,
-        )
-
-    override val memberDeclarationCheckers: Set<FirMemberDeclarationChecker>
-        get() = setOf(
             FirInfixFunctionDeclarationChecker,
             FirExposedVisibilityDeclarationChecker,
-            FirSealedSupertypeChecker,
-            FirTypeAliasChecker,
             FirCyclicTypeBoundsChecker,
-            FirInlineDeclarationChecker,
         )
 
     override val functionCheckers: Set<FirFunctionChecker>
         get() = setOf(
             FirContractChecker,
             FirFunctionParameterChecker,
+            FirInlineDeclarationChecker
         )
 
     override val simpleFunctionCheckers: Set<FirSimpleFunctionChecker>
@@ -66,7 +60,8 @@ object CommonDeclarationCheckers : DeclarationCheckers() {
             FirNotImplementedOverrideChecker,
             FirThrowableSubclassChecker,
             FirOpenMemberChecker,
-            FirClassVarianceChecker
+            FirClassVarianceChecker,
+            FirSealedSupertypeChecker,
         )
 
     override val regularClassCheckers: Set<FirRegularClassChecker>
@@ -128,4 +123,9 @@ object CommonDeclarationCheckers : DeclarationCheckers() {
         get() = setOf(
             FirAnnotationChecker,
         )
+
+    override val typeAliasCheckers: Set<FirTypeAliasChecker>
+        get() = setOf(
+            FirTopLevelTypeAliasChecker,
+        )
 }

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

@@ -7,25 +7,21 @@ package org.jetbrains.kotlin.fir.analysis.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.*
-import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker
-import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirMemberDeclarationChecker
-import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirSimpleFunctionChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.extended.*
 
 object ExtendedDeclarationCheckers : DeclarationCheckers() {
     override val basicDeclarationCheckers: Set<FirBasicDeclarationChecker>
         get() = setOf(
             RedundantVisibilityModifierSyntaxChecker,
-        )
-
-    override val memberDeclarationCheckers: Set<FirMemberDeclarationChecker>
-        get() = setOf(
             RedundantModalityModifierSyntaxChecker,
-            RedundantExplicitTypeChecker,
-            RedundantSetterParameterTypeChecker,
         )
 
+    override val propertyCheckers: Set<FirPropertyChecker>
+        get() = setOf(
+            RedundantSetterParameterTypeChecker,
+            RedundantExplicitTypeChecker,
+        )
     override val variableAssignmentCfaBasedCheckers: Set<AbstractFirPropertyInitializationChecker>
         get() = setOf(
             CanBeValChecker,

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

@@ -38,7 +38,7 @@ internal fun checkConstantArguments(
         }
         expression is FirConstExpression<*>
                 || expressionSymbol is FirEnumEntry
-                || (expressionSymbol as? FirMemberDeclaration<*>)?.isConst == true
+                || (expressionSymbol as? FirStatusOwner)?.isConst == true
                 || expressionSymbol is FirConstructor && classKindOfParent == ClassKind.ANNOTATION_CLASS -> {
             //DO NOTHING
         }
@@ -83,8 +83,8 @@ internal fun checkConstantArguments(
         expressionSymbol is FirField -> {
             //TODO: fix checking of Java fields initializer
             if (
-                !(expressionSymbol as FirMemberDeclaration<*>).status.isStatic
+                !(expressionSymbol as FirStatusOwner).status.isStatic
-                || (expressionSymbol as FirMemberDeclaration<*>).status.modality != Modality.FINAL
+                || (expressionSymbol as FirStatusOwner).status.modality != Modality.FINAL
             )
                 return ConstantArgumentKind.NOT_CONST
         }

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

@@ -234,7 +234,7 @@ fun FirClass<*>.modality(): Modality? {
 /**
  * returns implicit modality by FirMemberDeclaration<*>
  */
-fun FirMemberDeclaration<*>.implicitModality(context: CheckerContext): Modality {
+fun FirStatusOwner.implicitModality(context: CheckerContext): Modality {
     if (this is FirRegularClass && (this.classKind == ClassKind.CLASS || this.classKind == ClassKind.OBJECT)) {
         if (this.classKind == ClassKind.INTERFACE) return Modality.ABSTRACT
         return Modality.FINAL
@@ -257,6 +257,7 @@ fun FirMemberDeclaration<*>.implicitModality(context: CheckerContext): Modality
         && klass.classKind == ClassKind.INTERFACE
         && tree.visibilityModifier(source.lighterASTNode)?.tokenType != KtTokens.PRIVATE_KEYWORD
     ) {
+        require(this is FirDeclaration<*>)
         return if (this.hasBody()) Modality.OPEN else Modality.ABSTRACT
     }
 
@@ -379,7 +380,7 @@ private fun lowerThanBound(context: ConeInferenceContext, argument: ConeKotlinTy
     return false
 }
 
-fun FirMemberDeclaration<*>.isInlineOnly(): Boolean = isInline && hasAnnotation(INLINE_ONLY_ANNOTATION_CLASS_ID)
+fun FirStatusOwner.isInlineOnly(): Boolean = isInline && (this as FirAnnotatedDeclaration<*>).hasAnnotation(INLINE_ONLY_ANNOTATION_CLASS_ID)
 
 fun isSubtypeForTypeMismatch(context: ConeInferenceContext, subtype: ConeKotlinType, supertype: ConeKotlinType): Boolean {
     val subtypeFullyExpanded = subtype.fullyExpandedType(context.session)

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/context/CheckerContext.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.analysis.checkers.context
 
 import org.jetbrains.kotlin.diagnostics.Severity
+import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
@@ -62,7 +63,7 @@ abstract class CheckerContext {
  *   the closest setter, while we want to keep searching for a getter.
  */
 
-inline fun <reified T : FirDeclaration<*>> CheckerContext.findClosest(check: (T) -> Boolean = { true }): T? {
+inline fun <reified T : FirElement> CheckerContext.findClosest(check: (T) -> Boolean = { true }): T? {
     for (it in containingDeclarations.asReversed()) {
         return (it as? T)?.takeIf(check) ?: continue
     }

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

@@ -29,7 +29,7 @@ object FirClassVarianceChecker : FirClassChecker() {
         }
 
         for (member in declaration.declarations) {
-            if (member is FirMemberDeclaration<*>) {
+            if (member is FirStatusOwner) {
                 if (Visibilities.isPrivate(member.status.visibility)) {
                     continue
                 }

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

@@ -52,8 +52,8 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
         }
 
         private fun isExpectAndActual(declaration1: FirDeclaration<*>, declaration2: FirDeclaration<*>): Boolean {
-            if (declaration1 !is FirMemberDeclaration<*>) return false
+            if (declaration1 !is FirStatusOwner) return false
-            if (declaration2 !is FirMemberDeclaration<*>) return false
+            if (declaration2 !is FirStatusOwner) return false
             return (declaration1.status.isExpect && declaration2.status.isActual) ||
                     (declaration1.status.isActual && declaration2.status.isExpect)
         }
@@ -90,7 +90,7 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
             if (areCompatibleMainFunctions(declaration, containingFile, conflicting, actualConflictingFile)) return
             if (isExpectAndActual(declaration, conflicting)) return
             if (
-                conflicting is FirMemberDeclaration<*> &&
+                conflicting is FirStatusOwner &&
                 !session.visibilityChecker.isVisible(conflicting, session, containingFile, emptyList(), null)
             ) return
             declarationConflictingSymbols.getOrPut(declaration) { SmartSet.create() }.add(conflictingSymbol)

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

@@ -15,9 +15,10 @@ import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
-object FirCyclicTypeBoundsChecker : FirMemberDeclarationChecker() {
+object FirCyclicTypeBoundsChecker : FirBasicDeclarationChecker() {
 
-    override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+        if (declaration !is FirStatusOwner) return
         if (declaration is FirConstructor || declaration is FirTypeAlias) return
 
         val processed = mutableSetOf<Name>()

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

@@ -42,7 +42,7 @@ private inline fun isInsideSpecificClass(
             context.containingDeclarations.asReversed().any { it is FirRegularClass && predicate.invoke(it) }
 }
 
-internal fun FirMemberDeclaration<*>.isEffectivelyExpect(
+internal fun FirStatusOwner.isEffectivelyExpect(
     containingClass: FirRegularClass?,
     context: CheckerContext,
 ): Boolean {
@@ -51,7 +51,7 @@ internal fun FirMemberDeclaration<*>.isEffectivelyExpect(
     return containingClass != null && isInsideExpectClass(containingClass, context)
 }
 
-internal fun FirMemberDeclaration<*>.isEffectivelyExternal(
+internal fun FirStatusOwner.isEffectivelyExternal(
     containingClass: FirRegularClass?,
     context: CheckerContext,
 ): Boolean {
@@ -75,7 +75,7 @@ internal fun FirMemberDeclaration<*>.isEffectivelyExternal(
 
 // TODO: check class too
 internal fun checkExpectDeclarationVisibilityAndBody(
-    declaration: FirMemberDeclaration<*>,
+    declaration: FirStatusOwner,
     source: FirSourceElement,
     reporter: DiagnosticReporter,
     context: CheckerContext

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

@@ -21,8 +21,8 @@ import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 // TODO: check why coneTypeSafe is necessary at some points inside
-object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
+object FirExposedVisibilityDeclarationChecker : FirBasicDeclarationChecker() {
-    override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
         when (declaration) {
             is FirTypeAlias -> checkTypeAlias(declaration, reporter, context)
             is FirProperty -> checkProperty(declaration, reporter, context)
@@ -103,7 +103,7 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
     }
 
     private fun checkFunction(declaration: FirFunction<*>, reporter: DiagnosticReporter, context: CheckerContext) {
-        val functionVisibility = (declaration as FirMemberDeclaration<*>).effectiveVisibility
+        val functionVisibility = (declaration as FirStatusOwner).effectiveVisibility
 
         if (functionVisibility == EffectiveVisibility.Local) return
         if (declaration !is FirConstructor) {
@@ -193,14 +193,14 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
     private fun ConeKotlinType.findVisibilityExposure(
         context: CheckerContext,
         base: EffectiveVisibility
-    ): FirMemberDeclaration<*>? {
+    ): FirStatusOwner? {
         val type = this as? ConeClassLikeType ?: return null
         val fir = type.fullyExpandedType(context.session).lookupTag.toSymbol(context.session)?.let { firSymbol ->
             firSymbol.ensureResolved(FirResolvePhase.DECLARATIONS, context.session)
             firSymbol.fir
         } ?: return null
 
-        if (fir is FirMemberDeclaration<*>) {
+        if (fir is FirStatusOwner) {
             val effectiveVisibility = fir.effectiveVisibility
             when (effectiveVisibility.relation(base, context.session.typeContext)) {
                 EffectiveVisibility.Permissiveness.LESS,

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

@@ -9,22 +9,18 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
-import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
-import org.jetbrains.kotlin.fir.declarations.isInfix
 
-object FirInfixFunctionDeclarationChecker : FirMemberDeclarationChecker() {
+object FirInfixFunctionDeclarationChecker : FirBasicDeclarationChecker() {
-    override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
-        if (declaration is FirSimpleFunction && declaration.isInfix) {
+        if ((declaration as? FirStatusOwner)?.status?.isInfix != true) return
+        if (declaration is FirSimpleFunction) {
             if (declaration.valueParameters.size != 1 || !hasExtensionOrDispatchReceiver(declaration, context)) {
                 reporter.reportOn(declaration.source, FirErrors.INAPPLICABLE_INFIX_MODIFIER, context)
             }
             return
         }
-        if (declaration.isInfix) {
+        reporter.reportOn(declaration.source, FirErrors.INAPPLICABLE_INFIX_MODIFIER, context)
-            reporter.reportOn(declaration.source, FirErrors.INAPPLICABLE_INFIX_MODIFIER, context)
-        }
     }
 
     private fun hasExtensionOrDispatchReceiver(

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

@@ -31,16 +31,15 @@ import org.jetbrains.kotlin.fir.types.toSymbol
 import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
-object FirInlineDeclarationChecker : FirMemberDeclarationChecker() {
+object FirInlineDeclarationChecker : FirFunctionChecker() {
-    override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirFunction<*>, context: CheckerContext, reporter: DiagnosticReporter) {
         if (!declaration.isInline) return
         // local inline functions are prohibited
         if (declaration.isLocalMember) return
         if (declaration !is FirPropertyAccessor && declaration !is FirSimpleFunction) return
 
         val effectiveVisibility = declaration.effectiveVisibility
-        val function = declaration as FirFunction<*>
+        checkInlineFunctionBody(declaration, effectiveVisibility, context, reporter)
-        checkInlineFunctionBody(function, effectiveVisibility, context, reporter)
     }
 
     private fun checkInlineFunctionBody(
@@ -186,7 +185,9 @@ object FirInlineDeclarationChecker : FirMemberDeclarationChecker() {
 
         private fun FirQualifiedAccess.partOfCall(context: CheckerContext): Boolean {
             if (this !is FirExpression) return false
-            val containingQualifiedAccess = context.qualifiedAccessOrAnnotationCalls.getOrNull(context.qualifiedAccessOrAnnotationCalls.size - 2) ?: return false
+            val containingQualifiedAccess = context.qualifiedAccessOrAnnotationCalls.getOrNull(
+                context.qualifiedAccessOrAnnotationCalls.size - 2
+            ) ?: return false
             if (this == (containingQualifiedAccess as? FirQualifiedAccess)?.explicitReceiver) return true
             val call = containingQualifiedAccess as? FirCall ?: return false
             return call.arguments.any { it.unwrapArgument() == this }
@@ -283,7 +284,7 @@ object FirInlineDeclarationChecker : FirMemberDeclarationChecker() {
         private fun FirBasedSymbol<*>.isDefinedInInlineFunction(): Boolean {
             return when (val fir = this.fir) {
                 is FirAnonymousFunction -> true
-                is FirMemberDeclaration<*> -> fir.isLocalMember
+                is FirStatusOwner -> fir.isLocalMember
                 is FirAnonymousObject -> true
                 is FirRegularClass -> fir.classId.isLocal
                 else -> error("Unknown callable declaration type: ${fir.render()}")

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

@@ -90,8 +90,8 @@ object FirOverrideChecker : FirClassChecker() {
         overriddenSymbols: List<FirCallableSymbol<*>>,
     ): FirCallableDeclaration<*>? {
         for (overridden in overriddenSymbols) {
-            if (overridden.fir !is FirMemberDeclaration<*>) continue
+            if (overridden.fir !is FirStatusOwner) continue
-            val modality = (overridden.fir as FirMemberDeclaration<*>).status.modality
+            val modality = (overridden.fir as FirStatusOwner).status.modality
             val isEffectivelyFinal = modality == null || modality == Modality.FINAL
             if (isEffectivelyFinal) {
                 return overridden.fir
@@ -102,7 +102,7 @@ object FirOverrideChecker : FirClassChecker() {
 
     private fun FirProperty.checkMutability(
         overriddenSymbols: List<FirCallableSymbol<*>>,
-    ): FirMemberDeclaration<*>? {
+    ): FirStatusOwner? {
         if (isVar) return null
         return overriddenSymbols.find { (it.fir as? FirProperty)?.isVar == true }?.fir?.safeAs()
     }
@@ -113,8 +113,8 @@ object FirOverrideChecker : FirClassChecker() {
         context: CheckerContext
     ) {
         val visibilities = overriddenSymbols.mapNotNull {
-            if (it.fir !is FirMemberDeclaration<*>) return@mapNotNull null
+            if (it.fir !is FirStatusOwner) return@mapNotNull null
-            it to (it.fir as FirMemberDeclaration<*>).visibility
+            it to (it.fir as FirStatusOwner).visibility
         }.sortedBy { pair ->
             // Regard `null` compare as Int.MIN so that we can report CANNOT_CHANGE_... first deterministically
             Visibilities.compare(visibility, pair.second) ?: Int.MIN_VALUE
@@ -137,7 +137,7 @@ object FirOverrideChecker : FirClassChecker() {
         overriddenSymbols: List<FirCallableSymbol<*>>,
         typeCheckerContext: AbstractTypeCheckerContext,
         context: CheckerContext,
-    ): FirMemberDeclaration<*>? {
+    ): FirStatusOwner? {
         val overridingReturnType = returnTypeRef.coneType
 
         // Don't report *_ON_OVERRIDE diagnostics according to an error return type. That should be reported separately.
@@ -232,13 +232,13 @@ object FirOverrideChecker : FirClassChecker() {
     }
 
     @Suppress("UNUSED_PARAMETER") // TODO: delete me after implementing body
-    private fun DiagnosticReporter.reportNothingToOverride(declaration: FirMemberDeclaration<*>, context: CheckerContext) {
+    private fun DiagnosticReporter.reportNothingToOverride(declaration: FirStatusOwner, context: CheckerContext) {
         // TODO: not ready yet, e.g., Collections
         // reportOn(declaration.source, FirErrors.NOTHING_TO_OVERRIDE, declaration, context)
     }
 
     private fun DiagnosticReporter.reportOverridingFinalMember(
-        overriding: FirMemberDeclaration<*>,
+        overriding: FirStatusOwner,
         overridden: FirCallableDeclaration<*>,
         context: CheckerContext
     ) {
@@ -248,15 +248,15 @@ object FirOverrideChecker : FirClassChecker() {
     }
 
     private fun DiagnosticReporter.reportVarOverriddenByVal(
-        overriding: FirMemberDeclaration<*>,
+        overriding: FirStatusOwner,
-        overridden: FirMemberDeclaration<*>,
+        overridden: FirStatusOwner,
         context: CheckerContext
     ) {
         reportOn(overriding.source, FirErrors.VAR_OVERRIDDEN_BY_VAL, overriding, overridden, context)
     }
 
     private fun DiagnosticReporter.reportCannotWeakenAccessPrivilege(
-        overriding: FirMemberDeclaration<*>,
+        overriding: FirStatusOwner,
         overridden: FirCallableDeclaration<*>,
         context: CheckerContext
     ) {
@@ -272,7 +272,7 @@ object FirOverrideChecker : FirClassChecker() {
     }
 
     private fun DiagnosticReporter.reportCannotChangeAccessPrivilege(
-        overriding: FirMemberDeclaration<*>,
+        overriding: FirStatusOwner,
         overridden: FirCallableDeclaration<*>,
         context: CheckerContext
     ) {
@@ -288,24 +288,24 @@ object FirOverrideChecker : FirClassChecker() {
     }
 
     private fun DiagnosticReporter.reportReturnTypeMismatchOnFunction(
-        overriding: FirMemberDeclaration<*>,
+        overriding: FirStatusOwner,
-        overridden: FirMemberDeclaration<*>,
+        overridden: FirStatusOwner,
         context: CheckerContext
     ) {
         reportOn(overriding.source, FirErrors.RETURN_TYPE_MISMATCH_ON_OVERRIDE, overriding, overridden, context)
     }
 
     private fun DiagnosticReporter.reportTypeMismatchOnProperty(
-        overriding: FirMemberDeclaration<*>,
+        overriding: FirStatusOwner,
-        overridden: FirMemberDeclaration<*>,
+        overridden: FirStatusOwner,
         context: CheckerContext
     ) {
         reportOn(overriding.source, FirErrors.PROPERTY_TYPE_MISMATCH_ON_OVERRIDE, overriding, overridden, context)
     }
 
     private fun DiagnosticReporter.reportTypeMismatchOnVariable(
-        overriding: FirMemberDeclaration<*>,
+        overriding: FirStatusOwner,
-        overridden: FirMemberDeclaration<*>,
+        overridden: FirStatusOwner,
         context: CheckerContext
     ) {
         reportOn(overriding.source, FirErrors.VAR_TYPE_MISMATCH_ON_OVERRIDE, overriding, overridden, context)

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

@@ -17,18 +17,13 @@ import org.jetbrains.kotlin.fir.types.classId
 import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
-object FirSealedSupertypeChecker : FirMemberDeclarationChecker() {
+object FirSealedSupertypeChecker : FirClassChecker() {
-    override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirClass<*>, context: CheckerContext, reporter: DiagnosticReporter) {
-        if (declaration is FirClass<*>) {
+        // only the file declaration is present
-            // only the file declaration is present
+        if (declaration.classId.isLocal) {
-            if (declaration.classId.isLocal) {
+            checkLocalDeclaration(declaration, context, reporter)
-                checkLocalDeclaration(declaration, context, reporter)
+        } else {
-            } else {
+            checkGlobalDeclaration(declaration, context, reporter)
-                checkGlobalDeclaration(declaration, context, reporter)
-            }
-        } else if (declaration is FirProperty) {
-            val initializer = declaration.initializer as? FirAnonymousObjectExpression ?: return
-            checkLocalDeclaration(initializer.anonymousObject, context, reporter)
         }
     }
 

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

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirStatusOwner
 import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnsupportedDynamicType
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
@@ -18,10 +18,8 @@ import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.*
 
-object FirTypeAliasChecker : FirMemberDeclarationChecker() {
+object FirTopLevelTypeAliasChecker : FirTypeAliasChecker() {
-    override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirTypeAlias, context: CheckerContext, reporter: DiagnosticReporter) {
-        if (declaration !is FirTypeAlias) return
-
         if (context.containingDeclarations.lastOrNull() !is FirFile) {
             reporter.reportOn(declaration.source, FirErrors.TOPLEVEL_TYPEALIASES_ONLY, context)
         }

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

@@ -34,7 +34,7 @@ object FirTypeParameterBoundsChecker : FirTypeParameterChecker() {
         checkFinalUpperBounds(declaration, containingDeclaration, context, reporter)
         checkExtensionFunctionTypeBound(declaration, context, reporter)
 
-        if (containingDeclaration.safeAs<FirMemberDeclaration<*>>()?.isInlineOnly() != true) {
+        if (containingDeclaration.safeAs<FirStatusOwner>()?.isInlineOnly() != true) {
             checkOnlyOneTypeParameterBound(declaration, context, reporter)
         }
 

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCallableReferenceChecker.kt

@@ -47,7 +47,7 @@ object FirCallableReferenceChecker : FirQualifiedAccessExpressionChecker() {
             reporter.reportOn(source, FirErrors.CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR, context)
         }
         if ((referredDeclaration as? FirCallableMemberDeclaration<*>)?.isExtensionMember == true &&
-            (referredDeclaration as? FirMemberDeclaration<*>)?.isLocalMember == false
+            !referredDeclaration.isLocalMember
         ) {
             reporter.reportOn(source, FirErrors.EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED, referredDeclaration, context)
         }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantExplicitTypeChecker.kt

@@ -8,11 +8,10 @@ package org.jetbrains.kotlin.fir.analysis.checkers.extended
 import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
-import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirMemberDeclarationChecker
+import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirPropertyChecker
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.expressions.*
@@ -23,9 +22,8 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.types.ConstantValueKind
 
-object RedundantExplicitTypeChecker : FirMemberDeclarationChecker() {
+object RedundantExplicitTypeChecker : FirPropertyChecker() {
-    override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) {
-        if (declaration !is FirProperty) return
         if (!declaration.isLocal) return
 
         val initializer = declaration.initializer ?: return

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantModalityModifierSyntaxChecker.kt

@@ -17,21 +17,23 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_MODALIT
 import org.jetbrains.kotlin.fir.analysis.diagnostics.modalityModifier
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.declarations.FirClass
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirStatusOwner
 import org.jetbrains.kotlin.fir.declarations.modality
 import org.jetbrains.kotlin.psi.KtDeclaration
 
-object RedundantModalityModifierSyntaxChecker : FirDeclarationSyntaxChecker<FirMemberDeclaration<*>, KtDeclaration>() {
+object RedundantModalityModifierSyntaxChecker : FirDeclarationSyntaxChecker<FirDeclaration<*>, KtDeclaration>() {
 
-    override fun isApplicable(element: FirMemberDeclaration<*>, source: FirSourceElement): Boolean =
+    override fun isApplicable(element: FirDeclaration<*>, source: FirSourceElement): Boolean =
-        source.kind !is FirFakeSourceElementKind
+        source.kind !is FirFakeSourceElementKind && element is FirStatusOwner
 
     override fun checkLightTree(
-        element: FirMemberDeclaration<*>,
+        element: FirDeclaration<*>,
         source: FirSourceElement,
         context: CheckerContext,
         reporter: DiagnosticReporter
     ) {
+        require(element is FirStatusOwner)
         val modality = element.modality ?: return
         if (
             modality == Modality.FINAL

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantSetterParameterTypeChecker.kt

@@ -6,17 +6,15 @@
 package org.jetbrains.kotlin.fir.analysis.checkers.extended
 
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
-import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirMemberDeclarationChecker
+import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirPropertyChecker
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_SETTER_PARAMETER_TYPE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 
-object RedundantSetterParameterTypeChecker : FirMemberDeclarationChecker() {
+object RedundantSetterParameterTypeChecker : FirPropertyChecker() {
-    override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) {
-        if (declaration !is FirProperty) return
         val setter = declaration.setter ?: return
         if (setter is FirDefaultPropertyAccessor) return
         val valueParameter = setter.valueParameters.firstOrNull() ?: return

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantVisibilityModifierSyntaxChecker.kt

@@ -33,14 +33,15 @@ object RedundantVisibilityModifierSyntaxChecker : FirDeclarationSyntaxChecker<Fi
         if (element is FirConstructor && source.kind is FirFakeSourceElementKind) return
         if (source is FirFakeSourceElement) return
         if (
-            element !is FirMemberDeclaration<*>
+            element !is FirStatusOwner
             && !(element is FirPropertyAccessor && element.visibility == context.containingPropertyVisibility)
         ) return
 
         val visibilityModifier = source.treeStructure.visibilityModifier(source.lighterASTNode)
         val explicitVisibility = (visibilityModifier?.tokenType as? KtModifierKeywordToken)?.toVisibilityOrNull()
         val implicitVisibility = element.implicitVisibility(context)
-        val containingMemberDeclaration = context.findClosest<FirMemberDeclaration<*>>()
+        val containingMemberDeclaration = context.findClosest<FirStatusOwner>()
+        require(containingMemberDeclaration is FirDeclaration<*>?)
 
         val redundantVisibility = when {
             explicitVisibility == implicitVisibility -> implicitVisibility
@@ -105,7 +106,7 @@ object RedundantVisibilityModifierSyntaxChecker : FirDeclarationSyntaxChecker<Fi
     }
 
     private fun FirFunction<*>.visibility(): Visibility? {
-        (symbol.fir as? FirMemberDeclaration<*>)?.visibility?.let {
+        (symbol.fir as? FirStatusOwner)?.visibility?.let {
             return it
         }
 

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/DeclarationCheckersDiagnosticComponent.kt

@@ -42,7 +42,7 @@ class DeclarationCheckersDiagnosticComponent(
     }
 
     override fun visitTypeAlias(typeAlias: FirTypeAlias, data: CheckerContext) {
-        checkers.allMemberDeclarationCheckers.check(typeAlias, data, reporter)
+        checkers.allTypeAliasCheckers.check(typeAlias, data, reporter)
     }
 
     override fun visitConstructor(constructor: FirConstructor, data: CheckerContext) {

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt

@@ -58,7 +58,7 @@ object FirDiagnosticRenderers {
 
     val NAME = Renderer { element: FirElement ->
         when (element) {
-            is FirMemberDeclaration<*> -> DECLARATION_NAME.render(element)
+            is FirStatusOwner -> DECLARATION_NAME.render(element)
             is FirCallableDeclaration<*> -> element.symbol.callableId.callableName.asString()
             else -> "???"
         }
@@ -68,7 +68,7 @@ object FirDiagnosticRenderers {
         visibility.externalDisplayName
     }
 
-    val DECLARATION_NAME = Renderer { declaration: FirMemberDeclaration<*> ->
+    val DECLARATION_NAME = Renderer { declaration: FirStatusOwner ->
         val name = when (declaration) {
             is FirProperty -> declaration.name
             is FirSimpleFunction -> declaration.name

compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt

@@ -912,15 +912,15 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
         }
     }
 
-    private fun FlowContent.generate(memberDeclaration: FirMemberDeclaration<*>) {
+    private fun FlowContent.generate(statusOwner: FirStatusOwner) {
-        when (memberDeclaration) {
+        when (statusOwner) {
-            is FirEnumEntry -> generate(memberDeclaration)
+            is FirEnumEntry -> generate(statusOwner)
-            is FirRegularClass -> generate(memberDeclaration)
+            is FirRegularClass -> generate(statusOwner)
-            is FirSimpleFunction -> generate(memberDeclaration)
+            is FirSimpleFunction -> generate(statusOwner)
-            is FirProperty -> if (memberDeclaration.isLocal) generate(memberDeclaration as FirVariable<*>) else generate(memberDeclaration)
+            is FirProperty -> if (statusOwner.isLocal) generate(statusOwner as FirVariable<*>) else generate(statusOwner)
-            is FirConstructor -> generate(memberDeclaration)
+            is FirConstructor -> generate(statusOwner)
-            is FirTypeAlias -> generate(memberDeclaration)
+            is FirTypeAlias -> generate(statusOwner)
-            else -> unsupported(memberDeclaration)
+            else -> unsupported(statusOwner)
         }
     }
 
@@ -1770,7 +1770,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
     private fun FlowContent.generate(declaration: FirDeclaration<*>) {
         when (declaration) {
             is FirAnonymousInitializer -> generate(declaration)
-            is FirMemberDeclaration<*> -> generate(declaration)
+            is FirStatusOwner -> generate(declaration as FirStatusOwner)
             else -> unsupported(declaration)
         }
     }

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirJvmModuleVisibilityChecker.kt

@@ -7,11 +7,12 @@ package org.jetbrains.kotlin.fir.session
 
 import org.jetbrains.kotlin.fir.FirModuleVisibilityChecker
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirStatusOwner
 import org.jetbrains.kotlin.fir.moduleData
 
 class FirJvmModuleVisibilityChecker(private val session: FirSession) : FirModuleVisibilityChecker {
-    override fun isInFriendModule(declaration: FirMemberDeclaration<*>): Boolean {
+    override fun <T> isInFriendModule(declaration: T): Boolean where T : FirStatusOwner, T : FirDeclaration<*> {
         val useSiteModuleData = session.moduleData
         val declarationModuleData = declaration.moduleData
         return useSiteModuleData == declarationModuleData || declarationModuleData in useSiteModuleData.friendDependencies

compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt

@@ -195,7 +195,7 @@ fun deserializeClassToSymbol(
             override fun compare(a: FirDeclaration<*>, b: FirDeclaration<*>): Int {
                 // Reorder members based on their type and name only.
                 // See FE 1.0's [DeserializedMemberScope#addMembers].
-                if (a is FirMemberDeclaration<*> && b is FirMemberDeclaration<*>) {
+                if (a is FirStatusOwner && b is FirStatusOwner) {
                     return FirMemberDeclarationComparator.TypeAndNameComparator.compare(a, b)
                 }
                 return 0

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt

@@ -681,7 +681,7 @@ class FirElementSerializer private constructor(
             }
             is ConeTypeParameterType -> {
                 val typeParameter = type.lookupTag.typeParameterSymbol.fir
-                if (typeParameter in (containingDeclaration as? FirMemberDeclaration<*>)?.typeParameters ?: emptyList()) {
+                if (typeParameter in (containingDeclaration as? FirStatusOwner)?.typeParameters ?: emptyList()) {
                     builder.typeParameterName = getSimpleNameIndex(typeParameter.name)
                 } else {
                     builder.typeParameter = getTypeParameterId(typeParameter)
@@ -927,7 +927,7 @@ class FirElementSerializer private constructor(
     }
 
 
-    private fun normalizeVisibility(declaration: FirMemberDeclaration<*>): Visibility {
+    private fun normalizeVisibility(declaration: FirStatusOwner): Visibility {
         return declaration.visibility.normalize()
     }
 

compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmMangleComputer.kt

@@ -31,7 +31,7 @@ open class FirJvmMangleComputer(
     private val session: FirSession
 ) : FirVisitor<Unit, Boolean>(), KotlinMangleComputer<FirDeclaration<*>> {
 
-    private val typeParameterContainer = ArrayList<FirMemberDeclaration<*>>(4)
+    private val typeParameterContainer = ArrayList<FirStatusOwner>(4)
 
     private var isRealExpect = false
 
@@ -111,9 +111,9 @@ open class FirJvmMangleComputer(
 
     private fun FirFunction<*>.mangleFunction(isCtor: Boolean, isStatic: Boolean, container: FirDeclaration<*>) {
 
-        isRealExpect = isRealExpect || (this as? FirMemberDeclaration<*>)?.isExpect == true
+        isRealExpect = isRealExpect || (this as? FirStatusOwner)?.isExpect == true
 
-        if (container is FirMemberDeclaration<*>) {
+        if (container is FirStatusOwner) {
             typeParameterContainer.add(container)
         }
         visitParent()
@@ -164,7 +164,7 @@ open class FirJvmMangleComputer(
         }
     }
 
-    private fun FirTypeParameter.effectiveParent(): FirMemberDeclaration<*> {
+    private fun FirTypeParameter.effectiveParent(): FirStatusOwner {
         for (parent in typeParameterContainer) {
             if (this in parent.typeParameters) {
                 return parent

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/AdapterGenerator.kt

@@ -177,7 +177,7 @@ internal class AdapterGenerator(
     ): IrSimpleFunction {
         val returnType = type.arguments.last().typeOrNull!!
         val parameterTypes = type.arguments.dropLast(1).map { it.typeOrNull!! }
-        val firMemberAdaptee = firAdaptee as FirMemberDeclaration<*>
+        val firMemberAdaptee = firAdaptee as FirStatusOwner
         return irFactory.createFunction(
             startOffset, endOffset,
             IrDeclarationOrigin.ADAPTER_FOR_CALLABLE_REFERENCE,
@@ -297,7 +297,7 @@ internal class AdapterGenerator(
                 boundDispatchReceiver != null -> irCall.dispatchReceiver = receiverValue
                 boundExtensionReceiver != null -> irCall.extensionReceiver = receiverValue
             }
-        } else if (callableReferenceAccess.explicitReceiver is FirResolvedQualifier && ((firAdaptee as? FirMemberDeclaration<*>)?.isStatic != true)) {
+        } else if (callableReferenceAccess.explicitReceiver is FirResolvedQualifier && ((firAdaptee as? FirStatusOwner)?.isStatic != true)) {
             // Unbound callable reference 'A::foo'
             val adaptedReceiverParameter = adapterFunction.valueParameters[0]
             val adaptedReceiverValue = IrGetValueImpl(

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/AbstractFir2IrLazyDeclaration.kt

@@ -5,9 +5,11 @@
 
 package org.jetbrains.kotlin.fir.lazy
 
+import org.jetbrains.kotlin.fir.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
 import org.jetbrains.kotlin.fir.backend.toIrType
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirCallableMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirStatusOwner
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.symbols.Fir2IrBindableSymbol
 import org.jetbrains.kotlin.ir.declarations.IrDeclaration
@@ -18,8 +20,8 @@ import org.jetbrains.kotlin.ir.declarations.lazy.lazyVar
 import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import kotlin.properties.ReadWriteProperty
 
-interface AbstractFir2IrLazyDeclaration<F : FirMemberDeclaration<*>, D : IrDeclaration> :
+interface AbstractFir2IrLazyDeclaration<F, D : IrDeclaration> :
-    IrDeclaration, IrDeclarationParent, Fir2IrComponents {
+    IrDeclaration, IrDeclarationParent, Fir2IrComponents where F : FirStatusOwner, F : FirAnnotationContainer {
 
     val fir: F
     override val symbol: Fir2IrBindableSymbol<*, D>

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/AbstractFir2IrLazyFunction.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.lazy
 import org.jetbrains.kotlin.descriptors.DescriptorVisibility
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.fir.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
 import org.jetbrains.kotlin.fir.backend.declareThisReceiverParameter
 import org.jetbrains.kotlin.fir.declarations.*
@@ -27,7 +28,7 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.resolve.annotations.JVM_STATIC_ANNOTATION_FQ_NAME
 import kotlin.properties.ReadWriteProperty
 
-abstract class AbstractFir2IrLazyFunction<F : FirMemberDeclaration<*>>(
+abstract class AbstractFir2IrLazyFunction<F : FirCallableMemberDeclaration<*>>(
     components: Fir2IrComponents,
     override val startOffset: Int,
     override val endOffset: Int,

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyPropertyAccessor.kt

@@ -34,12 +34,12 @@ class Fir2IrLazyPropertyAccessor(
     firParentClass: FirRegularClass,
     symbol: Fir2IrSimpleFunctionSymbol,
     isFakeOverride: Boolean
-) : AbstractFir2IrLazyFunction<FirMemberDeclaration<*>>(components, startOffset, endOffset, origin, symbol, isFakeOverride) {
+) : AbstractFir2IrLazyFunction<FirCallableMemberDeclaration<*>>(components, startOffset, endOffset, origin, symbol, isFakeOverride) {
     init {
         symbol.bind(this)
     }
 
-    override val fir: FirMemberDeclaration<*>
+    override val fir: FirCallableMemberDeclaration<*>
         get() = firAccessor ?: firParentProperty
 
     // TODO: investigate why some deserialized properties are inline

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt

@@ -452,8 +452,6 @@ class JavaSymbolProvider(
             source = (javaMethod as? JavaElementImpl<*>)?.psi?.toFirPsiSourceElement()
             symbol = methodSymbol
             name = methodName
-            visibility = javaMethod.visibility
-            modality = javaMethod.modality
             returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session, javaTypeParameterStack)
             isStatic = javaMethod.isStatic
             typeParameters += javaMethod.typeParameters.convertTypeParameters(javaTypeParameterStack)

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaField.kt

@@ -41,7 +41,7 @@ class FirJavaField @FirImplementationDetail constructor(
     override var status: FirDeclarationStatus,
     override val isVar: Boolean,
     annotationBuilder: () -> List<FirAnnotationCall>,
-    override val typeParameters: MutableList<FirTypeParameter>,
+    override val typeParameters: MutableList<FirTypeParameterRef>,
     override var initializer: FirExpression?,
     override val dispatchReceiverType: ConeKotlinType?,
     override val attributes: FirDeclarationAttributes,

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaMethod.kt

@@ -5,8 +5,6 @@
 
 package org.jetbrains.kotlin.fir.java.declarations
 
-import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirImplementationDetail
 import org.jetbrains.kotlin.fir.FirModuleData
 import org.jetbrains.kotlin.fir.FirSourceElement
@@ -186,22 +184,27 @@ class FirJavaMethodBuilder : FirFunctionBuilder, FirTypeParametersOwnerBuilder,
     override lateinit var returnTypeRef: FirTypeRef
     override val valueParameters: MutableList<FirValueParameter> = mutableListOf()
     override var body: FirBlock? = null
-    lateinit var status: FirDeclarationStatus
+    override lateinit var status: FirDeclarationStatus
-    var dispatchReceiverType: ConeKotlinType? = null
+    override var dispatchReceiverType: ConeKotlinType? = null
     lateinit var name: Name
     lateinit var symbol: FirNamedFunctionSymbol
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
     override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
-    lateinit var visibility: Visibility
-    var modality: Modality? = null
     var isStatic: Boolean by Delegates.notNull()
     override var resolvePhase: FirResolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
     lateinit var annotationBuilder: () -> List<FirAnnotationCall>
 
+    @Deprecated("Modification of 'containerSource' has no impact for FirJavaFunctionBuilder", level = DeprecationLevel.HIDDEN)
+    override var containerSource: DeserializedContainerSource?
+        get() = throw IllegalStateException()
+        set(_) {
+            throw IllegalStateException()
+        }
+
     @Deprecated("Modification of 'origin' has no impact for FirJavaFunctionBuilder", level = DeprecationLevel.HIDDEN)
     override var origin: FirDeclarationOrigin
         get() = throw IllegalStateException()
-        set(@Suppress("UNUSED_PARAMETER") value) {
+        set(_) {
             throw IllegalStateException()
         }
 

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaValueParameter.kt

@@ -10,16 +10,19 @@ import org.jetbrains.kotlin.fir.FirModuleData
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
 import org.jetbrains.kotlin.fir.symbols.impl.FirDelegateFieldSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.fir.visitors.transformSingle
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
@@ -79,6 +82,18 @@ class FirJavaValueParameter @FirImplementationDetail constructor(
     override val controlFlowGraphReference: FirControlFlowGraphReference?
         get() = null
 
+    override val typeParameters: List<FirTypeParameterRef>
+        get() = emptyList()
+
+    override val status: FirDeclarationStatus
+        get() = FirResolvedDeclarationStatusImpl.DEFAULT_STATUS_FOR_STATUSLESS_DECLARATIONS
+
+    override val containerSource: DeserializedContainerSource?
+        get() = null
+
+    override val dispatchReceiverType: ConeKotlinType?
+        get() = null
+
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         returnTypeRef.accept(visitor, data)
         annotations.forEach { it.accept(visitor, data) }
@@ -125,6 +140,14 @@ class FirJavaValueParameter @FirImplementationDetail constructor(
         return this
     }
 
+    override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirValueParameter {
+        return this
+    }
+
+    override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirValueParameter {
+        return this
+    }
+
     override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
         resolvePhase = newResolvePhase
     }

compiler/fir/jvm/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/ConeEquivalentCallConflictResolver.kt

@@ -68,7 +68,7 @@ class ConeEquivalentCallConflictResolver(
         return when (declaration) {
             is FirSimpleFunction -> createFlatSignature(call, declaration)
             is FirConstructor -> createFlatSignature(call, declaration)
-            is FirVariable<*> -> createFlatSignature(call, declaration as FirVariable<*>)
+            is FirVariable<*> -> createFlatSignature(call, declaration)
             else -> error("Not supported: $declaration")
         }
     }

compiler/fir/jvm/src/org/jetbrains/kotlin/fir/scopes/jvm/DescriptorUtils.kt

@@ -21,7 +21,6 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 
 fun FirFunction<*>.computeJvmSignature(typeConversion: (FirTypeRef) -> ConeKotlinType? = FirTypeRef::coneTypeSafe): String? {
-    if (this !is FirCallableMemberDeclaration<*>) return null
     val containingClass = containingClass() ?: return null
 
     return SignatureBuildingComponents.signature(containingClass.classId, computeJvmDescriptor(typeConversion = typeConversion))

compiler/fir/raw-fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.fir.contracts.impl.FirEmptyContractDescription
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
+import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirEmptyArgumentList
 import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
@@ -180,7 +181,7 @@ private fun throwTwiceVisitingError(element: FirElement) {
         element is FirTypeProjection || element is FirValueParameter || element is FirAnnotationCall ||
         element is FirEmptyContractDescription ||
         element is FirStubReference || element.isExtensionFunctionAnnotation || element is FirEmptyArgumentList ||
-        element is FirStubStatement
+        element is FirStubStatement || element === FirResolvedDeclarationStatusImpl.DEFAULT_STATUS_FOR_STATUSLESS_DECLARATIONS
     ) {
         return
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt

@@ -596,7 +596,7 @@ class FirCallResolver(
                     createResolvedReferenceWithoutCandidateForLocalVariables &&
                     explicitReceiver?.typeRef?.coneTypeSafe<ConeIntegerLiteralType>() == null &&
                     coneSymbol is FirVariableSymbol &&
-                    (coneSymbol !is FirPropertySymbol || (coneSymbol.fir as FirMemberDeclaration<*>).typeParameters.isEmpty())
+                    (coneSymbol !is FirPropertySymbol || (coneSymbol.fir as FirStatusOwner).typeParameters.isEmpty())
                 ) {
                     return buildResolvedNamedReference {
                         this.source = source

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirVisibilityChecker.kt

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 
 interface FirModuleVisibilityChecker : FirSessionComponent {
-    fun isInFriendModule(declaration: FirMemberDeclaration<*>): Boolean
+    fun <T> isInFriendModule(declaration: T): Boolean where T : FirStatusOwner, T : FirDeclaration<*>
 }
 
 abstract class FirVisibilityChecker : FirSessionComponent {
@@ -43,12 +43,12 @@ abstract class FirVisibilityChecker : FirSessionComponent {
     }
 
     fun isVisible(
-        declaration: FirMemberDeclaration<*>,
+        declaration: FirStatusOwner,
         candidate: Candidate
     ): Boolean {
         if (declaration is FirCallableDeclaration<*> && (declaration.isIntersectionOverride || declaration.isSubstitutionOverride)) {
             @Suppress("UNCHECKED_CAST")
-            return isVisible(declaration.originalIfFakeOverride() as FirMemberDeclaration<*>, candidate)
+            return isVisible(declaration.originalIfFakeOverride() as FirStatusOwner, candidate)
         }
 
         val callInfo = candidate.callInfo
@@ -60,12 +60,13 @@ abstract class FirVisibilityChecker : FirSessionComponent {
     }
 
     fun isVisible(
-        declaration: FirMemberDeclaration<*>,
+        declaration: FirStatusOwner,
         session: FirSession,
         useSiteFile: FirFile,
         containingDeclarations: List<FirDeclaration<*>>,
         dispatchReceiver: ReceiverValue?
     ): Boolean {
+        require(declaration is FirDeclaration<*>)
         val provider = session.firProvider
         val symbol = declaration.symbol
         return when (declaration.visibility) {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt

@@ -413,7 +413,7 @@ fun FirFunction<*>.getAsForbiddenNamedArgumentsTarget(session: FirSession): Forb
             }
         }
     }
-    if (this is FirMemberDeclaration<*> && status.isExpect) {
+    if (status.isExpect) {
         return ForbiddenNamedArgumentsTarget.EXPECTED_CLASS_MEMBER
     }
     return when (origin) {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CallableReferenceResolution.kt

@@ -407,6 +407,6 @@ private fun FirVariable<*>.canBeMutableReference(candidate: Candidate): Boolean
     if (this is FirField) return true
     val original = this.unwrapFakeOverrides()
     return original.source?.kind == FirFakeSourceElementKind.PropertyFromParameter ||
-            (original.setter is FirMemberDeclaration<*> &&
+            (original.setter is FirStatusOwner &&
                     candidate.callInfo.session.visibilityChecker.isVisible(original.setter!!, candidate))
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.resolve.calls
 
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirStatusOwner
 import org.jetbrains.kotlin.fir.declarations.modality
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.inference.ConeTypeParameterBasedTypeVariable
@@ -102,7 +102,7 @@ class ConeOverloadConflictResolver(
         }
 
         if (discriminateAbstracts) {
-            val filtered = candidates.filterTo(mutableSetOf()) { (it.symbol.fir as? FirMemberDeclaration<*>)?.modality != Modality.ABSTRACT }
+            val filtered = candidates.filterTo(mutableSetOf()) { (it.symbol.fir as? FirStatusOwner)?.modality != Modality.ABSTRACT }
             when (filtered.size) {
                 1 -> return filtered
                 0, candidates.size -> {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt

@@ -100,7 +100,7 @@ object CheckDispatchReceiver : ResolutionStage() {
     override suspend fun check(candidate: Candidate, callInfo: CallInfo, sink: CheckerSink, context: ResolutionContext) {
         val explicitReceiverExpression = callInfo.explicitReceiver
         if (explicitReceiverExpression.isSuperCall()) {
-            val status = candidate.symbol.fir as? FirMemberDeclaration<*>
+            val status = candidate.symbol.fir as? FirStatusOwner
             if (status?.modality == Modality.ABSTRACT) {
                 sink.reportDiagnostic(ResolvedWithLowPriority)
             }
@@ -196,7 +196,7 @@ internal object CheckVisibility : CheckerStage() {
         val visibilityChecker = callInfo.session.visibilityChecker
         val symbol = candidate.symbol
         val declaration = symbol.fir
-        if (declaration is FirMemberDeclaration<*>) {
+        if (declaration is FirStatusOwner) {
             if (!checkVisibility(declaration, sink, candidate, visibilityChecker)) {
                 return
             }
@@ -215,7 +215,7 @@ internal object CheckVisibility : CheckerStage() {
         }
     }
 
-    private suspend fun <T : FirMemberDeclaration<*>> checkVisibility(
+    private suspend fun <T : FirStatusOwner> checkVisibility(
         declaration: T,
         sink: CheckerSink,
         candidate: Candidate,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt

@@ -88,7 +88,7 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(
         }
     }
 
-    protected fun FirMemberDeclaration<*>.addTypeParametersScope() {
+    protected fun FirStatusOwner.addTypeParametersScope() {
         if (typeParameters.isNotEmpty()) {
             scopes.add(FirMemberTypeParameterScope(this))
         }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt

@@ -171,7 +171,7 @@ open class FirApplySupertypesTransformer(
 }
 
 private fun FirClassLikeDeclaration<*>.typeParametersScope(): FirScope? {
-    if (this !is FirMemberDeclaration<*> || typeParameters.isEmpty()) return null
+    if (this !is FirStatusOwner || typeParameters.isEmpty()) return null
     return FirMemberTypeParameterScope(this)
 }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt

@@ -220,7 +220,7 @@ class BodyResolveContext(
     }
 
     @PrivateForInline
-    inline fun <T> withTypeParametersOf(declaration: FirMemberDeclaration<*>, l: () -> T): T {
+    inline fun <T> withTypeParametersOf(declaration: FirStatusOwner, l: () -> T): T {
         if (declaration.typeParameters.isEmpty()) return l()
         val scope = FirMemberTypeParameterScope(declaration)
         return withTowerDataCleanup {
@@ -229,7 +229,7 @@ class BodyResolveContext(
         }
     }
 
-    private fun FirMemberDeclaration<*>.typeParameterScope(): FirMemberTypeParameterScope? {
+    private fun FirStatusOwner.typeParameterScope(): FirMemberTypeParameterScope? {
         if (typeParameters.isEmpty()) return null
         return FirMemberTypeParameterScope(this)
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt

@@ -47,7 +47,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
     private val statusResolver: FirStatusResolver = FirStatusResolver(session, scopeSession)
 
     private fun FirDeclaration<*>.visibilityForApproximation(): Visibility {
-        if (this !is FirMemberDeclaration<*>) return Visibilities.Local
+        if (this !is FirStatusOwner) return Visibilities.Local
         val container = context.containers.getOrNull(context.containers.size - 2)
         val containerVisibility =
             if (container == null) Visibilities.Public
@@ -90,13 +90,13 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
         }
     }
 
-    protected fun createTypeParameterScope(declaration: FirMemberDeclaration<*>): FirMemberTypeParameterScope? {
+    protected fun createTypeParameterScope(declaration: FirStatusOwner): FirMemberTypeParameterScope? {
         if (declaration.typeParameters.isEmpty()) return null
         doTransformTypeParameters(declaration)
         return FirMemberTypeParameterScope(declaration)
     }
 
-    private fun doTransformTypeParameters(declaration: FirMemberDeclaration<*>) {
+    private fun doTransformTypeParameters(declaration: FirStatusOwner) {
         for (typeParameter in declaration.typeParameters) {
             (typeParameter as? FirTypeParameter)?.let { transformer.replaceDeclarationResolvePhaseIfNeeded(it, FirResolvePhase.STATUS) }
             typeParameter.transformChildren(transformer, ResolutionMode.ContextIndependent)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirGlobalExtensionStatusProcessor.kt

@@ -30,7 +30,7 @@ class FirGlobalExtensionStatusProcessor(
             val declarations = provider.getSymbolsWithOwnersByPredicate(extension.predicate)
             for ((declaration, owners) in declarations) {
                 // TODO: maybe replace with visitor?
-                if (declaration is FirMemberDeclaration<*>) {
+                if (declaration is FirStatusOwner) {
                     val newStatus = extension.transformStatus(declaration, owners, declaration.status)
                     declaration.transformStatus(ReplaceStatus, newStatus)
                 }
@@ -49,9 +49,9 @@ class FirTransformerBasedExtensionStatusProcessor(
         private val extensions = session.extensionService.statusTransformerExtensions
         private val predicateBasedProvider = session.predicateBasedProvider
 
-        private fun FirMemberDeclaration<*>.updateStatus() {
+        private fun FirStatusOwner.updateStatus() {
             if (extensions.isEmpty()) return
-            val owners = predicateBasedProvider.getOwnersOfDeclaration(this)
+            val owners = predicateBasedProvider.getOwnersOfDeclaration(this as FirAnnotatedDeclaration<*>)
             requireNotNull(owners)
             var status = this.status
             for (extension in extensions) {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractImportingScope.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.scopes.impl
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirStatusOwner
 import org.jetbrains.kotlin.fir.declarations.FirResolvedImport
 import org.jetbrains.kotlin.fir.declarations.expandedConeType
 import org.jetbrains.kotlin.fir.moduleData
@@ -31,7 +31,8 @@ enum class FirImportingScopeFilter {
     fun check(symbol: FirClassLikeSymbol<*>, session: FirSession): Boolean {
         if (this == ALL) return true
         // TODO: also check DeprecationLevel.HIDDEN and required Kotlin version
-        val fir = symbol.fir as? FirMemberDeclaration<*> ?: return false
+        val fir = symbol.fir
+        if (fir !is  FirStatusOwner) return false
         val isVisible = when (fir.status.visibility) {
             // When importing from the same module, status may be unknown because the status resolver depends on super types
             // to determine visibility for functions, so it may not have finished yet. Since we only care about classes,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirMemberTypeParameterScope.kt

@@ -5,12 +5,12 @@
 
 package org.jetbrains.kotlin.fir.scopes.impl
 
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirStatusOwner
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.scopes.FirTypeParameterScope
 import org.jetbrains.kotlin.name.Name
 
-class FirMemberTypeParameterScope(callableMember: FirMemberDeclaration<*>) : FirTypeParameterScope() {
+class FirMemberTypeParameterScope(callableMember: FirStatusOwner) : FirTypeParameterScope() {
     override val typeParameters: Map<Name, List<FirTypeParameter>> =
         callableMember.typeParameters.filterIsInstance<FirTypeParameter>().groupBy { it.name }
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirTypeIntersectionScope.kt

@@ -96,7 +96,7 @@ class FirTypeIntersectionScope private constructor(
             val maxByVisibility = findMemberWithMaxVisibility(allMembersWithScope)
             val extractBothWaysWithPrivate = extractBothWaysOverridable(maxByVisibility, allMembersWithScope)
             val extractedOverrides = extractBothWaysWithPrivate.filterNotTo(mutableListOf()) {
-                Visibilities.isPrivate((it.member.fir as FirMemberDeclaration<*>).visibility)
+                Visibilities.isPrivate((it.member.fir as FirStatusOwner).visibility)
             }.takeIf { it.isNotEmpty() } ?: extractBothWaysWithPrivate
             val baseMembersForIntersection = extractedOverrides.calcBaseMembersForIntersectionOverride()
             if (baseMembersForIntersection.size > 1) {
@@ -187,7 +187,7 @@ class FirTypeIntersectionScope private constructor(
         var hasAbstract = false
 
         for ((member) in extractedOverridden) {
-            when ((member.fir as FirMemberDeclaration<*>).modality) {
+            when ((member.fir as FirStatusOwner).modality) {
                 Modality.FINAL -> return Modality.FINAL
                 Modality.SEALED -> {
                     // Members should not be sealed. But, that will be reported as WRONG_MODIFIER_TARGET, and here we shouldn't raise an
@@ -218,7 +218,7 @@ class FirTypeIntersectionScope private constructor(
         val realOverridden = extractedOverridden.flatMap { realOverridden(it.member, it.baseScope, processDirectOverridden) }
         val filteredOverridden = filterOutOverridden(realOverridden, processDirectOverridden)
 
-        return filteredOverridden.minOf { (it.member.fir as FirMemberDeclaration<*>).modality ?: Modality.ABSTRACT }
+        return filteredOverridden.minOf { (it.member.fir as FirStatusOwner).modality ?: Modality.ABSTRACT }
     }
 
     private fun <D : FirCallableSymbol<*>> realOverridden(
@@ -296,7 +296,7 @@ class FirTypeIntersectionScope private constructor(
     ): Visibility {
         var maxVisibility: Visibility = Visibilities.Private
         for ((override) in extractedOverrides) {
-            val visibility = (override.fir as FirMemberDeclaration<*>).visibility
+            val visibility = (override.fir as FirStatusOwner).visibility
             // TODO: There is more complex logic at org.jetbrains.kotlin.resolve.OverridingUtil.resolveUnknownVisibilityForMember
             // TODO: and org.jetbrains.kotlin.resolve.OverridingUtil.findMaxVisibility
             val compare = Visibilities.compare(visibility, maxVisibility) ?: return Visibilities.DEFAULT_VISIBILITY

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnnotatedDeclaration.kt

@@ -18,14 +18,14 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-sealed interface FirAnnotatedDeclaration<E : FirAnnotatedDeclaration<E>> : FirDeclaration<E>, FirAnnotationContainer {
+sealed class FirAnnotatedDeclaration<E : FirAnnotatedDeclaration<E>> : FirDeclaration<E>(), FirAnnotationContainer {
-    override val source: FirSourceElement?
+    abstract override val source: FirSourceElement?
-    override val symbol: FirBasedSymbol<E>
+    abstract override val symbol: FirBasedSymbol<E>
-    override val moduleData: FirModuleData
+    abstract override val moduleData: FirModuleData
-    override val resolvePhase: FirResolvePhase
+    abstract override val resolvePhase: FirResolvePhase
-    override val origin: FirDeclarationOrigin
+    abstract override val origin: FirDeclarationOrigin
-    override val attributes: FirDeclarationAttributes
+    abstract override val attributes: FirDeclarationAttributes
-    override val annotations: List<FirAnnotationCall>
+    abstract override val annotations: List<FirAnnotationCall>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnnotatedDeclaration(this, data)
 
@@ -33,7 +33,7 @@ sealed interface FirAnnotatedDeclaration<E : FirAnnotatedDeclaration<E>> : FirDe
     override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
         transformer.transformAnnotatedDeclaration(this, data) as E
 
-    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+    abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
 
-    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAnnotatedDeclaration<E>
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAnnotatedDeclaration<E>
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnonymousFunction.kt

@@ -14,7 +14,9 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
 import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousFunctionSymbol
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 import org.jetbrains.kotlin.fir.visitors.*
 
 /*
@@ -31,6 +33,9 @@ abstract class FirAnonymousFunction : FirFunction<FirAnonymousFunction>(), FirTy
     abstract override val annotations: List<FirAnnotationCall>
     abstract override val returnTypeRef: FirTypeRef
     abstract override val receiverTypeRef: FirTypeRef?
+    abstract override val status: FirDeclarationStatus
+    abstract override val containerSource: DeserializedContainerSource?
+    abstract override val dispatchReceiverType: ConeKotlinType?
     abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
     abstract override val valueParameters: List<FirValueParameter>
     abstract override val body: FirBlock?
@@ -72,6 +77,8 @@ abstract class FirAnonymousFunction : FirFunction<FirAnonymousFunction>(), FirTy
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirAnonymousFunction
 
+    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirAnonymousFunction
+
     abstract override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirAnonymousFunction
 
     abstract override fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirAnonymousFunction

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnonymousInitializer.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.declarations
 
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirModuleData
-import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
@@ -19,7 +18,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirAnonymousInitializer : FirPureAbstractElement(), FirDeclaration<FirAnonymousInitializer>, FirControlFlowGraphOwner {
+abstract class FirAnonymousInitializer : FirDeclaration<FirAnonymousInitializer>(), FirControlFlowGraphOwner {
     abstract override val source: FirSourceElement?
     abstract override val moduleData: FirModuleData
     abstract override val resolvePhase: FirResolvePhase

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirCallableDeclaration.kt

@@ -18,16 +18,16 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-sealed interface FirCallableDeclaration<E : FirCallableDeclaration<E>> : FirTypedDeclaration<E> {
+sealed class FirCallableDeclaration<E : FirCallableDeclaration<E>> : FirTypedDeclaration<E>() {
-    override val source: FirSourceElement?
+    abstract override val source: FirSourceElement?
-    override val moduleData: FirModuleData
+    abstract override val moduleData: FirModuleData
-    override val resolvePhase: FirResolvePhase
+    abstract override val resolvePhase: FirResolvePhase
-    override val origin: FirDeclarationOrigin
+    abstract override val origin: FirDeclarationOrigin
-    override val attributes: FirDeclarationAttributes
+    abstract override val attributes: FirDeclarationAttributes
-    override val annotations: List<FirAnnotationCall>
+    abstract override val annotations: List<FirAnnotationCall>
-    override val returnTypeRef: FirTypeRef
+    abstract override val returnTypeRef: FirTypeRef
-    val receiverTypeRef: FirTypeRef?
+    abstract val receiverTypeRef: FirTypeRef?
-    override val symbol: FirCallableSymbol<E>
+    abstract override val symbol: FirCallableSymbol<E>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitCallableDeclaration(this, data)
 
@@ -35,15 +35,15 @@ sealed interface FirCallableDeclaration<E : FirCallableDeclaration<E>> : FirType
     override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
         transformer.transformCallableDeclaration(this, data) as E
 
-    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+    abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
 
-    override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
+    abstract override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
 
-    fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?)
+    abstract fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?)
 
-    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirCallableDeclaration<E>
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirCallableDeclaration<E>
 
-    override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirCallableDeclaration<E>
+    abstract override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirCallableDeclaration<E>
 
-    fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirCallableDeclaration<E>
+    abstract fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirCallableDeclaration<E>
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirCallableMemberDeclaration.kt

@@ -20,20 +20,20 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-sealed interface FirCallableMemberDeclaration<E : FirCallableMemberDeclaration<E>> : FirCallableDeclaration<E>, FirMemberDeclaration<E> {
+sealed class FirCallableMemberDeclaration<E : FirCallableMemberDeclaration<E>> : FirCallableDeclaration<E>(), FirStatusOwner {
-    override val source: FirSourceElement?
+    abstract override val source: FirSourceElement?
-    override val moduleData: FirModuleData
+    abstract override val moduleData: FirModuleData
-    override val resolvePhase: FirResolvePhase
+    abstract override val resolvePhase: FirResolvePhase
-    override val origin: FirDeclarationOrigin
+    abstract override val origin: FirDeclarationOrigin
-    override val attributes: FirDeclarationAttributes
+    abstract override val attributes: FirDeclarationAttributes
-    override val annotations: List<FirAnnotationCall>
+    abstract override val annotations: List<FirAnnotationCall>
-    override val returnTypeRef: FirTypeRef
+    abstract override val returnTypeRef: FirTypeRef
-    override val receiverTypeRef: FirTypeRef?
+    abstract override val receiverTypeRef: FirTypeRef?
-    override val symbol: FirCallableSymbol<E>
+    abstract override val symbol: FirCallableSymbol<E>
-    override val typeParameters: List<FirTypeParameterRef>
+    abstract override val typeParameters: List<FirTypeParameterRef>
-    override val status: FirDeclarationStatus
+    abstract override val status: FirDeclarationStatus
-    val containerSource: DeserializedContainerSource?
+    abstract val containerSource: DeserializedContainerSource?
-    val dispatchReceiverType: ConeKotlinType?
+    abstract val dispatchReceiverType: ConeKotlinType?
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitCallableMemberDeclaration(this, data)
 
@@ -41,19 +41,19 @@ sealed interface FirCallableMemberDeclaration<E : FirCallableMemberDeclaration<E
     override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
         transformer.transformCallableMemberDeclaration(this, data) as E
 
-    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+    abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
 
-    override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
+    abstract override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
 
-    override fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?)
+    abstract override fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?)
 
-    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<E>
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<E>
 
-    override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<E>
+    abstract override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<E>
 
-    override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<E>
+    abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<E>
 
-    override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<E>
+    abstract override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<E>
 
-    override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<E>
+    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<E>
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirClassLikeDeclaration.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.declarations
 
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirModuleData
-import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirStatement
@@ -19,7 +18,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-sealed class FirClassLikeDeclaration<E : FirClassLikeDeclaration<E>> : FirPureAbstractElement(), FirAnnotatedDeclaration<E>, FirStatement {
+sealed class FirClassLikeDeclaration<E : FirClassLikeDeclaration<E>> : FirAnnotatedDeclaration<E>(), FirStatement {
     abstract override val source: FirSourceElement?
     abstract override val moduleData: FirModuleData
     abstract override val resolvePhase: FirResolvePhase

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirConstructor.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirConstructor : FirFunction<FirConstructor>(), FirCallableMemberDeclaration<FirConstructor>, FirTypeParameterRefsOwner {
+abstract class FirConstructor : FirFunction<FirConstructor>(), FirTypeParameterRefsOwner {
     abstract override val source: FirSourceElement?
     abstract override val moduleData: FirModuleData
     abstract override val resolvePhase: FirResolvePhase
@@ -32,11 +32,11 @@ abstract class FirConstructor : FirFunction<FirConstructor>(), FirCallableMember
     abstract override val returnTypeRef: FirTypeRef
     abstract override val receiverTypeRef: FirTypeRef?
     abstract override val typeParameters: List<FirTypeParameterRef>
-    abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
-    abstract override val valueParameters: List<FirValueParameter>
     abstract override val status: FirDeclarationStatus
     abstract override val containerSource: DeserializedContainerSource?
     abstract override val dispatchReceiverType: ConeKotlinType?
+    abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
+    abstract override val valueParameters: List<FirValueParameter>
     abstract override val annotations: List<FirAnnotationCall>
     abstract override val symbol: FirConstructorSymbol
     abstract val delegatedConstructor: FirDelegatedConstructorCall?
@@ -67,10 +67,10 @@ abstract class FirConstructor : FirFunction<FirConstructor>(), FirCallableMember
 
     abstract override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirConstructor
 
-    abstract override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirConstructor
-
     abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirConstructor
 
+    abstract override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirConstructor
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirConstructor
 
     abstract fun <D> transformDelegatedConstructor(transformer: FirTransformer<D>, data: D): FirConstructor

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirDeclaration.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.declarations
 
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirModuleData
+import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.visitors.*
@@ -16,13 +17,13 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-sealed interface FirDeclaration<E : FirDeclaration<E>> : FirElement {
+sealed class FirDeclaration<E : FirDeclaration<E>> : FirPureAbstractElement(), FirElement {
-    override val source: FirSourceElement?
+    abstract override val source: FirSourceElement?
-    val symbol: FirBasedSymbol<E>
+    abstract val symbol: FirBasedSymbol<E>
-    val moduleData: FirModuleData
+    abstract val moduleData: FirModuleData
-    val resolvePhase: FirResolvePhase
+    abstract val resolvePhase: FirResolvePhase
-    val origin: FirDeclarationOrigin
+    abstract val origin: FirDeclarationOrigin
-    val attributes: FirDeclarationAttributes
+    abstract val attributes: FirDeclarationAttributes
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitDeclaration(this, data)
 
@@ -30,5 +31,5 @@ sealed interface FirDeclaration<E : FirDeclaration<E>> : FirElement {
     override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
         transformer.transformDeclaration(this, data) as E
 
-    fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+    abstract fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirEnumEntry : FirVariable<FirEnumEntry>(), FirCallableMemberDeclaration<FirEnumEntry> {
+abstract class FirEnumEntry : FirVariable<FirEnumEntry>() {
     abstract override val source: FirSourceElement?
     abstract override val moduleData: FirModuleData
     abstract override val resolvePhase: FirResolvePhase
@@ -31,6 +31,10 @@ abstract class FirEnumEntry : FirVariable<FirEnumEntry>(), FirCallableMemberDecl
     abstract override val attributes: FirDeclarationAttributes
     abstract override val returnTypeRef: FirTypeRef
     abstract override val receiverTypeRef: FirTypeRef?
+    abstract override val typeParameters: List<FirTypeParameterRef>
+    abstract override val status: FirDeclarationStatus
+    abstract override val containerSource: DeserializedContainerSource?
+    abstract override val dispatchReceiverType: ConeKotlinType?
     abstract override val name: Name
     abstract override val symbol: FirVariableSymbol<FirEnumEntry>
     abstract override val initializer: FirExpression?
@@ -41,10 +45,6 @@ abstract class FirEnumEntry : FirVariable<FirEnumEntry>(), FirCallableMemberDecl
     abstract override val getter: FirPropertyAccessor?
     abstract override val setter: FirPropertyAccessor?
     abstract override val annotations: List<FirAnnotationCall>
-    abstract override val typeParameters: List<FirTypeParameterRef>
-    abstract override val status: FirDeclarationStatus
-    abstract override val containerSource: DeserializedContainerSource?
-    abstract override val dispatchReceiverType: ConeKotlinType?
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitEnumEntry(this, data)
 
@@ -64,6 +64,10 @@ abstract class FirEnumEntry : FirVariable<FirEnumEntry>(), FirCallableMemberDecl
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirEnumEntry
 
+    abstract override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirEnumEntry
+
+    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirEnumEntry
+
     abstract override fun <D> transformInitializer(transformer: FirTransformer<D>, data: D): FirEnumEntry
 
     abstract override fun <D> transformDelegate(transformer: FirTransformer<D>, data: D): FirEnumEntry
@@ -74,9 +78,5 @@ abstract class FirEnumEntry : FirVariable<FirEnumEntry>(), FirCallableMemberDecl
 
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirEnumEntry
 
-    abstract override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirEnumEntry
-
-    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirEnumEntry
-
     abstract override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirEnumEntry
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirErrorFunction.kt

@@ -14,7 +14,9 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
 import org.jetbrains.kotlin.fir.symbols.impl.FirErrorFunctionSymbol
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 import org.jetbrains.kotlin.fir.visitors.*
 
 /*
@@ -22,7 +24,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirErrorFunction : FirFunction<FirErrorFunction>(), FirDiagnosticHolder, FirTypeParametersOwner {
+abstract class FirErrorFunction : FirFunction<FirErrorFunction>(), FirDiagnosticHolder {
     abstract override val source: FirSourceElement?
     abstract override val moduleData: FirModuleData
     abstract override val resolvePhase: FirResolvePhase
@@ -31,6 +33,9 @@ abstract class FirErrorFunction : FirFunction<FirErrorFunction>(), FirDiagnostic
     abstract override val annotations: List<FirAnnotationCall>
     abstract override val returnTypeRef: FirTypeRef
     abstract override val receiverTypeRef: FirTypeRef?
+    abstract override val status: FirDeclarationStatus
+    abstract override val containerSource: DeserializedContainerSource?
+    abstract override val dispatchReceiverType: ConeKotlinType?
     abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
     abstract override val valueParameters: List<FirValueParameter>
     abstract override val body: FirBlock?
@@ -62,6 +67,8 @@ abstract class FirErrorFunction : FirFunction<FirErrorFunction>(), FirDiagnostic
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirErrorFunction
 
+    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirErrorFunction
+
     abstract override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirErrorFunction
 
     abstract override fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirErrorFunction

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirErrorProperty.kt

@@ -14,8 +14,10 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.symbols.impl.FirDelegateFieldSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirErrorPropertySymbol
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 import org.jetbrains.kotlin.fir.visitors.*
 
 /*
@@ -23,7 +25,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirErrorProperty : FirVariable<FirErrorProperty>(), FirDiagnosticHolder, FirTypeParametersOwner {
+abstract class FirErrorProperty : FirVariable<FirErrorProperty>(), FirDiagnosticHolder {
     abstract override val source: FirSourceElement?
     abstract override val moduleData: FirModuleData
     abstract override val resolvePhase: FirResolvePhase
@@ -31,6 +33,10 @@ abstract class FirErrorProperty : FirVariable<FirErrorProperty>(), FirDiagnostic
     abstract override val attributes: FirDeclarationAttributes
     abstract override val returnTypeRef: FirTypeRef
     abstract override val receiverTypeRef: FirTypeRef?
+    abstract override val typeParameters: List<FirTypeParameterRef>
+    abstract override val status: FirDeclarationStatus
+    abstract override val containerSource: DeserializedContainerSource?
+    abstract override val dispatchReceiverType: ConeKotlinType?
     abstract override val name: Name
     abstract override val initializer: FirExpression?
     abstract override val delegate: FirExpression?
@@ -41,7 +47,6 @@ abstract class FirErrorProperty : FirVariable<FirErrorProperty>(), FirDiagnostic
     abstract override val setter: FirPropertyAccessor?
     abstract override val annotations: List<FirAnnotationCall>
     abstract override val diagnostic: ConeDiagnostic
-    abstract override val typeParameters: List<FirTypeParameter>
     abstract override val symbol: FirErrorPropertySymbol
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorProperty(this, data)
@@ -62,6 +67,10 @@ abstract class FirErrorProperty : FirVariable<FirErrorProperty>(), FirDiagnostic
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirErrorProperty
 
+    abstract override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirErrorProperty
+
+    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirErrorProperty
+
     abstract override fun <D> transformInitializer(transformer: FirTransformer<D>, data: D): FirErrorProperty
 
     abstract override fun <D> transformDelegate(transformer: FirTransformer<D>, data: D): FirErrorProperty
@@ -72,7 +81,5 @@ abstract class FirErrorProperty : FirVariable<FirErrorProperty>(), FirDiagnostic
 
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirErrorProperty
 
-    abstract override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirErrorProperty
-
     abstract override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirErrorProperty
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirField.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirField : FirVariable<FirField>(), FirTypeParametersOwner, FirCallableMemberDeclaration<FirField> {
+abstract class FirField : FirVariable<FirField>() {
     abstract override val source: FirSourceElement?
     abstract override val moduleData: FirModuleData
     abstract override val resolvePhase: FirResolvePhase
@@ -31,6 +31,10 @@ abstract class FirField : FirVariable<FirField>(), FirTypeParametersOwner, FirCa
     abstract override val attributes: FirDeclarationAttributes
     abstract override val returnTypeRef: FirTypeRef
     abstract override val receiverTypeRef: FirTypeRef?
+    abstract override val typeParameters: List<FirTypeParameterRef>
+    abstract override val status: FirDeclarationStatus
+    abstract override val containerSource: DeserializedContainerSource?
+    abstract override val dispatchReceiverType: ConeKotlinType?
     abstract override val name: Name
     abstract override val symbol: FirVariableSymbol<FirField>
     abstract override val initializer: FirExpression?
@@ -41,10 +45,6 @@ abstract class FirField : FirVariable<FirField>(), FirTypeParametersOwner, FirCa
     abstract override val getter: FirPropertyAccessor?
     abstract override val setter: FirPropertyAccessor?
     abstract override val annotations: List<FirAnnotationCall>
-    abstract override val typeParameters: List<FirTypeParameter>
-    abstract override val status: FirDeclarationStatus
-    abstract override val containerSource: DeserializedContainerSource?
-    abstract override val dispatchReceiverType: ConeKotlinType?
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitField(this, data)
 
@@ -64,6 +64,10 @@ abstract class FirField : FirVariable<FirField>(), FirTypeParametersOwner, FirCa
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirField
 
+    abstract override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirField
+
+    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirField
+
     abstract override fun <D> transformInitializer(transformer: FirTransformer<D>, data: D): FirField
 
     abstract override fun <D> transformDelegate(transformer: FirTransformer<D>, data: D): FirField
@@ -74,9 +78,5 @@ abstract class FirField : FirVariable<FirField>(), FirTypeParametersOwner, FirCa
 
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirField
 
-    abstract override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirField
-
-    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirField
-
     abstract override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirField
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirFile.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.declarations
 
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirModuleData
-import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.symbols.impl.FirFileSymbol
@@ -19,7 +18,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirFile : FirPureAbstractElement(), FirAnnotatedDeclaration<FirFile> {
+abstract class FirFile : FirAnnotatedDeclaration<FirFile>() {
     abstract override val source: FirSourceElement?
     abstract override val moduleData: FirModuleData
     abstract override val resolvePhase: FirResolvePhase

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirFunction.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.declarations
 
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirModuleData
-import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.FirTargetElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
@@ -15,7 +14,9 @@ import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 import org.jetbrains.kotlin.fir.visitors.*
 
 /*
@@ -23,7 +24,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-sealed class FirFunction<E : FirFunction<E>> : FirPureAbstractElement(), FirCallableDeclaration<E>, FirTargetElement, FirTypeParameterRefsOwner, FirControlFlowGraphOwner, FirStatement {
+sealed class FirFunction<E : FirFunction<E>> : FirCallableMemberDeclaration<E>(), FirTargetElement, FirControlFlowGraphOwner, FirStatement {
     abstract override val source: FirSourceElement?
     abstract override val moduleData: FirModuleData
     abstract override val resolvePhase: FirResolvePhase
@@ -33,6 +34,9 @@ sealed class FirFunction<E : FirFunction<E>> : FirPureAbstractElement(), FirCall
     abstract override val returnTypeRef: FirTypeRef
     abstract override val receiverTypeRef: FirTypeRef?
     abstract override val typeParameters: List<FirTypeParameterRef>
+    abstract override val status: FirDeclarationStatus
+    abstract override val containerSource: DeserializedContainerSource?
+    abstract override val dispatchReceiverType: ConeKotlinType?
     abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
     abstract override val symbol: FirFunctionSymbol<E>
     abstract val valueParameters: List<FirValueParameter>
@@ -64,6 +68,8 @@ sealed class FirFunction<E : FirFunction<E>> : FirPureAbstractElement(), FirCall
 
     abstract override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirFunction<E>
 
+    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirFunction<E>
+
     abstract fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirFunction<E>
 
     abstract fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirFunction<E>

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirMemberDeclaration.kt

@@ -1,44 +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.declarations
-
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirModuleData
-import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.fir.visitors.*
-
-/*
- * This file was generated automatically
- * DO NOT MODIFY IT MANUALLY
- */
-
-sealed interface FirMemberDeclaration<E : FirMemberDeclaration<E>> : FirAnnotatedDeclaration<E>, FirTypeParameterRefsOwner {
-    override val source: FirSourceElement?
-    override val symbol: FirBasedSymbol<E>
-    override val moduleData: FirModuleData
-    override val resolvePhase: FirResolvePhase
-    override val origin: FirDeclarationOrigin
-    override val attributes: FirDeclarationAttributes
-    override val annotations: List<FirAnnotationCall>
-    override val typeParameters: List<FirTypeParameterRef>
-    val status: FirDeclarationStatus
-
-    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitMemberDeclaration(this, data)
-
-    @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
-        transformer.transformMemberDeclaration(this, data) as E
-
-    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
-
-    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirMemberDeclaration<E>
-
-    override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirMemberDeclaration<E>
-
-    fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirMemberDeclaration<E>
-}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirProperty.kt

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirProperty : FirVariable<FirProperty>(), FirTypeParametersOwner, FirControlFlowGraphOwner, FirCallableMemberDeclaration<FirProperty> {
+abstract class FirProperty : FirVariable<FirProperty>(), FirTypeParametersOwner, FirControlFlowGraphOwner {
     abstract override val source: FirSourceElement?
     abstract override val moduleData: FirModuleData
     abstract override val resolvePhase: FirResolvePhase
@@ -33,6 +33,9 @@ abstract class FirProperty : FirVariable<FirProperty>(), FirTypeParametersOwner,
     abstract override val attributes: FirDeclarationAttributes
     abstract override val returnTypeRef: FirTypeRef
     abstract override val receiverTypeRef: FirTypeRef?
+    abstract override val status: FirDeclarationStatus
+    abstract override val containerSource: DeserializedContainerSource?
+    abstract override val dispatchReceiverType: ConeKotlinType?
     abstract override val name: Name
     abstract override val initializer: FirExpression?
     abstract override val delegate: FirExpression?
@@ -42,14 +45,11 @@ abstract class FirProperty : FirVariable<FirProperty>(), FirTypeParametersOwner,
     abstract override val getter: FirPropertyAccessor?
     abstract override val setter: FirPropertyAccessor?
     abstract override val annotations: List<FirAnnotationCall>
-    abstract override val typeParameters: List<FirTypeParameter>
     abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
-    abstract override val containerSource: DeserializedContainerSource?
-    abstract override val dispatchReceiverType: ConeKotlinType?
     abstract override val symbol: FirPropertySymbol
     abstract val backingFieldSymbol: FirBackingFieldSymbol
     abstract val isLocal: Boolean
-    abstract override val status: FirDeclarationStatus
+    abstract override val typeParameters: List<FirTypeParameter>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitProperty(this, data)
 
@@ -71,6 +71,8 @@ abstract class FirProperty : FirVariable<FirProperty>(), FirTypeParametersOwner,
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirProperty
 
+    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirProperty
+
     abstract override fun <D> transformInitializer(transformer: FirTransformer<D>, data: D): FirProperty
 
     abstract override fun <D> transformDelegate(transformer: FirTransformer<D>, data: D): FirProperty
@@ -83,7 +85,5 @@ abstract class FirProperty : FirVariable<FirProperty>(), FirTypeParametersOwner,
 
     abstract override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirProperty
 
-    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirProperty
-
     abstract override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirProperty
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirPropertyAccessor.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirPropertyAccessor : FirFunction<FirPropertyAccessor>(), FirCallableMemberDeclaration<FirPropertyAccessor>, FirContractDescriptionOwner, FirTypeParametersOwner {
+abstract class FirPropertyAccessor : FirFunction<FirPropertyAccessor>(), FirContractDescriptionOwner, FirTypeParametersOwner {
     abstract override val source: FirSourceElement?
     abstract override val moduleData: FirModuleData
     abstract override val resolvePhase: FirResolvePhase
@@ -31,12 +31,12 @@ abstract class FirPropertyAccessor : FirFunction<FirPropertyAccessor>(), FirCall
     abstract override val attributes: FirDeclarationAttributes
     abstract override val returnTypeRef: FirTypeRef
     abstract override val receiverTypeRef: FirTypeRef?
-    abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
-    abstract override val valueParameters: List<FirValueParameter>
-    abstract override val body: FirBlock?
     abstract override val status: FirDeclarationStatus
     abstract override val containerSource: DeserializedContainerSource?
     abstract override val dispatchReceiverType: ConeKotlinType?
+    abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
+    abstract override val valueParameters: List<FirValueParameter>
+    abstract override val body: FirBlock?
     abstract override val contractDescription: FirContractDescription
     abstract override val symbol: FirPropertyAccessorSymbol
     abstract val isGetter: Boolean
@@ -68,12 +68,12 @@ abstract class FirPropertyAccessor : FirFunction<FirPropertyAccessor>(), FirCall
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirPropertyAccessor
 
+    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirPropertyAccessor
+
     abstract override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirPropertyAccessor
 
     abstract override fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirPropertyAccessor
 
-    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirPropertyAccessor
-
     abstract override fun <D> transformContractDescription(transformer: FirTransformer<D>, data: D): FirPropertyAccessor
 
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirPropertyAccessor

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirRegularClass.kt

@@ -22,19 +22,19 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirRegularClass : FirMemberDeclaration<FirRegularClass>, FirTypeParameterRefsOwner, FirControlFlowGraphOwner, FirClass<FirRegularClass>() {
+abstract class FirRegularClass : FirClass<FirRegularClass>(), FirStatusOwner, FirControlFlowGraphOwner {
     abstract override val source: FirSourceElement?
     abstract override val moduleData: FirModuleData
     abstract override val resolvePhase: FirResolvePhase
     abstract override val origin: FirDeclarationOrigin
     abstract override val attributes: FirDeclarationAttributes
-    abstract override val annotations: List<FirAnnotationCall>
     abstract override val typeParameters: List<FirTypeParameterRef>
-    abstract override val status: FirDeclarationStatus
-    abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
     abstract override val classKind: ClassKind
     abstract override val declarations: List<FirDeclaration<*>>
+    abstract override val annotations: List<FirAnnotationCall>
     abstract override val scopeProvider: FirScopeProvider
+    abstract override val status: FirDeclarationStatus
+    abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
     abstract val name: Name
     abstract override val symbol: FirRegularClassSymbol
     abstract val companionObject: FirRegularClass?
@@ -53,14 +53,14 @@ abstract class FirRegularClass : FirMemberDeclaration<FirRegularClass>, FirTypeP
 
     abstract override fun replaceSuperTypeRefs(newSuperTypeRefs: List<FirTypeRef>)
 
-    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirRegularClass
-
     abstract override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirRegularClass
 
-    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirRegularClass
-
     abstract override fun <D> transformDeclarations(transformer: FirTransformer<D>, data: D): FirRegularClass
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirRegularClass
+
+    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirRegularClass
+
     abstract fun <D> transformCompanionObject(transformer: FirTransformer<D>, data: D): FirRegularClass
 
     abstract override fun <D> transformSuperTypeRefs(transformer: FirTransformer<D>, data: D): FirRegularClass

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirSimpleFunction.kt

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirSimpleFunction : FirFunction<FirSimpleFunction>(), FirCallableMemberDeclaration<FirSimpleFunction>, FirContractDescriptionOwner, FirTypeParametersOwner {
+abstract class FirSimpleFunction : FirFunction<FirSimpleFunction>(), FirContractDescriptionOwner, FirTypeParametersOwner {
     abstract override val source: FirSourceElement?
     abstract override val moduleData: FirModuleData
     abstract override val resolvePhase: FirResolvePhase
@@ -32,12 +32,12 @@ abstract class FirSimpleFunction : FirFunction<FirSimpleFunction>(), FirCallable
     abstract override val attributes: FirDeclarationAttributes
     abstract override val returnTypeRef: FirTypeRef
     abstract override val receiverTypeRef: FirTypeRef?
-    abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
-    abstract override val valueParameters: List<FirValueParameter>
-    abstract override val body: FirBlock?
     abstract override val status: FirDeclarationStatus
     abstract override val containerSource: DeserializedContainerSource?
     abstract override val dispatchReceiverType: ConeKotlinType?
+    abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
+    abstract override val valueParameters: List<FirValueParameter>
+    abstract override val body: FirBlock?
     abstract override val contractDescription: FirContractDescription
     abstract val name: Name
     abstract override val symbol: FirNamedFunctionSymbol
@@ -68,12 +68,12 @@ abstract class FirSimpleFunction : FirFunction<FirSimpleFunction>(), FirCallable
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirSimpleFunction
 
+    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirSimpleFunction
+
     abstract override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirSimpleFunction
 
     abstract override fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirSimpleFunction
 
-    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirSimpleFunction
-
     abstract override fun <D> transformContractDescription(transformer: FirTransformer<D>, data: D): FirSimpleFunction
 
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirSimpleFunction

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirStatusOwner.kt

@@ -0,0 +1,31 @@
+/*
+ * 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.declarations
+
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.visitors.*
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+sealed interface FirStatusOwner : FirTypeParameterRefsOwner {
+    override val source: FirSourceElement?
+    override val typeParameters: List<FirTypeParameterRef>
+    val status: FirDeclarationStatus
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitStatusOwner(this, data)
+
+    @Suppress("UNCHECKED_CAST")
+    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+        transformer.transformStatusOwner(this, data) as E
+
+    override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirStatusOwner
+
+    fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirStatusOwner
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypeAlias.kt

@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirTypeAlias : FirClassLikeDeclaration<FirTypeAlias>(), FirMemberDeclaration<FirTypeAlias>, FirTypeParametersOwner {
+abstract class FirTypeAlias : FirClassLikeDeclaration<FirTypeAlias>(), FirStatusOwner, FirTypeParametersOwner {
     abstract override val source: FirSourceElement?
     abstract override val moduleData: FirModuleData
     abstract override val resolvePhase: FirResolvePhase

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypeParameter.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.declarations
 
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirModuleData
-import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
@@ -21,7 +20,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirTypeParameter : FirPureAbstractElement(), FirTypeParameterRef, FirAnnotatedDeclaration<FirTypeParameter> {
+abstract class FirTypeParameter : FirTypeParameterRef, FirAnnotatedDeclaration<FirTypeParameter>() {
     abstract override val source: FirSourceElement?
     abstract override val moduleData: FirModuleData
     abstract override val resolvePhase: FirResolvePhase

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypedDeclaration.kt

@@ -18,15 +18,15 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-sealed interface FirTypedDeclaration<E : FirTypedDeclaration<E>> : FirAnnotatedDeclaration<E> {
+sealed class FirTypedDeclaration<E : FirTypedDeclaration<E>> : FirAnnotatedDeclaration<E>() {
-    override val source: FirSourceElement?
+    abstract override val source: FirSourceElement?
-    override val symbol: FirBasedSymbol<E>
+    abstract override val symbol: FirBasedSymbol<E>
-    override val moduleData: FirModuleData
+    abstract override val moduleData: FirModuleData
-    override val resolvePhase: FirResolvePhase
+    abstract override val resolvePhase: FirResolvePhase
-    override val origin: FirDeclarationOrigin
+    abstract override val origin: FirDeclarationOrigin
-    override val attributes: FirDeclarationAttributes
+    abstract override val attributes: FirDeclarationAttributes
-    override val annotations: List<FirAnnotationCall>
+    abstract override val annotations: List<FirAnnotationCall>
-    val returnTypeRef: FirTypeRef
+    abstract val returnTypeRef: FirTypeRef
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTypedDeclaration(this, data)
 
@@ -34,11 +34,11 @@ sealed interface FirTypedDeclaration<E : FirTypedDeclaration<E>> : FirAnnotatedD
     override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
         transformer.transformTypedDeclaration(this, data) as E
 
-    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+    abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
 
-    fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
+    abstract fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
 
-    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirTypedDeclaration<E>
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirTypedDeclaration<E>
 
-    fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirTypedDeclaration<E>
+    abstract fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirTypedDeclaration<E>
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirValueParameter.kt

@@ -13,8 +13,10 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
 import org.jetbrains.kotlin.fir.symbols.impl.FirDelegateFieldSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 import org.jetbrains.kotlin.fir.visitors.*
 
 /*
@@ -30,6 +32,10 @@ abstract class FirValueParameter : FirVariable<FirValueParameter>(), FirControlF
     abstract override val attributes: FirDeclarationAttributes
     abstract override val returnTypeRef: FirTypeRef
     abstract override val receiverTypeRef: FirTypeRef?
+    abstract override val typeParameters: List<FirTypeParameterRef>
+    abstract override val status: FirDeclarationStatus
+    abstract override val containerSource: DeserializedContainerSource?
+    abstract override val dispatchReceiverType: ConeKotlinType?
     abstract override val name: Name
     abstract override val symbol: FirVariableSymbol<FirValueParameter>
     abstract override val initializer: FirExpression?
@@ -66,6 +72,10 @@ abstract class FirValueParameter : FirVariable<FirValueParameter>(), FirControlF
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirValueParameter
 
+    abstract override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirValueParameter
+
+    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirValueParameter
+
     abstract override fun <D> transformInitializer(transformer: FirTransformer<D>, data: D): FirValueParameter
 
     abstract override fun <D> transformDelegate(transformer: FirTransformer<D>, data: D): FirValueParameter

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirVariable.kt

@@ -7,15 +7,16 @@ package org.jetbrains.kotlin.fir.declarations
 
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirModuleData
-import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.symbols.impl.FirDelegateFieldSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 import org.jetbrains.kotlin.fir.visitors.*
 
 /*
@@ -23,7 +24,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-sealed class FirVariable<E : FirVariable<E>> : FirPureAbstractElement(), FirCallableDeclaration<E>, FirAnnotatedDeclaration<E>, FirStatement {
+sealed class FirVariable<E : FirVariable<E>> : FirCallableMemberDeclaration<E>(), FirStatement {
     abstract override val source: FirSourceElement?
     abstract override val moduleData: FirModuleData
     abstract override val resolvePhase: FirResolvePhase
@@ -31,6 +32,10 @@ sealed class FirVariable<E : FirVariable<E>> : FirPureAbstractElement(), FirCall
     abstract override val attributes: FirDeclarationAttributes
     abstract override val returnTypeRef: FirTypeRef
     abstract override val receiverTypeRef: FirTypeRef?
+    abstract override val typeParameters: List<FirTypeParameterRef>
+    abstract override val status: FirDeclarationStatus
+    abstract override val containerSource: DeserializedContainerSource?
+    abstract override val dispatchReceiverType: ConeKotlinType?
     abstract val name: Name
     abstract override val symbol: FirVariableSymbol<E>
     abstract val initializer: FirExpression?
@@ -60,6 +65,10 @@ sealed class FirVariable<E : FirVariable<E>> : FirPureAbstractElement(), FirCall
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirVariable<E>
 
+    abstract override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirVariable<E>
+
+    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirVariable<E>
+
     abstract fun <D> transformInitializer(transformer: FirTransformer<D>, data: D): FirVariable<E>
 
     abstract fun <D> transformDelegate(transformer: FirTransformer<D>, data: D): FirVariable<E>

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirAbstractConstructorBuilder.kt

@@ -40,14 +40,14 @@ interface FirAbstractConstructorBuilder : FirFunctionBuilder {
     abstract override var attributes: FirDeclarationAttributes
     abstract override val annotations: MutableList<FirAnnotationCall>
     abstract override var returnTypeRef: FirTypeRef
+    abstract override var status: FirDeclarationStatus
+    abstract override var containerSource: DeserializedContainerSource?
+    abstract override var dispatchReceiverType: ConeKotlinType?
     abstract override val valueParameters: MutableList<FirValueParameter>
     abstract override var body: FirBlock?
     abstract var receiverTypeRef: FirTypeRef?
     abstract val typeParameters: MutableList<FirTypeParameterRef>
     abstract var controlFlowGraphReference: FirControlFlowGraphReference?
-    abstract var status: FirDeclarationStatus
-    abstract var containerSource: DeserializedContainerSource?
-    abstract var dispatchReceiverType: ConeKotlinType?
     abstract var symbol: FirConstructorSymbol
     abstract var delegatedConstructor: FirDelegatedConstructorCall?
     override fun build(): FirConstructor

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirAnonymousFunctionBuilder.kt

@@ -15,19 +15,23 @@ import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationAttributes
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.declarations.InlineStatus
 import org.jetbrains.kotlin.fir.declarations.builder.FirFunctionBuilder
 import org.jetbrains.kotlin.fir.declarations.impl.FirAnonymousFunctionImpl
+import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
 import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousFunctionSymbol
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.*
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 
 /*
  * This file was generated automatically
@@ -43,6 +47,8 @@ class FirAnonymousFunctionBuilder : FirFunctionBuilder, FirAnnotationContainerBu
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
     override lateinit var returnTypeRef: FirTypeRef
     var receiverTypeRef: FirTypeRef? = null
+    override var containerSource: DeserializedContainerSource? = null
+    override var dispatchReceiverType: ConeKotlinType? = null
     var controlFlowGraphReference: FirControlFlowGraphReference? = null
     override val valueParameters: MutableList<FirValueParameter> = mutableListOf()
     override var body: FirBlock? = null
@@ -63,6 +69,8 @@ class FirAnonymousFunctionBuilder : FirFunctionBuilder, FirAnnotationContainerBu
             annotations,
             returnTypeRef,
             receiverTypeRef,
+            containerSource,
+            dispatchReceiverType,
             controlFlowGraphReference,
             valueParameters,
             body,
@@ -83,6 +91,13 @@ class FirAnonymousFunctionBuilder : FirFunctionBuilder, FirAnnotationContainerBu
         set(_) {
             throw IllegalStateException()
         }
+
+    @Deprecated("Modification of 'status' has no impact for FirAnonymousFunctionBuilder", level = DeprecationLevel.HIDDEN)
+    override var status: FirDeclarationStatus
+        get() = throw IllegalStateException()
+        set(_) {
+            throw IllegalStateException()
+        }
 }
 
 @OptIn(ExperimentalContracts::class)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirConstructorBuilder.kt

@@ -44,10 +44,10 @@ open class FirConstructorBuilder : FirAbstractConstructorBuilder, FirAnnotationC
     override lateinit var returnTypeRef: FirTypeRef
     override var receiverTypeRef: FirTypeRef? = null
     override val typeParameters: MutableList<FirTypeParameterRef> = mutableListOf()
-    override val valueParameters: MutableList<FirValueParameter> = mutableListOf()
     override lateinit var status: FirDeclarationStatus
     override var containerSource: DeserializedContainerSource? = null
     override var dispatchReceiverType: ConeKotlinType? = null
+    override val valueParameters: MutableList<FirValueParameter> = mutableListOf()
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
     override lateinit var symbol: FirConstructorSymbol
     override var delegatedConstructor: FirDelegatedConstructorCall? = null
@@ -63,10 +63,10 @@ open class FirConstructorBuilder : FirAbstractConstructorBuilder, FirAnnotationC
             returnTypeRef,
             receiverTypeRef,
             typeParameters,
-            valueParameters,
             status,
             containerSource,
             dispatchReceiverType,
+            valueParameters,
             annotations,
             symbol,
             delegatedConstructor,
@@ -105,10 +105,10 @@ inline fun buildConstructorCopy(original: FirConstructor, init: FirConstructorBu
     copyBuilder.returnTypeRef = original.returnTypeRef
     copyBuilder.receiverTypeRef = original.receiverTypeRef
     copyBuilder.typeParameters.addAll(original.typeParameters)
-    copyBuilder.valueParameters.addAll(original.valueParameters)
     copyBuilder.status = original.status
     copyBuilder.containerSource = original.containerSource
     copyBuilder.dispatchReceiverType = original.dispatchReceiverType
+    copyBuilder.valueParameters.addAll(original.valueParameters)
     copyBuilder.annotations.addAll(original.annotations)
     copyBuilder.symbol = original.symbol
     copyBuilder.delegatedConstructor = original.delegatedConstructor

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirDefaultSetterValueParameterBuilder.kt

@@ -12,18 +12,23 @@ import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationAttributes
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
 import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultSetterValueParameter
+import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
 import org.jetbrains.kotlin.fir.symbols.impl.FirDelegateFieldSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 
 /*
  * This file was generated automatically
@@ -39,6 +44,8 @@ class FirDefaultSetterValueParameterBuilder : FirAnnotationContainerBuilder {
     var attributes: FirDeclarationAttributes = FirDeclarationAttributes()
     lateinit var returnTypeRef: FirTypeRef
     var receiverTypeRef: FirTypeRef? = null
+    var containerSource: DeserializedContainerSource? = null
+    var dispatchReceiverType: ConeKotlinType? = null
     lateinit var symbol: FirVariableSymbol<FirValueParameter>
     var initializer: FirExpression? = null
     var delegate: FirExpression? = null
@@ -62,6 +69,8 @@ class FirDefaultSetterValueParameterBuilder : FirAnnotationContainerBuilder {
             attributes,
             returnTypeRef,
             receiverTypeRef,
+            containerSource,
+            dispatchReceiverType,
             symbol,
             initializer,
             delegate,

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirEnumEntryBuilder.kt

@@ -41,14 +41,14 @@ class FirEnumEntryBuilder : FirAnnotationContainerBuilder {
     lateinit var origin: FirDeclarationOrigin
     var attributes: FirDeclarationAttributes = FirDeclarationAttributes()
     lateinit var returnTypeRef: FirTypeRef
-    lateinit var name: Name
-    lateinit var symbol: FirVariableSymbol<FirEnumEntry>
-    var initializer: FirExpression? = null
-    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
     val typeParameters: MutableList<FirTypeParameterRef> = mutableListOf()
     lateinit var status: FirDeclarationStatus
     var containerSource: DeserializedContainerSource? = null
     var dispatchReceiverType: ConeKotlinType? = null
+    lateinit var name: Name
+    lateinit var symbol: FirVariableSymbol<FirEnumEntry>
+    var initializer: FirExpression? = null
+    override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
 
     override fun build(): FirEnumEntry {
         return FirEnumEntryImpl(
@@ -58,14 +58,14 @@ class FirEnumEntryBuilder : FirAnnotationContainerBuilder {
             origin,
             attributes,
             returnTypeRef,
-            name,
-            symbol,
-            initializer,
-            annotations,
             typeParameters,
             status,
             containerSource,
             dispatchReceiverType,
+            name,
+            symbol,
+            initializer,
+            annotations,
         )
     }
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirErrorFunctionBuilder.kt

@@ -12,19 +12,23 @@ import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationAttributes
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
 import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.declarations.impl.FirErrorFunctionImpl
+import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
 import org.jetbrains.kotlin.fir.symbols.impl.FirErrorFunctionSymbol
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.*
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 
 /*
  * This file was generated automatically
@@ -39,10 +43,11 @@ class FirErrorFunctionBuilder : FirAnnotationContainerBuilder {
     lateinit var origin: FirDeclarationOrigin
     var attributes: FirDeclarationAttributes = FirDeclarationAttributes()
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+    var containerSource: DeserializedContainerSource? = null
+    var dispatchReceiverType: ConeKotlinType? = null
     val valueParameters: MutableList<FirValueParameter> = mutableListOf()
     lateinit var diagnostic: ConeDiagnostic
     lateinit var symbol: FirErrorFunctionSymbol
-    val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
 
     override fun build(): FirErrorFunction {
         return FirErrorFunctionImpl(
@@ -52,10 +57,11 @@ class FirErrorFunctionBuilder : FirAnnotationContainerBuilder {
             origin,
             attributes,
             annotations,
+            containerSource,
+            dispatchReceiverType,
             valueParameters,
             diagnostic,
             symbol,
-            typeParameters,
         )
     }
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirErrorPropertyBuilder.kt

@@ -12,20 +12,24 @@ import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationAttributes
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
 import org.jetbrains.kotlin.fir.declarations.FirErrorProperty
 import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
 import org.jetbrains.kotlin.fir.declarations.impl.FirErrorPropertyImpl
+import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.symbols.impl.FirDelegateFieldSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirErrorPropertySymbol
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.*
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 
 /*
  * This file was generated automatically
@@ -39,10 +43,11 @@ class FirErrorPropertyBuilder : FirAnnotationContainerBuilder {
     var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
     lateinit var origin: FirDeclarationOrigin
     var attributes: FirDeclarationAttributes = FirDeclarationAttributes()
+    var containerSource: DeserializedContainerSource? = null
+    var dispatchReceiverType: ConeKotlinType? = null
     lateinit var name: Name
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
     lateinit var diagnostic: ConeDiagnostic
-    val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
     lateinit var symbol: FirErrorPropertySymbol
 
     override fun build(): FirErrorProperty {
@@ -52,10 +57,11 @@ class FirErrorPropertyBuilder : FirAnnotationContainerBuilder {
             resolvePhase,
             origin,
             attributes,
+            containerSource,
+            dispatchReceiverType,
             name,
             annotations,
             diagnostic,
-            typeParameters,
             symbol,
         )
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirFieldBuilder.kt

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
 import org.jetbrains.kotlin.fir.declarations.FirField
 import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
 import org.jetbrains.kotlin.fir.declarations.builder.FirDeclarationBuilder
 import org.jetbrains.kotlin.fir.declarations.impl.FirFieldImpl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
@@ -43,15 +43,15 @@ open class FirFieldBuilder : FirDeclarationBuilder, FirAnnotationContainerBuilde
     override lateinit var origin: FirDeclarationOrigin
     override var attributes: FirDeclarationAttributes = FirDeclarationAttributes()
     open lateinit var returnTypeRef: FirTypeRef
+    open val typeParameters: MutableList<FirTypeParameterRef> = mutableListOf()
+    open lateinit var status: FirDeclarationStatus
+    open var containerSource: DeserializedContainerSource? = null
+    open var dispatchReceiverType: ConeKotlinType? = null
     open lateinit var name: Name
     open lateinit var symbol: FirVariableSymbol<FirField>
     open var initializer: FirExpression? = null
     open var isVar: Boolean by kotlin.properties.Delegates.notNull<Boolean>()
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
-    open val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
-    open lateinit var status: FirDeclarationStatus
-    open var containerSource: DeserializedContainerSource? = null
-    open var dispatchReceiverType: ConeKotlinType? = null
 
     @OptIn(FirImplementationDetail::class)
     override fun build(): FirField {
@@ -62,15 +62,15 @@ open class FirFieldBuilder : FirDeclarationBuilder, FirAnnotationContainerBuilde
             origin,
             attributes,
             returnTypeRef,
+            typeParameters,
+            status,
+            containerSource,
+            dispatchReceiverType,
             name,
             symbol,
             initializer,
             isVar,
             annotations,
-            typeParameters,
-            status,
-            containerSource,
-            dispatchReceiverType,
         )
     }
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirFunctionBuilder.kt

@@ -11,14 +11,17 @@ import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationAttributes
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.declarations.builder.FirDeclarationBuilder
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 
 /*
  * This file was generated automatically
@@ -34,6 +37,9 @@ interface FirFunctionBuilder : FirDeclarationBuilder, FirAnnotationContainerBuil
     abstract override var attributes: FirDeclarationAttributes
     abstract override val annotations: MutableList<FirAnnotationCall>
     abstract var returnTypeRef: FirTypeRef
+    abstract var status: FirDeclarationStatus
+    abstract var containerSource: DeserializedContainerSource?
+    abstract var dispatchReceiverType: ConeKotlinType?
     abstract val valueParameters: MutableList<FirValueParameter>
     abstract var body: FirBlock?
     override fun build(): FirFunction<*>

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirPrimaryConstructorBuilder.kt

@@ -44,10 +44,10 @@ class FirPrimaryConstructorBuilder : FirAbstractConstructorBuilder, FirAnnotatio
     override lateinit var returnTypeRef: FirTypeRef
     override var receiverTypeRef: FirTypeRef? = null
     override val typeParameters: MutableList<FirTypeParameterRef> = mutableListOf()
-    override val valueParameters: MutableList<FirValueParameter> = mutableListOf()
     override lateinit var status: FirDeclarationStatus
     override var containerSource: DeserializedContainerSource? = null
     override var dispatchReceiverType: ConeKotlinType? = null
+    override val valueParameters: MutableList<FirValueParameter> = mutableListOf()
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
     override lateinit var symbol: FirConstructorSymbol
     override var delegatedConstructor: FirDelegatedConstructorCall? = null
@@ -63,10 +63,10 @@ class FirPrimaryConstructorBuilder : FirAbstractConstructorBuilder, FirAnnotatio
             returnTypeRef,
             receiverTypeRef,
             typeParameters,
-            valueParameters,
             status,
             containerSource,
             dispatchReceiverType,
+            valueParameters,
             annotations,
             symbol,
             delegatedConstructor,

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirPropertyAccessorBuilder.kt

@@ -45,11 +45,11 @@ class FirPropertyAccessorBuilder : FirFunctionBuilder, FirAnnotationContainerBui
     override lateinit var origin: FirDeclarationOrigin
     override var attributes: FirDeclarationAttributes = FirDeclarationAttributes()
     override lateinit var returnTypeRef: FirTypeRef
+    override lateinit var status: FirDeclarationStatus
+    override var containerSource: DeserializedContainerSource? = null
+    override var dispatchReceiverType: ConeKotlinType? = null
     override val valueParameters: MutableList<FirValueParameter> = mutableListOf()
     override var body: FirBlock? = null
-    lateinit var status: FirDeclarationStatus
-    var containerSource: DeserializedContainerSource? = null
-    var dispatchReceiverType: ConeKotlinType? = null
     var contractDescription: FirContractDescription = FirEmptyContractDescription
     lateinit var symbol: FirPropertyAccessorSymbol
     var isGetter: Boolean by kotlin.properties.Delegates.notNull<Boolean>()
@@ -65,11 +65,11 @@ class FirPropertyAccessorBuilder : FirFunctionBuilder, FirAnnotationContainerBui
             origin,
             attributes,
             returnTypeRef,
-            valueParameters,
-            body,
             status,
             containerSource,
             dispatchReceiverType,
+            valueParameters,
+            body,
             contractDescription,
             symbol,
             isGetter,
@@ -100,11 +100,11 @@ inline fun buildPropertyAccessorCopy(original: FirPropertyAccessor, init: FirPro
     copyBuilder.origin = original.origin
     copyBuilder.attributes = original.attributes.copy()
     copyBuilder.returnTypeRef = original.returnTypeRef
-    copyBuilder.valueParameters.addAll(original.valueParameters)
-    copyBuilder.body = original.body
     copyBuilder.status = original.status
     copyBuilder.containerSource = original.containerSource
     copyBuilder.dispatchReceiverType = original.dispatchReceiverType
+    copyBuilder.valueParameters.addAll(original.valueParameters)
+    copyBuilder.body = original.body
     copyBuilder.contractDescription = original.contractDescription
     copyBuilder.symbol = original.symbol
     copyBuilder.isGetter = original.isGetter

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirPropertyBuilder.kt

@@ -46,6 +46,9 @@ class FirPropertyBuilder : FirDeclarationBuilder, FirTypeParametersOwnerBuilder,
     override var attributes: FirDeclarationAttributes = FirDeclarationAttributes()
     lateinit var returnTypeRef: FirTypeRef
     var receiverTypeRef: FirTypeRef? = null
+    lateinit var status: FirDeclarationStatus
+    var containerSource: DeserializedContainerSource? = null
+    var dispatchReceiverType: ConeKotlinType? = null
     lateinit var name: Name
     var initializer: FirExpression? = null
     var delegate: FirExpression? = null
@@ -54,12 +57,9 @@ class FirPropertyBuilder : FirDeclarationBuilder, FirTypeParametersOwnerBuilder,
     var getter: FirPropertyAccessor? = null
     var setter: FirPropertyAccessor? = null
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
-    override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
-    var containerSource: DeserializedContainerSource? = null
-    var dispatchReceiverType: ConeKotlinType? = null
     lateinit var symbol: FirPropertySymbol
     var isLocal: Boolean by kotlin.properties.Delegates.notNull<Boolean>()
-    lateinit var status: FirDeclarationStatus
+    override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
 
     override fun build(): FirProperty {
         return FirPropertyImpl(
@@ -70,6 +70,9 @@ class FirPropertyBuilder : FirDeclarationBuilder, FirTypeParametersOwnerBuilder,
             attributes,
             returnTypeRef,
             receiverTypeRef,
+            status,
+            containerSource,
+            dispatchReceiverType,
             name,
             initializer,
             delegate,
@@ -78,12 +81,9 @@ class FirPropertyBuilder : FirDeclarationBuilder, FirTypeParametersOwnerBuilder,
             getter,
             setter,
             annotations,
-            typeParameters,
-            containerSource,
-            dispatchReceiverType,
             symbol,
             isLocal,
-            status,
+            typeParameters,
         )
     }
 
@@ -110,6 +110,9 @@ inline fun buildPropertyCopy(original: FirProperty, init: FirPropertyBuilder.()
     copyBuilder.attributes = original.attributes.copy()
     copyBuilder.returnTypeRef = original.returnTypeRef
     copyBuilder.receiverTypeRef = original.receiverTypeRef
+    copyBuilder.status = original.status
+    copyBuilder.containerSource = original.containerSource
+    copyBuilder.dispatchReceiverType = original.dispatchReceiverType
     copyBuilder.name = original.name
     copyBuilder.initializer = original.initializer
     copyBuilder.delegate = original.delegate
@@ -118,11 +121,8 @@ inline fun buildPropertyCopy(original: FirProperty, init: FirPropertyBuilder.()
     copyBuilder.getter = original.getter
     copyBuilder.setter = original.setter
     copyBuilder.annotations.addAll(original.annotations)
-    copyBuilder.typeParameters.addAll(original.typeParameters)
-    copyBuilder.containerSource = original.containerSource
-    copyBuilder.dispatchReceiverType = original.dispatchReceiverType
     copyBuilder.symbol = original.symbol
     copyBuilder.isLocal = original.isLocal
-    copyBuilder.status = original.status
+    copyBuilder.typeParameters.addAll(original.typeParameters)
     return copyBuilder.apply(init).build()
 }