[FIR] Add symbol to all declarations. Get rid of FirSymbolOwner

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

@@ -26,7 +26,7 @@ fun renderJavaClass(renderer: FirRenderer, javaClass: FirJavaClass, session: Fir
     renderer.visitMemberDeclaration(javaClass)
     renderer.renderSupertypes(javaClass)
     renderer.renderInBraces {
-        val renderedDeclarations = mutableListOf<FirDeclaration>()
+        val renderedDeclarations = mutableListOf<FirDeclaration<*>>()
 
         fun renderAndCache(symbol: FirCallableSymbol<*>) {
             val enhanced = symbol.fir

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

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

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

@@ -482,7 +482,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
 
         val NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER by error<KtSimpleNameExpression> {
             parameter<Name>("typeParameterName")
-            parameter<FirDeclaration>("typeParametersOwner")
+            parameter<FirDeclaration<*>>("typeParametersOwner")
         }
 
         val BOUND_ON_TYPE_ALIAS_PARAMETER_NOT_ALLOWED by error<KtTypeReference>()
@@ -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<FirMemberDeclaration<*>>("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<FirMemberDeclaration<*>>("function")
-            parameter<FirMemberDeclaration>("superFunction")
+            parameter<FirMemberDeclaration<*>>("superFunction")
         }
         val PROPERTY_TYPE_MISMATCH_ON_OVERRIDE by error<KtNamedDeclaration>(PositioningStrategy.DECLARATION_RETURN_TYPE) {
-            parameter<FirMemberDeclaration>("property")
+            parameter<FirMemberDeclaration<*>>("property")
-            parameter<FirMemberDeclaration>("superProperty")
+            parameter<FirMemberDeclaration<*>>("superProperty")
         }
         val VAR_TYPE_MISMATCH_ON_OVERRIDE by error<KtNamedDeclaration>(PositioningStrategy.DECLARATION_RETURN_TYPE) {
-            parameter<FirMemberDeclaration>("variable")
+            parameter<FirMemberDeclaration<*>>("variable")
-            parameter<FirMemberDeclaration>("superVariable")
+            parameter<FirMemberDeclaration<*>>("superVariable")
         }
         val VAR_OVERRIDDEN_BY_VAL by error<KtNamedDeclaration>(PositioningStrategy.VAL_OR_VAR_NODE) {
-            parameter<FirMemberDeclaration>("overridingDeclaration")
+            parameter<FirMemberDeclaration<*>>("overridingDeclaration")
-            parameter<FirMemberDeclaration>("overriddenDeclaration")
+            parameter<FirMemberDeclaration<*>>("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<FirMemberDeclaration<*>>("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<FirMemberDeclaration<*>>("function")
             parameter<FirClass<*>>("containingClass")
         }
         val ABSTRACT_FUNCTION_WITH_BODY by error<KtFunction>(PositioningStrategy.MODALITY_MODIFIER) {
-            parameter<FirMemberDeclaration>("function")
+            parameter<FirMemberDeclaration<*>>("function")
         }
         val NON_ABSTRACT_FUNCTION_WITH_NO_BODY by error<KtFunction>(PositioningStrategy.DECLARATION_SIGNATURE) {
-            parameter<FirMemberDeclaration>("function")
+            parameter<FirMemberDeclaration<*>>("function")
         }
         val PRIVATE_FUNCTION_WITH_NO_BODY by error<KtFunction>(PositioningStrategy.VISIBILITY_MODIFIER) {
-            parameter<FirMemberDeclaration>("function")
+            parameter<FirMemberDeclaration<*>>("function")
         }
 
         val NON_MEMBER_FUNCTION_NO_BODY by error<KtFunction>(PositioningStrategy.DECLARATION_SIGNATURE) {
-            parameter<FirMemberDeclaration>("function")
+            parameter<FirMemberDeclaration<*>>("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<FirMemberDeclaration<*>>("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<FirMemberDeclaration<*>>("restrictingDeclaration")
     parameter<EffectiveVisibility>("restrictingVisibility")
 }
 

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

@@ -5,7 +5,8 @@
 
 package org.jetbrains.kotlin.fir.analysis.jvm.checkers
 
-import org.jetbrains.kotlin.fir.analysis.checkers.declaration.*
+import org.jetbrains.kotlin.fir.analysis.checkers.declaration.DeclarationCheckers
+import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirMemberDeclarationChecker
 import org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration.FirJvmExternalDeclarationChecker
 
 object JvmDeclarationCheckers : DeclarationCheckers() {

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

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.lexer.KtTokens
 
 object FirJvmExternalDeclarationChecker : FirMemberDeclarationChecker() {
-    override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
         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/FirDeclarationCheckerAliases.kt

@@ -22,8 +22,8 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 
-typealias FirBasicDeclarationChecker = FirDeclarationChecker<FirDeclaration>
+typealias FirBasicDeclarationChecker = FirDeclarationChecker<FirDeclaration<*>>
-typealias FirMemberDeclarationChecker = FirDeclarationChecker<FirMemberDeclaration>
+typealias FirMemberDeclarationChecker = FirDeclarationChecker<FirMemberDeclaration<*>>
 typealias FirFunctionChecker = FirDeclarationChecker<FirFunction<*>>
 typealias FirSimpleFunctionChecker = FirDeclarationChecker<FirSimpleFunction>
 typealias FirPropertyChecker = FirDeclarationChecker<FirProperty>
@@ -32,4 +32,4 @@ typealias FirRegularClassChecker = FirDeclarationChecker<FirRegularClass>
 typealias FirConstructorChecker = FirDeclarationChecker<FirConstructor>
 typealias FirFileChecker = FirDeclarationChecker<FirFile>
 typealias FirTypeParameterChecker = FirDeclarationChecker<FirTypeParameter>
-typealias FirAnnotatedDeclarationChecker = FirDeclarationChecker<FirAnnotatedDeclaration>
+typealias FirAnnotatedDeclarationChecker = FirDeclarationChecker<FirAnnotatedDeclaration<*>>

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

@@ -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, FirMemberDeclaration<*>, 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, FirMemberDeclaration<*>, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
-    val EXPOSED_RECEIVER_TYPE by error3<KtTypeReference, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>()
+    val EXPOSED_RECEIVER_TYPE by error3<KtTypeReference, EffectiveVisibility, FirMemberDeclaration<*>, EffectiveVisibility>()
-    val EXPOSED_PROPERTY_TYPE by error3<KtNamedDeclaration, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
+    val EXPOSED_PROPERTY_TYPE by error3<KtNamedDeclaration, EffectiveVisibility, FirMemberDeclaration<*>, 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, FirMemberDeclaration<*>, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
-    val EXPOSED_PARAMETER_TYPE by error3<KtParameter, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>()
+    val EXPOSED_PARAMETER_TYPE by error3<KtParameter, EffectiveVisibility, FirMemberDeclaration<*>, EffectiveVisibility>()
-    val EXPOSED_SUPER_INTERFACE by error3<KtTypeReference, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>()
+    val EXPOSED_SUPER_INTERFACE by error3<KtTypeReference, EffectiveVisibility, FirMemberDeclaration<*>, EffectiveVisibility>()
-    val EXPOSED_SUPER_CLASS by error3<KtTypeReference, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>()
+    val EXPOSED_SUPER_CLASS by error3<KtTypeReference, EffectiveVisibility, FirMemberDeclaration<*>, EffectiveVisibility>()
-    val EXPOSED_TYPE_PARAMETER_BOUND by error3<KtTypeReference, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>()
+    val EXPOSED_TYPE_PARAMETER_BOUND by error3<KtTypeReference, EffectiveVisibility, FirMemberDeclaration<*>, EffectiveVisibility>()
 
     // Modifiers
     val INAPPLICABLE_INFIX_MODIFIER by error0<PsiElement>()
@@ -313,7 +313,7 @@ object FirErrors {
     val ONLY_ONE_CLASS_BOUND_ALLOWED by error0<KtTypeReference>()
     val REPEATED_BOUND by error0<KtTypeReference>()
     val CONFLICTING_UPPER_BOUNDS by error1<KtNamedDeclaration, FirTypeParameterSymbol>()
-    val NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER by error2<KtSimpleNameExpression, Name, FirDeclaration>()
+    val NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER by error2<KtSimpleNameExpression, Name, FirDeclaration<*>>()
     val BOUND_ON_TYPE_ALIAS_PARAMETER_NOT_ALLOWED by error0<KtTypeReference>()
     val REIFIED_TYPE_PARAMETER_NO_INLINE by error0<KtTypeParameter>(SourceElementPositioningStrategies.REIFIED_MODIFIER)
     val TYPE_PARAMETERS_NOT_ALLOWED by error0<KtDeclaration>(SourceElementPositioningStrategies.TYPE_PARAMETERS_LIST)
@@ -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, FirMemberDeclaration<*>>(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, FirMemberDeclaration<*>, FirMemberDeclaration<*>>(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, FirMemberDeclaration<*>, FirMemberDeclaration<*>>(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, FirMemberDeclaration<*>, FirMemberDeclaration<*>>(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, FirMemberDeclaration<*>, FirMemberDeclaration<*>>(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, FirMemberDeclaration<*>, 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, FirMemberDeclaration<*>, FirClass<*>>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
-    val ABSTRACT_FUNCTION_WITH_BODY by error1<KtFunction, FirMemberDeclaration>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
+    val ABSTRACT_FUNCTION_WITH_BODY by error1<KtFunction, FirMemberDeclaration<*>>(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, FirMemberDeclaration<*>>(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, FirMemberDeclaration<*>>(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, FirMemberDeclaration<*>>(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, FirMemberDeclaration<*>, 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/FirCheckersResolveProcessor.kt

@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollector
 import org.jetbrains.kotlin.fir.analysis.collectors.FirDiagnosticsCollector
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporterFactory
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor
@@ -30,9 +29,9 @@ class FirCheckersRunnerTransformer(private val diagnosticCollector: AbstractDiag
         return element
     }
 
-    override fun transformFile(file: FirFile, data: Nothing?): FirDeclaration {
+    override fun transformFile(file: FirFile, data: Nothing?): FirFile {
         val reporter = DiagnosticReporterFactory.createReporter()
         diagnosticCollector.collectDiagnostics(file, reporter)
         return file
     }
-}
+}

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

@@ -11,10 +11,10 @@ import org.jetbrains.kotlin.fir.analysis.cfa.FirPropertyInitializationAnalyzer
 import org.jetbrains.kotlin.fir.analysis.cfa.FirReturnsImpliesAnalyzer
 import org.jetbrains.kotlin.fir.analysis.checkers.cfa.FirControlFlowChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.*
+import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirReservedUnderscoreDeclarationChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.syntax.FirDelegationInInterfaceSyntaxChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.syntax.FirFunctionTypeParametersSyntaxChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.syntax.FirTypeParameterSyntaxChecker
-import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirReservedUnderscoreDeclarationChecker
 
 object CommonDeclarationCheckers : DeclarationCheckers() {
     override val basicDeclarationCheckers: Set<FirBasicDeclarationChecker>

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

@@ -7,7 +7,10 @@ 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.*
+import org.jetbrains.kotlin.fir.analysis.checkers.declaration.DeclarationCheckers
+import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker
+import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirMemberDeclarationChecker
+import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirSimpleFunctionChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.extended.*
 
 object ExtendedDeclarationCheckers : DeclarationCheckers() {

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

@@ -60,11 +60,11 @@ fun FirRegularClass.getAllowedAnnotationTargets(): Set<KotlinTarget> {
     }
 }
 
-fun FirAnnotatedDeclaration.getRetentionAnnotation(): FirAnnotationCall? {
+fun FirAnnotatedDeclaration<*>.getRetentionAnnotation(): FirAnnotationCall? {
     return getAnnotationByFqName(StandardNames.FqNames.retention)
 }
 
-fun FirAnnotatedDeclaration.getTargetAnnotation(): FirAnnotationCall? {
+fun FirAnnotatedDeclaration<*>.getTargetAnnotation(): FirAnnotationCall? {
     return getAnnotationByFqName(StandardNames.FqNames.target)
 }
 

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

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.analysis.checkers
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
@@ -39,7 +38,7 @@ internal fun checkConstantArguments(
         }
         expression is FirConstExpression<*>
                 || expressionSymbol is FirEnumEntry
-                || (expressionSymbol as? FirMemberDeclaration)?.isConst == true
+                || (expressionSymbol as? FirMemberDeclaration<*>)?.isConst == true
                 || expressionSymbol is FirConstructor && classKindOfParent == ClassKind.ANNOTATION_CLASS -> {
             //DO NOTHING
         }
@@ -84,8 +83,8 @@ internal fun checkConstantArguments(
         expressionSymbol is FirField -> {
             //TODO: fix checking of Java fields initializer
             if (
-                !(expressionSymbol as FirMemberDeclaration).status.isStatic
+                !(expressionSymbol as FirMemberDeclaration<*>).status.isStatic
-                || (expressionSymbol as FirMemberDeclaration).status.modality != Modality.FINAL
+                || (expressionSymbol as FirMemberDeclaration<*>).status.modality != Modality.FINAL
             )
                 return ConstantArgumentKind.NOT_CONST
         }
@@ -189,7 +188,7 @@ internal fun checkConstantArguments(
     return null
 }
 
-private fun FirTypedDeclaration?.getReferencedClass(session: FirSession): FirSymbolOwner<*>? =
+private fun FirTypedDeclaration<*>?.getReferencedClass(session: FirSession): FirDeclaration<*>? =
     this?.returnTypeRef
         ?.coneTypeSafe<ConeLookupTagBasedType>()
         ?.lookupTag

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

@@ -8,8 +8,8 @@ package org.jetbrains.kotlin.fir.analysis.checkers
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
@@ -218,7 +218,7 @@ private val NO_NAME_PROVIDED = Name.special("<no name provided>")
 // explicitly.
 // - see tests with `fun () {}`.
 // you can't redeclare something that has no name.
-private fun FirDeclaration.isCollectable() = when (this) {
+private fun FirDeclaration<*>.isCollectable() = when (this) {
     is FirSimpleFunction -> source?.kind !is FirFakeSourceElementKind && name != NO_NAME_PROVIDED
     is FirRegularClass -> name != NO_NAME_PROVIDED
     else -> true
@@ -230,10 +230,10 @@ private fun FirDeclaration.isCollectable() = when (this) {
 open class FirDeclarationInspector(
     protected val presenter: FirDeclarationPresenter = FirDefaultDeclarationPresenter()
 ) {
-    val otherDeclarations = mutableMapOf<String, MutableList<FirDeclaration>>()
+    val otherDeclarations = mutableMapOf<String, MutableList<FirDeclaration<*>>>()
     val functionDeclarations = mutableMapOf<String, MutableList<FirSimpleFunction>>()
 
-    fun collect(declaration: FirDeclaration) {
+    fun collect(declaration: FirDeclaration<*>) {
         when {
             !declaration.isCollectable() -> {}
             declaration is FirSimpleFunction -> collectFunction(presenter.represent(declaration), declaration)
@@ -243,7 +243,7 @@ open class FirDeclarationInspector(
         }
     }
 
-    protected open fun collectNonFunctionDeclaration(key: String, declaration: FirDeclaration): MutableList<FirDeclaration> =
+    protected open fun collectNonFunctionDeclaration(key: String, declaration: FirDeclaration<*>): MutableList<FirDeclaration<*>> =
         otherDeclarations.getOrPut(key) {
             mutableListOf()
         }.also {
@@ -257,11 +257,11 @@ open class FirDeclarationInspector(
             it.add(declaration)
         }
 
-    fun contains(declaration: FirDeclaration) = when (declaration) {
+    fun contains(declaration: FirDeclaration<*>) = when (declaration) {
         is FirSimpleFunction -> presenter.represent(declaration) in functionDeclarations
         is FirRegularClass -> presenter.represent(declaration) in otherDeclarations
         is FirTypeAlias -> presenter.represent(declaration) in otherDeclarations
         is FirProperty -> presenter.represent(declaration) in otherDeclarations
         else -> false
     }
-}
+}

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

@@ -12,9 +12,6 @@ import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.*
-import org.jetbrains.kotlin.fir.analysis.diagnostics.modalityModifier
-import org.jetbrains.kotlin.fir.analysis.diagnostics.overrideModifier
-import org.jetbrains.kotlin.fir.analysis.diagnostics.visibilityModifier
 import org.jetbrains.kotlin.fir.analysis.getChild
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirExpression
@@ -35,7 +32,10 @@ import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 import org.jetbrains.kotlin.lexer.KtTokens
-import org.jetbrains.kotlin.name.*
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.psi.KtModifierList
 import org.jetbrains.kotlin.psi.KtParameter.VAL_VAR_TOKEN_SET
 import org.jetbrains.kotlin.psi.psiUtil.visibilityModifierType
@@ -134,7 +134,7 @@ inline fun <reified T : Any> FirQualifiedAccessExpression.getDeclaration(): T? {
  * Returns the ClassLikeDeclaration where the Fir object has been defined
  * or null if no proper declaration has been found.
  */
-fun FirSymbolOwner<*>.getContainingClass(context: CheckerContext): FirClassLikeDeclaration<*>? =
+fun FirDeclaration<*>.getContainingClass(context: CheckerContext): FirClassLikeDeclaration<*>? =
     this.safeAs<FirCallableMemberDeclaration<*>>()?.containingClass()?.toSymbol(context.session)?.fir
 
 fun FirClassLikeSymbol<*>.outerClass(context: CheckerContext): FirClassLikeSymbol<*>? {
@@ -232,9 +232,9 @@ fun FirClass<*>.modality(): Modality? {
 }
 
 /**
- * returns implicit modality by FirMemberDeclaration
+ * returns implicit modality by FirMemberDeclaration<*>
  */
-fun FirMemberDeclaration.implicitModality(context: CheckerContext): Modality {
+fun FirMemberDeclaration<*>.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
@@ -263,7 +263,7 @@ fun FirMemberDeclaration.implicitModality(context: CheckerContext): Modality {
     return Modality.FINAL
 }
 
-private fun FirDeclaration.hasBody(): Boolean = when (this) {
+private fun FirDeclaration<*>.hasBody(): Boolean = when (this) {
     is FirSimpleFunction -> this.body != null && this.body !is FirEmptyExpressionBlock
     is FirProperty -> this.setter?.body !is FirEmptyExpressionBlock? || this.getter?.body !is FirEmptyExpressionBlock?
     else -> false
@@ -379,7 +379,7 @@ private fun lowerThanBound(context: ConeInferenceContext, argument: ConeKotlinTy
     return false
 }
 
-fun FirMemberDeclaration.isInlineOnly(): Boolean = isInline && hasAnnotation(INLINE_ONLY_ANNOTATION_CLASS_ID)
+fun FirMemberDeclaration<*>.isInlineOnly(): Boolean = isInline && hasAnnotation(INLINE_ONLY_ANNOTATION_CLASS_ID)
 
 fun isSubtypeForTypeMismatch(context: ConeInferenceContext, subtype: ConeKotlinType, supertype: ConeKotlinType): Boolean {
     val subtypeFullyExpanded = subtype.fullyExpandedType(context.session)
@@ -508,7 +508,7 @@ private val FirSimpleFunction.matchesDataClassSyntheticMemberSignatures: Boolean
             (this.name == HASHCODE_NAME && matchesHashCodeSignature) ||
             (this.name == OperatorNameConventions.TO_STRING && matchesToStringSignature)
 
-private fun FirSymbolOwner<*>.getContainingClass(sessionHolder: SessionHolder): FirClassLikeDeclaration<*>? =
+private fun FirDeclaration<*>.getContainingClass(sessionHolder: SessionHolder): FirClassLikeDeclaration<*>? =
     this.safeAs<FirCallableMemberDeclaration<*>>()?.containingClass()?.toSymbol(sessionHolder.session)?.fir
 
 // NB: we intentionally do not check return types

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

@@ -40,7 +40,7 @@ private data class FirSinceKotlinValue(
     val wasExperimentalMarkerClasses: List<FirRegularClassSymbol>
 )
 
-fun FirAnnotatedDeclaration.checkSinceKotlinVersionAccessibility(context: CheckerContext): FirSinceKotlinAccessibility {
+fun FirAnnotatedDeclaration<*>.checkSinceKotlinVersionAccessibility(context: CheckerContext): FirSinceKotlinAccessibility {
     val value = getOwnSinceKotlinVersion(context.session)
     val version = value?.apiVersion
     val languageVersionSettings = context.session.languageVersionSettings
@@ -59,11 +59,11 @@ fun FirAnnotatedDeclaration.checkSinceKotlinVersionAccessibility(context: Checke
     return FirSinceKotlinAccessibility.NotAccessible(version)
 }
 
-private fun FirAnnotatedDeclaration.getOwnSinceKotlinVersion(session: FirSession): FirSinceKotlinValue? {
+private fun FirAnnotatedDeclaration<*>.getOwnSinceKotlinVersion(session: FirSession): FirSinceKotlinValue? {
     var result: FirSinceKotlinValue? = null
 
     // TODO: use-site targeted annotations
-    fun FirAnnotatedDeclaration.consider() {
+    fun FirAnnotatedDeclaration<*>.consider() {
         val sinceKotlinSingleArgument = getAnnotationByFqName(SINCE_KOTLIN_FQ_NAME)?.arguments?.singleOrNull()
         val apiVersion = ((sinceKotlinSingleArgument as? FirConstExpression<*>)?.value as? String)?.let(ApiVersion.Companion::parse)
         if (apiVersion != null) {
@@ -90,7 +90,7 @@ private fun FirAnnotatedDeclaration.getOwnSinceKotlinVersion(session: FirSession
     return result
 }
 
-private fun FirAnnotatedDeclaration.loadWasExperimentalMarkerClasses(): List<FirRegularClassSymbol> {
+private fun FirAnnotatedDeclaration<*>.loadWasExperimentalMarkerClasses(): List<FirRegularClassSymbol> {
     val wasExperimental = getAnnotationByFqName(OptInNames.WAS_EXPERIMENTAL_FQ_NAME) ?: return emptyList()
     val annotationClasses = wasExperimental.findArgumentByName(OptInNames.WAS_EXPERIMENTAL_ANNOTATION_CLASS) ?: return emptyList()
     return annotationClasses.extractClassesFromArgument()

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

@@ -22,7 +22,7 @@ abstract class CheckerContext {
 
     // Context
     abstract val implicitReceiverStack: ImplicitReceiverStack
-    abstract val containingDeclarations: List<FirDeclaration>
+    abstract val containingDeclarations: List<FirDeclaration<*>>
     abstract val qualifiedAccessOrAnnotationCalls: List<FirStatement>
     abstract val getClassCalls: List<FirGetClassCall>
 
@@ -62,7 +62,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 : FirDeclaration<*>> 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/context/PersistentCheckerContext.kt

@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.name.Name
 
 class PersistentCheckerContext private constructor(
     override val implicitReceiverStack: PersistentImplicitReceiverStack,
-    override val containingDeclarations: PersistentList<FirDeclaration>,
+    override val containingDeclarations: PersistentList<FirDeclaration<*>>,
     override val qualifiedAccessOrAnnotationCalls: PersistentList<FirStatement>,
     override val getClassCalls: PersistentList<FirGetClassCall>,
     override val sessionHolder: SessionHolder,
@@ -58,7 +58,7 @@ class PersistentCheckerContext private constructor(
         )
     }
 
-    fun addDeclaration(declaration: FirDeclaration): PersistentCheckerContext {
+    fun addDeclaration(declaration: FirDeclaration<*>): PersistentCheckerContext {
         return PersistentCheckerContext(
             implicitReceiverStack,
             containingDeclarations.add(declaration),

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

@@ -19,7 +19,9 @@ import org.jetbrains.kotlin.fir.expressions.argumentMapping
 import org.jetbrains.kotlin.fir.resolve.fqName
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.StandardClassIds
-import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.KtDestructuringDeclaration
+import org.jetbrains.kotlin.psi.KtDestructuringDeclarationEntry
+import org.jetbrains.kotlin.psi.KtLambdaExpression
 import org.jetbrains.kotlin.resolve.AnnotationTargetList
 import org.jetbrains.kotlin.resolve.AnnotationTargetLists
 
@@ -28,7 +30,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
     private val deprecatedSinceKotlinClassId = FqName("kotlin.DeprecatedSinceKotlin")
 
     override fun check(
-        declaration: FirAnnotatedDeclaration,
+        declaration: FirAnnotatedDeclaration<*>,
         context: CheckerContext,
         reporter: DiagnosticReporter
     ) {
@@ -54,7 +56,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
     }
 
     private fun checkAnnotationTarget(
-        declaration: FirAnnotatedDeclaration,
+        declaration: FirAnnotatedDeclaration<*>,
         annotation: FirAnnotationCall,
         context: CheckerContext,
         reporter: DiagnosticReporter
@@ -106,7 +108,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
     }
 
     private fun checkAnnotationUseSiteTarget(
-        annotated: FirAnnotatedDeclaration,
+        annotated: FirAnnotatedDeclaration<*>,
         annotation: FirAnnotationCall,
         target: AnnotationUseSiteTarget,
         context: CheckerContext,
@@ -195,7 +197,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
         }
     }
 
-    private fun getActualTargetList(annotated: FirDeclaration): AnnotationTargetList {
+    private fun getActualTargetList(annotated: FirDeclaration<*>): AnnotationTargetList {
         return when (annotated) {
             is FirRegularClass -> {
                 AnnotationTargetList(

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

@@ -12,15 +12,14 @@ import org.jetbrains.kotlin.descriptors.ClassKind.ENUM_CLASS
 import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.checkers.*
-import org.jetbrains.kotlin.fir.analysis.checkers.checkConstantArguments
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.name.StandardClassIds
-import org.jetbrains.kotlin.name.StandardClassIds.primitiveArrayTypeByElementType
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.StandardClassIds
+import org.jetbrains.kotlin.name.StandardClassIds.primitiveArrayTypeByElementType
 import org.jetbrains.kotlin.name.StandardClassIds.unsignedArrayTypeByElementType
 
 object FirAnnotationClassDeclarationChecker : FirRegularClassChecker() {
@@ -44,7 +43,7 @@ object FirAnnotationClassDeclarationChecker : FirRegularClassChecker() {
         }
     }
 
-    private fun checkAnnotationClassMember(member: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+    private fun checkAnnotationClassMember(member: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
         when {
             member is FirConstructor && member.isPrimary -> {
                 for (parameter in member.valueParameters) {

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

@@ -6,7 +6,8 @@
 package org.jetbrains.kotlin.fir.analysis.checkers.declaration
 
 import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.extractArgumentTypeRefAndSource
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
@@ -28,7 +29,7 @@ object FirClassVarianceChecker : FirClassChecker() {
         }
 
         for (member in declaration.declarations) {
-            if (member is FirMemberDeclaration) {
+            if (member is FirMemberDeclaration<*>) {
                 if (Visibilities.isPrivate(member.status.visibility)) {
                     continue
                 }

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

@@ -28,9 +28,9 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
 
     private class DeclarationInspector : FirDeclarationInspector() {
 
-        val declarationConflictingSymbols: HashMap<FirDeclaration, SmartSet<FirBasedSymbol<*>>> = hashMapOf()
+        val declarationConflictingSymbols: HashMap<FirDeclaration<*>, SmartSet<FirBasedSymbol<*>>> = hashMapOf()
 
-        override fun collectNonFunctionDeclaration(key: String, declaration: FirDeclaration): MutableList<FirDeclaration> =
+        override fun collectNonFunctionDeclaration(key: String, declaration: FirDeclaration<*>): MutableList<FirDeclaration<*>> =
             super.collectNonFunctionDeclaration(key, declaration).also {
                 collectLocalConflicts(declaration, it)
             }
@@ -40,30 +40,26 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
                 collectLocalConflicts(declaration, it)
             }
 
-        private fun collectLocalConflicts(declaration: FirDeclaration, conflicting: List<FirDeclaration>) {
+        private fun collectLocalConflicts(declaration: FirDeclaration<*>, conflicting: List<FirDeclaration<*>>) {
             val localConflicts = SmartSet.create<FirBasedSymbol<*>>()
             for (otherDeclaration in conflicting) {
-                if (otherDeclaration is FirSymbolOwner<*>) {
+                if (otherDeclaration != declaration && !isExpectAndActual(declaration, otherDeclaration)) {
-                    if (otherDeclaration != declaration && declaration is FirSymbolOwner<*> &&
+                    localConflicts.add(otherDeclaration.symbol)
-                        !isExpectAndActual(declaration, otherDeclaration)
+                    declarationConflictingSymbols.getOrPut(otherDeclaration) { SmartSet.create() }.add(declaration.symbol)
-                    ) {
-                        localConflicts.add(otherDeclaration.symbol)
-                        declarationConflictingSymbols.getOrPut(otherDeclaration) { SmartSet.create() }.add(declaration.symbol)
-                    }
                 }
             }
             declarationConflictingSymbols[declaration] = localConflicts
         }
 
-        private fun isExpectAndActual(declaration1: FirDeclaration, declaration2: FirDeclaration): Boolean {
+        private fun isExpectAndActual(declaration1: FirDeclaration<*>, declaration2: FirDeclaration<*>): Boolean {
-            if (declaration1 !is FirMemberDeclaration) return false
+            if (declaration1 !is FirMemberDeclaration<*>) return false
-            if (declaration2 !is FirMemberDeclaration) return false
+            if (declaration2 !is FirMemberDeclaration<*>) return false
             return (declaration1.status.isExpect && declaration2.status.isActual) ||
                     (declaration1.status.isActual && declaration2.status.isExpect)
         }
 
         private fun areCompatibleMainFunctions(
-            declaration1: FirDeclaration, file1: FirFile, declaration2: FirDeclaration, file2: FirFile?
+            declaration1: FirDeclaration<*>, file1: FirFile, declaration2: FirDeclaration<*>, file2: FirFile?
         ): Boolean {
             // TODO: proper main function detector
             if (declaration1 !is FirSimpleFunction || declaration2 !is FirSimpleFunction) return false
@@ -72,7 +68,7 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
         }
 
         private fun collectExternalConflict(
-            declaration: FirDeclaration,
+            declaration: FirDeclaration<*>,
             declarationPresentation: String,
             containingFile: FirFile,
             conflictingSymbol: FirBasedSymbol<*>,
@@ -93,16 +89,15 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
             if (containingFile == actualConflictingFile) return // TODO: rewrite local decls checker to the same logic and then remove the check
             if (areCompatibleMainFunctions(declaration, containingFile, conflicting, actualConflictingFile)) return
             if (isExpectAndActual(declaration, conflicting)) return
-            if (conflicting is FirMemberDeclaration && !(conflicting is FirSymbolOwner<*> &&
+            if (
-                        session.visibilityChecker.isVisible(conflicting, session, containingFile, emptyList(), null))
+                conflicting is FirMemberDeclaration<*> &&
-            ) {
+                !session.visibilityChecker.isVisible(conflicting, session, containingFile, emptyList(), null)
-                return
+            ) return
-            }
             declarationConflictingSymbols.getOrPut(declaration) { SmartSet.create() }.add(conflictingSymbol)
         }
 
         fun collectWithExternalConflicts(
-            declaration: FirDeclaration,
+            declaration: FirDeclaration<*>,
             containingFile: FirFile,
             session: FirSession,
             packageMemberScope: FirPackageMemberScope
@@ -205,7 +200,7 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
         }
     }
 
-    override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
         val inspector = DeclarationInspector()
 
         when (declaration) {
@@ -243,7 +238,7 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
     }
 }
 
-private fun FirDeclarationPresenter.represent(declaration: FirDeclaration): String? =
+private fun FirDeclarationPresenter.represent(declaration: FirDeclaration<*>): String? =
     when (declaration) {
         is FirSimpleFunction -> represent(declaration)
         is FirRegularClass -> represent(declaration)
@@ -272,7 +267,7 @@ class FirNameConflictsTracker : FirNameConflictsTrackerComponent() {
     }
 }
 
-private fun FirDeclaration.onConstructors(action: (ctor: FirConstructor) -> Unit) {
+private fun FirDeclaration<*>.onConstructors(action: (ctor: FirConstructor) -> Unit) {
 
     class ClassConstructorVisitor : FirVisitorVoid() {
         override fun visitElement(element: FirElement) {}

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

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 object FirCyclicTypeBoundsChecker : FirMemberDeclarationChecker() {
 
-    override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration is FirConstructor || declaration is FirTypeAlias) return
 
         val processed = mutableSetOf<Name>()

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

@@ -7,8 +7,8 @@ package org.jetbrains.kotlin.fir.analysis.checkers.declaration
 
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 
-abstract class FirDeclarationChecker<in D : FirDeclaration> {
+abstract class FirDeclarationChecker<in D : FirDeclaration<*>> {
     abstract fun check(declaration: D, context: CheckerContext, reporter: DiagnosticReporter)
 }

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 FirMemberDeclaration<*>.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 FirMemberDeclaration<*>.isEffectivelyExternal(
     containingClass: FirRegularClass?,
     context: CheckerContext,
 ): Boolean {
@@ -75,7 +75,7 @@ internal fun FirMemberDeclaration.isEffectivelyExternal(
 
 // TODO: check class too
 internal fun checkExpectDeclarationVisibilityAndBody(
-    declaration: FirMemberDeclaration,
+    declaration: FirMemberDeclaration<*>,
     source: FirSourceElement,
     reporter: DiagnosticReporter,
     context: CheckerContext
@@ -191,14 +191,14 @@ internal fun FirRegularClass.isInlineOrValueClass(): Boolean {
     return isInline || hasModifier(KtTokens.VALUE_KEYWORD)
 }
 
-internal val FirDeclaration.isEnumEntryInitializer: Boolean
+internal val FirDeclaration<*>.isEnumEntryInitializer: Boolean
     get() {
         if (this !is FirConstructor || !this.isPrimary) return false
         return (containingClassAttr as? ConeClassLookupTagWithFixedSymbol)?.symbol?.fir?.classKind == ClassKind.ENUM_ENTRY
     }
 
-// contract: returns(true) implies (this is FirMemberDeclaration)
+// contract: returns(true) implies (this is FirMemberDeclaration<*>)
-internal val FirDeclaration.isLocalMember: Boolean
+internal val FirDeclaration<*>.isLocalMember: Boolean
     get() = when (this) {
         is FirProperty -> this.isLocal
         is FirRegularClass -> this.isLocal

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

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 // TODO: check why coneTypeSafe is necessary at some points inside
 object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
-    override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirMemberDeclaration<*>, 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 FirMemberDeclaration<*>).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? {
+    ): FirMemberDeclaration<*>? {
         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 FirMemberDeclaration<*>) {
             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/FirImportsChecker.kt

@@ -57,7 +57,7 @@ object FirImportsChecker : FirFileChecker() {
         if (classId != null) {
             val classFir = classId.resolveToClass(context) ?: return
             if (classFir.classKind.isSingleton) return
-            
+
             if (!classFir.canBeImported(context, importedName)) {
                 reporter.reportOn(import.source, FirErrors.CANNOT_BE_IMPORTED, importedName, context)
             }
@@ -167,4 +167,4 @@ object FirImportsChecker : FirFileChecker() {
 
         return hasStatic || !hasIllegal
     }
-}
+}

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

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.isInfix
 
 object FirInfixFunctionDeclarationChecker : FirMemberDeclarationChecker() {
-    override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration is FirSimpleFunction && declaration.isInfix) {
             if (declaration.valueParameters.size != 1 || !hasExtensionOrDispatchReceiver(declaration, context)) {
                 reporter.reportOn(declaration.source, FirErrors.INAPPLICABLE_INFIX_MODIFIER, context)

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

@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
 object FirInlineDeclarationChecker : FirMemberDeclarationChecker() {
-    override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
         if (!declaration.isInline) return
         // local inline functions are prohibited
         if (declaration.isLocalMember) return
@@ -283,7 +283,7 @@ object FirInlineDeclarationChecker : FirMemberDeclarationChecker() {
         private fun FirBasedSymbol<*>.isDefinedInInlineFunction(): Boolean {
             return when (val fir = this.fir) {
                 is FirAnonymousFunction -> true
-                is FirMemberDeclaration -> fir.isLocalMember
+                is FirMemberDeclaration<*> -> 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/FirModifierChecker.kt

@@ -107,7 +107,7 @@ object FirModifierChecker : FirBasicDeclarationChecker() {
         secondModifier: FirModifier<*>,
         reporter: DiagnosticReporter,
         reportedNodes: MutableSet<FirModifier<*>>,
-        owner: FirDeclaration?,
+        owner: FirDeclaration<*>?,
         context: CheckerContext
     ) {
         val firstToken = firstModifier.token
@@ -137,7 +137,7 @@ object FirModifierChecker : FirBasicDeclarationChecker() {
 
     private fun checkModifiers(
         list: FirModifierList,
-        owner: FirDeclaration,
+        owner: FirDeclaration<*>,
         reporter: DiagnosticReporter,
         context: CheckerContext
     ) {
@@ -156,7 +156,7 @@ object FirModifierChecker : FirBasicDeclarationChecker() {
         }
     }
 
-    private fun isDeclarationMappedToSourceCorrectly(declaration: FirDeclaration, source: FirSourceElement): Boolean =
+    private fun isDeclarationMappedToSourceCorrectly(declaration: FirDeclaration<*>, source: FirSourceElement): Boolean =
         when (source.elementType) {
             KtNodeTypes.CLASS -> declaration is FirClass<*>
             KtNodeTypes.OBJECT_DECLARATION -> declaration is FirClass<*>
@@ -166,7 +166,7 @@ object FirModifierChecker : FirBasicDeclarationChecker() {
             else -> true
         }
 
-    override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration is FirFile) return
 
         val source = declaration.source ?: return

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 FirMemberDeclaration<*>) continue
-            val modality = (overridden.fir as FirMemberDeclaration).status.modality
+            val modality = (overridden.fir as FirMemberDeclaration<*>).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? {
+    ): FirMemberDeclaration<*>? {
         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 FirMemberDeclaration<*>) return@mapNotNull null
-            it to (it.fir as FirMemberDeclaration).visibility
+            it to (it.fir as FirMemberDeclaration<*>).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? {
+    ): FirMemberDeclaration<*>? {
         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: FirMemberDeclaration<*>, 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: FirMemberDeclaration<*>,
         overridden: FirCallableDeclaration<*>,
         context: CheckerContext
     ) {
@@ -248,15 +248,15 @@ object FirOverrideChecker : FirClassChecker() {
     }
 
     private fun DiagnosticReporter.reportVarOverriddenByVal(
-        overriding: FirMemberDeclaration,
+        overriding: FirMemberDeclaration<*>,
-        overridden: FirMemberDeclaration,
+        overridden: FirMemberDeclaration<*>,
         context: CheckerContext
     ) {
         reportOn(overriding.source, FirErrors.VAR_OVERRIDDEN_BY_VAL, overriding, overridden, context)
     }
 
     private fun DiagnosticReporter.reportCannotWeakenAccessPrivilege(
-        overriding: FirMemberDeclaration,
+        overriding: FirMemberDeclaration<*>,
         overridden: FirCallableDeclaration<*>,
         context: CheckerContext
     ) {
@@ -272,7 +272,7 @@ object FirOverrideChecker : FirClassChecker() {
     }
 
     private fun DiagnosticReporter.reportCannotChangeAccessPrivilege(
-        overriding: FirMemberDeclaration,
+        overriding: FirMemberDeclaration<*>,
         overridden: FirCallableDeclaration<*>,
         context: CheckerContext
     ) {
@@ -288,24 +288,24 @@ object FirOverrideChecker : FirClassChecker() {
     }
 
     private fun DiagnosticReporter.reportReturnTypeMismatchOnFunction(
-        overriding: FirMemberDeclaration,
+        overriding: FirMemberDeclaration<*>,
-        overridden: FirMemberDeclaration,
+        overridden: FirMemberDeclaration<*>,
         context: CheckerContext
     ) {
         reportOn(overriding.source, FirErrors.RETURN_TYPE_MISMATCH_ON_OVERRIDE, overriding, overridden, context)
     }
 
     private fun DiagnosticReporter.reportTypeMismatchOnProperty(
-        overriding: FirMemberDeclaration,
+        overriding: FirMemberDeclaration<*>,
-        overridden: FirMemberDeclaration,
+        overridden: FirMemberDeclaration<*>,
         context: CheckerContext
     ) {
         reportOn(overriding.source, FirErrors.PROPERTY_TYPE_MISMATCH_ON_OVERRIDE, overriding, overridden, context)
     }
 
     private fun DiagnosticReporter.reportTypeMismatchOnVariable(
-        overriding: FirMemberDeclaration,
+        overriding: FirMemberDeclaration<*>,
-        overridden: FirMemberDeclaration,
+        overridden: FirMemberDeclaration<*>,
         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/FirProjectionRelationChecker.kt

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 object FirProjectionRelationChecker : FirBasicDeclarationChecker() {
-    override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration is FirPropertyAccessor) {
             return
         }

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

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 object FirSealedSupertypeChecker : FirMemberDeclarationChecker() {
-    override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration is FirClass<*>) {
             // only the file declaration is present
             if (declaration.classId.isLocal) {

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

@@ -38,6 +38,6 @@ object FirThrowableSubclassChecker : FirClassChecker() {
     private fun FirClass<*>.hasGenericOuterDeclaration(context: CheckerContext) =
         classId.isLocal && context.containingDeclarations.anyIsGeneric()
 
-    private fun Collection<FirDeclaration>.anyIsGeneric() =
+    private fun Collection<FirDeclaration<*>>.anyIsGeneric() =
         any { it is FirTypeParameterRefsOwner && it.typeParameters.isNotEmpty() }
-}
+}

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

@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.*
 
 object FirTypeAliasChecker : FirMemberDeclarationChecker() {
-    override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration !is FirTypeAlias) return
 
         if (context.containingDeclarations.lastOrNull() !is FirFile) {
@@ -57,4 +57,4 @@ object FirTypeAliasChecker : FirMemberDeclarationChecker() {
             )
         }
     }
-}
+}

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

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.getDanglingTypeConstraintsOrEmpty
 
 object FirTypeConstraintsChecker : FirBasicDeclarationChecker() {
 
-    override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration !is FirTypeParameterRefsOwner) return
 
         //basically we transfer errors, which were discovered in ast parsers

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<FirMemberDeclaration<*>>()?.isInlineOnly() != true) {
             checkOnlyOneTypeParameterBound(declaration, context, reporter)
         }
 
@@ -47,7 +47,7 @@ object FirTypeParameterBoundsChecker : FirTypeParameterChecker() {
 
     private fun checkFinalUpperBounds(
         declaration: FirTypeParameter,
-        containingDeclaration: FirDeclaration,
+        containingDeclaration: FirDeclaration<*>,
         context: CheckerContext,
         reporter: DiagnosticReporter
     ) {
@@ -71,7 +71,7 @@ object FirTypeParameterBoundsChecker : FirTypeParameterChecker() {
 
     private fun checkTypeAliasBound(
         declaration: FirTypeParameter,
-        containingDeclaration: FirDeclaration,
+        containingDeclaration: FirDeclaration<*>,
         context: CheckerContext,
         reporter: DiagnosticReporter
     ) {

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

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.declarations.*
 
 object FirUpperBoundViolatedDeclarationChecker : FirBasicDeclarationChecker() {
-    override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration is FirClass<*>) {
             for (typeParameter in declaration.typeParameters) {
                 if (typeParameter is FirTypeParameter) {
@@ -36,4 +36,4 @@ object FirUpperBoundViolatedDeclarationChecker : FirBasicDeclarationChecker() {
             }
         }
     }
-}
+}

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 as? FirMemberDeclaration<*>)?.isLocalMember == false
         ) {
             reporter.reportOn(source, FirErrors.EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED, referredDeclaration, context)
         }

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

@@ -22,7 +22,7 @@ object FirExpressionAnnotationChecker : FirBasicExpressionChecker() {
     override fun check(expression: FirStatement, context: CheckerContext, reporter: DiagnosticReporter) {
         // Declarations are checked separately
         // See KT-33658 about annotations on non-expression statements
-        if (expression is FirDeclaration ||
+        if (expression is FirDeclaration<*> ||
             expression !is FirExpression ||
             expression is FirBlock && expression.source?.kind == FirFakeSourceElementKind.DesugaredForLoop
         ) return
@@ -34,4 +34,4 @@ object FirExpressionAnnotationChecker : FirBasicExpressionChecker() {
             }
         }
     }
-}
+}

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

@@ -112,7 +112,7 @@ object FirReservedUnderscoreExpressionChecker : FirBasicExpressionChecker() {
 }
 
 object FirReservedUnderscoreDeclarationChecker : FirBasicDeclarationChecker() {
-    override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
         if (
             declaration is FirClass<*> ||
             declaration is FirFunction<*> ||
@@ -141,7 +141,7 @@ object FirReservedUnderscoreDeclarationChecker : FirBasicDeclarationChecker() {
 }
 
 private fun reportIfUnderscore(
-    declaration: FirDeclaration,
+    declaration: FirDeclaration<*>,
     context: CheckerContext,
     reporter: DiagnosticReporter,
     isSingleUnderscoreAllowed: Boolean = false

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

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.fir.analysis.checkers.expression
 
 import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.isEnumEntryInitializer
 import org.jetbrains.kotlin.fir.analysis.checkers.getContainingClass
@@ -98,7 +97,7 @@ object FirUninitializedEnumChecker : FirQualifiedAccessExpressionChecker() {
             //     INSTANCE(EnumCompanion2.foo())
             //   }
             // find an accessed context within the same enum class.
-            (it as? FirSymbolOwner<*>)?.getContainingClass(context) == enumClass
+            it.getContainingClass(context) == enumClass
         } ?: return
 
         val enumMemberProperties = enumClass.declarations.filterIsInstance<FirProperty>()

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

@@ -17,14 +17,14 @@ import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.references.FirNamedReference
-import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.types.ConstantValueKind
 
 object RedundantExplicitTypeChecker : FirMemberDeclarationChecker() {
-    override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration !is FirProperty) return
         if (!declaration.isLocal) return
 

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

@@ -21,13 +21,13 @@ import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.modality
 import org.jetbrains.kotlin.psi.KtDeclaration
 
-object RedundantModalityModifierSyntaxChecker : FirDeclarationSyntaxChecker<FirMemberDeclaration, KtDeclaration>() {
+object RedundantModalityModifierSyntaxChecker : FirDeclarationSyntaxChecker<FirMemberDeclaration<*>, KtDeclaration>() {
 
-    override fun isApplicable(element: FirMemberDeclaration, source: FirSourceElement): Boolean =
+    override fun isApplicable(element: FirMemberDeclaration<*>, source: FirSourceElement): Boolean =
         source.kind !is FirFakeSourceElementKind
 
     override fun checkLightTree(
-        element: FirMemberDeclaration,
+        element: FirMemberDeclaration<*>,
         source: FirSourceElement,
         context: CheckerContext,
         reporter: DiagnosticReporter

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

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 
 object RedundantSetterParameterTypeChecker : FirMemberDeclarationChecker() {
-    override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirMemberDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration !is FirProperty) return
         val setter = declaration.setter ?: return
         if (setter is FirDefaultPropertyAccessor) return

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

@@ -22,10 +22,10 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 import org.jetbrains.kotlin.psi.KtDeclaration
 
-object RedundantVisibilityModifierSyntaxChecker : FirDeclarationSyntaxChecker<FirDeclaration, KtDeclaration>() {
+object RedundantVisibilityModifierSyntaxChecker : FirDeclarationSyntaxChecker<FirDeclaration<*>, KtDeclaration>() {
 
     override fun checkLightTree(
-        element: FirDeclaration,
+        element: FirDeclaration<*>,
         source: FirSourceElement,
         context: CheckerContext,
         reporter: DiagnosticReporter
@@ -33,14 +33,14 @@ object RedundantVisibilityModifierSyntaxChecker : FirDeclarationSyntaxChecker<Fi
         if (element is FirConstructor && source.kind is FirFakeSourceElementKind) return
         if (source is FirFakeSourceElement) return
         if (
-            element !is FirMemberDeclaration
+            element !is FirMemberDeclaration<*>
             && !(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<FirMemberDeclaration<*>>()
 
         val redundantVisibility = when {
             explicitVisibility == implicitVisibility -> implicitVisibility
@@ -59,7 +59,7 @@ object RedundantVisibilityModifierSyntaxChecker : FirDeclarationSyntaxChecker<Fi
         reporter.reportOn(source, FirErrors.REDUNDANT_VISIBILITY_MODIFIER, context)
     }
 
-    private fun FirDeclaration.implicitVisibility(context: CheckerContext): Visibility {
+    private fun FirDeclaration<*>.implicitVisibility(context: CheckerContext): Visibility {
         return when {
             this is FirPropertyAccessor && isSetter && status.isOverride -> this.visibility
 
@@ -105,7 +105,7 @@ object RedundantVisibilityModifierSyntaxChecker : FirDeclarationSyntaxChecker<Fi
     }
 
     private fun FirFunction<*>.visibility(): Visibility? {
-        (symbol.fir as? FirMemberDeclaration)?.visibility?.let {
+        (symbol.fir as? FirMemberDeclaration<*>)?.visibility?.let {
             return it
         }
 

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

@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.fir.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.analysis.cfa.*
 import org.jetbrains.kotlin.fir.analysis.checkers.cfa.FirControlFlowChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
@@ -32,7 +31,7 @@ import org.jetbrains.kotlin.fir.types.coneType
 
 object UnusedChecker : FirControlFlowChecker() {
     override fun analyze(graph: ControlFlowGraph, reporter: DiagnosticReporter, context: CheckerContext) {
-        if ((graph.declaration as? FirSymbolOwner<*>)?.getContainingClass(context)?.takeIf {
+        if (graph.declaration?.getContainingClass(context)?.takeIf {
                 !it.symbol.classId.isLocal
             } != null
         ) return

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/syntax/FirSyntaxChecker.kt

@@ -48,7 +48,7 @@ interface FirSyntaxChecker<in D : FirElement, P : PsiElement> {
     fun checkLightTree(element: D, source: FirSourceElement, context: CheckerContext, reporter: DiagnosticReporter)
 }
 
-abstract class FirDeclarationSyntaxChecker<in D : FirDeclaration, P : PsiElement> :
+abstract class FirDeclarationSyntaxChecker<in D : FirDeclaration<*>, P : PsiElement> :
     FirDeclarationChecker<D>(),
     FirSyntaxChecker<D, P> {
     final override fun check(declaration: D, context: CheckerContext, reporter: DiagnosticReporter) {

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

@@ -5,22 +5,26 @@
 
 package org.jetbrains.kotlin.fir.analysis.collectors
 
-import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.FirAnnotationContainer
-import org.jetbrains.kotlin.fir.analysis.collectors.components.*
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.analysis.collectors.components.AbstractDiagnosticCollectorComponent
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirVarargArgumentsExpression
+import org.jetbrains.kotlin.fir.expressions.arguments
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.SessionHolder
+import org.jetbrains.kotlin.fir.types.ConeClassLikeType
+import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.name.StandardClassIds
-import org.jetbrains.kotlin.fir.types.*
 
 abstract class AbstractDiagnosticCollector(
     override val session: FirSession,
     override val scopeSession: ScopeSession = ScopeSession(),
     protected val createComponents: (DiagnosticReporter) -> List<AbstractDiagnosticCollectorComponent>,
 ) : SessionHolder {
-    fun collectDiagnostics(firDeclaration: FirDeclaration, reporter: DiagnosticReporter) {
+    fun collectDiagnostics(firDeclaration: FirDeclaration<*>, reporter: DiagnosticReporter) {
         val components = createComponents(reporter)
         val visitor = createVisitor(components)
         firDeclaration.accept(visitor, null)

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

@@ -24,8 +24,8 @@ abstract class AbstractDiagnosticCollectorVisitor(
     @set:PrivateForInline var context: PersistentCheckerContext,
 ) : FirDefaultVisitor<Unit, Nothing?>() {
 
-    protected open fun shouldVisitDeclaration(declaration: FirDeclaration) = true
+    protected open fun shouldVisitDeclaration(declaration: FirDeclaration<*>) = true
-    protected open fun onDeclarationExit(declaration: FirDeclaration) {}
+    protected open fun onDeclarationExit(declaration: FirDeclaration<*>) {}
 
     protected open fun visitNestedElements(element: FirElement) {
         element.acceptChildren(this, null)
@@ -204,7 +204,7 @@ abstract class AbstractDiagnosticCollectorVisitor(
     }
 
     protected inline fun visitWithDeclaration(
-        declaration: FirDeclaration,
+        declaration: FirDeclaration<*>,
         block: () -> Unit = { visitNestedElements(declaration) }
     ) {
         if (shouldVisitDeclaration(declaration)) {
@@ -216,7 +216,7 @@ abstract class AbstractDiagnosticCollectorVisitor(
         }
     }
 
-    private fun visitWithDeclarationAndReceiver(declaration: FirDeclaration, labelName: Name?, receiverTypeRef: FirTypeRef?) {
+    private fun visitWithDeclarationAndReceiver(declaration: FirDeclaration<*>, labelName: Name?, receiverTypeRef: FirTypeRef?) {
         visitWithDeclaration(declaration) {
             withLabelAndReceiverType(
                 labelName,
@@ -265,7 +265,7 @@ abstract class AbstractDiagnosticCollectorVisitor(
 
 
     @OptIn(PrivateForInline::class)
-    inline fun <R> withDeclaration(declaration: FirDeclaration, block: () -> R): R {
+    inline fun <R> withDeclaration(declaration: FirDeclaration<*>, block: () -> R): R {
         val existingContext = context
         context = context.addDeclaration(declaration)
         try {
@@ -279,7 +279,7 @@ abstract class AbstractDiagnosticCollectorVisitor(
     @OptIn(PrivateForInline::class)
     inline fun <R> withLabelAndReceiverType(
         labelName: Name?,
-        owner: FirDeclaration,
+        owner: FirDeclaration<*>,
         type: ConeKotlinType?,
         block: () -> R
     ): R {

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

@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.DeclarationCheckers
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirDeclarationChecker
 import org.jetbrains.kotlin.fir.analysis.checkersComponent
-import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollector
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.declarations.*
 
@@ -78,7 +77,7 @@ class DeclarationCheckersDiagnosticComponent(
         checkers.allBasicDeclarationCheckers.check(anonymousInitializer, data, reporter)
     }
 
-    private fun <D : FirDeclaration> Collection<FirDeclarationChecker<D>>.check(
+    private fun <D : FirDeclaration<*>> Collection<FirDeclarationChecker<D>>.check(
         declaration: D,
         context: CheckerContext,
         reporter: DiagnosticReporter

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 FirMemberDeclaration<*> -> 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: FirMemberDeclaration<*> ->
         val name = when (declaration) {
             is FirProperty -> declaration.name
             is FirSimpleFunction -> declaration.name

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

@@ -376,9 +376,9 @@ class MultiModuleHtmlFirDump(private val outputRoot: File) {
                     visitElement(regularClass)
                 }
 
-                fun indexDeclaration(symbolOwner: FirSymbolOwner<*>) {
+                fun indexDeclaration(declaration: FirDeclaration<*>) {
-                    symbols[symbolOwner.symbol] = location
+                    symbols[declaration.symbol] = location
-                    symbolIds[symbolOwner.symbol] = symbolCounter++
+                    symbolIds[declaration.symbol] = symbolCounter++
                 }
 
                 override fun <F : FirVariable<F>> visitVariable(variable: FirVariable<F>) {
@@ -912,7 +912,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
         }
     }
 
-    private fun FlowContent.generate(memberDeclaration: FirMemberDeclaration) {
+    private fun FlowContent.generate(memberDeclaration: FirMemberDeclaration<*>) {
         when (memberDeclaration) {
             is FirEnumEntry -> generate(memberDeclaration)
             is FirRegularClass -> generate(memberDeclaration)
@@ -1524,7 +1524,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
                 is FirConstExpression<*> -> generate(expression)
                 is FirReturnExpression -> {
                     span("return-label") {
-                        symbolRef((expression.target.labeledElement as? FirSymbolOwner<*>)?.symbol) {
+                        symbolRef(expression.target.labeledElement.symbol) {
                             +"^"
                             +(expression.target.labelName ?: "")
                         }
@@ -1682,7 +1682,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
         }
     }
 
-    private fun FlowContent.generateDeclarations(declarations: List<FirDeclaration>) {
+    private fun FlowContent.generateDeclarations(declarations: List<FirDeclaration<*>>) {
         if (declarations.isNotEmpty()) {
             +" {"
             br
@@ -1767,10 +1767,10 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
         }
     }
 
-    private fun FlowContent.generate(declaration: FirDeclaration) {
+    private fun FlowContent.generate(declaration: FirDeclaration<*>) {
         when (declaration) {
             is FirAnonymousInitializer -> generate(declaration)
-            is FirMemberDeclaration -> generate(declaration)
+            is FirMemberDeclaration<*> -> generate(declaration)
             else -> unsupported(declaration)
         }
     }

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

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.moduleData
 
 class FirJvmModuleVisibilityChecker(private val session: FirSession) : FirModuleVisibilityChecker {
-    override fun isInFriendModule(declaration: FirMemberDeclaration): Boolean {
+    override fun isInFriendModule(declaration: FirMemberDeclaration<*>): Boolean {
         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

@@ -191,11 +191,11 @@ fun deserializeClassToSymbol(
         addCloneForArrayIfNeeded(classId, context.dispatchReceiver)
         addSerializableIfNeeded(classId)
 
-        declarations.sortWith(object : Comparator<FirDeclaration> {
+        declarations.sortWith(object : Comparator<FirDeclaration<*>> {
-            override fun compare(a: FirDeclaration, b: FirDeclaration): Int {
+            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 FirMemberDeclaration<*> && b is FirMemberDeclaration<*>) {
                     return FirMemberDeclarationComparator.TypeAndNameComparator.compare(a, b)
                 }
                 return 0

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

@@ -58,7 +58,7 @@ import org.jetbrains.kotlin.types.TypeApproximatorConfiguration
 class FirElementSerializer private constructor(
     private val session: FirSession,
     private val scopeSession: ScopeSession,
-    private val containingDeclaration: FirDeclaration?,
+    private val containingDeclaration: FirDeclaration<*>?,
     private val typeParameters: Interner<FirTypeParameter>,
     private val extension: FirSerializerExtension,
     private val typeTable: MutableTypeTable,
@@ -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? FirMemberDeclaration<*>)?.typeParameters ?: emptyList()) {
                     builder.typeParameterName = getSimpleNameIndex(typeParameter.name)
                 } else {
                     builder.typeParameter = getTypeParameterId(typeParameter)
@@ -820,7 +820,7 @@ class FirElementSerializer private constructor(
         )
     }
 
-    private fun createChildSerializer(declaration: FirDeclaration): FirElementSerializer =
+    private fun createChildSerializer(declaration: FirDeclaration<*>): FirElementSerializer =
         FirElementSerializer(
             session, scopeSession, declaration, Interner(typeParameters), extension,
             typeTable, versionRequirementTable, serializeTypeTableToFunction = false,
@@ -832,7 +832,7 @@ class FirElementSerializer private constructor(
 
     private fun useTypeTable(): Boolean = extension.shouldUseTypeTable()
 
-    private fun FirDeclaration.hasInlineClassTypesInSignature(): Boolean {
+    private fun FirDeclaration<*>.hasInlineClassTypesInSignature(): Boolean {
         // TODO
         return false
     }
@@ -927,7 +927,7 @@ class FirElementSerializer private constructor(
     }
 
 
-    private fun normalizeVisibility(declaration: FirMemberDeclaration): Visibility {
+    private fun normalizeVisibility(declaration: FirMemberDeclaration<*>): Visibility {
         return declaration.visibility.normalize()
     }
 

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

@@ -12,28 +12,28 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.signaturer.FirMangler
 
 @NoMutableState
-class FirJvmKotlinMangler(private val session: FirSession) : AbstractKotlinMangler<FirDeclaration>(), FirMangler {
+class FirJvmKotlinMangler(private val session: FirSession) : AbstractKotlinMangler<FirDeclaration<*>>(), FirMangler {
 
-    override val FirDeclaration.mangleString: String
+    override val FirDeclaration<*>.mangleString: String
         get() = getMangleComputer(MangleMode.FULL).computeMangle(this)
 
-    override val FirDeclaration.signatureString: String
+    override val FirDeclaration<*>.signatureString: String
         get() = getMangleComputer(MangleMode.SIGNATURE).computeMangle(this)
 
-    override val FirDeclaration.fqnString: String
+    override val FirDeclaration<*>.fqnString: String
         get() = getMangleComputer(MangleMode.FQNAME).computeMangle(this)
 
-    override fun FirDeclaration.isExported(): Boolean = true
+    override fun FirDeclaration<*>.isExported(): Boolean = true
 
-    override fun getExportChecker(): KotlinExportChecker<FirDeclaration> {
+    override fun getExportChecker(): KotlinExportChecker<FirDeclaration<*>> {
-        return object : KotlinExportChecker<FirDeclaration> {
+        return object : KotlinExportChecker<FirDeclaration<*>> {
-            override fun check(declaration: FirDeclaration, type: SpecialDeclarationType): Boolean = true
+            override fun check(declaration: FirDeclaration<*>, type: SpecialDeclarationType): Boolean = true
 
-            override fun FirDeclaration.isPlatformSpecificExported(): Boolean = true
+            override fun FirDeclaration<*>.isPlatformSpecificExported(): Boolean = true
         }
     }
 
-    override fun getMangleComputer(mode: MangleMode): KotlinMangleComputer<FirDeclaration> {
+    override fun getMangleComputer(mode: MangleMode): KotlinMangleComputer<FirDeclaration<*>> {
         return FirJvmMangleComputer(StringBuilder(256), mode, session)
     }
 }

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

@@ -12,8 +12,8 @@ import org.jetbrains.kotlin.backend.common.serialization.mangle.collectForMangle
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.firProvider
-import org.jetbrains.kotlin.fir.resolve.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
+import org.jetbrains.kotlin.fir.resolve.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
@@ -29,9 +29,9 @@ open class FirJvmMangleComputer(
     private val builder: StringBuilder,
     private val mode: MangleMode,
     private val session: FirSession
-) : FirVisitor<Unit, Boolean>(), KotlinMangleComputer<FirDeclaration> {
+) : FirVisitor<Unit, Boolean>(), KotlinMangleComputer<FirDeclaration<*>> {
 
-    private val typeParameterContainer = ArrayList<FirMemberDeclaration>(4)
+    private val typeParameterContainer = ArrayList<FirMemberDeclaration<*>>(4)
 
     private var isRealExpect = false
 
@@ -79,7 +79,7 @@ open class FirJvmMangleComputer(
         }
     }
 
-    private fun FirDeclaration.visitParent() {
+    private fun FirDeclaration<*>.visitParent() {
         val (parentPackageFqName, parentClassId) = when (this) {
             is FirCallableMemberDeclaration<*> -> this.containingClass()?.classId?.let { it.packageFqName to it } ?: return
             is FirClassLikeDeclaration<*> -> this.symbol.classId.let { it.packageFqName to it.outerClassId }
@@ -98,7 +98,7 @@ open class FirJvmMangleComputer(
         }
     }
 
-    private fun FirDeclaration.mangleSimpleDeclaration(name: String) {
+    private fun FirDeclaration<*>.mangleSimpleDeclaration(name: String) {
         val l = builder.length
         visitParent()
 
@@ -109,11 +109,11 @@ open class FirJvmMangleComputer(
         builder.appendName(name)
     }
 
-    private fun FirFunction<*>.mangleFunction(isCtor: Boolean, isStatic: Boolean, container: FirDeclaration) {
+    private fun FirFunction<*>.mangleFunction(isCtor: Boolean, isStatic: Boolean, container: FirDeclaration<*>) {
 
-        isRealExpect = isRealExpect || (this as? FirMemberDeclaration)?.isExpect == true
+        isRealExpect = isRealExpect || (this as? FirMemberDeclaration<*>)?.isExpect == true
 
-        if (container is FirMemberDeclaration) {
+        if (container is FirMemberDeclaration<*>) {
             typeParameterContainer.add(container)
         }
         visitParent()
@@ -164,7 +164,7 @@ open class FirJvmMangleComputer(
         }
     }
 
-    private fun FirTypeParameter.effectiveParent(): FirMemberDeclaration {
+    private fun FirTypeParameter.effectiveParent(): FirMemberDeclaration<*> {
         for (parent in typeParameterContainer) {
             if (this in parent.typeParameters) {
                 return parent
@@ -315,7 +315,7 @@ open class FirJvmMangleComputer(
     override fun visitConstructor(constructor: FirConstructor, data: Boolean) =
         constructor.mangleFunction(isCtor = true, isStatic = false, constructor)
 
-    override fun computeMangle(declaration: FirDeclaration): String {
+    override fun computeMangle(declaration: FirDeclaration<*>): String {
         declaration.accept(this, true)
         return builder.toString()
     }

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConverter.kt

@@ -161,7 +161,7 @@ class Fir2IrConverter(
         return irClass
     }
 
-    private fun delegatedMembers(irClass: IrClass): List<FirDeclaration> {
+    private fun delegatedMembers(irClass: IrClass): List<FirDeclaration<*>> {
         return irClass.declarations.filter {
             it.origin == IrDeclarationOrigin.DELEGATED_MEMBER
         }.mapNotNull {
@@ -172,7 +172,7 @@ class Fir2IrConverter(
     // Sort declarations so that all non-synthetic declarations are before synthetic ones.
     // This is needed because converting synthetic fields for implementation delegation needs to know
     // existing declarations in the class to avoid adding redundant delegated members.
-    private fun syntheticPropertiesLast(declarations: List<FirDeclaration>): Iterable<FirDeclaration> {
+    private fun syntheticPropertiesLast(declarations: List<FirDeclaration<*>>): Iterable<FirDeclaration<*>> {
         return declarations.sortedBy { it !is FirField && it.isSynthetic }
     }
 
@@ -196,7 +196,7 @@ class Fir2IrConverter(
     }
 
     private fun processMemberDeclaration(
-        declaration: FirDeclaration,
+        declaration: FirDeclaration<*>,
         containingClass: FirClass<*>?,
         parent: IrDeclarationParent
     ): IrDeclaration? {

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt

@@ -97,7 +97,7 @@ class Fir2IrDeclarationStorage(
     // For pure fields (from Java) only
     private val fieldToPropertyCache = ConcurrentHashMap<Pair<FirField, IrDeclarationParent>, IrProperty>()
 
-    private val delegatedReverseCache = ConcurrentHashMap<IrDeclaration, FirDeclaration>()
+    private val delegatedReverseCache = ConcurrentHashMap<IrDeclaration, FirDeclaration<*>>()
 
     private val fieldCache = ConcurrentHashMap<FirField, IrField>()
 
@@ -411,7 +411,7 @@ class Fir2IrDeclarationStorage(
         delegatedReverseCache[irFunction] = function
     }
 
-    fun originalDeclarationForDelegated(irDeclaration: IrDeclaration): FirDeclaration? = delegatedReverseCache[irDeclaration]
+    fun originalDeclarationForDelegated(irDeclaration: IrDeclaration): FirDeclaration<*>? = delegatedReverseCache[irDeclaration]
 
     internal fun declareIrSimpleFunction(
         signature: IdSignature?,
@@ -1266,7 +1266,7 @@ class Fir2IrDeclarationStorage(
     }
 
     private fun IrMutableAnnotationContainer.convertAnnotationsFromLibrary(firAnnotationContainer: FirAnnotationContainer) {
-        if ((firAnnotationContainer as? FirDeclaration)?.isFromLibrary == true ||
+        if ((firAnnotationContainer as? FirDeclaration<*>)?.isFromLibrary == true ||
             (firAnnotationContainer is FirCallableMemberDeclaration<*> && firAnnotationContainer.isSubstitutionOrIntersectionOverride)
         ) {
             annotationGenerator.generate(this, firAnnotationContainer)

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrSignatureComposer.kt

@@ -11,6 +11,6 @@ import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.ir.util.IdSignature
 
 interface Fir2IrSignatureComposer {
-    fun composeSignature(declaration: FirDeclaration, containingClass: ConeClassLikeLookupTag? = null): IdSignature?
+    fun composeSignature(declaration: FirDeclaration<*>, containingClass: ConeClassLikeLookupTag? = null): IdSignature?
     fun composeAccessorSignature(property: FirProperty, isSetter: Boolean, containingClass: ConeClassLikeLookupTag? = null): IdSignature?
 }

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt

@@ -86,7 +86,7 @@ class Fir2IrVisitor(
         }
     }
 
-    private fun FirDeclaration.toIrDeclaration(): IrDeclaration =
+    private fun FirDeclaration<*>.toIrDeclaration(): IrDeclaration =
         accept(this@Fir2IrVisitor, null) as IrDeclaration
 
     // ==================================================================================

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/FirMetadataSource.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.ir.declarations.MetadataSource
 import org.jetbrains.kotlin.name.Name
 
 sealed class FirMetadataSource : MetadataSource {
-    abstract val fir: FirDeclaration
+    abstract val fir: FirDeclaration<*>
 
     val declarationSiteSession: FirSession
         get() = fir.moduleData.session

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

@@ -7,7 +7,9 @@ package org.jetbrains.kotlin.fir.backend.generators
 
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.fir.backend.*
+import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
+import org.jetbrains.kotlin.fir.backend.Fir2IrConversionScope
+import org.jetbrains.kotlin.fir.backend.FirMetadataSource
 import org.jetbrains.kotlin.fir.backend.convertWithOffsets
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.*
@@ -32,7 +34,10 @@ import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
 import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
 import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl
-import org.jetbrains.kotlin.ir.types.*
+import org.jetbrains.kotlin.ir.types.IrSimpleType
+import org.jetbrains.kotlin.ir.types.IrType
+import org.jetbrains.kotlin.ir.types.isUnit
+import org.jetbrains.kotlin.ir.types.typeOrNull
 import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.name.Name
 
@@ -172,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 FirMemberDeclaration<*>
         return irFactory.createFunction(
             startOffset, endOffset,
             IrDeclarationOrigin.ADAPTER_FOR_CALLABLE_REFERENCE,
@@ -292,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? FirMemberDeclaration<*>)?.isStatic != true)) {
             // Unbound callable reference 'A::foo'
             val adaptedReceiverParameter = adapterFunction.valueParameters[0]
             val adaptedReceiverValue = IrGetValueImpl(

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

@@ -58,10 +58,10 @@ import org.jetbrains.kotlin.util.OperatorNameConventions.TO_STRING
 @OptIn(ObsoleteDescriptorBasedAPI::class)
 class DataClassMembersGenerator(val components: Fir2IrComponents) {
 
-    fun generateInlineClassMembers(klass: FirClass<*>, irClass: IrClass): List<FirDeclaration> =
+    fun generateInlineClassMembers(klass: FirClass<*>, irClass: IrClass): List<FirDeclaration<*>> =
         MyDataClassMethodsGenerator(irClass, klass.symbol.toLookupTag(), IrDeclarationOrigin.GENERATED_INLINE_CLASS_MEMBER).generate(klass)
 
-    fun generateDataClassMembers(klass: FirClass<*>, irClass: IrClass): List<FirDeclaration> =
+    fun generateDataClassMembers(klass: FirClass<*>, irClass: IrClass): List<FirDeclaration<*>> =
         MyDataClassMethodsGenerator(irClass, klass.symbol.toLookupTag(), IrDeclarationOrigin.GENERATED_DATA_CLASS_MEMBER).generate(klass)
 
     fun generateDataClassComponentBody(irFunction: IrFunction, lookupTag: ConeClassLikeLookupTag) =
@@ -175,14 +175,14 @@ class DataClassMembersGenerator(val components: Fir2IrComponents) {
                     (this.name == HASHCODE_NAME && matchesHashCodeSignature) ||
                     (this.name == TO_STRING && matchesToStringSignature)
 
-        fun generate(klass: FirClass<*>): List<FirDeclaration> {
+        fun generate(klass: FirClass<*>): List<FirDeclaration<*>> {
             val propertyParametersCount = irClass.primaryConstructor?.explicitParameters?.size ?: 0
             val properties = irClass.properties.filter { it.backingField != null }.take(propertyParametersCount).toList()
             if (properties.isEmpty()) {
                 return emptyList()
             }
 
-            val result = mutableListOf<FirDeclaration>()
+            val result = mutableListOf<FirDeclaration<*>>()
 
             val contributedFunctionsInThisType = klass.declarations.mapNotNull {
                 if (it is FirSimpleFunction && it.matchesDataClassSyntheticMemberSignatures) {

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

@@ -14,8 +14,8 @@ import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.scopes.*
 import org.jetbrains.kotlin.fir.scopes.impl.FirFakeOverrideGenerator
 import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData
-import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
@@ -59,18 +59,18 @@ class FakeOverrideGenerator(
         }
     }
 
-    fun IrClass.addFakeOverrides(klass: FirClass<*>, declarations: Collection<FirDeclaration>) {
+    fun IrClass.addFakeOverrides(klass: FirClass<*>, declarations: Collection<FirDeclaration<*>>) {
         this.declarations += getFakeOverrides(
             klass,
             declarations
         )
     }
 
-    fun IrClass.getFakeOverrides(klass: FirClass<*>, realDeclarations: Collection<FirDeclaration>): List<IrDeclaration> {
+    fun IrClass.getFakeOverrides(klass: FirClass<*>, realDeclarations: Collection<FirDeclaration<*>>): List<IrDeclaration> {
         val result = mutableListOf<IrDeclaration>()
         val useSiteMemberScope = klass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = true)
         val superTypesCallableNames = useSiteMemberScope.getCallableNames()
-        val realDeclarationSymbols = realDeclarations.filterIsInstance<FirSymbolOwner<*>>().mapTo(mutableSetOf(), FirSymbolOwner<*>::symbol)
+        val realDeclarationSymbols = realDeclarations.mapTo(mutableSetOf(), FirDeclaration<*>::symbol)
 
         for (name in superTypesCallableNames) {
             generateFakeOverridesForName(this, useSiteMemberScope, name, klass, result, realDeclarationSymbols)

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

@@ -10,12 +10,15 @@ import org.jetbrains.kotlin.fir.backend.toIrType
 import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.symbols.Fir2IrBindableSymbol
-import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.declarations.IrDeclaration
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
+import org.jetbrains.kotlin.ir.declarations.IrFactory
+import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
 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 : FirMemberDeclaration<*>, D : IrDeclaration> :
     IrDeclaration, IrDeclarationParent, Fir2IrComponents {
 
     val fir: F

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

@@ -27,7 +27,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 : FirMemberDeclaration<*>>(
     components: Fir2IrComponents,
     override val startOffset: Int,
     override val endOffset: Int,

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

@@ -5,11 +5,17 @@
 
 package org.jetbrains.kotlin.fir.lazy
 
-import org.jetbrains.kotlin.fir.backend.*
+import org.jetbrains.kotlin.fir.backend.ConversionTypeContext
+import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
+import org.jetbrains.kotlin.fir.backend.generateOverriddenAccessorSymbols
+import org.jetbrains.kotlin.fir.backend.toIrType
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticPropertyAccessor
 import org.jetbrains.kotlin.fir.symbols.Fir2IrSimpleFunctionSymbol
-import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrFunction
+import org.jetbrains.kotlin.ir.declarations.IrValueParameter
 import org.jetbrains.kotlin.ir.declarations.lazy.lazyVar
 import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
@@ -28,12 +34,12 @@ class Fir2IrLazyPropertyAccessor(
     firParentClass: FirRegularClass,
     symbol: Fir2IrSimpleFunctionSymbol,
     isFakeOverride: Boolean
-) : AbstractFir2IrLazyFunction<FirMemberDeclaration>(components, startOffset, endOffset, origin, symbol, isFakeOverride) {
+) : AbstractFir2IrLazyFunction<FirMemberDeclaration<*>>(components, startOffset, endOffset, origin, symbol, isFakeOverride) {
     init {
         symbol.bind(this)
     }
 
-    override val fir: FirMemberDeclaration
+    override val fir: FirMemberDeclaration<*>
         get() = firAccessor ?: firParentProperty
 
     // TODO: investigate why some deserialized properties are inline

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/signaturer/FirBasedSignatureComposer.kt

@@ -56,7 +56,7 @@ class FirBasedSignatureComposer(private val mangler: FirMangler) : Fir2IrSignatu
         }
     }
 
-    override fun composeSignature(declaration: FirDeclaration, containingClass: ConeClassLikeLookupTag?): IdSignature? {
+    override fun composeSignature(declaration: FirDeclaration<*>, containingClass: ConeClassLikeLookupTag?): IdSignature? {
         if (declaration is FirAnonymousObject || declaration is FirAnonymousFunction) return null
         if (declaration is FirRegularClass && declaration.classId.isLocal) return null
         if (declaration is FirCallableMemberDeclaration<*>) {

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/signaturer/FirMangler.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.signaturer
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.ir.util.KotlinMangler
 
-interface FirMangler : KotlinMangler<FirDeclaration> {
+interface FirMangler : KotlinMangler<FirDeclaration<*>> {
     override val manglerName: String
         get() = "Fir"
-}
+}

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

@@ -22,7 +22,7 @@ object FirJavaVisibilityChecker : FirVisibilityChecker() {
         declarationVisibility: Visibility,
         symbol: FirBasedSymbol<*>,
         useSiteFile: FirFile,
-        containingDeclarations: List<FirDeclaration>,
+        containingDeclarations: List<FirDeclaration<*>>,
         dispatchReceiver: ReceiverValue?,
         session: FirSession
     ): Boolean {

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

@@ -371,7 +371,7 @@ class JavaSymbolProvider(
         classId: ClassId,
         javaTypeParameterStack: JavaTypeParameterStack,
         dispatchReceiver: ConeClassLikeType
-    ): FirDeclaration {
+    ): FirDeclaration<*> {
         val fieldName = javaField.name
         val fieldId = CallableId(classId.packageFqName, classId.relativeClassName, fieldName)
         val returnType = javaField.type

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

@@ -37,7 +37,7 @@ class FirJavaClass @FirImplementationDetail internal constructor(
     override val annotations: MutableList<FirAnnotationCall>,
     override var status: FirDeclarationStatus,
     override val classKind: ClassKind,
-    override val declarations: MutableList<FirDeclaration>,
+    override val declarations: MutableList<FirDeclaration<*>>,
     override val scopeProvider: FirScopeProvider,
     override val symbol: FirRegularClassSymbol,
     override val superTypeRefs: MutableList<FirTypeRef>,
@@ -132,7 +132,7 @@ internal class FirJavaClassBuilder : FirRegularClassBuilder(), FirAnnotationCont
     override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
     override val typeParameters: MutableList<FirTypeParameterRef> = mutableListOf()
-    override val declarations: MutableList<FirDeclaration> = mutableListOf()
+    override val declarations: MutableList<FirDeclaration<*>> = mutableListOf()
 
     override val superTypeRefs: MutableList<FirTypeRef> = mutableListOf()
 

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt

@@ -87,7 +87,7 @@ class DeclarationsConverter(
 
         val fileAnnotationList = mutableListOf<FirAnnotationCall>()
         val importList = mutableListOf<FirImport>()
-        val firDeclarationList = mutableListOf<FirDeclaration>()
+        val firDeclarationList = mutableListOf<FirDeclaration<*>>()
         context.packageFqName = FqName.ROOT
         file.forEachChildren {
             when (it.tokenType) {
@@ -95,7 +95,7 @@ class DeclarationsConverter(
                 PACKAGE_DIRECTIVE -> context.packageFqName = convertPackageName(it)
                 IMPORT_LIST -> importList += convertImportDirectives(it)
                 CLASS -> firDeclarationList += convertClass(it)
-                FUN -> firDeclarationList += convertFunctionDeclaration(it) as FirDeclaration
+                FUN -> firDeclarationList += convertFunctionDeclaration(it) as FirDeclaration<*>
                 PROPERTY -> firDeclarationList += convertPropertyDeclaration(it)
                 TYPEALIAS -> firDeclarationList += convertTypeAlias(it)
                 OBJECT_DECLARATION -> firDeclarationList += convertClass(it)
@@ -358,7 +358,7 @@ class DeclarationsConverter(
     /**
      * @see org.jetbrains.kotlin.parsing.KotlinParsing.parseClassOrObject
      */
-    private fun convertClass(classNode: LighterASTNode): FirDeclaration {
+    private fun convertClass(classNode: LighterASTNode): FirDeclaration<*> {
         var modifiers = Modifier()
         var classKind: ClassKind = ClassKind.CLASS //TODO
         var identifier: String? = null
@@ -730,12 +730,12 @@ class DeclarationsConverter(
      * @see org.jetbrains.kotlin.parsing.KotlinParsing.parseClassBody
      * @see org.jetbrains.kotlin.parsing.KotlinParsing.parseEnumClassBody
      */
-    private fun convertClassBody(classBody: LighterASTNode, classWrapper: ClassWrapper): List<FirDeclaration> {
+    private fun convertClassBody(classBody: LighterASTNode, classWrapper: ClassWrapper): List<FirDeclaration<*>> {
         return classBody.forEachChildrenReturnList { node, container ->
             when (node.tokenType) {
                 ENUM_ENTRY -> container += convertEnumEntry(node, classWrapper)
                 CLASS -> container += convertClass(node)
-                FUN -> container += convertFunctionDeclaration(node, classWrapper) as FirDeclaration
+                FUN -> container += convertFunctionDeclaration(node, classWrapper) as FirDeclaration<*>
                 PROPERTY -> container += convertPropertyDeclaration(node, classWrapper)
                 TYPEALIAS -> container += convertTypeAlias(node)
                 OBJECT_DECLARATION -> container += convertClass(node)
@@ -826,7 +826,7 @@ class DeclarationsConverter(
      * @see org.jetbrains.kotlin.parsing.KotlinParsing.parseMemberDeclarationRest
      * at INIT keyword
      */
-    private fun convertAnonymousInitializer(anonymousInitializer: LighterASTNode): FirDeclaration {
+    private fun convertAnonymousInitializer(anonymousInitializer: LighterASTNode): FirDeclaration<*> {
         var firBlock: FirBlock? = null
         anonymousInitializer.forEachChildren {
             when (it.tokenType) {
@@ -949,7 +949,7 @@ class DeclarationsConverter(
     /**
      * @see org.jetbrains.kotlin.parsing.KotlinParsing.parseTypeAlias
      */
-    private fun convertTypeAlias(typeAlias: LighterASTNode): FirDeclaration {
+    private fun convertTypeAlias(typeAlias: LighterASTNode): FirDeclaration<*> {
         var modifiers = Modifier()
         var identifier: String? = null
         lateinit var firType: FirTypeRef
@@ -985,7 +985,7 @@ class DeclarationsConverter(
     /**
      * @see org.jetbrains.kotlin.parsing.KotlinParsing.parseProperty
      */
-    fun convertPropertyDeclaration(property: LighterASTNode, classWrapper: ClassWrapper? = null): FirDeclaration {
+    fun convertPropertyDeclaration(property: LighterASTNode, classWrapper: ClassWrapper? = null): FirDeclaration<*> {
         var modifiers = Modifier()
         var identifier: String? = null
         val firTypeParameters = mutableListOf<FirTypeParameter>()
@@ -1991,7 +1991,7 @@ class DeclarationsConverter(
         typeParameters: List<FirTypeParameter>,
         typeConstraints: List<TypeConstraint>,
         to: T
-    ) where T : FirDeclaration, T : FirTypeParameterRefsOwner {
+    ) where T : FirDeclaration<T>, T : FirTypeParameterRefsOwner {
         val typeParamNames = typeParameters.map { it.name }.toSet()
         val result = typeConstraints.mapNotNull { constraint ->
             val name = constraint.identifier.nameAsSafeName()

compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt

@@ -218,7 +218,7 @@ open class RawFirBuilder(
             owner: KtClassOrObject,
             ownerClassBuilder: FirClassBuilder,
             ownerTypeParameters: List<FirTypeParameterRef>
-        ): FirDeclaration {
+        ): FirDeclaration<*> {
             return when (this) {
                 is KtSecondaryConstructor -> {
                     disabledLazyMode {
@@ -514,7 +514,7 @@ open class RawFirBuilder(
             }
         }
 
-        private fun <T> KtTypeParameterListOwner.fillDanglingConstraintsTo(to: T) where T : FirDeclaration, T : FirTypeParameterRefsOwner {
+        private fun <T> KtTypeParameterListOwner.fillDanglingConstraintsTo(to: T) where T : FirDeclaration<T>, T : FirTypeParameterRefsOwner {
             val typeParamNames = typeParameters.mapNotNull { it.nameAsName }.toSet()
             val result = typeConstraints.mapNotNull { constraint ->
                 constraint.subjectTypeParameterName?.getReferencedNameAsName()?.let { name ->
@@ -730,7 +730,7 @@ open class RawFirBuilder(
                     }
                 }
                 for (declaration in file.declarations) {
-                    declarations += declaration.convert<FirDeclaration>()
+                    declarations += declaration.convert<FirDeclaration<*>>()
                 }
             }
         }
@@ -738,7 +738,7 @@ open class RawFirBuilder(
         private fun KtEnumEntry.toFirEnumEntry(
             delegatedEnumSelfTypeRef: FirResolvedTypeRef,
             ownerClassHasDefaultConstructor: Boolean
-        ): FirDeclaration {
+        ): FirDeclaration<*> {
             val ktEnumEntry = this@toFirEnumEntry
             return buildEnumEntry {
                 source = toFirSourceElement()

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

@@ -113,7 +113,7 @@ class RawFirBuilderTotalKotlinTestCase : AbstractRawFirBuilderTestCase() {
 //                        errorDeclaration.psi?.let { println(it) }
 //                    }
 
-                    override fun visitDeclaration(declaration: FirDeclaration) {
+                    override fun <T : FirDeclaration<T>> visitDeclaration(declaration: FirDeclaration<T>) {
                         normalDeclarations++
                         declaration.acceptChildren(this)
                     }

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 FirMemberDeclaration<*>).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 isInFriendModule(declaration: FirMemberDeclaration<*>): Boolean
 }
 
 abstract class FirVisibilityChecker : FirSessionComponent {
@@ -34,7 +34,7 @@ abstract class FirVisibilityChecker : FirSessionComponent {
             declarationVisibility: Visibility,
             symbol: FirBasedSymbol<*>,
             useSiteFile: FirFile,
-            containingDeclarations: List<FirDeclaration>,
+            containingDeclarations: List<FirDeclaration<*>>,
             dispatchReceiver: ReceiverValue?,
             session: FirSession
         ): Boolean {
@@ -42,13 +42,13 @@ abstract class FirVisibilityChecker : FirSessionComponent {
         }
     }
 
-    fun <T> isVisible(
+    fun isVisible(
-        declaration: T,
+        declaration: FirMemberDeclaration<*>,
         candidate: Candidate
-    ): Boolean where T : FirMemberDeclaration, T : FirSymbolOwner<*> {
+    ): Boolean {
         if (declaration is FirCallableDeclaration<*> && (declaration.isIntersectionOverride || declaration.isSubstitutionOverride)) {
             @Suppress("UNCHECKED_CAST")
-            return isVisible(declaration.originalIfFakeOverride() as T, candidate)
+            return isVisible(declaration.originalIfFakeOverride() as FirMemberDeclaration<*>, candidate)
         }
 
         val callInfo = candidate.callInfo
@@ -59,13 +59,13 @@ abstract class FirVisibilityChecker : FirSessionComponent {
         return isVisible(declaration, session, useSiteFile, containingDeclarations, candidate.dispatchReceiverValue)
     }
 
-    fun <T> isVisible(
+    fun isVisible(
-        declaration: T,
+        declaration: FirMemberDeclaration<*>,
         session: FirSession,
         useSiteFile: FirFile,
-        containingDeclarations: List<FirDeclaration>,
+        containingDeclarations: List<FirDeclaration<*>>,
         dispatchReceiver: ReceiverValue?
-    ): Boolean where T : FirMemberDeclaration, T : FirSymbolOwner<*> {
+    ): Boolean {
         val provider = session.firProvider
         val symbol = declaration.symbol
         return when (declaration.visibility) {
@@ -124,13 +124,13 @@ abstract class FirVisibilityChecker : FirSessionComponent {
         declarationVisibility: Visibility,
         symbol: FirBasedSymbol<*>,
         useSiteFile: FirFile,
-        containingDeclarations: List<FirDeclaration>,
+        containingDeclarations: List<FirDeclaration<*>>,
         dispatchReceiver: ReceiverValue?,
         session: FirSession
     ): Boolean
 
     private fun canSeePrivateMemberOf(
-        containingDeclarationOfUseSite: List<FirDeclaration>,
+        containingDeclarationOfUseSite: List<FirDeclaration<*>>,
         ownerId: ClassId,
         session: FirSession
     ): Boolean {
@@ -195,7 +195,7 @@ abstract class FirVisibilityChecker : FirSessionComponent {
     }
 
     protected fun canSeeProtectedMemberOf(
-        containingDeclarationOfUseSite: List<FirDeclaration>,
+        containingDeclarationOfUseSite: List<FirDeclaration<*>>,
         dispatchReceiver: ReceiverValue?,
         ownerId: ClassId, session: FirSession
     ): Boolean {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/FirAnnotationUtils.kt

@@ -85,6 +85,6 @@ private val USE_SITE_TARGET_NAME_MAP = mapOf(
 private val DEFAULT_USE_SITE_TARGETS: Set<AnnotationUseSiteTarget> =
     USE_SITE_TARGET_NAME_MAP.values.fold(setOf<AnnotationUseSiteTarget>()) { a, b -> a + b } - setOf(AnnotationUseSiteTarget.FILE)
 
-fun FirAnnotatedDeclaration.hasAnnotation(classId: ClassId): Boolean {
+fun FirAnnotatedDeclaration<*>.hasAnnotation(classId: ClassId): Boolean {
     return annotations.any { it.toAnnotationClassId() == classId }
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/FirVersionRequirementsTableKey.kt

@@ -9,4 +9,4 @@ import org.jetbrains.kotlin.metadata.deserialization.VersionRequirementTable
 
 object FirVersionRequirementsTableKey : FirDeclarationDataKey()
 
-var FirDeclaration.versionRequirementsTable: VersionRequirementTable? by FirDeclarationDataRegistry.data(FirVersionRequirementsTableKey)
+var FirDeclaration<*>.versionRequirementsTable: VersionRequirementTable? by FirDeclarationDataRegistry.data(FirVersionRequirementsTableKey)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirDeclarationGenerationExtension.kt

@@ -27,18 +27,18 @@ abstract class FirDeclarationGenerationExtension(session: FirSession) : FirPredi
     final override val extensionType: KClass<out FirExtension> = FirDeclarationGenerationExtension::class
 
     abstract fun generateClasses(
-        annotatedDeclaration: FirDeclaration,
+        annotatedDeclaration: FirDeclaration<*>,
-        owners: List<FirAnnotatedDeclaration>
+        owners: List<FirAnnotatedDeclaration<*>>
     ): List<GeneratedDeclaration<FirRegularClass>>
 
-    abstract fun generateMembersForGeneratedClass(generatedClass: GeneratedClass): List<FirDeclaration>
+    abstract fun generateMembersForGeneratedClass(generatedClass: GeneratedClass): List<FirDeclaration<*>>
 
     abstract fun generateMembers(
-        annotatedDeclaration: FirDeclaration,
+        annotatedDeclaration: FirDeclaration<*>,
-        owners: List<FirAnnotatedDeclaration>
+        owners: List<FirAnnotatedDeclaration<*>>
     ): List<GeneratedDeclaration<*>>
 
-    data class GeneratedDeclaration<out T : FirDeclaration>(val newDeclaration: T, val owner: FirAnnotatedDeclaration)
+    data class GeneratedDeclaration<out T : FirDeclaration<*>>(val newDeclaration: T, val owner: FirAnnotatedDeclaration<*>)
 
     fun interface Factory : FirExtension.Factory<FirDeclarationGenerationExtension>
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirPredicateBasedProvider.kt

@@ -23,30 +23,30 @@ abstract class FirPredicateBasedProvider : FirSessionComponent {
         }
     }
 
-    abstract fun getSymbolsByPredicate(predicate: DeclarationPredicate): List<FirAnnotatedDeclaration>
+    abstract fun getSymbolsByPredicate(predicate: DeclarationPredicate): List<FirAnnotatedDeclaration<*>>
 
     abstract fun getSymbolsByPredicate(
-        declarations: Collection<FirAnnotatedDeclaration>,
+        declarations: Collection<FirAnnotatedDeclaration<*>>,
         predicate: DeclarationPredicate
-    ): List<FirAnnotatedDeclaration>
+    ): List<FirAnnotatedDeclaration<*>>
 
     abstract fun getSymbolsWithOwnersByPredicate(
         predicate: DeclarationPredicate
-    ): List<Pair<FirAnnotatedDeclaration, List<FirAnnotatedDeclaration>>>
+    ): List<Pair<FirAnnotatedDeclaration<*>, List<FirAnnotatedDeclaration<*>>>>
 
     abstract fun getSymbolsWithOwnersByPredicate(
-        declarations: Collection<FirAnnotatedDeclaration>,
+        declarations: Collection<FirAnnotatedDeclaration<*>>,
         predicate: DeclarationPredicate
-    ): List<Pair<FirAnnotatedDeclaration, List<FirAnnotatedDeclaration>>>
+    ): List<Pair<FirAnnotatedDeclaration<*>, List<FirAnnotatedDeclaration<*>>>>
 
-    abstract fun getOwnersOfDeclaration(declaration: FirAnnotatedDeclaration): List<FirAnnotatedDeclaration>?
+    abstract fun getOwnersOfDeclaration(declaration: FirAnnotatedDeclaration<*>): List<FirAnnotatedDeclaration<*>>?
 
     abstract fun fileHasPluginAnnotations(file: FirFile): Boolean
 
-    abstract fun registerAnnotatedDeclaration(declaration: FirAnnotatedDeclaration, owners: PersistentList<FirAnnotatedDeclaration>)
+    abstract fun registerAnnotatedDeclaration(declaration: FirAnnotatedDeclaration<*>, owners: PersistentList<FirAnnotatedDeclaration<*>>)
-    abstract fun registerGeneratedDeclaration(declaration: FirAnnotatedDeclaration, owner: FirAnnotatedDeclaration)
+    abstract fun registerGeneratedDeclaration(declaration: FirAnnotatedDeclaration<*>, owner: FirAnnotatedDeclaration<*>)
 
-    abstract fun matches(predicate: DeclarationPredicate, declaration: FirAnnotatedDeclaration): Boolean
+    abstract fun matches(predicate: DeclarationPredicate, declaration: FirAnnotatedDeclaration<*>): Boolean
 }
 
 @NoMutableState
@@ -54,7 +54,7 @@ private class FirPredicateBasedProviderImpl(private val session: FirSession) : F
     private val registeredPluginAnnotations = session.registeredPluginAnnotations
     private val cache = Cache()
 
-    override fun getSymbolsByPredicate(predicate: DeclarationPredicate): List<FirAnnotatedDeclaration> {
+    override fun getSymbolsByPredicate(predicate: DeclarationPredicate): List<FirAnnotatedDeclaration<*>> {
         val annotations = registeredPluginAnnotations.getAnnotationsForPredicate(predicate)
         if (annotations.isEmpty()) return emptyList()
         val declarations = annotations.flatMapTo(mutableSetOf()) { cache.declarationByAnnotation[it] + cache.declarationsUnderAnnotated[it] }
@@ -62,24 +62,24 @@ private class FirPredicateBasedProviderImpl(private val session: FirSession) : F
     }
 
     override fun getSymbolsByPredicate(
-        declarations: Collection<FirAnnotatedDeclaration>,
+        declarations: Collection<FirAnnotatedDeclaration<*>>,
         predicate: DeclarationPredicate
-    ): List<FirAnnotatedDeclaration> {
+    ): List<FirAnnotatedDeclaration<*>> {
         return declarations.filter { matches(predicate, it) }
     }
 
-    override fun getSymbolsWithOwnersByPredicate(predicate: DeclarationPredicate): List<Pair<FirAnnotatedDeclaration, List<FirAnnotatedDeclaration>>> {
+    override fun getSymbolsWithOwnersByPredicate(predicate: DeclarationPredicate): List<Pair<FirAnnotatedDeclaration<*>, List<FirAnnotatedDeclaration<*>>>> {
         return getSymbolsByPredicate(predicate).zipWithParents()
     }
 
     override fun getSymbolsWithOwnersByPredicate(
-        declarations: Collection<FirAnnotatedDeclaration>,
+        declarations: Collection<FirAnnotatedDeclaration<*>>,
         predicate: DeclarationPredicate
-    ): List<Pair<FirAnnotatedDeclaration, List<FirAnnotatedDeclaration>>> {
+    ): List<Pair<FirAnnotatedDeclaration<*>, List<FirAnnotatedDeclaration<*>>>> {
         return getSymbolsByPredicate(declarations, predicate).zipWithParents()
     }
 
-    private fun List<FirAnnotatedDeclaration>.zipWithParents(): List<Pair<FirAnnotatedDeclaration, List<FirAnnotatedDeclaration>>> {
+    private fun List<FirAnnotatedDeclaration<*>>.zipWithParents(): List<Pair<FirAnnotatedDeclaration<*>, List<FirAnnotatedDeclaration<*>>>> {
         return this.map { it to cache.ownersForDeclaration.getValue(it) }
     }
 
@@ -87,7 +87,7 @@ private class FirPredicateBasedProviderImpl(private val session: FirSession) : F
         return file in cache.filesWithPluginAnnotations
     }
 
-    override fun registerAnnotatedDeclaration(declaration: FirAnnotatedDeclaration, owners: PersistentList<FirAnnotatedDeclaration>) {
+    override fun registerAnnotatedDeclaration(declaration: FirAnnotatedDeclaration<*>, owners: PersistentList<FirAnnotatedDeclaration<*>>) {
         cache.ownersForDeclaration[declaration] = owners
         registerOwnersDeclarations(declaration, owners)
 
@@ -101,16 +101,16 @@ private class FirPredicateBasedProviderImpl(private val session: FirSession) : F
         cache.filesWithPluginAnnotations += file
     }
 
-    override fun getOwnersOfDeclaration(declaration: FirAnnotatedDeclaration): List<FirAnnotatedDeclaration>? {
+    override fun getOwnersOfDeclaration(declaration: FirAnnotatedDeclaration<*>): List<FirAnnotatedDeclaration<*>>? {
         return cache.ownersForDeclaration[declaration]
     }
 
-    override fun registerGeneratedDeclaration(declaration: FirAnnotatedDeclaration, owner: FirAnnotatedDeclaration) {
+    override fun registerGeneratedDeclaration(declaration: FirAnnotatedDeclaration<*>, owner: FirAnnotatedDeclaration<*>) {
         val owners = cache.ownersForDeclaration.getValue(owner).add(owner)
         registerAnnotatedDeclaration(declaration, owners)
     }
 
-    private fun registerOwnersDeclarations(declaration: FirAnnotatedDeclaration, owners: PersistentList<FirAnnotatedDeclaration>) {
+    private fun registerOwnersDeclarations(declaration: FirAnnotatedDeclaration<*>, owners: PersistentList<FirAnnotatedDeclaration<*>>) {
         val lastOwner = owners.lastOrNull() ?: return
         val annotationsFromLastOwner = cache.annotationsOfDeclaration[lastOwner]
         val annotationsFromPreviousOwners = cache.parentAnnotationsOfDeclaration[lastOwner]
@@ -122,53 +122,53 @@ private class FirPredicateBasedProviderImpl(private val session: FirSession) : F
 
     // ---------------------------------- Matching ----------------------------------
 
-    override fun matches(predicate: DeclarationPredicate, declaration: FirAnnotatedDeclaration): Boolean {
+    override fun matches(predicate: DeclarationPredicate, declaration: FirAnnotatedDeclaration<*>): Boolean {
         return predicate.accept(matcher, declaration)
     }
 
     private val matcher = Matcher()
 
-    private inner class Matcher : DeclarationPredicateVisitor<Boolean, FirAnnotatedDeclaration>() {
+    private inner class Matcher : DeclarationPredicateVisitor<Boolean, FirAnnotatedDeclaration<*>>() {
-        override fun visitPredicate(predicate: DeclarationPredicate, data: FirAnnotatedDeclaration): Boolean {
+        override fun visitPredicate(predicate: DeclarationPredicate, data: FirAnnotatedDeclaration<*>): Boolean {
             throw IllegalStateException("Should not be there")
         }
 
-        override fun visitAny(predicate: DeclarationPredicate.Any, data: FirAnnotatedDeclaration): Boolean {
+        override fun visitAny(predicate: DeclarationPredicate.Any, data: FirAnnotatedDeclaration<*>): Boolean {
             return true
         }
 
-        override fun visitAnd(predicate: DeclarationPredicate.And, data: FirAnnotatedDeclaration): Boolean {
+        override fun visitAnd(predicate: DeclarationPredicate.And, data: FirAnnotatedDeclaration<*>): Boolean {
             return predicate.a.accept(this, data) && predicate.b.accept(this, data)
         }
 
-        override fun visitOr(predicate: DeclarationPredicate.Or, data: FirAnnotatedDeclaration): Boolean {
+        override fun visitOr(predicate: DeclarationPredicate.Or, data: FirAnnotatedDeclaration<*>): Boolean {
             return predicate.a.accept(this, data) || predicate.b.accept(this, data)
         }
 
-        override fun visitAnnotatedWith(predicate: AnnotatedWith, data: FirAnnotatedDeclaration): Boolean {
+        override fun visitAnnotatedWith(predicate: AnnotatedWith, data: FirAnnotatedDeclaration<*>): Boolean {
             return matchWith(data, predicate.annotations)
         }
 
-        override fun visitUnderAnnotatedWith(predicate: UnderAnnotatedWith, data: FirAnnotatedDeclaration): Boolean {
+        override fun visitUnderAnnotatedWith(predicate: UnderAnnotatedWith, data: FirAnnotatedDeclaration<*>): Boolean {
             return matchUnder(data, predicate.annotations)
         }
 
-        override fun visitAnnotatedWithMeta(predicate: AnnotatedWithMeta, data: FirAnnotatedDeclaration): Boolean {
+        override fun visitAnnotatedWithMeta(predicate: AnnotatedWithMeta, data: FirAnnotatedDeclaration<*>): Boolean {
             return matchWith(data, predicate.userDefinedAnnotations)
         }
 
-        override fun visitUnderMetaAnnotated(predicate: UnderMetaAnnotated, data: FirAnnotatedDeclaration): Boolean {
+        override fun visitUnderMetaAnnotated(predicate: UnderMetaAnnotated, data: FirAnnotatedDeclaration<*>): Boolean {
             return matchUnder(data, predicate.userDefinedAnnotations)
         }
 
         private val MetaAnnotated.userDefinedAnnotations: Set<AnnotationFqn>
             get() = metaAnnotations.flatMapTo(mutableSetOf()) { registeredPluginAnnotations.getAnnotationsWithMetaAnnotation(it) }
 
-        private fun matchWith(declaration: FirAnnotatedDeclaration, annotations: Set<AnnotationFqn>): Boolean {
+        private fun matchWith(declaration: FirAnnotatedDeclaration<*>, annotations: Set<AnnotationFqn>): Boolean {
             return cache.annotationsOfDeclaration[declaration].any { it in annotations }
         }
 
-        private fun matchUnder(declaration: FirAnnotatedDeclaration, annotations: Set<AnnotationFqn>): Boolean {
+        private fun matchUnder(declaration: FirAnnotatedDeclaration<*>, annotations: Set<AnnotationFqn>): Boolean {
             return cache.parentAnnotationsOfDeclaration[declaration].any { it in annotations }
         }
     }
@@ -176,13 +176,13 @@ private class FirPredicateBasedProviderImpl(private val session: FirSession) : F
     // ---------------------------------- Cache ----------------------------------
 
     private class Cache {
-        val declarationByAnnotation: Multimap<AnnotationFqn, FirAnnotatedDeclaration> = LinkedHashMultimap.create()
+        val declarationByAnnotation: Multimap<AnnotationFqn, FirAnnotatedDeclaration<*>> = LinkedHashMultimap.create()
-        val annotationsOfDeclaration: LinkedHashMultimap<FirAnnotatedDeclaration, AnnotationFqn> = LinkedHashMultimap.create()
+        val annotationsOfDeclaration: LinkedHashMultimap<FirAnnotatedDeclaration<*>, AnnotationFqn> = LinkedHashMultimap.create()
 
-        val declarationsUnderAnnotated: Multimap<AnnotationFqn, FirAnnotatedDeclaration> = LinkedHashMultimap.create()
+        val declarationsUnderAnnotated: Multimap<AnnotationFqn, FirAnnotatedDeclaration<*>> = LinkedHashMultimap.create()
-        val parentAnnotationsOfDeclaration: LinkedHashMultimap<FirAnnotatedDeclaration, AnnotationFqn> = LinkedHashMultimap.create()
+        val parentAnnotationsOfDeclaration: LinkedHashMultimap<FirAnnotatedDeclaration<*>, AnnotationFqn> = LinkedHashMultimap.create()
 
-        val ownersForDeclaration: MutableMap<FirAnnotatedDeclaration, PersistentList<FirAnnotatedDeclaration>> = mutableMapOf()
+        val ownersForDeclaration: MutableMap<FirAnnotatedDeclaration<*>, PersistentList<FirAnnotatedDeclaration<*>>> = mutableMapOf()
 
         val filesWithPluginAnnotations: MutableSet<FirFile> = mutableSetOf()
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirStatusTransformerExtension.kt

@@ -25,8 +25,8 @@ abstract class FirStatusTransformerExtension(session: FirSession) : FirPredicate
     final override val extensionType: KClass<out FirExtension> = FirStatusTransformerExtension::class
 
     abstract fun transformStatus(
-        declaration: FirDeclaration,
+        declaration: FirDeclaration<*>,
-        owners: List<FirAnnotatedDeclaration>,
+        owners: List<FirAnnotatedDeclaration<*>>,
         status: FirDeclarationStatus
     ): FirDeclarationStatus
 

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

@@ -45,7 +45,7 @@ data class SessionHolderImpl(override val session: FirSession, override val scop
 abstract class BodyResolveComponents : SessionHolder {
     abstract val returnTypeCalculator: ReturnTypeCalculator
     abstract val implicitReceiverStack: ImplicitReceiverStack
-    abstract val containingDeclarations: List<FirDeclaration>
+    abstract val containingDeclarations: List<FirDeclaration<*>>
     abstract val fileImportsScope: List<FirScope>
     abstract val towerDataElements: List<FirTowerDataElement>
     abstract val towerDataContext: FirTowerDataContext
@@ -53,7 +53,7 @@ abstract class BodyResolveComponents : SessionHolder {
     abstract val noExpectedType: FirTypeRef
     abstract val symbolProvider: FirSymbolProvider
     abstract val file: FirFile
-    abstract val container: FirDeclaration
+    abstract val container: FirDeclaration<*>
     abstract val resolutionStageRunner: ResolutionStageRunner
     abstract val samResolver: FirSamResolver
     abstract val callResolver: FirCallResolver
@@ -211,7 +211,7 @@ data class ImplicitReceivers(
 
 fun SessionHolder.collectImplicitReceivers(
     type: ConeKotlinType?,
-    owner: FirDeclaration
+    owner: FirDeclaration<*>
 ): ImplicitReceivers {
     if (type == null) return ImplicitReceivers(null, emptyList())
 

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

@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType
 import org.jetbrains.kotlin.fir.resolve.transformers.ensureResolved
 import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData
 import org.jetbrains.kotlin.fir.scopes.impl.importedFromObjectData
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
@@ -59,7 +59,7 @@ fun FirFunction<*>.constructFunctionalTypeRef(isSuspend: Boolean = false): FirRe
             )
         )
     }
-    val rawReturnType = (this as FirTypedDeclaration).returnTypeRef.coneType
+    val rawReturnType = (this as FirTypedDeclaration<*>).returnTypeRef.coneType
 
     val functionalType = createFunctionalType(parameters, receiverTypeRef?.coneType, rawReturnType, isSuspend = isSuspend)
 
@@ -155,7 +155,7 @@ internal fun typeForReifiedParameterReference(parameterReferenceBuilder: FirReso
     return resultType.resolvedTypeFromPrototype(typeParameterSymbol.constructType(emptyArray(), false))
 }
 
-internal fun typeForQualifierByDeclaration(declaration: FirDeclaration, resultType: FirTypeRef, session: FirSession): FirTypeRef? {
+internal fun typeForQualifierByDeclaration(declaration: FirDeclaration<*>, resultType: FirTypeRef, session: FirSession): FirTypeRef? {
     if (declaration is FirTypeAlias) {
         val expandedDeclaration = declaration.expandedConeType?.lookupTag?.toSymbol(session)?.fir ?: return null
         return typeForQualifierByDeclaration(expandedDeclaration, resultType, session)
@@ -413,7 +413,7 @@ fun FirFunction<*>.getAsForbiddenNamedArgumentsTarget(session: FirSession): Forb
             }
         }
     }
-    if (this is FirMemberDeclaration && status.isExpect) {
+    if (this is FirMemberDeclaration<*> && status.isExpect) {
         return ForbiddenNamedArgumentsTarget.EXPECTED_CLASS_MEMBER
     }
     return when (origin) {

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

@@ -18,11 +18,11 @@ import org.jetbrains.kotlin.fir.resolve.createFunctionalType
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnsupportedCallableReferenceTarget
 import org.jetbrains.kotlin.fir.resolve.inference.extractInputOutputTypesFromCallableReferenceExpectedType
 import org.jetbrains.kotlin.fir.resolve.inference.isSuspendFunctionType
-import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
+import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.resolve.calls.components.SuspendConversionStrategy
 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemOperation
 import org.jetbrains.kotlin.resolve.calls.inference.model.SimpleConstraintSystemConstraintPosition
@@ -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 FirMemberDeclaration<*> &&
                     candidate.callInfo.session.visibilityChecker.isVisible(original.setter!!, candidate))
 }

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

@@ -48,7 +48,7 @@ data class CallInfo(
     val typeArguments: List<FirTypeProjection>,
     val session: FirSession,
     val containingFile: FirFile,
-    val containingDeclarations: List<FirDeclaration>,
+    val containingDeclarations: List<FirDeclaration<*>>,
 
     val candidateForCommonInvokeReceiver: Candidate? = null,
 

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

@@ -10,8 +10,8 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.modality
 import org.jetbrains.kotlin.fir.render
-import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents
 import org.jetbrains.kotlin.fir.resolve.inference.ConeTypeParameterBasedTypeVariable
+import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents
 import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
 import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
 import org.jetbrains.kotlin.fir.types.coneType
@@ -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? FirMemberDeclaration<*>)?.modality != Modality.ABSTRACT }
             when (filtered.size) {
                 1 -> return filtered
                 0, candidates.size -> {

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

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.fir.resolve.calls
 
 import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.FirVisibilityChecker
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.*
@@ -101,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? FirMemberDeclaration<*>
             if (status?.modality == Modality.ABSTRACT) {
                 sink.reportDiagnostic(ResolvedWithLowPriority)
             }
@@ -197,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 FirMemberDeclaration<*>) {
             if (!checkVisibility(declaration, sink, candidate, visibilityChecker)) {
                 return
             }
@@ -216,12 +215,12 @@ internal object CheckVisibility : CheckerStage() {
         }
     }
 
-    private suspend fun <T> checkVisibility(
+    private suspend fun <T : FirMemberDeclaration<*>> checkVisibility(
         declaration: T,
         sink: CheckerSink,
         candidate: Candidate,
         visibilityChecker: FirVisibilityChecker
-    ): Boolean where T : FirMemberDeclaration, T : FirSymbolOwner<*> {
+    ): Boolean {
         if (!visibilityChecker.isVisible(declaration, candidate)) {
             sink.yieldDiagnostic(HiddenCandidate)
             return false

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/Stack.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.resolve.dfa
 
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirSymbolOwner
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.resolve.dfa.cfg.CFGNode
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 
@@ -76,12 +76,12 @@ class SymbolBasedNodeStorage<T, N : CFGNode<T>> : Stack<N>() where T : FirElemen
     override fun top(): N = stack.top()
 
     override fun pop(): N = stack.pop().also {
-        map.remove((it.fir as FirSymbolOwner<*>).symbol)
+        map.remove((it.fir as FirDeclaration<*>).symbol)
     }
 
     override fun push(value: N) {
         stack.push(value)
-        map[(value.fir as FirSymbolOwner<*>).symbol] = value
+        map[(value.fir as FirDeclaration<*>).symbol] = value
     }
 
     operator fun get(key: FirBasedSymbol<*>): N? {
@@ -92,4 +92,4 @@ class SymbolBasedNodeStorage<T, N : CFGNode<T>> : Stack<N>() where T : FirElemen
         stack.reset()
         map.clear()
     }
-}
+}

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraph.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.resolve.dfa.cfg
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 
-class ControlFlowGraph(val declaration: FirDeclaration?, val name: String, val kind: Kind) {
+class ControlFlowGraph(val declaration: FirDeclaration<*>?, val name: String, val kind: Kind) {
     private var _nodes: MutableList<CFGNode<*>> = mutableListOf()
 
     val nodes: List<CFGNode<*>>

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphBuilder.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.resolve.dfa.cfg
 
 import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.buildAnonymousFunctionExpression
@@ -413,13 +412,13 @@ class ControlFlowGraphBuilder {
         return popGraph()
     }
 
-    fun prepareForLocalClassMembers(members: Collection<FirSymbolOwner<*>>) {
+    fun prepareForLocalClassMembers(members: Collection<FirDeclaration<*>>) {
         members.forEachMember {
             enterToLocalClassesMembers[it.symbol] = lastNodes.topOrNull()
         }
     }
 
-    fun cleanAfterForLocalClassMembers(members: Collection<FirSymbolOwner<*>>) {
+    fun cleanAfterForLocalClassMembers(members: Collection<FirDeclaration<*>>) {
         members.forEachMember {
             enterToLocalClassesMembers.remove(it.symbol)
         }
@@ -1362,7 +1361,7 @@ class ControlFlowGraphBuilder {
 
     // ----------------------------------- Utils -----------------------------------
 
-    private inline fun Collection<FirSymbolOwner<*>>.forEachMember(block: (FirSymbolOwner<*>) -> Unit) {
+    private inline fun Collection<FirDeclaration<*>>.forEachMember(block: (FirDeclaration<*>) -> Unit) {
         for (member in this) {
             for (callableDeclaration in member.unwrap()) {
                 block(callableDeclaration)
@@ -1370,7 +1369,7 @@ class ControlFlowGraphBuilder {
         }
     }
 
-    private fun FirSymbolOwner<*>.unwrap(): List<FirSymbolOwner<*>> =
+    private fun FirDeclaration<*>.unwrap(): List<FirDeclaration<*>> =
         when (this) {
             is FirFunction<*>, is FirAnonymousInitializer -> listOf(this)
             is FirProperty -> listOfNotNull(this.getter, this.setter, this)
@@ -1384,4 +1383,4 @@ class ControlFlowGraphBuilder {
 
 }
 
-fun FirDeclaration?.isLocalClassOrAnonymousObject() = ((this as? FirRegularClass)?.isLocal == true) || this is FirAnonymousObject
+fun FirDeclaration<*>?.isLocalClassOrAnonymousObject() = ((this as? FirRegularClass)?.isLocal == true) || this is FirAnonymousObject

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/util.kt

@@ -7,9 +7,9 @@ package org.jetbrains.kotlin.fir.resolve.dfa
 
 import kotlinx.collections.immutable.PersistentMap
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.contracts.description.ConeBooleanConstantReference
 import org.jetbrains.kotlin.fir.contracts.description.ConeConstantReference
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.references.FirThisReference
@@ -95,7 +95,7 @@ internal val FirExpression.coneType: ConeKotlinType
 internal val FirElement.symbol: FirBasedSymbol<*>?
     get() = when (this) {
         is FirResolvable -> symbol
-        is FirSymbolOwner<*> -> symbol
+        is FirDeclaration<*> -> symbol
         is FirWhenSubjectExpression -> whenRef.value.subject?.symbol
         is FirSafeCallExpression -> regularQualifiedAccess.symbol
         else -> null

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirBuilderInferenceSession.kt

@@ -273,4 +273,4 @@ class FirStubTypeTransformer(
 private val BUILDER_INFERENCE_ANNOTATION_CLASS_ID = ClassId.topLevel(BUILDER_INFERENCE_ANNOTATION_FQ_NAME)
 
 fun FirElement.hasBuilderInferenceAnnotation(): Boolean =
-    (this as? FirAnnotatedDeclaration)?.hasAnnotation(BUILDER_INFERENCE_ANNOTATION_CLASS_ID) == true
+    (this as? FirAnnotatedDeclaration<*>)?.hasAnnotation(BUILDER_INFERENCE_ANNOTATION_CLASS_ID) == true

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/FirProvider.kt

@@ -41,10 +41,10 @@ abstract class FirProvider : FirSessionComponent {
     abstract fun getFirFilesByPackage(fqName: FqName): List<FirFile>
 
     @FirProviderInternals
-    abstract fun recordGeneratedClass(owner: FirAnnotatedDeclaration, klass: FirRegularClass)
+    abstract fun recordGeneratedClass(owner: FirAnnotatedDeclaration<*>, klass: FirRegularClass)
 
     @FirProviderInternals
-    abstract fun recordGeneratedMember(owner: FirAnnotatedDeclaration, klass: FirDeclaration)
+    abstract fun recordGeneratedMember(owner: FirAnnotatedDeclaration<*>, klass: FirDeclaration<*>)
 
     abstract fun getClassNamesInPackage(fqName: FqName): Set<Name>
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/FirSymbolProvider.kt

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.scopes.getDeclaredConstructors
 import org.jetbrains.kotlin.fir.scopes.getFunctions
 import org.jetbrains.kotlin.fir.scopes.getProperties
 import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType
 import org.jetbrains.kotlin.fir.types.FirTypeRef

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirLibrarySessionProvider.kt

@@ -27,12 +27,12 @@ class FirLibrarySessionProvider(
     override fun getFirFilesByPackage(fqName: FqName): List<FirFile> = emptyList()
 
     @FirProviderInternals
-    override fun recordGeneratedClass(owner: FirAnnotatedDeclaration, klass: FirRegularClass) = shouldNotBeCalled()
+    override fun recordGeneratedClass(owner: FirAnnotatedDeclaration<*>, klass: FirRegularClass) = shouldNotBeCalled()
 
     @FirProviderInternals
-    override fun recordGeneratedMember(owner: FirAnnotatedDeclaration, klass: FirDeclaration) = shouldNotBeCalled()
+    override fun recordGeneratedMember(owner: FirAnnotatedDeclaration<*>, klass: FirDeclaration<*>) = shouldNotBeCalled()
 
     override fun getClassNamesInPackage(fqName: FqName): Set<Name> = shouldNotBeCalled()
 
     private fun shouldNotBeCalled(): Nothing = error("Should not be called for FirLibrarySessionProvider")
-}
+}

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirProviderImpl.kt

@@ -14,9 +14,9 @@ import org.jetbrains.kotlin.fir.resolve.providers.FirProviderInternals
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProviderInternals
 import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
-import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor
+import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -78,16 +78,16 @@ class FirProviderImpl(val session: FirSession, val kotlinScopeProvider: FirKotli
     }
 
     @FirProviderInternals
-    override fun recordGeneratedClass(owner: FirAnnotatedDeclaration, klass: FirRegularClass) {
+    override fun recordGeneratedClass(owner: FirAnnotatedDeclaration<*>, klass: FirRegularClass) {
         klass.accept(FirRecorder, FirRecorderData(state, owner.file, session.nameConflictsTracker))
     }
 
     @FirProviderInternals
-    override fun recordGeneratedMember(owner: FirAnnotatedDeclaration, klass: FirDeclaration) {
+    override fun recordGeneratedMember(owner: FirAnnotatedDeclaration<*>, klass: FirDeclaration<*>) {
         klass.accept(FirRecorder, FirRecorderData(state, owner.file, session.nameConflictsTracker))
     }
 
-    private val FirAnnotatedDeclaration.file: FirFile
+    private val FirAnnotatedDeclaration<*>.file: FirFile
         get() = when (this) {
             is FirFile -> this
             is FirRegularClass -> getFirClassifierContainerFile(this.symbol.classId)

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

@@ -31,11 +31,10 @@ abstract class FirAbstractPhaseTransformer<D>(
             file.replaceResolvePhase(transformerPhase)
         }
 
-        @Suppress("UNCHECKED_CAST")
+        return super.transformFile(file, data)
-        return super.transformFile(file, data) as FirFile
     }
 
-    override fun transformDeclaration(declaration: FirDeclaration, data: D): FirDeclaration {
+    override fun <T : FirDeclaration<T>> transformDeclaration(declaration: FirDeclaration<T>, data: D): FirDeclaration<T> {
         if (declaration.resolvePhase < transformerPhase) {
             declaration.replaceResolvePhase(transformerPhase)
         }

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

@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.expressions.FirStatement
-import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.lookupSuperTypes
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
@@ -33,7 +32,7 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(
     protected val scopes = mutableListOf<FirScope>()
     protected val towerScope = FirCompositeScope(scopes.asReversed())
 
-    protected open fun needReplacePhase(firDeclaration: FirDeclaration): Boolean = transformerPhase > firDeclaration.resolvePhase
+    protected open fun needReplacePhase(firDeclaration: FirDeclaration<*>): Boolean = transformerPhase > firDeclaration.resolvePhase
 
     protected inline fun <T> withScopeCleanup(crossinline l: () -> T): T {
         val sizeBefore = scopes.size
@@ -89,13 +88,13 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(
         }
     }
 
-    protected fun FirMemberDeclaration.addTypeParametersScope() {
+    protected fun FirMemberDeclaration<*>.addTypeParametersScope() {
         if (typeParameters.isNotEmpty()) {
             scopes.add(FirMemberTypeParameterScope(this))
         }
     }
 
-    open fun transformDeclarationContent(declaration: FirDeclaration, data: Any?): FirDeclaration {
+    open fun transformDeclarationContent(declaration: FirDeclaration<*>, data: Any?): FirDeclaration<*> {
         return transformElement(declaration, data)
     }
 }