[FIR] Remove generic parameter from FirDeclaration

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

@@ -27,7 +27,7 @@ fun renderJavaClass(renderer: FirRenderer, javaClass: FirJavaClass, session: Fir
     renderer.visitStatusOwner(javaClass)
     renderer.renderSupertypes(javaClass)
     renderer.renderInBraces {
-        val renderedDeclarations = mutableListOf<FirDeclaration<*>>()
+        val renderedDeclarations = mutableListOf<FirDeclaration>()
 
         fun renderAndCache(symbol: FirCallableSymbol<*>) {
             val enhanced = symbol.fir
@@ -42,7 +42,7 @@ fun renderJavaClass(renderer: FirRenderer, javaClass: FirJavaClass, session: Fir
             if (declaration in renderedDeclarations) continue
 
             val scopeToUse =
-                if (declaration is FirCallableMemberDeclaration<*> && declaration.status.isStatic)
+                if (declaration is FirCallableMemberDeclaration && declaration.status.isStatic)
                     staticScope
                 else
                     memberScope

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

@@ -51,16 +51,16 @@ fun main(args: Array<String>) {
 
     val declarationPackage = "$basePackage.checkers.declaration"
     generateCheckersComponents(generationPath, declarationPackage, "FirDeclarationChecker") {
-        alias<FirDeclaration<*>>("BasicDeclarationChecker")
+        alias<FirDeclaration>("BasicDeclarationChecker")
-        alias<FirFunction<*>>("FunctionChecker")
+        alias<FirFunction>("FunctionChecker")
         alias<FirSimpleFunction>("SimpleFunctionChecker")
         alias<FirProperty>("PropertyChecker")
-        alias<FirClass<*>>("ClassChecker")
+        alias<FirClass>("ClassChecker")
         alias<FirRegularClass>("RegularClassChecker")
         alias<FirConstructor>("ConstructorChecker")
         alias<FirFile>("FileChecker")
         alias<FirTypeParameter>("FirTypeParameterChecker")
-        alias<FirAnnotatedDeclaration<*>>("FirAnnotatedDeclarationChecker")
+        alias<FirAnnotatedDeclaration>("FirAnnotatedDeclarationChecker")
         alias<FirTypeAlias>("TypeAliasChecker")
 
         additional(

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

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.fir.checkers.generator.diagnostics
 
 import com.intellij.psi.PsiElement
-import com.intellij.psi.PsiTypeElement
 import com.intellij.psi.impl.source.tree.LeafPsiElement
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
@@ -120,7 +119,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
         val NOT_A_SUPERTYPE by error<PsiElement>()
         val SUPERCLASS_NOT_ACCESSIBLE_FROM_INTERFACE by error<PsiElement>()
         val QUALIFIED_SUPERTYPE_EXTENDED_BY_OTHER_SUPERTYPE by error<KtTypeReference> {
-            parameter<FirClass<*>>("otherSuperType")
+            parameter<FirClass>("otherSuperType")
         }
         val SUPERTYPE_INITIALIZED_IN_INTERFACE by error<KtTypeReference>()
         val INTERFACE_WITH_SUPERCLASS by error<KtTypeReference>()
@@ -370,7 +369,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
         val NON_VARARG_SPREAD by error<LeafPsiElement>()
         val ARGUMENT_PASSED_TWICE by error<KtValueArgument>(PositioningStrategy.NAME_OF_NAMED_ARGUMENT)
         val TOO_MANY_ARGUMENTS by error<PsiElement> {
-            parameter<FirCallableDeclaration<*>>("function")
+            parameter<FirCallableDeclaration>("function")
         }
         val NO_VALUE_FOR_PARAMETER by error<KtElement>(PositioningStrategy.VALUE_ARGUMENTS) {
             parameter<FirValueParameter>("violatedParameter")
@@ -482,7 +481,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>()
@@ -540,7 +539,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
 
     val REFLECTION by object : DiagnosticGroup("Reflection") {
         val EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED by error<KtExpression>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
-            parameter<FirCallableDeclaration<*>>("referencedDeclaration")
+            parameter<FirCallableDeclaration>("referencedDeclaration")
         }
         val CALLABLE_REFERENCE_LHS_NOT_A_CLASS by error<KtExpression>()
         val CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR by error<KtExpression>(PositioningStrategy.REFERENCE_BY_QUALIFIED)
@@ -559,51 +558,51 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
 
         val CANNOT_WEAKEN_ACCESS_PRIVILEGE by error<KtModifierListOwner>(PositioningStrategy.VISIBILITY_MODIFIER) {
             parameter<Visibility>("overridingVisibility")
-            parameter<FirCallableDeclaration<*>>("overridden")
+            parameter<FirCallableDeclaration>("overridden")
             parameter<Name>("containingClassName")
         }
         val CANNOT_CHANGE_ACCESS_PRIVILEGE by error<KtModifierListOwner>(PositioningStrategy.VISIBILITY_MODIFIER) {
             parameter<Visibility>("overridingVisibility")
-            parameter<FirCallableDeclaration<*>>("overridden")
+            parameter<FirCallableDeclaration>("overridden")
             parameter<Name>("containingClassName")
         }
 
         val OVERRIDING_FINAL_MEMBER by error<KtNamedDeclaration>(PositioningStrategy.OVERRIDE_MODIFIER) {
-            parameter<FirCallableDeclaration<*>>("overriddenDeclaration")
+            parameter<FirCallableDeclaration>("overriddenDeclaration")
             parameter<Name>("containingClassName")
         }
 
         val ABSTRACT_MEMBER_NOT_IMPLEMENTED by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
-            parameter<FirClass<*>>("classOrObject")
+            parameter<FirClass>("classOrObject")
-            parameter<FirCallableDeclaration<*>>("missingDeclaration")
+            parameter<FirCallableDeclaration>("missingDeclaration")
         }
         val ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
-            parameter<FirClass<*>>("classOrObject")
+            parameter<FirClass>("classOrObject")
-            parameter<FirCallableDeclaration<*>>("missingDeclaration")
+            parameter<FirCallableDeclaration>("missingDeclaration")
         }
         val INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
-            parameter<FirClass<*>>("classOrObject")
+            parameter<FirClass>("classOrObject")
-            parameter<FirCallableDeclaration<*>>("invisibleDeclaration")
+            parameter<FirCallableDeclaration>("invisibleDeclaration")
         }
         val INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING by warning<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
-            parameter<FirClass<*>>("classOrObject")
+            parameter<FirClass>("classOrObject")
-            parameter<FirCallableDeclaration<*>>("invisibleDeclaration")
+            parameter<FirCallableDeclaration>("invisibleDeclaration")
         }
         val MANY_IMPL_MEMBER_NOT_IMPLEMENTED by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
-            parameter<FirClass<*>>("classOrObject")
+            parameter<FirClass>("classOrObject")
-            parameter<FirCallableDeclaration<*>>("missingDeclaration")
+            parameter<FirCallableDeclaration>("missingDeclaration")
         }
         val MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
-            parameter<FirClass<*>>("classOrObject")
+            parameter<FirClass>("classOrObject")
-            parameter<FirCallableDeclaration<*>>("missingDeclaration")
+            parameter<FirCallableDeclaration>("missingDeclaration")
         }
         val OVERRIDING_FINAL_MEMBER_BY_DELEGATION by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
-            parameter<FirCallableDeclaration<*>>("delegatedDeclaration")
+            parameter<FirCallableDeclaration>("delegatedDeclaration")
-            parameter<FirCallableDeclaration<*>>("overriddenDeclaration")
+            parameter<FirCallableDeclaration>("overriddenDeclaration")
         }
         val DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE by warning<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
-            parameter<FirCallableDeclaration<*>>("delegatedDeclaration")
+            parameter<FirCallableDeclaration>("delegatedDeclaration")
-            parameter<FirCallableDeclaration<*>>("overriddenDeclaration")
+            parameter<FirCallableDeclaration>("overriddenDeclaration")
         }
 
         val RETURN_TYPE_MISMATCH_ON_OVERRIDE by error<KtNamedDeclaration>(PositioningStrategy.DECLARATION_RETURN_TYPE) {
@@ -653,7 +652,7 @@ 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<FirStatusOwner>("function")
-            parameter<FirClass<*>>("containingClass")
+            parameter<FirClass>("containingClass")
         }
         val ABSTRACT_FUNCTION_WITH_BODY by error<KtFunction>(PositioningStrategy.MODALITY_MODIFIER) {
             parameter<FirStatusOwner>("function")
@@ -697,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<FirStatusOwner>("property")
-            parameter<FirClass<*>>("containingClass")
+            parameter<FirClass>("containingClass")
         }
         val PRIVATE_PROPERTY_IN_INTERFACE by error<KtProperty>(PositioningStrategy.VISIBILITY_MODIFIER)
 

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

@@ -17,14 +17,14 @@ import org.jetbrains.kotlin.fir.declarations.utils.isExternal
 import org.jetbrains.kotlin.lexer.KtTokens
 
 object FirJvmExternalDeclarationChecker : FirBasicDeclarationChecker() {
-    override fun check(declaration: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration !is FirStatusOwner) return
         if (!declaration.isExternal) return
         val source = declaration.source ?: return
         if (source.kind is FirFakeSourceElementKind) return
 
         // WRONG_MODIFIER_TARGET on external constructor is intentionally NOT covered in this checker.
-        if (declaration !is FirFunction<*>) {
+        if (declaration !is FirFunction) {
             val target = when (declaration) {
                 is FirProperty -> "property"
                 is FirRegularClass -> "class"

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

@@ -22,14 +22,14 @@ import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 
-typealias FirBasicDeclarationChecker = FirDeclarationChecker<FirDeclaration<*>>
+typealias FirBasicDeclarationChecker = FirDeclarationChecker<FirDeclaration>
-typealias FirFunctionChecker = FirDeclarationChecker<FirFunction<*>>
+typealias FirFunctionChecker = FirDeclarationChecker<FirFunction>
 typealias FirSimpleFunctionChecker = FirDeclarationChecker<FirSimpleFunction>
 typealias FirPropertyChecker = FirDeclarationChecker<FirProperty>
-typealias FirClassChecker = FirDeclarationChecker<FirClass<*>>
+typealias FirClassChecker = FirDeclarationChecker<FirClass>
 typealias FirRegularClassChecker = FirDeclarationChecker<FirRegularClass>
 typealias FirConstructorChecker = FirDeclarationChecker<FirConstructor>
 typealias FirFileChecker = FirDeclarationChecker<FirFile>
 typealias FirTypeParameterChecker = FirDeclarationChecker<FirTypeParameter>
-typealias FirAnnotatedDeclarationChecker = FirDeclarationChecker<FirAnnotatedDeclaration<*>>
+typealias FirAnnotatedDeclarationChecker = FirDeclarationChecker<FirAnnotatedDeclaration>
 typealias FirTypeAliasChecker = FirDeclarationChecker<FirTypeAlias>

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

@@ -131,7 +131,7 @@ object FirErrors {
     val RECURSION_IN_SUPERTYPES by error0<PsiElement>()
     val NOT_A_SUPERTYPE by error0<PsiElement>()
     val SUPERCLASS_NOT_ACCESSIBLE_FROM_INTERFACE by error0<PsiElement>()
-    val QUALIFIED_SUPERTYPE_EXTENDED_BY_OTHER_SUPERTYPE by error1<KtTypeReference, FirClass<*>>()
+    val QUALIFIED_SUPERTYPE_EXTENDED_BY_OTHER_SUPERTYPE by error1<KtTypeReference, FirClass>()
     val SUPERTYPE_INITIALIZED_IN_INTERFACE by error0<KtTypeReference>()
     val INTERFACE_WITH_SUPERCLASS by error0<KtTypeReference>()
     val FINAL_SUPERTYPE by error0<KtTypeReference>()
@@ -269,7 +269,7 @@ object FirErrors {
     val NAMED_ARGUMENTS_NOT_ALLOWED by error1<KtValueArgument, ForbiddenNamedArgumentsTarget>(SourceElementPositioningStrategies.NAME_OF_NAMED_ARGUMENT)
     val NON_VARARG_SPREAD by error0<LeafPsiElement>()
     val ARGUMENT_PASSED_TWICE by error0<KtValueArgument>(SourceElementPositioningStrategies.NAME_OF_NAMED_ARGUMENT)
-    val TOO_MANY_ARGUMENTS by error1<PsiElement, FirCallableDeclaration<*>>()
+    val TOO_MANY_ARGUMENTS by error1<PsiElement, FirCallableDeclaration>()
     val NO_VALUE_FOR_PARAMETER by error1<KtElement, FirValueParameter>(SourceElementPositioningStrategies.VALUE_ARGUMENTS)
     val NAMED_PARAMETER_NOT_FOUND by error1<KtValueArgument, String>(SourceElementPositioningStrategies.NAME_OF_NAMED_ARGUMENT)
     val ASSIGNMENT_TYPE_MISMATCH by error2<KtExpression, ConeKotlinType, ConeKotlinType>()
@@ -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)
@@ -330,7 +330,7 @@ object FirErrors {
     val SMARTCAST_IMPOSSIBLE by error3<KtExpression, ConeKotlinType, FirExpression, String>()
 
     // Reflection
-    val EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED by error1<KtExpression, FirCallableDeclaration<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED by error1<KtExpression, FirCallableDeclaration>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
     val CALLABLE_REFERENCE_LHS_NOT_A_CLASS by error0<KtExpression>()
     val CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR by error0<KtExpression>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
     val CLASS_LITERAL_LHS_NOT_A_CLASS by error0<KtExpression>()
@@ -339,17 +339,17 @@ object FirErrors {
 
     // overrides
     val NOTHING_TO_OVERRIDE by error1<KtModifierListOwner, FirStatusOwner>(SourceElementPositioningStrategies.OVERRIDE_MODIFIER)
-    val CANNOT_WEAKEN_ACCESS_PRIVILEGE by error3<KtModifierListOwner, Visibility, FirCallableDeclaration<*>, Name>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
+    val CANNOT_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 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)
+    val OVERRIDING_FINAL_MEMBER by error2<KtNamedDeclaration, FirCallableDeclaration, Name>(SourceElementPositioningStrategies.OVERRIDE_MODIFIER)
-    val ABSTRACT_MEMBER_NOT_IMPLEMENTED by error2<KtClassOrObject, FirClass<*>, FirCallableDeclaration<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
+    val ABSTRACT_MEMBER_NOT_IMPLEMENTED by error2<KtClassOrObject, FirClass, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
-    val ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED by error2<KtClassOrObject, FirClass<*>, FirCallableDeclaration<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
+    val ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED by error2<KtClassOrObject, FirClass, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
-    val INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER by error2<KtClassOrObject, FirClass<*>, FirCallableDeclaration<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
+    val INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER by error2<KtClassOrObject, FirClass, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
-    val INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING by warning2<KtClassOrObject, FirClass<*>, FirCallableDeclaration<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
+    val INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING by warning2<KtClassOrObject, FirClass, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
-    val MANY_IMPL_MEMBER_NOT_IMPLEMENTED by error2<KtClassOrObject, FirClass<*>, FirCallableDeclaration<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
+    val MANY_IMPL_MEMBER_NOT_IMPLEMENTED by error2<KtClassOrObject, FirClass, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
-    val MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED by error2<KtClassOrObject, FirClass<*>, FirCallableDeclaration<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
+    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 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 DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE by warning2<KtClassOrObject, FirCallableDeclaration, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
     val RETURN_TYPE_MISMATCH_ON_OVERRIDE by error2<KtNamedDeclaration, FirStatusOwner, FirStatusOwner>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE)
     val PROPERTY_TYPE_MISMATCH_ON_OVERRIDE by error2<KtNamedDeclaration, FirStatusOwner, FirStatusOwner>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE)
     val VAR_TYPE_MISMATCH_ON_OVERRIDE by error2<KtNamedDeclaration, FirStatusOwner, FirStatusOwner>(SourceElementPositioningStrategies.DECLARATION_RETURN_TYPE)
@@ -369,7 +369,7 @@ 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, FirStatusOwner, FirClass<*>>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
+    val ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS by error2<KtFunction, FirStatusOwner, FirClass>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
     val ABSTRACT_FUNCTION_WITH_BODY by error1<KtFunction, FirStatusOwner>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
     val NON_ABSTRACT_FUNCTION_WITH_NO_BODY by error1<KtFunction, FirStatusOwner>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
     val PRIVATE_FUNCTION_WITH_NO_BODY by error1<KtFunction, FirStatusOwner>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
@@ -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, FirStatusOwner, FirClass<*>>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
+    val ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS by error2<KtModifierListOwner, FirStatusOwner, FirClass>(SourceElementPositioningStrategies.MODALITY_MODIFIER)
     val PRIVATE_PROPERTY_IN_INTERFACE by error0<KtProperty>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
     val ABSTRACT_PROPERTY_WITH_INITIALIZER by error0<KtExpression>()
     val PROPERTY_INITIALIZER_IN_INTERFACE by error0<KtExpression>()

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/CfaUtils.kt

@@ -74,7 +74,7 @@ class LocalPropertyAndCapturedWriteCollector private constructor() : ControlFlow
     // `false` if it is declared in a lambda or a local function (inside the currently visited function).
     private val symbols: MutableMap<FirPropertySymbol, Boolean> = mutableMapOf()
 
-    private val lambdaOrLocalFunctionStack: MutableList<FirFunction<*>> = mutableListOf()
+    private val lambdaOrLocalFunctionStack: MutableList<FirFunction> = mutableListOf()
     private val capturedWrites: MutableSet<FirVariableAssignment> = mutableSetOf()
 
     override fun visitNode(node: CFGNode<*>) {}
@@ -266,7 +266,7 @@ class DeclaredVariableCollector {
     val declaredVariablesPerElement: SetMultimap<FirStatement, FirPropertySymbol> = setMultimapOf()
 
     fun enterCapturingStatement(statement: FirStatement): Set<FirPropertySymbol> {
-        assert(statement is FirLoop || statement is FirClass<*> || statement is FirFunction<*>)
+        assert(statement is FirLoop || statement is FirClass || statement is FirFunction)
         if (statement !in declaredVariablesPerElement) {
             statement.accept(visitor, null)
         }
@@ -274,7 +274,7 @@ class DeclaredVariableCollector {
     }
 
     fun exitCapturingStatement(statement: FirStatement) {
-        assert(statement is FirLoop || statement is FirClass<*> || statement is FirFunction<*>)
+        assert(statement is FirLoop || statement is FirClass || statement is FirFunction)
         declaredVariablesPerElement.removeKey(statement)
     }
 

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirCallsEffectAnalyzer.kt

@@ -45,7 +45,7 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() {
 
     override fun analyze(graph: ControlFlowGraph, reporter: DiagnosticReporter, context: CheckerContext) {
         val session = context.session
-        val function = (graph.declaration as? FirFunction<*>) ?: return
+        val function = (graph.declaration as? FirFunction) ?: return
         if (function !is FirContractDescriptionOwner) return
         if (function.contractDescription.coneEffects?.any { it is ConeCallsEffectDeclaration } != true) return
 
@@ -153,7 +153,7 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() {
         }
     }
 
-    private class CapturedLambdaFinder(val rootFunction: FirFunction<*>) : ControlFlowGraphVisitor<Unit, IllegalScopeContext>() {
+    private class CapturedLambdaFinder(val rootFunction: FirFunction) : ControlFlowGraphVisitor<Unit, IllegalScopeContext>() {
 
         override fun visitNode(node: CFGNode<*>, data: IllegalScopeContext) {}
 
@@ -303,7 +303,7 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() {
         return this?.coneTypeSafe<ConeKotlinType>()?.isBuiltinFunctionalType(session) == true
     }
 
-    private val FirFunction<*>.contractDescription: FirContractDescription?
+    private val FirFunction.contractDescription: FirContractDescription?
         get() = (this as? FirContractDescriptionOwner)?.contractDescription
 
     private fun FirContractDescription?.getParameterCallsEffectDeclaration(index: Int): ConeCallsEffectDeclaration? {
@@ -327,7 +327,7 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() {
         return getParameterCallsEffectDeclaration(index)?.kind
     }
 
-    private fun FirFunction<*>.isInPlaceLambda(): Boolean {
+    private fun FirFunction.isInPlaceLambda(): Boolean {
         return this is FirAnonymousFunction && this.isLambda && this.invocationKind != null
     }
 

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirControlFlowAnalyzer.kt

@@ -25,17 +25,17 @@ class FirControlFlowAnalyzer(
 
     // Currently declaration in analyzeXXX is not used, but it may be useful in future
     @Suppress("UNUSED_PARAMETER")
-    fun analyzeClassInitializer(klass: FirClass<*>, graph: ControlFlowGraph, context: CheckerContext, reporter: DiagnosticReporter) {
+    fun analyzeClassInitializer(klass: FirClass, graph: ControlFlowGraph, context: CheckerContext, reporter: DiagnosticReporter) {
         if (graph.owner != null) return
         cfaCheckers.forEach { it.analyze(graph, reporter, context) }
     }
 
     @Suppress("UNUSED_PARAMETER")
-    fun analyzeFunction(function: FirFunction<*>, graph: ControlFlowGraph, context: CheckerContext, reporter: DiagnosticReporter) {
+    fun analyzeFunction(function: FirFunction, graph: ControlFlowGraph, context: CheckerContext, reporter: DiagnosticReporter) {
         if (graph.owner != null) return
 
         cfaCheckers.forEach { it.analyze(graph, reporter, context) }
-        if (context.containingDeclarations.any { it is FirProperty || it is FirFunction<*> }) return
+        if (context.containingDeclarations.any { it is FirProperty || it is FirFunction }) return
         runAssignmentCfaCheckers(graph, reporter, context)
     }
 

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt

@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.utils.addIfNotNull
 object FirReturnsImpliesAnalyzer : FirControlFlowChecker() {
 
     override fun analyze(graph: ControlFlowGraph, reporter: DiagnosticReporter, context: CheckerContext) {
-        val function = graph.declaration as? FirFunction<*> ?: return
+        val function = graph.declaration as? FirFunction ?: return
         val graphRef = function.controlFlowGraphReference as FirControlFlowGraphReferenceImpl
         val dataFlowInfo = graphRef.dataFlowInfo
         if (function !is FirContractDescriptionOwner || dataFlowInfo == null) return
@@ -72,7 +72,7 @@ object FirReturnsImpliesAnalyzer : FirControlFlowChecker() {
     private fun isWrongConditionOnNode(
         node: CFGNode<*>,
         effectDeclaration: ConeConditionalEffectDeclaration,
-        function: FirFunction<*>,
+        function: FirFunction,
         logicSystem: LogicSystem<PersistentFlow>,
         dataFlowInfo: DataFlowInfo,
         context: CheckerContext
@@ -150,7 +150,7 @@ object FirReturnsImpliesAnalyzer : FirControlFlowChecker() {
     }
 
     private fun ConeBooleanExpression.buildTypeStatements(
-        function: FirFunction<*>,
+        function: FirFunction,
         logicSystem: LogicSystem<*>,
         variableStorage: VariableStorage,
         flow: Flow,
@@ -216,7 +216,7 @@ object FirReturnsImpliesAnalyzer : FirControlFlowChecker() {
     private val CheckerContext.containingProperty: FirProperty?
         get() = (containingDeclarations.asReversed().firstOrNull { it is FirProperty } as? FirProperty)
 
-    private fun FirFunction<*>.getParameterType(symbol: FirBasedSymbol<*>, context: CheckerContext): ConeKotlinType? {
+    private fun FirFunction.getParameterType(symbol: FirBasedSymbol<*>, context: CheckerContext): ConeKotlinType? {
         val typeRef = if (this.symbol == symbol) {
             if (symbol is FirPropertyAccessorSymbol) {
                 context.containingProperty?.receiverTypeRef
@@ -229,7 +229,7 @@ object FirReturnsImpliesAnalyzer : FirControlFlowChecker() {
         return typeRef?.coneType
     }
 
-    private fun FirFunction<*>.getParameterSymbol(index: Int, context: CheckerContext): FirBasedSymbol<*> {
+    private fun FirFunction.getParameterSymbol(index: Int, context: CheckerContext): FirBasedSymbol<*> {
         return if (index == -1) {
             if (symbol !is FirPropertyAccessorSymbol) {
                 symbol

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

@@ -337,7 +337,7 @@ internal object ConeTypeCompatibilityChecker {
 
     private fun MutableMap<FirTypeParameterRef, BoundTypeArguments>.collect(
         ctx: ConeInferenceContext,
-        typeParameterOwner: FirClassLikeDeclaration<*>,
+        typeParameterOwner: FirClassLikeDeclaration,
         parameter: FirTypeParameterRef,
         boundTypeArgument: BoundTypeArgument,
         compatibilityUpperBound: Compatibility,
@@ -365,28 +365,28 @@ internal object ConeTypeCompatibilityChecker {
         }
     }
 
-    private fun FirClassLikeDeclaration<*>.getSuperTypes(): List<ConeClassLikeType> {
+    private fun FirClassLikeDeclaration.getSuperTypes(): List<ConeClassLikeType> {
         return when (this) {
             is FirTypeAlias -> listOfNotNull(expandedTypeRef.coneTypeSafe())
-            is FirClass<*> -> superTypeRefs.mapNotNull { it.coneTypeSafe() }
+            is FirClass -> superTypeRefs.mapNotNull { it.coneTypeSafe() }
             else -> emptyList()
         }
     }
 
-    private fun ConeClassLikeType.getClassLikeElement(ctx: ConeInferenceContext): FirClassLikeDeclaration<*>? =
+    private fun ConeClassLikeType.getClassLikeElement(ctx: ConeInferenceContext): FirClassLikeDeclaration? =
         ctx.symbolProvider.getSymbolByLookupTag(lookupTag)?.fir
 
-    private fun FirClassLikeDeclaration<*>.getTypeParameter(index: Int): FirTypeParameterRef? {
+    private fun FirClassLikeDeclaration.getTypeParameter(index: Int): FirTypeParameterRef? {
         return when (this) {
             is FirTypeAlias -> typeParameters[index]
-            is FirClass<*> -> typeParameters[index]
+            is FirClass -> typeParameters[index]
             else -> return null
         }
     }
 
     /** A class declaration and the arguments bound to the declared type parameters. */
     private data class TypeArgumentMapping(
-        val typeParameterOwner: FirClassLikeDeclaration<*>,
+        val typeParameterOwner: FirClassLikeDeclaration,
         val mapping: Map<FirTypeParameterRef, BoundTypeArgument>
     )
 
@@ -408,11 +408,11 @@ internal object ConeTypeCompatibilityChecker {
         ctx: ConeInferenceContext
     ): FirClassWithSuperClasses? = when (val klass = ctx.symbolProvider.getSymbolByLookupTag(this)?.fir) {
         is FirTypeAlias -> klass.fullyExpandedClass(ctx.session)?.let { FirClassWithSuperClasses(it, ctx) }
-        is FirClass<*> -> FirClassWithSuperClasses(klass, ctx)
+        is FirClass -> FirClassWithSuperClasses(klass, ctx)
         else -> null
     }
 
-    private data class FirClassWithSuperClasses(val firClass: FirClass<*>, val ctx: ConeInferenceContext) {
+    private data class FirClassWithSuperClasses(val firClass: FirClass, val ctx: ConeInferenceContext) {
         val isInterface: Boolean get() = firClass.isInterface
 
         val superClasses: Set<FirClassWithSuperClasses> by lazy {
@@ -454,7 +454,7 @@ internal object ConeTypeCompatibilityChecker {
                     (firClass is FirRegularClass && (firClass.isData || firClass.isInline))
         }
 
-        private val FirClass<*>.isFinal: Boolean
+        private val FirClass.isFinal: Boolean
             get() {
                 return when (this) {
                     is FirAnonymousObject -> true

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

@@ -189,7 +189,7 @@ internal fun checkConstantArguments(
     return null
 }
 
-private fun FirTypedDeclaration<*>?.getReferencedClass(session: FirSession): FirDeclaration<*>? =
+private fun FirTypedDeclaration?.getReferencedClass(session: FirSession): FirDeclaration? =
     this?.returnTypeRef
         ?.coneTypeSafe<ConeLookupTagBasedType>()
         ?.lookupTag

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

@@ -219,7 +219,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
@@ -231,10 +231,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)
@@ -244,7 +244,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 {
@@ -258,7 +258,7 @@ 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

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

@@ -50,21 +50,21 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 private val INLINE_ONLY_ANNOTATION_CLASS_ID = ClassId.topLevel(FqName("kotlin.internal.InlineOnly"))
 
-fun FirClass<*>.unsubstitutedScope(context: CheckerContext) =
+fun FirClass.unsubstitutedScope(context: CheckerContext) =
     this.unsubstitutedScope(context.sessionHolder.session, context.sessionHolder.scopeSession, withForcedTypeCalculator = false)
 
 /**
  * Returns true if this is a supertype of other.
  */
-fun FirClass<*>.isSupertypeOf(other: FirClass<*>, session: FirSession): Boolean {
+fun FirClass.isSupertypeOf(other: FirClass, session: FirSession): Boolean {
     /**
      * Hides additional parameters.
      */
-    fun FirClass<*>.isSupertypeOf(other: FirClass<*>, exclude: MutableSet<FirClass<*>>): Boolean {
+    fun FirClass.isSupertypeOf(other: FirClass, exclude: MutableSet<FirClass>): Boolean {
         for (it in other.superTypeRefs) {
             val candidate = it.firClassLike(session)
                 ?.followAllAlias(session)
-                ?.safeAs<FirClass<*>>()
+                ?.safeAs<FirClass>()
                 ?: continue
 
             if (candidate in exclude) {
@@ -92,7 +92,7 @@ fun FirClass<*>.isSupertypeOf(other: FirClass<*>, session: FirSession): Boolean
  * Returns the FirClass associated with this
  * or null of something goes wrong.
  */
-fun ConeClassLikeType.toClass(session: FirSession): FirClass<*>? {
+fun ConeClassLikeType.toClass(session: FirSession): FirClass? {
     return lookupTag.toSymbol(session).safeAs<FirClassSymbol<*>>()?.fir
 }
 
@@ -135,8 +135,8 @@ 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 FirDeclaration<*>.getContainingClass(context: CheckerContext): FirClassLikeDeclaration<*>? =
+fun FirDeclaration.getContainingClass(context: CheckerContext): FirClassLikeDeclaration? =
-    this.safeAs<FirCallableMemberDeclaration<*>>()?.containingClass()?.toSymbol(context.session)?.fir
+    this.safeAs<FirCallableMemberDeclaration>()?.containingClass()?.toSymbol(context.session)?.fir
 
 fun FirClassLikeSymbol<*>.outerClass(context: CheckerContext): FirClassLikeSymbol<*>? {
     if (this !is FirClassSymbol<*>) return null
@@ -144,8 +144,8 @@ fun FirClassLikeSymbol<*>.outerClass(context: CheckerContext): FirClassLikeSymbo
     return context.session.symbolProvider.getClassLikeSymbolByFqName(outerClassId)
 }
 
-fun FirClass<*>.outerClass(context: CheckerContext): FirClass<*>? {
+fun FirClass.outerClass(context: CheckerContext): FirClass? {
-    return symbol.outerClass(context)?.fir as? FirClass<*>
+    return symbol.outerClass(context)?.fir as? FirClass
 }
 
 /**
@@ -153,8 +153,8 @@ fun FirClass<*>.outerClass(context: CheckerContext): FirClass<*>? {
  * sequence of FirTypeAlias'es points to starting
  * with `this`. Or null if something goes wrong.
  */
-fun FirClassLikeDeclaration<*>.followAllAlias(session: FirSession): FirClassLikeDeclaration<*>? {
+fun FirClassLikeDeclaration.followAllAlias(session: FirSession): FirClassLikeDeclaration? {
-    var it: FirClassLikeDeclaration<*>? = this
+    var it: FirClassLikeDeclaration? = this
 
     while (it is FirTypeAlias) {
         it = it.expandedTypeRef.firClassLike(session)
@@ -168,13 +168,13 @@ fun FirClassLikeDeclaration<*>.followAllAlias(session: FirSession): FirClassLike
  * item like FirRegularClass or FirAnonymousObject
  * or null if no such item could be found.
  */
-fun CheckerContext.findClosestClassOrObject(): FirClass<*>? {
+fun CheckerContext.findClosestClassOrObject(): FirClass? {
     for (it in containingDeclarations.asReversed()) {
         if (
             it is FirRegularClass ||
             it is FirAnonymousObject
         ) {
-            return it as FirClass<*>
+            return it as FirClass
         }
     }
 
@@ -185,7 +185,7 @@ fun CheckerContext.findClosestClassOrObject(): FirClass<*>? {
  * Returns the list of functions that overridden by given
  */
 fun FirSimpleFunction.overriddenFunctions(
-    containingClass: FirClass<*>,
+    containingClass: FirClass,
     context: CheckerContext
 ): List<FirFunctionSymbol<*>> {
     val firTypeScope = containingClass.unsubstitutedScope(
@@ -225,7 +225,7 @@ fun KtModifierKeywordToken.toVisibilityOrNull(): Visibility? {
 /**
  * Returns the modality of the class
  */
-fun FirClass<*>.modality(): Modality? {
+fun FirClass.modality(): Modality? {
     return when (this) {
         is FirRegularClass -> modality
         else -> Modality.FINAL
@@ -258,14 +258,14 @@ fun FirStatusOwner.implicitModality(context: CheckerContext): Modality {
         && klass.classKind == ClassKind.INTERFACE
         && tree.visibilityModifier(source.lighterASTNode)?.tokenType != KtTokens.PRIVATE_KEYWORD
     ) {
-        require(this is FirDeclaration<*>)
+        require(this is FirDeclaration)
         return if (this.hasBody()) Modality.OPEN else Modality.ABSTRACT
     }
 
     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
@@ -275,12 +275,12 @@ private fun FirDeclaration<*>.hasBody(): Boolean = when (this) {
  * Finds any non-interface supertype and returns it
  * or null if couldn't find any.
  */
-fun FirClass<*>.findNonInterfaceSupertype(context: CheckerContext): FirTypeRef? {
+fun FirClass.findNonInterfaceSupertype(context: CheckerContext): FirTypeRef? {
     for (superTypeRef in superTypeRefs) {
         val lookupTag = superTypeRef.coneType.safeAs<ConeClassLikeType>()?.lookupTag ?: continue
 
         val fir = lookupTag.toSymbol(context.session)
-            ?.fir.safeAs<FirClass<*>>()
+            ?.fir.safeAs<FirClass>()
             ?: continue
 
         if (fir.classKind != ClassKind.INTERFACE) {
@@ -381,7 +381,7 @@ private fun lowerThanBound(context: ConeInferenceContext, argument: ConeKotlinTy
     return false
 }
 
-fun FirStatusOwner.isInlineOnly(): Boolean = isInline && (this as FirAnnotatedDeclaration<*>).hasAnnotation(INLINE_ONLY_ANNOTATION_CLASS_ID)
+fun FirStatusOwner.isInlineOnly(): Boolean = isInline && (this as FirAnnotatedDeclaration).hasAnnotation(INLINE_ONLY_ANNOTATION_CLASS_ID)
 
 fun isSubtypeForTypeMismatch(context: ConeInferenceContext, subtype: ConeKotlinType, supertype: ConeKotlinType): Boolean {
     val subtypeFullyExpanded = subtype.fullyExpandedType(context.session)
@@ -418,7 +418,7 @@ private fun isSubtypeOfForFunctionalTypeReturningUnit(
     return false
 }
 
-fun FirCallableMemberDeclaration<*>.isVisibleInClass(parentClass: FirClass<*>): Boolean {
+fun FirCallableMemberDeclaration.isVisibleInClass(parentClass: FirClass): Boolean {
     val classPackage = parentClass.symbol.classId.packageFqName
     if (visibility == Visibilities.Private ||
         !visibility.visibleFromPackage(classPackage, symbol.callableId.packageName)
@@ -435,7 +435,7 @@ fun FirCallableMemberDeclaration<*>.isVisibleInClass(parentClass: FirClass<*>):
  *
  * @param parentClass the contextual class for this query.
  */
-fun FirCallableMemberDeclaration<*>.getImplementationStatus(sessionHolder: SessionHolder, parentClass: FirClass<*>): ImplementationStatus {
+fun FirCallableMemberDeclaration.getImplementationStatus(sessionHolder: SessionHolder, parentClass: FirClass): ImplementationStatus {
     val containingClass = getContainingClass(sessionHolder)
     val symbol = this.symbol
     if (symbol is FirIntersectionCallableSymbol) {
@@ -510,8 +510,8 @@ private val FirSimpleFunction.matchesDataClassSyntheticMemberSignatures: Boolean
             (this.name == HASHCODE_NAME && matchesHashCodeSignature) ||
             (this.name == OperatorNameConventions.TO_STRING && matchesToStringSignature)
 
-private fun FirDeclaration<*>.getContainingClass(sessionHolder: SessionHolder): FirClassLikeDeclaration<*>? =
+private fun FirDeclaration.getContainingClass(sessionHolder: SessionHolder): FirClassLikeDeclaration? =
-    this.safeAs<FirCallableMemberDeclaration<*>>()?.containingClass()?.toSymbol(sessionHolder.session)?.fir
+    this.safeAs<FirCallableMemberDeclaration>()?.containingClass()?.toSymbol(sessionHolder.session)?.fir
 
 // NB: we intentionally do not check return types
 private val FirSimpleFunction.matchesEqualsSignature: Boolean

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: Che
     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: FirSess
     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

@@ -23,7 +23,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>
 

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

@@ -34,7 +34,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
     private val deprecatedSinceKotlinClassId = FqName("kotlin.DeprecatedSinceKotlin")
 
     override fun check(
-        declaration: FirAnnotatedDeclaration<*>,
+        declaration: FirAnnotatedDeclaration,
         context: CheckerContext,
         reporter: DiagnosticReporter
     ) {
@@ -60,7 +60,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
     }
 
     private fun checkAnnotationTarget(
-        declaration: FirAnnotatedDeclaration<*>,
+        declaration: FirAnnotatedDeclaration,
         annotation: FirAnnotationCall,
         context: CheckerContext,
         reporter: DiagnosticReporter
@@ -112,7 +112,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
     }
 
     private fun checkAnnotationUseSiteTarget(
-        annotated: FirAnnotatedDeclaration<*>,
+        annotated: FirAnnotatedDeclaration,
         annotation: FirAnnotationCall,
         target: AnnotationUseSiteTarget,
         context: CheckerContext,
@@ -201,7 +201,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

@@ -44,7 +44,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

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.checker.TypeCheckingProcedure
 
 object FirClassVarianceChecker : FirClassChecker() {
-    override fun check(declaration: FirClass<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) {
         checkTypeParameters(declaration.typeParameters, Variance.OUT_VARIANCE, context, reporter)
 
         for (superTypeRef in declaration.superTypeRefs) {
@@ -39,14 +39,14 @@ object FirClassVarianceChecker : FirClassChecker() {
                 checkTypeParameters(member.typeParameters, Variance.IN_VARIANCE, context, reporter)
             }
 
-            if (member is FirCallableDeclaration<*>) {
+            if (member is FirCallableDeclaration) {
                 checkCallableDeclaration(member, context, reporter)
             }
         }
     }
 
     private fun checkCallableDeclaration(
-        member: FirCallableDeclaration<*>,
+        member: FirCallableDeclaration,
         context: CheckerContext,
         reporter: DiagnosticReporter
     ) {
@@ -134,7 +134,7 @@ object FirClassVarianceChecker : FirClassChecker() {
         if (type is ConeClassLikeType) {
             val fullyExpandedType = type.fullyExpandedType(context.session)
             val declFir = fullyExpandedType.lookupTag.toSymbol(context.session)?.fir
-            if (declFir is FirClass<*>) {
+            if (declFir is FirClass) {
                 for ((index, typeArgument) in fullyExpandedType.typeArguments.withIndex()) {
                     val paramVariance = (declFir.typeParameters.getOrNull(index) as? FirTypeParameter)?.variance ?: 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,7 +40,7 @@ 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 != declaration && !isExpectAndActual(declaration, otherDeclaration)) {
@@ -51,7 +51,7 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
             declarationConflictingSymbols[declaration] = localConflicts
         }
 
-        private fun isExpectAndActual(declaration1: FirDeclaration<*>, declaration2: FirDeclaration<*>): Boolean {
+        private fun isExpectAndActual(declaration1: FirDeclaration, declaration2: FirDeclaration): Boolean {
             if (declaration1 !is FirStatusOwner) return false
             if (declaration2 !is FirStatusOwner) return false
             return (declaration1.status.isExpect && declaration2.status.isActual) ||
@@ -59,7 +59,7 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
         }
 
         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
@@ -68,7 +68,7 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
         }
 
         private fun collectExternalConflict(
-            declaration: FirDeclaration<*>,
+            declaration: FirDeclaration,
             declarationPresentation: String,
             containingFile: FirFile,
             conflictingSymbol: FirBasedSymbol<*>,
@@ -97,7 +97,7 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
         }
 
         fun collectWithExternalConflicts(
-            declaration: FirDeclaration<*>,
+            declaration: FirDeclaration,
             containingFile: FirFile,
             session: FirSession,
             packageMemberScope: FirPackageMemberScope
@@ -127,7 +127,7 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
                         }
                     }
                 }
-                is FirVariable<*> -> {
+                is FirVariable -> {
                     declarationName = declaration.name
                     if (!declarationName.isSpecial) {
                         packageMemberScope.processPropertiesByName(declarationName) {
@@ -200,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) {
@@ -238,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)
@@ -267,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/FirConstructorAllowedChecker.kt

@@ -14,14 +14,16 @@ import org.jetbrains.kotlin.fir.analysis.checkers.getModifierList
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirConstructor
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.utils.modality
 import org.jetbrains.kotlin.fir.declarations.utils.visibility
 import org.jetbrains.kotlin.lexer.KtTokens
 
 object FirConstructorAllowedChecker : FirConstructorChecker() {
     override fun check(declaration: FirConstructor, context: CheckerContext, reporter: DiagnosticReporter) {
-        val containingClass = context.containingDeclarations.lastOrNull() as? FirClass<*> ?: return
+        val containingClass = context.containingDeclarations.lastOrNull() as? FirClass ?: return
         val source = declaration.source
         val elementType = source?.elementType
         if (elementType != KtNodeTypes.PRIMARY_CONSTRUCTOR && elementType != KtNodeTypes.SECONDARY_CONSTRUCTOR) {

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

@@ -18,7 +18,7 @@ object FirContractChecker : FirFunctionChecker() {
     // TODO: The message should vary. Migrate this to [ConeEffectExtractor] when creating fine-grained errors.
     private const val UNEXPECTED_CONSTRUCTION = "unexpected construction in contract description"
 
-    override fun check(declaration: FirFunction<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration !is FirContractDescriptionOwner ||
             declaration.contractDescription !is FirResolvedContractDescription
         ) {

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 : FirBasicDeclarationChecker() {
 
-    override fun check(declaration: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration !is FirStatusOwner) return
         if (declaration is FirConstructor || declaration is FirTypeAlias) return
 

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

@@ -9,6 +9,6 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 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

@@ -184,7 +184,7 @@ private val FirProperty.hasAccessorImplementation: Boolean
     get() = (getter !is FirDefaultPropertyAccessor && getter?.hasBody == true) ||
             (setter !is FirDefaultPropertyAccessor && setter?.hasBody == true)
 
-internal val FirClass<*>.canHaveOpenMembers: Boolean get() = modality() != Modality.FINAL || classKind == ClassKind.ENUM_CLASS
+internal val FirClass.canHaveOpenMembers: Boolean get() = modality() != Modality.FINAL || classKind == ClassKind.ENUM_CLASS
 
 internal fun FirRegularClass.isInlineOrValueClass(): Boolean {
     if (this.classKind != ClassKind.CLASS) return false
@@ -192,14 +192,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<*>)
-internal val FirDeclaration<*>.isLocalMember: Boolean
+internal val FirDeclaration.isLocalMember: Boolean
     get() = when (this) {
         is FirProperty -> this.isLocal
         is FirRegularClass -> this.isLocal
@@ -207,7 +207,7 @@ internal val FirDeclaration<*>.isLocalMember: Boolean
         else -> false
     }
 
-internal val FirCallableMemberDeclaration<*>.isExtensionMember: Boolean
+internal val FirCallableMemberDeclaration.isExtensionMember: Boolean
     get() {
         return receiverTypeRef != null && dispatchReceiverType != null
     }

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

@@ -66,7 +66,7 @@ object FirDestructuringDeclarationChecker : FirPropertyChecker() {
         val originalDestructuringDeclarationOrInitializerSource = originalDestructuringDeclarationOrInitializer.source ?: return
         val originalDestructuringDeclarationType =
             when (originalDestructuringDeclarationOrInitializer) {
-                is FirVariable<*> -> originalDestructuringDeclarationOrInitializer.returnTypeRef.coneTypeSafe<ConeKotlinType>()
+                is FirVariable -> originalDestructuringDeclarationOrInitializer.returnTypeRef.coneTypeSafe<ConeKotlinType>()
                 is FirExpression -> originalDestructuringDeclarationOrInitializer.typeRef.coneTypeSafe<ConeKotlinType>()
                 else -> null
             } ?: return
@@ -109,7 +109,7 @@ object FirDestructuringDeclarationChecker : FirPropertyChecker() {
         reference: FirErrorNamedReference,
         property: FirProperty,
         componentCall: FirComponentCall,
-        destructuringDeclaration: FirVariable<*>,
+        destructuringDeclaration: FirVariable,
         reporter: DiagnosticReporter,
         context: CheckerContext
     ) {
@@ -181,6 +181,6 @@ object FirDestructuringDeclarationChecker : FirPropertyChecker() {
                 else -> this
             }
 
-    private val FirQualifiedAccessExpression.resolvedVariable: FirVariable<*>?
+    private val FirQualifiedAccessExpression.resolvedVariable: FirVariable?
-        get() = ((calleeReference as? FirResolvedNamedReference)?.resolvedSymbol as? FirVariableSymbol)?.fir as? FirVariable<*>
+        get() = ((calleeReference as? FirResolvedNamedReference)?.resolvedSymbol as? FirVariableSymbol)?.fir as? FirVariable
 }

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

@@ -25,12 +25,12 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 // TODO: check why coneTypeSafe is necessary at some points inside
 object FirExposedVisibilityDeclarationChecker : FirBasicDeclarationChecker() {
-    override fun check(declaration: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
         when (declaration) {
             is FirAnonymousFunction -> return
             is FirTypeAlias -> checkTypeAlias(declaration, reporter, context)
             is FirProperty -> checkProperty(declaration, reporter, context)
-            is FirFunction<*> -> checkFunction(declaration, reporter, context)
+            is FirFunction -> checkFunction(declaration, reporter, context)
             is FirRegularClass -> checkClass(declaration, reporter, context)
         }
     }
@@ -106,7 +106,7 @@ object FirExposedVisibilityDeclarationChecker : FirBasicDeclarationChecker() {
         }
     }
 
-    private fun checkFunction(declaration: FirFunction<*>, reporter: DiagnosticReporter, context: CheckerContext) {
+    private fun checkFunction(declaration: FirFunction, reporter: DiagnosticReporter, context: CheckerContext) {
         val functionVisibility = (declaration as FirStatusOwner).effectiveVisibility
 
         if (functionVisibility == EffectiveVisibility.Local) return
@@ -141,7 +141,7 @@ object FirExposedVisibilityDeclarationChecker : FirBasicDeclarationChecker() {
                 }
             }
         }
-        checkMemberReceiver(declaration.receiverTypeRef, declaration as? FirCallableMemberDeclaration<*>, reporter, context)
+        checkMemberReceiver(declaration.receiverTypeRef, declaration as? FirCallableMemberDeclaration, reporter, context)
     }
 
     private fun checkProperty(declaration: FirProperty, reporter: DiagnosticReporter, context: CheckerContext) {
@@ -172,7 +172,7 @@ object FirExposedVisibilityDeclarationChecker : FirBasicDeclarationChecker() {
 
     private fun checkMemberReceiver(
         typeRef: FirTypeRef?,
-        memberDeclaration: FirCallableMemberDeclaration<*>?,
+        memberDeclaration: FirCallableMemberDeclaration?,
         reporter: DiagnosticReporter,
         context: CheckerContext
     ) {

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

@@ -20,7 +20,7 @@ object FirFunctionNameChecker : FirSimpleFunctionChecker() {
         val source = declaration.source
         if (source == null || source.kind is FirFakeSourceElementKind) return
         val containingDeclaration = context.containingDeclarations.lastOrNull()
-        val isNonLocal = containingDeclaration is FirFile || containingDeclaration is FirClass<*>
+        val isNonLocal = containingDeclaration is FirFile || containingDeclaration is FirClass
         if (declaration.name == SpecialNames.NO_NAME_PROVIDED && isNonLocal) {
             reporter.reportOn(source, FirErrors.FUNCTION_DECLARATION_WITH_NO_NAME, context)
         }

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

@@ -11,7 +11,10 @@ import org.jetbrains.kotlin.fir.FirRealSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.isInline
 import org.jetbrains.kotlin.fir.analysis.checkers.valOrVarKeyword
-import org.jetbrains.kotlin.fir.analysis.diagnostics.*
+import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
+import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
+import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOnWithSuppression
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
@@ -28,14 +31,14 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
 import org.jetbrains.kotlin.types.AbstractTypeChecker
 
 object FirFunctionParameterChecker : FirFunctionChecker() {
-    override fun check(declaration: FirFunction<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) {
         checkVarargParameters(declaration, context, reporter)
         checkParameterTypes(declaration, context, reporter)
         checkUninitializedParameter(declaration, context, reporter)
         checkValOrVarParameter(declaration, context, reporter)
     }
 
-    private fun checkParameterTypes(function: FirFunction<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    private fun checkParameterTypes(function: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) {
         for (valueParameter in function.valueParameters) {
             val returnTypeRef = valueParameter.returnTypeRef
             if (returnTypeRef !is FirErrorTypeRef) continue
@@ -53,7 +56,7 @@ object FirFunctionParameterChecker : FirFunctionChecker() {
         }
     }
 
-    private fun checkVarargParameters(function: FirFunction<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    private fun checkVarargParameters(function: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) {
         val varargParameters = function.valueParameters.filter { it.isVararg }
         if (varargParameters.size > 1) {
             for (parameter in varargParameters) {
@@ -79,7 +82,7 @@ object FirFunctionParameterChecker : FirFunctionChecker() {
         }
     }
 
-    private fun checkUninitializedParameter(function: FirFunction<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    private fun checkUninitializedParameter(function: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) {
         for ((index, parameter) in function.valueParameters.withIndex()) {
             // Alas, CheckerContext.qualifiedAccesses stack is not available at this point.
             // Thus, manually visit default value expression and report the diagnostic on qualified accesses of interest.
@@ -108,7 +111,7 @@ object FirFunctionParameterChecker : FirFunctionChecker() {
         }
     }
 
-    private fun checkValOrVarParameter(function: FirFunction<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    private fun checkValOrVarParameter(function: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) {
         if (function is FirConstructor && function.isPrimary) {
             // `val/var` is valid for primary constructors, but not for secondary constructors
             return

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

@@ -9,10 +9,13 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
+import org.jetbrains.kotlin.fir.declarations.FirStatusOwner
 
 object FirInfixFunctionDeclarationChecker : FirBasicDeclarationChecker() {
-    override fun check(declaration: FirDeclaration<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
         if ((declaration as? FirStatusOwner)?.status?.isInfix != true) return
         if (declaration is FirSimpleFunction) {
             if (declaration.valueParameters.size != 1 || !hasExtensionOrDispatchReceiver(declaration, context)) {
@@ -28,6 +31,6 @@ object FirInfixFunctionDeclarationChecker : FirBasicDeclarationChecker() {
         context: CheckerContext
     ): Boolean {
         if (function.receiverTypeRef != null) return true
-        return context.containingDeclarations.lastOrNull() is FirClass<*>
+        return context.containingDeclarations.lastOrNull() is FirClass
     }
 }

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

@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
 object FirInlineDeclarationChecker : FirFunctionChecker() {
-    override fun check(declaration: FirFunction<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) {
         if (!declaration.isInline) return
         // local inline functions are prohibited
         if (declaration.isLocalMember) return
@@ -47,7 +47,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker() {
     }
 
     private fun checkInlineFunctionBody(
-        function: FirFunction<*>,
+        function: FirFunction,
         effectiveVisibility: EffectiveVisibility,
         context: CheckerContext,
         reporter: DiagnosticReporter
@@ -70,7 +70,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker() {
     }
 
     private class Visitor(
-        val inlineFunction: FirFunction<*>,
+        val inlineFunction: FirFunction,
         val inlineFunEffectiveVisibility: EffectiveVisibility,
         val inlinableParameters: List<FirValueParameter>,
         val session: FirSession,
@@ -175,7 +175,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker() {
         ) {
             val source = qualifiedAccess.source ?: return
             if (targetSymbol == null) return
-            val targetFir = targetSymbol.fir as? FirCallableMemberDeclaration<*>
+            val targetFir = targetSymbol.fir as? FirCallableMemberDeclaration
 
             if (targetSymbol.fir in inlinableParameters) {
                 if (!qualifiedAccess.partOfCall(context)) {
@@ -199,7 +199,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker() {
 
         private fun checkVisibilityAndAccess(
             accessExpression: FirQualifiedAccess,
-            calledDeclaration: FirCallableMemberDeclaration<*>?,
+            calledDeclaration: FirCallableMemberDeclaration?,
             source: FirSourceElement,
             context: CheckerContext
         ) {
@@ -248,7 +248,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker() {
         }
 
         private fun checkPrivateClassMemberAccess(
-            calledDeclaration: FirCallableMemberDeclaration<*>,
+            calledDeclaration: FirCallableMemberDeclaration,
             source: FirSourceElement,
             context: CheckerContext
         ) {
@@ -266,7 +266,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker() {
         }
 
         private fun checkSuperCalls(
-            calledDeclaration: FirCallableMemberDeclaration<*>,
+            calledDeclaration: FirCallableMemberDeclaration,
             callExpression: FirQualifiedAccess,
             context: CheckerContext
         ) {
@@ -305,7 +305,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker() {
             }
         }
 
-        private fun FirCallableMemberDeclaration<*>.isInsidePrivateClass(): Boolean {
+        private fun FirCallableMemberDeclaration.isInsidePrivateClass(): Boolean {
             val containingClass = this.containingClass()?.toSymbol(session)?.fir ?: return false
 
             val containingClassVisibility = when (containingClass) {

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

@@ -10,7 +10,9 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirCallableMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirFile
+import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeTypeParameterInQualifiedAccess
 import org.jetbrains.kotlin.fir.resolve.inference.inferenceComponents
 import org.jetbrains.kotlin.fir.resolve.inference.isKClassType
@@ -21,7 +23,7 @@ import org.jetbrains.kotlin.fir.types.*
 object FirKClassWithIncorrectTypeArgumentChecker : FirFileChecker() {
     override fun check(declaration: FirFile, context: CheckerContext, reporter: DiagnosticReporter) {
         for (topLevelDeclaration in declaration.declarations) {
-            if (topLevelDeclaration is FirCallableMemberDeclaration<*>) {
+            if (topLevelDeclaration is FirCallableMemberDeclaration) {
                 checkTopLevelDeclaration(topLevelDeclaration, context, reporter)
             }
         }
@@ -31,7 +33,7 @@ object FirKClassWithIncorrectTypeArgumentChecker : FirFileChecker() {
     //  bad:  fun <T> test1() = T::class
     //  okay: fun <T: Any> test2() = T::class
     private fun checkTopLevelDeclaration(
-        declaration: FirCallableMemberDeclaration<*>,
+        declaration: FirCallableMemberDeclaration,
         context: CheckerContext,
         reporter: DiagnosticReporter
     ) {

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
@@ -126,7 +126,7 @@ object FirModifierChecker : FirBasicDeclarationChecker() {
                 reporter.reportDeprecatedModifierPair(secondModifier, secondToken, firstToken, context)
             }
             CompatibilityType.INCOMPATIBLE, CompatibilityType.COMPATIBLE_FOR_CLASSES -> {
-                if (compatibilityType == CompatibilityType.COMPATIBLE_FOR_CLASSES && owner is FirClass<*>) {
+                if (compatibilityType == CompatibilityType.COMPATIBLE_FOR_CLASSES && owner is FirClass) {
                     return
                 }
                 if (reportedNodes.add(firstModifier)) reporter.reportIncompatibleModifiers(firstModifier, firstToken, secondToken, context)
@@ -137,7 +137,7 @@ object FirModifierChecker : FirBasicDeclarationChecker() {
 
     private fun checkModifiers(
         list: FirModifierList,
-        owner: FirDeclaration<*>,
+        owner: FirDeclaration,
         reporter: DiagnosticReporter,
         context: CheckerContext
     ) {
@@ -156,17 +156,17 @@ 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.CLASS -> declaration is FirClass
-            KtNodeTypes.OBJECT_DECLARATION -> declaration is FirClass<*>
+            KtNodeTypes.OBJECT_DECLARATION -> declaration is FirClass
             KtNodeTypes.PROPERTY -> declaration is FirProperty
             KtNodeTypes.VALUE_PARAMETER -> declaration is FirValueParameter
             // TODO more FIR-PSI relations possibly have to be added
             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/FirNestedClassChecker.kt

@@ -10,7 +10,8 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NESTED_CLASS_NOT_ALLOWED
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.utils.isCompanion
 import org.jetbrains.kotlin.fir.declarations.utils.isInner
 import org.jetbrains.kotlin.fir.declarations.utils.isLocal
@@ -29,7 +30,7 @@ object FirNestedClassChecker : FirRegularClassChecker() {
                     reporter.reportOn(declaration.source, NESTED_CLASS_NOT_ALLOWED, declaration.description, context)
                 }
             }
-            is FirClass<*> -> {
+            is FirClass -> {
                 // Since 1.3, enum entries can contain inner classes only.
                 // Companion objects are reported with code WRONG_MODIFIER_CONTAINING_DECLARATION instead
                 if (containingDeclaration.classKind == ClassKind.ENUM_ENTRY && !declaration.isInner && !declaration.isCompanion) {

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

@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.util.ImplementationStatus
 
 object FirNotImplementedOverrideChecker : FirClassChecker() {
 
-    override fun check(declaration: FirClass<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) {
         val source = declaration.source ?: return
         val sourceKind = source.kind
         if (sourceKind is FirFakeSourceElementKind && sourceKind != FirFakeSourceElementKind.EnumInitializer) return
@@ -53,7 +53,7 @@ object FirNotImplementedOverrideChecker : FirClassChecker() {
         val invisibleSymbols = mutableListOf<FirCallableSymbol<*>>()
 
         fun collectSymbol(symbol: FirCallableSymbol<*>) {
-            val fir = symbol.fir as? FirCallableMemberDeclaration<*> ?: return
+            val fir = symbol.fir as? FirCallableMemberDeclaration ?: return
             when (fir.getImplementationStatus(context.sessionHolder, declaration)) {
                 ImplementationStatus.AMBIGUOUSLY_INHERITED -> notImplementedIntersectionSymbols.add(symbol)
                 ImplementationStatus.NOT_IMPLEMENTED -> when {
@@ -144,6 +144,6 @@ object FirNotImplementedOverrideChecker : FirClassChecker() {
         }
     }
 
-    private fun FirCallableDeclaration<*>.isFromInterfaceOrEnum(context: CheckerContext): Boolean =
+    private fun FirCallableDeclaration.isFromInterfaceOrEnum(context: CheckerContext): Boolean =
         (getContainingClass(context) as? FirRegularClass)?.let { it.isInterface || it.isEnumClass } == true
 }

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

@@ -21,10 +21,10 @@ import org.jetbrains.kotlin.fir.declarations.utils.isOpen
 import org.jetbrains.kotlin.lexer.KtTokens
 
 object FirOpenMemberChecker : FirClassChecker() {
-    override fun check(declaration: FirClass<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration.canHaveOpenMembers) return
         for (memberDeclaration in declaration.declarations) {
-            if (memberDeclaration !is FirCallableMemberDeclaration<*> ||
+            if (memberDeclaration !is FirCallableMemberDeclaration ||
                 // Marking a constructor `open` is an error covered by diagnostic code WRONG_MODIFIER_TARGET
                 memberDeclaration is FirConstructor
             ) continue

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

@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.types.AbstractTypeCheckerContext
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 object FirOverrideChecker : FirClassChecker() {
-    override fun check(declaration: FirClass<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) {
         val typeCheckerContext = context.session.typeContext.newBaseTypeCheckerContext(
             errorTypesEqualToAnything = false,
             stubTypesEqualToAnything = false
@@ -44,12 +44,12 @@ object FirOverrideChecker : FirClassChecker() {
 
         for (it in declaration.declarations) {
             if (it is FirSimpleFunction || it is FirProperty) {
-                checkMember(it as FirCallableMemberDeclaration<*>, reporter, typeCheckerContext, firTypeScope, context)
+                checkMember(it as FirCallableMemberDeclaration, reporter, typeCheckerContext, firTypeScope, context)
             }
         }
     }
 
-    private fun FirTypeScope.retrieveDirectOverriddenOf(member: FirCallableMemberDeclaration<*>): List<FirCallableSymbol<*>> {
+    private fun FirTypeScope.retrieveDirectOverriddenOf(member: FirCallableMemberDeclaration): List<FirCallableSymbol<*>> {
         return when (member) {
             is FirSimpleFunction -> {
                 processFunctionsByName(member.name) {}
@@ -64,8 +64,8 @@ object FirOverrideChecker : FirClassChecker() {
     }
 
     private fun ConeKotlinType.substituteAllTypeParameters(
-        overrideDeclaration: FirCallableMemberDeclaration<*>,
+        overrideDeclaration: FirCallableMemberDeclaration,
-        baseDeclaration: FirCallableDeclaration<*>,
+        baseDeclaration: FirCallableDeclaration,
         context: CheckerContext
     ): ConeKotlinType {
         if (overrideDeclaration.typeParameters.isEmpty()) {
@@ -90,7 +90,7 @@ object FirOverrideChecker : FirClassChecker() {
 
     private fun checkModality(
         overriddenSymbols: List<FirCallableSymbol<*>>,
-    ): FirCallableDeclaration<*>? {
+    ): FirCallableDeclaration? {
         for (overridden in overriddenSymbols) {
             if (overridden.fir !is FirStatusOwner) continue
             val modality = (overridden.fir as FirStatusOwner).status.modality
@@ -109,7 +109,7 @@ object FirOverrideChecker : FirClassChecker() {
         return overriddenSymbols.find { (it.fir as? FirProperty)?.isVar == true }?.fir?.safeAs()
     }
 
-    private fun FirCallableMemberDeclaration<*>.checkVisibility(
+    private fun FirCallableMemberDeclaration.checkVisibility(
         reporter: DiagnosticReporter,
         overriddenSymbols: List<FirCallableSymbol<*>>,
         context: CheckerContext
@@ -135,7 +135,7 @@ object FirOverrideChecker : FirClassChecker() {
     }
 
     // See [OverrideResolver#isReturnTypeOkForOverride]
-    private fun FirCallableMemberDeclaration<*>.checkReturnType(
+    private fun FirCallableMemberDeclaration.checkReturnType(
         overriddenSymbols: List<FirCallableSymbol<*>>,
         typeCheckerContext: AbstractTypeCheckerContext,
         context: CheckerContext,
@@ -169,7 +169,7 @@ object FirOverrideChecker : FirClassChecker() {
     }
 
     private fun checkMember(
-        member: FirCallableMemberDeclaration<*>,
+        member: FirCallableMemberDeclaration,
         reporter: DiagnosticReporter,
         typeCheckerContext: AbstractTypeCheckerContext,
         firTypeScope: FirTypeScope,
@@ -241,7 +241,7 @@ object FirOverrideChecker : FirClassChecker() {
 
     private fun DiagnosticReporter.reportOverridingFinalMember(
         overriding: FirStatusOwner,
-        overridden: FirCallableDeclaration<*>,
+        overridden: FirCallableDeclaration,
         context: CheckerContext
     ) {
         overridden.containingClass()?.let { containingClass ->
@@ -259,7 +259,7 @@ object FirOverrideChecker : FirClassChecker() {
 
     private fun DiagnosticReporter.reportCannotWeakenAccessPrivilege(
         overriding: FirStatusOwner,
-        overridden: FirCallableDeclaration<*>,
+        overridden: FirCallableDeclaration,
         context: CheckerContext
     ) {
         val containingClass = overridden.containingClass() ?: return
@@ -275,7 +275,7 @@ object FirOverrideChecker : FirClassChecker() {
 
     private fun DiagnosticReporter.reportCannotChangeAccessPrivilege(
         overriding: FirStatusOwner,
-        overridden: FirCallableDeclaration<*>,
+        overridden: FirCallableDeclaration,
         context: CheckerContext
     ) {
         val containingClass = overridden.containingClass() ?: return

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
         }
@@ -32,7 +32,7 @@ object FirProjectionRelationChecker : FirBasicDeclarationChecker() {
         }
 
         when (declaration) {
-            is FirClass<*> -> {
+            is FirClass -> {
                 for (it in declaration.superTypeRefs) {
                     checkTypeRef(it, context, reporter)
                 }

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

@@ -10,7 +10,8 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.utils.classId
 import org.jetbrains.kotlin.fir.resolve.symbolProvider
 import org.jetbrains.kotlin.fir.types.classId
@@ -18,7 +19,7 @@ import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 object FirSealedSupertypeChecker : FirClassChecker() {
-    override fun check(declaration: FirClass<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) {
         // only the file declaration is present
         if (declaration.classId.isLocal) {
             checkLocalDeclaration(declaration, context, reporter)
@@ -27,7 +28,7 @@ object FirSealedSupertypeChecker : FirClassChecker() {
         }
     }
 
-    private fun checkGlobalDeclaration(declaration: FirClass<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    private fun checkGlobalDeclaration(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) {
         for (it in declaration.superTypeRefs) {
             val classId = it.coneType.classId ?: continue
 
@@ -46,7 +47,7 @@ object FirSealedSupertypeChecker : FirClassChecker() {
         }
     }
 
-    private fun checkLocalDeclaration(declaration: FirClass<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    private fun checkLocalDeclaration(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) {
         for (it in declaration.superTypeRefs) {
             val classId = it.coneType.classId ?: continue
 

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

@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 object FirSupertypesChecker : FirClassChecker() {
-    override fun check(declaration: FirClass<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) {
         val isInterface = declaration.classKind == ClassKind.INTERFACE
         var nullableSupertypeReported = false
         var extensionFunctionSupertypeReported = false
@@ -159,7 +159,7 @@ object FirSupertypesChecker : FirClassChecker() {
     }
 
     private fun checkDelegationNotToInterface(
-        declaration: FirClass<*>,
+        declaration: FirClass,
         context: CheckerContext,
         reporter: DiagnosticReporter
     ) {

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

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.superConeTypes
 import org.jetbrains.kotlin.fir.types.ConeClassErrorType
 
 object FirThrowableSubclassChecker : FirClassChecker() {
-    override fun check(declaration: FirClass<*>, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) {
         if (!declaration.hasThrowableSupertype(context))
             return
 
@@ -35,12 +35,12 @@ object FirThrowableSubclassChecker : FirClassChecker() {
         }
     }
 
-    private fun FirClass<*>.hasThrowableSupertype(context: CheckerContext) =
+    private fun FirClass.hasThrowableSupertype(context: CheckerContext) =
         superConeTypes.any { it !is ConeClassErrorType && it.isSubtypeOfThrowable(context.session) }
 
-    private fun FirClass<*>.hasGenericOuterDeclaration(context: CheckerContext) =
+    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/FirTypeConstraintsChecker.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.getDanglingTypeConstraintsOrE
 
 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

@@ -48,7 +48,7 @@ object FirTypeParameterBoundsChecker : FirTypeParameterChecker() {
 
     private fun checkFinalUpperBounds(
         declaration: FirTypeParameter,
-        containingDeclaration: FirDeclaration<*>,
+        containingDeclaration: FirDeclaration,
         context: CheckerContext,
         reporter: DiagnosticReporter
     ) {
@@ -72,7 +72,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,8 +12,8 @@ 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<*>) {
+        if (declaration is FirClass) {
             for (typeParameter in declaration.typeParameters) {
                 if (typeParameter is FirTypeParameter) {
                     for (bound in typeParameter.bounds) {
@@ -27,7 +27,7 @@ object FirUpperBoundViolatedDeclarationChecker : FirBasicDeclarationChecker() {
             }
         } else if (declaration is FirTypeAlias) {
             checkUpperBoundViolated(declaration.expandedTypeRef, context, reporter, isIgnoreTypeParameters = true)
-        } else if (declaration is FirCallableDeclaration<*>) {
+        } else if (declaration is FirCallableDeclaration) {
             if (declaration.returnTypeRef.source?.kind !is FirFakeSourceElementKind) {
                 checkUpperBoundViolated(
                     declaration.returnTypeRef, context, reporter,

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

@@ -33,7 +33,7 @@ object FirAbstractSuperCallChecker : FirQualifiedAccessExpressionChecker() {
 
         if (closestClass.classKind == ClassKind.CLASS) {
             // handles all the FirSimpleFunction/FirProperty/etc.
-            val item = expression.getDeclaration<FirCallableMemberDeclaration<*>>()
+            val item = expression.getDeclaration<FirCallableMemberDeclaration>()
                 ?: return
 
             val declaration = item.getContainingClass(context).safeAs<FirRegularClass>()

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

@@ -13,7 +13,10 @@ import org.jetbrains.kotlin.fir.analysis.checkers.declaration.isLocalMember
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirCallableMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirConstructor
+import org.jetbrains.kotlin.fir.declarations.FirProperty
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
 import org.jetbrains.kotlin.fir.expressions.FirGetClassCall
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
@@ -46,7 +49,7 @@ object FirCallableReferenceChecker : FirQualifiedAccessExpressionChecker() {
         if (referredDeclaration is FirConstructor && referredDeclaration.getContainingClass(context.session)?.classKind == ClassKind.ANNOTATION_CLASS) {
             reporter.reportOn(source, FirErrors.CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR, context)
         }
-        if ((referredDeclaration as? FirCallableMemberDeclaration<*>)?.isExtensionMember == true &&
+        if ((referredDeclaration as? FirCallableMemberDeclaration)?.isExtensionMember == true &&
             !referredDeclaration.isLocalMember
         ) {
             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

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

@@ -38,10 +38,10 @@ object FirNotASupertypeChecker : FirQualifiedAccessExpressionChecker() {
      * item like FirRegularClass or FirAnonymousObject
      * or null if no such item could be found.
      */
-    private fun CheckerContext.findClosestClass(label: String?): FirClass<*>? {
+    private fun CheckerContext.findClosestClass(label: String?): FirClass? {
         for (it in containingDeclarations.reversed()) {
             if (it is FirRegularClass || it is FirAnonymousObject) {
-                val firClass = it as FirClass<*>
+                val firClass = it as FirClass
                 val className = firClass.symbol.classId.shortClassName
                 if (label == null || (!className.isSpecial && className.identifier == label)) {
                     return firClass

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

@@ -27,7 +27,7 @@ object FirQualifiedSupertypeExtendedByOtherSupertypeChecker : FirQualifiedAccess
 
         val explicitType = superReference.superTypeRef
             .firClassLike(context.session)
-            ?.followAllAlias(context.session).safeAs<FirClass<*>>()
+            ?.followAllAlias(context.session).safeAs<FirClass>()
             ?: return
 
         val surroundingType = context.findClosestClassOrObject()
@@ -37,11 +37,11 @@ object FirQualifiedSupertypeExtendedByOtherSupertypeChecker : FirQualifiedAccess
         // have `explicitType` as their supertype or
         // equal to it
         var count = 0
-        var candidate: FirClass<*>? = null
+        var candidate: FirClass? = null
 
         for (it in surroundingType.superTypeRefs) {
             val that = it.firClassLike(context.session)
-                ?.followAllAlias(context.session).safeAs<FirClass<*>>()
+                ?.followAllAlias(context.session).safeAs<FirClass>()
                 ?: continue
 
             val isSupertype = explicitType.isSupertypeOf(that, context.session)

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

@@ -112,17 +112,17 @@ 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 FirClass ||
-            declaration is FirFunction<*> ||
+            declaration is FirFunction ||
             declaration is FirTypeParameter ||
             declaration is FirProperty ||
             declaration is FirTypeAlias
         ) {
             reportIfUnderscore(declaration, context, reporter)
 
-            if (declaration is FirFunction<*>) {
+            if (declaration is FirFunction) {
                 for (parameter in declaration.valueParameters) {
                     reportIfUnderscore(
                         parameter,
@@ -141,7 +141,7 @@ object FirReservedUnderscoreDeclarationChecker : FirBasicDeclarationChecker() {
 }
 
 private fun reportIfUnderscore(
-    declaration: FirDeclaration<*>,
+    declaration: FirDeclaration,
     context: CheckerContext,
     reporter: DiagnosticReporter,
     isSingleUnderscoreAllowed: Boolean = false
@@ -160,7 +160,7 @@ private fun reportIfUnderscore(
 
     val returnOrReceiverTypeRef = when (declaration) {
         is FirValueParameter -> declaration.returnTypeRef.source
-        is FirFunction<*> -> declaration.receiverTypeRef?.source
+        is FirFunction -> declaration.receiverTypeRef?.source
         else -> null
     }
 

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

@@ -27,7 +27,7 @@ object FirReturnAllowedChecker : FirReturnExpressionChecker() {
         }
 
         val containingDeclaration = context.containingDeclarations.last()
-        if (containingDeclaration is FirFunction<*> && containingDeclaration.body is FirSingleExpressionBlock) {
+        if (containingDeclaration is FirFunction && containingDeclaration.body is FirSingleExpressionBlock) {
             reporter.reportOn(source, FirErrors.RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY, context)
         }
     }
@@ -36,8 +36,8 @@ object FirReturnAllowedChecker : FirReturnExpressionChecker() {
         for (containingDeclaration in context.containingDeclarations.asReversed()) {
             when (containingDeclaration) {
                 // return from member of local class or anonymous object
-                is FirClass<*> -> return false
+                is FirClass -> return false
-                is FirFunction<*> -> {
+                is FirFunction -> {
                     when {
                         containingDeclaration.symbol == targetSymbol -> return true
                         containingDeclaration is FirAnonymousFunction -> {

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

@@ -19,7 +19,7 @@ object FirSuperNotAvailableChecker : FirQualifiedAccessExpressionChecker() {
         if (expression.calleeReference.safeAs<FirSuperReference>()?.hadExplicitTypeInSource() != true) return
 
         val isInsideClass = context.containingDeclarations.any {
-            it is FirClass<*>
+            it is FirClass
         }
 
         if (!isInsideClass) {

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

@@ -44,7 +44,7 @@ object FirSuperclassNotAccessibleFromInterfaceChecker : FirQualifiedAccessExpres
      * Returns the ClassLikeDeclaration where the function has been defined
      * or null if no proper declaration has been found.
      */
-    private fun getClassLikeDeclaration(functionCall: FirQualifiedAccessExpression, context: CheckerContext): FirClassLikeDeclaration<*>? {
+    private fun getClassLikeDeclaration(functionCall: FirQualifiedAccessExpression, context: CheckerContext): FirClassLikeDeclaration? {
         return functionCall.calleeReference.safeAs<FirResolvedNamedReference>()?.resolvedSymbol?.fir?.getContainingClass(context)
     }
 }

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

@@ -22,13 +22,13 @@ import org.jetbrains.kotlin.fir.declarations.FirStatusOwner
 import org.jetbrains.kotlin.fir.declarations.utils.modality
 import org.jetbrains.kotlin.psi.KtDeclaration
 
-object RedundantModalityModifierSyntaxChecker : FirDeclarationSyntaxChecker<FirDeclaration<*>, KtDeclaration>() {
+object RedundantModalityModifierSyntaxChecker : FirDeclarationSyntaxChecker<FirDeclaration, KtDeclaration>() {
 
-    override fun isApplicable(element: FirDeclaration<*>, source: FirSourceElement): Boolean =
+    override fun isApplicable(element: FirDeclaration, source: FirSourceElement): Boolean =
         source.kind !is FirFakeSourceElementKind && element is FirStatusOwner
 
     override fun checkLightTree(
-        element: FirDeclaration<*>,
+        element: FirDeclaration,
         source: FirSourceElement,
         context: CheckerContext,
         reporter: DiagnosticReporter
@@ -37,7 +37,7 @@ object RedundantModalityModifierSyntaxChecker : FirDeclarationSyntaxChecker<FirD
         val modality = element.modality ?: return
         if (
             modality == Modality.FINAL
-            && (context.containingDeclarations.last() as? FirClass<*>)?.classKind == ClassKind.INTERFACE
+            && (context.containingDeclarations.last() as? FirClass)?.classKind == ClassKind.INTERFACE
         ) return
 
         if (source.treeStructure.modalityModifier(source.lighterASTNode) == null) return

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

@@ -24,10 +24,10 @@ import org.jetbrains.kotlin.fir.declarations.utils.visibility
 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
@@ -43,7 +43,7 @@ object RedundantVisibilityModifierSyntaxChecker : FirDeclarationSyntaxChecker<Fi
         val explicitVisibility = (visibilityModifier?.tokenType as? KtModifierKeywordToken)?.toVisibilityOrNull()
         val implicitVisibility = element.implicitVisibility(context)
         val containingMemberDeclaration = context.findClosest<FirStatusOwner>()
-        require(containingMemberDeclaration is FirDeclaration<*>?)
+        require(containingMemberDeclaration is FirDeclaration?)
 
         val redundantVisibility = when {
             explicitVisibility == implicitVisibility -> implicitVisibility
@@ -62,7 +62,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
 
@@ -83,7 +83,7 @@ object RedundantVisibilityModifierSyntaxChecker : FirDeclarationSyntaxChecker<Fi
             }
 
             this is FirSimpleFunction
-                    && context.containingDeclarations.last() is FirClass<*>
+                    && context.containingDeclarations.last() is FirClass
                     && this.isOverride -> findFunctionVisibility(this, context)
 
             else -> Visibilities.DEFAULT_VISIBILITY
@@ -107,7 +107,7 @@ object RedundantVisibilityModifierSyntaxChecker : FirDeclarationSyntaxChecker<Fi
         return visibility
     }
 
-    private fun FirFunction<*>.visibility(): Visibility? {
+    private fun FirFunction.visibility(): Visibility? {
         (symbol.fir as? FirStatusOwner)?.visibility?.let {
             return it
         }

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

@@ -24,7 +24,7 @@ abstract class AbstractDiagnosticCollector(
     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)
@@ -64,7 +64,7 @@ abstract class AbstractDiagnosticCollectorVisitor(
         visitJump(continueExpression)
     }
 
-    private fun visitClassAndChildren(klass: FirClass<*>, type: ConeKotlinType) {
+    private fun visitClassAndChildren(klass: FirClass, type: ConeKotlinType) {
         val typeRef = buildResolvedTypeRef {
             this.type = type
         }
@@ -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/ControlFlowAnalysisDiagnosticComponent.kt

@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.fir.analysis.cfa.FirControlFlowAnalyzer
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.DeclarationCheckers
 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.*
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
@@ -33,8 +32,8 @@ class ControlFlowAnalysisDiagnosticComponent(
         visitClass(anonymousObject, anonymousObject.controlFlowGraphReference, data)
     }
 
-    private fun <F : FirClass<F>> visitClass(
+    private fun visitClass(
-        klass: FirClass<F>,
+        klass: FirClass,
         controlFlowGraphReference: FirControlFlowGraphReference?,
         data: CheckerContext
     ) {
@@ -50,7 +49,7 @@ class ControlFlowAnalysisDiagnosticComponent(
 
     // ------------------------------- Function -------------------------------
 
-    override fun <F : FirFunction<F>> visitFunction(function: FirFunction<F>, data: CheckerContext) {
+    override fun visitFunction(function: FirFunction, data: CheckerContext) {
         val graph = function.controlFlowGraphReference?.controlFlowGraph ?: return
 
         controlFlowAnalyzer.analyzeFunction(function, graph, data, reporter)

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

@@ -29,7 +29,7 @@ class DeclarationCheckersDiagnosticComponent(
         checkers.allPropertyCheckers.check(property, data, reporter)
     }
 
-    override fun <F : FirClass<F>> visitClass(klass: FirClass<F>, data: CheckerContext) {
+    override fun visitClass(klass: FirClass, data: CheckerContext) {
         checkers.allClassCheckers.check(klass, data, reporter)
     }
 
@@ -77,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

@@ -60,7 +60,7 @@ object FirDiagnosticRenderers {
     val NAME = Renderer { element: FirElement ->
         when (element) {
             is FirStatusOwner -> DECLARATION_NAME.render(element)
-            is FirCallableDeclaration<*> -> element.symbol.callableId.callableName.asString()
+            is FirCallableDeclaration -> element.symbol.callableId.callableName.asString()
             else -> "???"
         }
     }
@@ -83,7 +83,7 @@ object FirDiagnosticRenderers {
         name.asString()
     }
 
-    val RENDER_CLASS_OR_OBJECT = Renderer { firClass: FirClass<*> ->
+    val RENDER_CLASS_OR_OBJECT = Renderer { firClass: FirClass ->
         val name = firClass.classId.relativeClassName.asString()
         val classOrObject = if (firClass is FirRegularClass) "Class" else "Object"
         "$classOrObject $name"

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

@@ -378,12 +378,12 @@ class MultiModuleHtmlFirDump(private val outputRoot: File) {
                     visitElement(regularClass)
                 }
 
-                fun indexDeclaration(declaration: FirDeclaration<*>) {
+                fun indexDeclaration(declaration: FirDeclaration) {
                     symbols[declaration.symbol] = location
                     symbolIds[declaration.symbol] = symbolCounter++
                 }
 
-                override fun <F : FirVariable<F>> visitVariable(variable: FirVariable<F>) {
+                override fun visitVariable(variable: FirVariable) {
                     indexDeclaration(variable)
                     visitElement(variable)
                 }
@@ -919,7 +919,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
             is FirEnumEntry -> generate(statusOwner)
             is FirRegularClass -> generate(statusOwner)
             is FirSimpleFunction -> generate(statusOwner)
-            is FirProperty -> if (statusOwner.isLocal) generate(statusOwner as FirVariable<*>) else generate(statusOwner)
+            is FirProperty -> if (statusOwner.isLocal) generate(statusOwner as FirVariable) else generate(statusOwner)
             is FirConstructor -> generate(statusOwner)
             is FirTypeAlias -> generate(statusOwner)
             else -> unsupported(statusOwner)
@@ -962,7 +962,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
         +"> "
     }
 
-    private fun FlowContent.generateReceiver(declaration: FirCallableDeclaration<*>) {
+    private fun FlowContent.generateReceiver(declaration: FirCallableDeclaration) {
         generateReceiver(declaration.receiverTypeRef)
     }
 
@@ -1047,7 +1047,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
             is FirWhenExpression -> generate(statement, isStatement = true)
             is FirTryExpression -> generate(statement, isStatement = true)
             is FirExpression -> iline { generate(statement) }
-            is FirVariable<*> -> iline { generate(statement) }
+            is FirVariable -> iline { generate(statement) }
             is FirVariableAssignment -> iline { generate(statement) }
             else -> unsupported(statement)
         }
@@ -1072,7 +1072,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
         }
     }
 
-    private fun FlowContent.generate(variable: FirVariable<*>) {
+    private fun FlowContent.generate(variable: FirVariable) {
         if (variable.isVal) {
             keyword("val ")
         } else {
@@ -1112,7 +1112,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
         }
     }
 
-    private fun FlowContent.describeVerbose(symbol: FirCallableSymbol<*>, fir: FirFunction<*>) {
+    private fun FlowContent.describeVerbose(symbol: FirCallableSymbol<*>, fir: FirFunction) {
         describeTypeParameters(fir)
 
         fir.receiverTypeRef?.let {
@@ -1131,7 +1131,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
         generate(fir.returnTypeRef)
     }
 
-    private fun FlowContent.describeVerbose(symbol: FirCallableSymbol<*>, fir: FirVariable<*>) {
+    private fun FlowContent.describeVerbose(symbol: FirCallableSymbol<*>, fir: FirVariable) {
         if (fir is FirTypeParametersOwner) describeTypeParameters(fir)
 
         fir.receiverTypeRef?.let {
@@ -1684,7 +1684,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
@@ -1769,7 +1769,7 @@ 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 FirStatusOwner -> generate(declaration as FirStatusOwner)

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

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

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

@@ -11,7 +11,10 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClass
 import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope
 import org.jetbrains.kotlin.fir.containingClass
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirCallableMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
+import org.jetbrains.kotlin.fir.declarations.FirProperty
+import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.utils.isFinal
 import org.jetbrains.kotlin.fir.dispatchReceiverTypeOrNull
 import org.jetbrains.kotlin.fir.originalOrSelf
@@ -50,7 +53,7 @@ object FirJvmOverridesBackwardCompatibilityHelper : FirOverridesBackwardCompatib
         visitedSymbols: MutableSet<FirCallableSymbol<*>>,
         context: CheckerContext
     ): Boolean {
-        val fir = symbol.fir as? FirCallableMemberDeclaration<*> ?: return false
+        val fir = symbol.fir as? FirCallableMemberDeclaration ?: return false
         if (fir.isFinal) return false
 
         if (symbol in visitedSymbols) return true

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

@@ -24,7 +24,10 @@ import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvide
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider.Companion.CLONEABLE_CLASS_ID
 import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
-import org.jetbrains.kotlin.fir.symbols.impl.*
+import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
+import org.jetbrains.kotlin.fir.symbols.impl.FirEnumEntrySymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.ConeAttributes
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
@@ -192,8 +195,8 @@ 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 FirStatusOwner && b is FirStatusOwner) {

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

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.fir.serialization
 
-import org.jetbrains.kotlin.contracts.description.*
+import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
 import org.jetbrains.kotlin.fir.contracts.FirContractDescription
 import org.jetbrains.kotlin.fir.contracts.description.*
 import org.jetbrains.kotlin.fir.contracts.effects
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.metadata.deserialization.Flags
 
 class FirContractSerializer {
     fun serializeContractOfFunctionIfAny(
-        function: FirFunction<*>,
+        function: FirFunction,
         proto: ProtoBuf.Function.Builder,
         parentSerializer: FirElementSerializer
     ) {

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

@@ -15,13 +15,13 @@ interface FirElementAwareStringTable : StringTable {
     fun getQualifiedClassNameIndex(classId: ClassId): Int =
         getQualifiedClassNameIndex(classId.asString(), classId.isLocal)
 
-    fun getFqNameIndex(classLikeDeclaration: FirClassLikeDeclaration<*>): Int {
+    fun getFqNameIndex(classLikeDeclaration: FirClassLikeDeclaration): Int {
         val classId = classLikeDeclaration.symbol.classId.takeIf { !it.isLocal }
-            ?: getLocalClassIdReplacement(classLikeDeclaration as FirClass<*>)
+            ?: getLocalClassIdReplacement(classLikeDeclaration as FirClass)
             ?: throw IllegalStateException("Cannot get FQ name of local class: ${classLikeDeclaration.render()}")
 
         return getQualifiedClassNameIndex(classId)
     }
 
-    fun getLocalClassIdReplacement(firClass: FirClass<*>): ClassId? = null
+    fun getLocalClassIdReplacement(firClass: FirClass): ClassId? = null
 }

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

@@ -60,7 +60,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,
@@ -96,7 +96,7 @@ class FirElementSerializer private constructor(
         return builder
     }
 
-    fun classProto(klass: FirClass<*>): ProtoBuf.Class.Builder {
+    fun classProto(klass: FirClass): ProtoBuf.Class.Builder {
         val builder = ProtoBuf.Class.newBuilder()
 
         val regularClass = klass as? FirRegularClass
@@ -156,7 +156,7 @@ class FirElementSerializer private constructor(
             }
         }
 
-        val nestedClassifiers = klass.declarations.filterIsInstance<FirClassLikeDeclaration<*>>()
+        val nestedClassifiers = klass.declarations.filterIsInstance<FirClassLikeDeclaration>()
         for (nestedClassifier in nestedClassifiers) {
             if (nestedClassifier is FirTypeAlias) {
                 typeAliasProto(nestedClassifier)?.let { builder.addTypeAlias(it) }
@@ -218,13 +218,13 @@ class FirElementSerializer private constructor(
     }
 
     @OptIn(ExperimentalStdlibApi::class)
-    private fun FirClass<*>.declarations(): List<FirCallableMemberDeclaration<*>> = buildList {
+    private fun FirClass.declarations(): List<FirCallableMemberDeclaration> = buildList {
         val memberScope =
             defaultType().scope(session, scopeSession, FakeOverrideTypeCalculator.DoNothing)
                 ?: error("Null scope for $this")
 
         fun addDeclarationIfNeeded(symbol: FirCallableSymbol<*>) {
-            val declaration = symbol.fir as? FirCallableMemberDeclaration<*> ?: return
+            val declaration = symbol.fir as? FirCallableMemberDeclaration ?: return
             if (declaration.isIntersectionOverride) {
                 // This part is a kind of hack for case like
                 //
@@ -259,7 +259,7 @@ class FirElementSerializer private constructor(
         memberScope.processAllProperties(::addDeclarationIfNeeded)
 
         for (declaration in declarations) {
-            if (declaration is FirCallableMemberDeclaration<*> && declaration.isStatic) {
+            if (declaration is FirCallableMemberDeclaration && declaration.isStatic) {
                 add(declaration)
             }
         }
@@ -375,7 +375,7 @@ class FirElementSerializer private constructor(
         return builder
     }
 
-    fun functionProto(function: FirFunction<*>): ProtoBuf.Function.Builder? {
+    fun functionProto(function: FirFunction): ProtoBuf.Function.Builder? {
         if (!extension.shouldSerializeFunction(function)) return null
 
         val builder = ProtoBuf.Function.newBuilder()
@@ -822,7 +822,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,
@@ -834,18 +834,18 @@ class FirElementSerializer private constructor(
 
     private fun useTypeTable(): Boolean = extension.shouldUseTypeTable()
 
-    private fun FirDeclaration<*>.hasInlineClassTypesInSignature(): Boolean {
+    private fun FirDeclaration.hasInlineClassTypesInSignature(): Boolean {
         // TODO
         return false
     }
 
-    private fun FirCallableDeclaration<*>.isSuspendOrHasSuspendTypesInSignature(): Boolean {
+    private fun FirCallableDeclaration.isSuspendOrHasSuspendTypesInSignature(): Boolean {
         // TODO (types in signature)
-        return this is FirCallableMemberDeclaration<*> && this.isSuspend
+        return this is FirCallableMemberDeclaration && this.isSuspend
     }
 
     private fun writeVersionRequirementForInlineClasses(
-        klass: FirClass<*>,
+        klass: FirClass,
         builder: ProtoBuf.Class.Builder,
         versionRequirementTable: MutableVersionRequirementTable
     ) {
@@ -937,7 +937,7 @@ class FirElementSerializer private constructor(
         return declaration.visibility.normalize()
     }
 
-    private fun getClassifierId(declaration: FirClassLikeDeclaration<*>): Int =
+    private fun getClassifierId(declaration: FirClassLikeDeclaration): Int =
         stringTable.getFqNameIndex(declaration)
 
     private fun getClassifierId(classId: ClassId): Int =
@@ -982,7 +982,7 @@ class FirElementSerializer private constructor(
         fun create(
             session: FirSession,
             scopeSession: ScopeSession,
-            klass: FirClass<*>,
+            klass: FirClass,
             extension: FirSerializerExtension,
             parentSerializer: FirElementSerializer?,
             typeApproximator: AbstractTypeApproximator,

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

@@ -28,14 +28,14 @@ abstract class FirSerializerExtension {
     open fun shouldSerializeTypeAlias(typeAlias: FirTypeAlias): Boolean = true
     open fun shouldUseTypeTable(): Boolean = false
     open fun shouldUseNormalizedVisibility(): Boolean = false
-    open fun shouldSerializeFunction(function: FirFunction<*>): Boolean = false
+    open fun shouldSerializeFunction(function: FirFunction): Boolean = false
     open fun shouldSerializeProperty(property: FirProperty): Boolean = false
 
     open fun serializePackage(packageFqName: FqName, proto: ProtoBuf.Package.Builder) {
     }
 
     open fun serializeClass(
-        klass: FirClass<*>,
+        klass: FirClass,
         proto: ProtoBuf.Class.Builder,
         versionRequirementTable: MutableVersionRequirementTable,
         childSerializer: FirElementSerializer
@@ -50,7 +50,7 @@ abstract class FirSerializerExtension {
     }
 
     open fun serializeFunction(
-        function: FirFunction<*>,
+        function: FirFunction,
         proto: ProtoBuf.Function.Builder,
         versionRequirementTable: MutableVersionRequirementTable?,
         childSerializer: FirElementSerializer
@@ -91,7 +91,7 @@ abstract class FirSerializerExtension {
         get() = null
 
     interface ClassMembersProducer {
-        fun getCallableMembers(klass: FirClass<*>): Collection<FirCallableMemberDeclaration<*>>
+        fun getCallableMembers(klass: FirClass): Collection<FirCallableMemberDeclaration>
     }
 
 }

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

@@ -21,7 +21,7 @@ class FirJvmElementAwareStringTable(
     private val components: Fir2IrComponents,
     nameResolver: JvmNameResolver? = null
 ) : JvmStringTable(nameResolver), FirElementAwareStringTable {
-    override fun getLocalClassIdReplacement(firClass: FirClass<*>): ClassId =
+    override fun getLocalClassIdReplacement(firClass: FirClass): ClassId =
         components.classifierStorage.getCachedIrClass(firClass)?.getLocalClassIdReplacement()
             ?: throw AssertionError("not a local class: ${firClass.symbol.classId}")
 

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

@@ -31,20 +31,20 @@ 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<FirStatusOwner>(4)
 
     private var isRealExpect = false
 
-    open fun FirFunction<*>.platformSpecificFunctionName(): String? = null
+    open fun FirFunction.platformSpecificFunctionName(): String? = null
 
-    open fun FirFunction<*>.platformSpecificSuffix(): String? =
+    open fun FirFunction.platformSpecificSuffix(): String? =
         if (this is FirSimpleFunction && name.asString() == "main")
             this@FirJvmMangleComputer.session.firProvider.getFirCallableContainerFile(symbol)?.name
         else null
 
-    open fun FirFunction<*>.specialValueParamPrefix(param: FirValueParameter): String = ""
+    open fun FirFunction.specialValueParamPrefix(param: FirValueParameter): String = ""
 
     private fun addReturnType(): Boolean = false
 
@@ -81,10 +81,10 @@ 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 FirCallableMemberDeclaration -> this.containingClass()?.classId?.let { it.packageFqName to it } ?: return
-            is FirClassLikeDeclaration<*> -> this.symbol.classId.let { it.packageFqName to it.outerClassId }
+            is FirClassLikeDeclaration -> this.symbol.classId.let { it.packageFqName to it.outerClassId }
             else -> return
         }
         if (parentClassId != null && !parentClassId.isLocal) {
@@ -100,7 +100,7 @@ open class FirJvmMangleComputer(
         }
     }
 
-    private fun FirDeclaration<*>.mangleSimpleDeclaration(name: String) {
+    private fun FirDeclaration.mangleSimpleDeclaration(name: String) {
         val l = builder.length
         visitParent()
 
@@ -111,7 +111,7 @@ 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? FirStatusOwner)?.isExpect == true
 
@@ -138,7 +138,7 @@ open class FirJvmMangleComputer(
         mangleSignature(isCtor, isStatic)
     }
 
-    private fun FirFunction<*>.mangleSignature(isCtor: Boolean, isStatic: Boolean) {
+    private fun FirFunction.mangleSignature(isCtor: Boolean, isStatic: Boolean) {
         if (!mode.signature) {
             return
         }
@@ -171,7 +171,7 @@ open class FirJvmMangleComputer(
             if (this in parent.typeParameters) {
                 return parent
             }
-            if (parent is FirCallableDeclaration<*>) {
+            if (parent is FirCallableDeclaration) {
                 val overriddenFir = parent.originalForSubstitutionOverride
                 if (overriddenFir is FirTypeParametersOwner && this in overriddenFir.typeParameters) {
                     return parent
@@ -317,7 +317,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/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt

@@ -59,7 +59,7 @@ class FirJvmSerializerExtension(
     private val jvmDefaultMode = state.jvmDefaultMode
 
     override fun shouldUseTypeTable(): Boolean = useTypeTable
-    override fun shouldSerializeFunction(function: FirFunction<*>): Boolean {
+    override fun shouldSerializeFunction(function: FirFunction): Boolean {
         return classBuilderMode != ClassBuilderMode.ABI ||
                 function !is FirSimpleFunction || function.visibility != Visibilities.Private
     }
@@ -77,7 +77,7 @@ class FirJvmSerializerExtension(
     }
 
     override fun serializeClass(
-        klass: FirClass<*>,
+        klass: FirClass,
         proto: ProtoBuf.Class.Builder,
         versionRequirementTable: MutableVersionRequirementTable,
         childSerializer: FirElementSerializer
@@ -103,7 +103,7 @@ class FirJvmSerializerExtension(
     // Interfaces which have @JvmDefault members somewhere in the hierarchy need the compiler 1.2.40+
     // so that the generated bridges in subclasses would call the super members correctly
     private fun writeVersionRequirementForJvmDefaultIfNeeded(
-        klass: FirClass<*>,
+        klass: FirClass,
         builder: ProtoBuf.Class.Builder,
         versionRequirementTable: MutableVersionRequirementTable
     ) {
@@ -182,7 +182,7 @@ class FirJvmSerializerExtension(
     }
 
     override fun serializeFunction(
-        function: FirFunction<*>,
+        function: FirFunction,
         proto: ProtoBuf.Function.Builder,
         versionRequirementTable: MutableVersionRequirementTable?,
         childSerializer: FirElementSerializer
@@ -208,7 +208,7 @@ class FirJvmSerializerExtension(
         }
     }
 
-    private fun FirFunction<*>.needsInlineParameterNullCheckRequirement(): Boolean =
+    private fun FirFunction.needsInlineParameterNullCheckRequirement(): Boolean =
         this is FirSimpleFunction && isInline && !isSuspend && !isParamAssertionsDisabled &&
                 !Visibilities.isPrivate(visibility) &&
                 (valueParameters.any { it.returnTypeRef.coneType.isBuiltinFunctionalType(session) } ||
@@ -284,7 +284,7 @@ class FirJvmSerializerExtension(
         bindings.get(slice, key) ?: globalBindings.get(slice, key)
 
     private inner class SignatureSerializer {
-        fun methodSignature(function: FirFunction<*>?, method: Method): JvmProtoBuf.JvmMethodSignature? {
+        fun methodSignature(function: FirFunction?, method: Method): JvmProtoBuf.JvmMethodSignature? {
             val builder = JvmProtoBuf.JvmMethodSignature.newBuilder()
             if (function == null || (function as? FirSimpleFunction)?.name?.asString() != method.name) {
                 builder.name = stringTable.getStringIndex(method.name)
@@ -297,7 +297,7 @@ class FirJvmSerializerExtension(
 
         // We don't write those signatures which can be trivially reconstructed from already serialized data
         // TODO: make JvmStringTable implement NameResolver and use JvmProtoBufUtil#getJvmMethodSignature instead
-        private fun requiresSignature(function: FirFunction<*>, desc: String): Boolean {
+        private fun requiresSignature(function: FirFunction, desc: String): Boolean {
             val sb = StringBuilder()
             sb.append("(")
             val receiverTypeRef = function.receiverTypeRef
@@ -375,9 +375,9 @@ class FirJvmSerializerExtension(
     }
 
     companion object {
-        val METHOD_FOR_FIR_FUNCTION = JvmSerializationBindings.SerializationMappingSlice.create<FirFunction<*>, Method>()
+        val METHOD_FOR_FIR_FUNCTION = JvmSerializationBindings.SerializationMappingSlice.create<FirFunction, Method>()
         val FIELD_FOR_PROPERTY = JvmSerializationBindings.SerializationMappingSlice.create<FirProperty, Pair<Type, String>>()
-        val SYNTHETIC_METHOD_FOR_FIR_VARIABLE = JvmSerializationBindings.SerializationMappingSlice.create<FirVariable<*>, Method>()
+        val SYNTHETIC_METHOD_FOR_FIR_VARIABLE = JvmSerializationBindings.SerializationMappingSlice.create<FirVariable, Method>()
     }
 
 }

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

@@ -75,7 +75,7 @@ class FirMetadataSerializer(
         }
     }
 
-    private fun FirFunction<*>.copyToFreeAnonymousFunction(): FirAnonymousFunction {
+    private fun FirFunction.copyToFreeAnonymousFunction(): FirAnonymousFunction {
         val function = this
         return buildAnonymousFunction {
             val typeParameterSet = function.typeParameters.filterIsInstanceTo(mutableSetOf<FirTypeParameter>())

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

@@ -30,10 +30,12 @@ import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.calls.FirSyntheticPropertySymbol
 import org.jetbrains.kotlin.fir.resolve.calls.originalConstructorIfTypeAlias
 import org.jetbrains.kotlin.fir.resolve.providers.FirProvider
-import org.jetbrains.kotlin.fir.scopes.*
+import org.jetbrains.kotlin.fir.scopes.FirTypeScope
+import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData
-import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
+import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
 import org.jetbrains.kotlin.fir.symbols.AccessorSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.ir.IrElement
@@ -293,7 +295,7 @@ internal tailrec fun FirCallableSymbol<*>.unwrapCallRepresentative(root: FirCall
 }
 
 internal fun FirSimpleFunction.generateOverriddenFunctionSymbols(
-    containingClass: FirClass<*>,
+    containingClass: FirClass,
     session: FirSession,
     scopeSession: ScopeSession,
     declarationStorage: Fir2IrDeclarationStorage,
@@ -321,7 +323,7 @@ internal fun FirSimpleFunction.generateOverriddenFunctionSymbols(
 
 fun FirTypeScope.processOverriddenFunctionsFromSuperClasses(
     functionSymbol: FirNamedFunctionSymbol,
-    containingClass: FirClass<*>,
+    containingClass: FirClass,
     processor: (FirNamedFunctionSymbol) -> ProcessorAction
 ): ProcessorAction = processDirectOverriddenFunctionsWithBaseScope(functionSymbol) { overridden, baseScope ->
     val unwrapped =
@@ -337,7 +339,7 @@ fun FirTypeScope.processOverriddenFunctionsFromSuperClasses(
 
 fun FirTypeScope.processOverriddenPropertiesFromSuperClasses(
     propertySymbol: FirPropertySymbol,
-    containingClass: FirClass<*>,
+    containingClass: FirClass,
     processor: (FirPropertySymbol) -> ProcessorAction
 ): ProcessorAction = processDirectOverriddenPropertiesWithBaseScope(propertySymbol) { overridden, baseScope ->
     if (overridden.containingClass() == containingClass.symbol.toLookupTag()) {
@@ -347,7 +349,7 @@ fun FirTypeScope.processOverriddenPropertiesFromSuperClasses(
     }
 }
 
-private fun FirClass<*>.getSuperTypesAsIrClasses(
+private fun FirClass.getSuperTypesAsIrClasses(
     declarationStorage: Fir2IrDeclarationStorage
 ): Set<IrClass>? {
     val irClass =
@@ -357,7 +359,7 @@ private fun FirClass<*>.getSuperTypesAsIrClasses(
 }
 
 internal fun FirProperty.generateOverriddenPropertySymbols(
-    containingClass: FirClass<*>,
+    containingClass: FirClass,
     session: FirSession,
     scopeSession: ScopeSession,
     declarationStorage: Fir2IrDeclarationStorage,
@@ -384,7 +386,7 @@ internal fun FirProperty.generateOverriddenPropertySymbols(
 }
 
 internal fun FirProperty.generateOverriddenAccessorSymbols(
-    containingClass: FirClass<*>,
+    containingClass: FirClass,
     isGetter: Boolean,
     session: FirSession,
     scopeSession: ScopeSession,
@@ -463,7 +465,7 @@ internal fun IrDeclarationParent.declareThisReceiverParameter(
         this.parent = this@declareThisReceiverParameter
     }
 
-fun FirClass<*>.irOrigin(firProvider: FirProvider): IrDeclarationOrigin = when {
+fun FirClass.irOrigin(firProvider: FirProvider): IrDeclarationOrigin = when {
     firProvider.getFirClassifierContainerFileIfAny(symbol) != null -> IrDeclarationOrigin.DEFINED
     isJava -> IrDeclarationOrigin.IR_EXTERNAL_JAVA_DECLARATION_STUB
     else -> IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB

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

@@ -16,7 +16,10 @@ import org.jetbrains.kotlin.fir.lazy.Fir2IrLazyClass
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.fir.symbols.*
+import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
+import org.jetbrains.kotlin.fir.symbols.Fir2IrClassSymbol
+import org.jetbrains.kotlin.fir.symbols.Fir2IrEnumEntrySymbol
+import org.jetbrains.kotlin.fir.symbols.Fir2IrTypeAliasSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
@@ -118,14 +121,14 @@ class Fir2IrClassifierStorage(
         }
     }
 
-    private fun IrClass.declareTypeParameters(klass: FirClass<*>) {
+    private fun IrClass.declareTypeParameters(klass: FirClass) {
         if (klass is FirRegularClass) {
             preCacheTypeParameters(klass)
             setTypeParameters(klass)
         }
     }
 
-    private fun IrClass.declareSupertypes(klass: FirClass<*>) {
+    private fun IrClass.declareSupertypes(klass: FirClass) {
         superTypes = klass.superTypeRefs.map { superTypeRef -> superTypeRef.toIrType() }
     }
 
@@ -133,13 +136,13 @@ class Fir2IrClassifierStorage(
         inlineClassRepresentation = computeInlineClassRepresentation(klass)
     }
 
-    private fun IrClass.declareSupertypesAndTypeParameters(klass: FirClass<*>): IrClass {
+    private fun IrClass.declareSupertypesAndTypeParameters(klass: FirClass): IrClass {
         declareTypeParameters(klass)
         declareSupertypes(klass)
         return this
     }
 
-    fun getCachedIrClass(klass: FirClass<*>): IrClass? {
+    fun getCachedIrClass(klass: FirClass): IrClass? {
         return if (klass is FirAnonymousObject || klass is FirRegularClass && klass.visibility == Visibilities.Local) {
             localStorage.getLocalClass(klass)
         } else {
@@ -148,12 +151,12 @@ class Fir2IrClassifierStorage(
     }
 
     internal fun getCachedLocalClass(lookupTag: ConeClassLikeLookupTag): IrClass? {
-        return localStorage.getLocalClass(lookupTag.toSymbol(session)!!.fir as FirClass<*>)
+        return localStorage.getLocalClass(lookupTag.toSymbol(session)!!.fir as FirClass)
     }
 
     private fun FirRegularClass.enumClassModality(): Modality {
         return when {
-            declarations.any { it is FirCallableMemberDeclaration<*> && it.modality == Modality.ABSTRACT } -> {
+            declarations.any { it is FirCallableMemberDeclaration && it.modality == Modality.ABSTRACT } -> {
                 Modality.ABSTRACT
             }
             declarations.any { it is FirEnumEntry && it.initializer != null } -> {
@@ -165,7 +168,7 @@ class Fir2IrClassifierStorage(
         }
     }
 
-    private fun createIrClass(klass: FirClass<*>, parent: IrDeclarationParent? = null): IrClass {
+    private fun createIrClass(klass: FirClass, parent: IrDeclarationParent? = null): IrClass {
         // NB: klass can be either FirRegularClass or FirAnonymousObject
         if (klass is FirAnonymousObject) {
             return createIrAnonymousObject(klass, irParent = parent)

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

@@ -5,7 +5,10 @@
 
 package org.jetbrains.kotlin.fir.backend
 
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirConstructor
+import org.jetbrains.kotlin.fir.declarations.FirProperty
+import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
 import org.jetbrains.kotlin.fir.expressions.FirReturnExpression
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.util.parentClassOrNull
@@ -13,7 +16,7 @@ import org.jetbrains.kotlin.ir.util.parentClassOrNull
 class Fir2IrConversionScope {
     private val parentStack = mutableListOf<IrDeclarationParent>()
 
-    private val containingFirClassStack = mutableListOf<FirClass<*>>()
+    private val containingFirClassStack = mutableListOf<FirClass>()
 
     fun <T : IrDeclarationParent?> withParent(parent: T, f: T.() -> Unit): T {
         if (parent == null) return parent
@@ -25,7 +28,7 @@ class Fir2IrConversionScope {
 
     fun containingFileIfAny(): IrFile? = parentStack.getOrNull(0) as? IrFile
 
-    fun withContainingFirClass(containingFirClass: FirClass<*>, f: () -> Unit) {
+    fun withContainingFirClass(containingFirClass: FirClass, f: () -> Unit) {
         containingFirClassStack += containingFirClass
         f()
         containingFirClassStack.removeAt(containingFirClassStack.size - 1)
@@ -48,7 +51,7 @@ class Fir2IrConversionScope {
         return declaration
     }
 
-    fun containerFirClass(): FirClass<*>? = containingFirClassStack.lastOrNull()
+    fun containerFirClass(): FirClass? = containingFirClassStack.lastOrNull()
 
     private val functionStack = mutableListOf<IrFunction>()
 

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

@@ -164,7 +164,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 {
@@ -175,7 +175,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 }
     }
 
@@ -199,8 +199,8 @@ class Fir2IrConverter(
     }
 
     private fun processMemberDeclaration(
-        declaration: FirDeclaration<*>,
+        declaration: FirDeclaration,
-        containingClass: FirClass<*>?,
+        containingClass: FirClass?,
         parent: IrDeclarationParent
     ): IrDeclaration? {
         val isLocal = containingClass != null &&

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

@@ -70,7 +70,7 @@ class Fir2IrDeclarationStorage(
 
     private val fileCache = ConcurrentHashMap<FirFile, IrFile>()
 
-    private val functionCache = ConcurrentHashMap<FirFunction<*>, IrSimpleFunction>()
+    private val functionCache = ConcurrentHashMap<FirFunction, IrSimpleFunction>()
 
     private val constructorCache = ConcurrentHashMap<FirConstructor, IrConstructor>()
 
@@ -93,12 +93,12 @@ class Fir2IrDeclarationStorage(
     // so remember that in class B there's a fake override $2 for real $1.
     //
     // Thus we may obtain it by fakeOverridesInClass[ir(B)][fir(A::foo)] -> fir(B::foo)
-    private val fakeOverridesInClass = mutableMapOf<IrClass, MutableMap<FirCallableDeclaration<*>, FirCallableDeclaration<*>>>()
+    private val fakeOverridesInClass = mutableMapOf<IrClass, MutableMap<FirCallableDeclaration, FirCallableDeclaration>>()
 
     // 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>()
 
@@ -106,7 +106,7 @@ class Fir2IrDeclarationStorage(
 
     private val delegatedMemberGenerator = DelegatedMemberGenerator(components)
 
-    private fun areCompatible(firFunction: FirFunction<*>, irFunction: IrFunction): Boolean {
+    private fun areCompatible(firFunction: FirFunction, irFunction: IrFunction): Boolean {
         if (firFunction is FirSimpleFunction && irFunction is IrSimpleFunction) {
             if (irFunction.name != firFunction.name) return false
         }
@@ -253,7 +253,7 @@ class Fir2IrDeclarationStorage(
         }
     }
 
-    internal fun findIrParent(callableDeclaration: FirCallableDeclaration<*>): IrDeclarationParent? {
+    internal fun findIrParent(callableDeclaration: FirCallableDeclaration): IrDeclarationParent? {
         val firBasedSymbol = callableDeclaration.symbol
         val callableId = firBasedSymbol.callableId
         return findIrParent(callableId.packageName, callableDeclaration.containingClass(), firBasedSymbol)
@@ -295,7 +295,7 @@ class Fir2IrDeclarationStorage(
     }
 
     private fun <T : IrFunction> T.declareParameters(
-        function: FirFunction<*>?,
+        function: FirFunction?,
         containingClass: IrClass?,
         isStatic: Boolean,
         // Can be not-null only for property accessors
@@ -368,7 +368,7 @@ class Fir2IrDeclarationStorage(
     }
 
     private fun <T : IrFunction> T.bindAndDeclareParameters(
-        function: FirFunction<*>?,
+        function: FirFunction?,
         irParent: IrDeclarationParent?,
         thisReceiverOwner: IrClass? = irParent as? IrClass,
         isStatic: Boolean,
@@ -379,14 +379,14 @@ class Fir2IrDeclarationStorage(
         return this
     }
 
-    fun <T : IrFunction> T.putParametersInScope(function: FirFunction<*>): T {
+    fun <T : IrFunction> T.putParametersInScope(function: FirFunction): T {
         for ((firParameter, irParameter) in function.valueParameters.zip(valueParameters)) {
             localStorage.putParameter(firParameter, irParameter)
         }
         return this
     }
 
-    fun getCachedIrFunction(function: FirFunction<*>): IrSimpleFunction? =
+    fun getCachedIrFunction(function: FirFunction): IrSimpleFunction? =
         if (function is FirSimpleFunction) getCachedIrFunction(function)
         else localStorage.getLocalFunction(function)
 
@@ -412,7 +412,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?,
@@ -435,7 +435,7 @@ class Fir2IrDeclarationStorage(
     }
 
     fun createIrFunction(
-        function: FirFunction<*>,
+        function: FirFunction,
         irParent: IrDeclarationParent?,
         thisReceiverOwner: IrClass? = irParent as? IrClass,
         origin: IrDeclarationOrigin = IrDeclarationOrigin.DEFINED,
@@ -867,16 +867,16 @@ class Fir2IrDeclarationStorage(
 
     internal fun saveFakeOverrideInClass(
         irClass: IrClass,
-        originalDeclaration: FirCallableDeclaration<*>,
+        originalDeclaration: FirCallableDeclaration,
-        fakeOverride: FirCallableDeclaration<*>
+        fakeOverride: FirCallableDeclaration
     ) {
         fakeOverridesInClass.getOrPut(irClass, ::mutableMapOf)[originalDeclaration] = fakeOverride
     }
 
     fun getFakeOverrideInClass(
         irClass: IrClass,
-        callableDeclaration: FirCallableDeclaration<*>
+        callableDeclaration: FirCallableDeclaration
-    ): FirCallableDeclaration<*>? {
+    ): FirCallableDeclaration? {
         if (irClass is Fir2IrLazyClass) {
             irClass.getFakeOverridesByName(callableDeclaration.symbol.callableId.callableName)
         }
@@ -885,7 +885,7 @@ class Fir2IrDeclarationStorage(
 
     fun getCachedIrField(field: FirField): IrField? = fieldCache[field]
 
-    fun createIrFieldAndDelegatedMembers(field: FirField, owner: FirClass<*>, irClass: IrClass): IrField {
+    fun createIrFieldAndDelegatedMembers(field: FirField, owner: FirClass, irClass: IrClass): IrField {
         val irField = createIrField(field, origin = IrDeclarationOrigin.DELEGATE)
         irField.setAndModifyParent(irClass)
         delegatedMemberGenerator.generate(irField, field, owner, irClass)
@@ -968,7 +968,7 @@ class Fir2IrDeclarationStorage(
         )
 
     fun createIrVariable(
-        variable: FirVariable<*>,
+        variable: FirVariable,
         irParent: IrDeclarationParent,
         givenOrigin: IrDeclarationOrigin? = null
     ): IrVariable = convertCatching(variable) {
@@ -1145,7 +1145,7 @@ class Fir2IrDeclarationStorage(
 
     private inline fun <
             reified FS : FirCallableSymbol<*>,
-            reified F : FirCallableDeclaration<*>,
+            reified F : FirCallableDeclaration,
             I : IrSymbolOwner,
             > getIrCallableSymbol(
         firSymbol: FS,
@@ -1235,7 +1235,7 @@ class Fir2IrDeclarationStorage(
         }
     }
 
-    private fun getIrVariableSymbol(firVariable: FirVariable<*>): IrVariableSymbol {
+    private fun getIrVariableSymbol(firVariable: FirVariable): IrVariableSymbol {
         return localStorage.getVariable(firVariable)?.symbol
             ?: run {
                 throw IllegalArgumentException("Cannot find variable ${firVariable.render()} in local storage")
@@ -1267,8 +1267,8 @@ 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)
+            (firAnnotationContainer is FirCallableMemberDeclaration && firAnnotationContainer.isSubstitutionOrIntersectionOverride)
         ) {
             annotationGenerator.generate(this, firAnnotationContainer)
         }

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

@@ -6,8 +6,6 @@
 package org.jetbrains.kotlin.fir.backend
 
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
 import org.jetbrains.kotlin.fir.declarations.FirCallableMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.expressions.*
@@ -28,7 +26,6 @@ import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.util.classId
 import org.jetbrains.kotlin.ir.util.parentAsClass
 import org.jetbrains.kotlin.types.AbstractTypeChecker
-import org.jetbrains.kotlin.types.SmartcastStability
 
 class Fir2IrImplicitCastInserter(
     private val components: Fir2IrComponents
@@ -295,7 +292,7 @@ class Fir2IrImplicitCastInserter(
     ): IrExpression {
         val referencedDeclaration =
             ((calleeReference as? FirResolvedNamedReference)?.resolvedSymbol as? FirCallableSymbol<*>)?.unwrapCallRepresentative()
-                ?.fir as? FirCallableMemberDeclaration<*>
+                ?.fir as? FirCallableMemberDeclaration
 
         val dispatchReceiverType =
             referencedDeclaration?.dispatchReceiverType as? ConeClassLikeType

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

@@ -7,13 +7,12 @@ package org.jetbrains.kotlin.fir.backend
 
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.name.ClassId
 
 class Fir2IrLocalStorage {
 
     private val cacheStack = mutableListOf<Fir2IrScopeCache>()
 
-    private val localClassCache = mutableMapOf<FirClass<*>, IrClass>()
+    private val localClassCache = mutableMapOf<FirClass, IrClass>()
 
     fun enterCallable() {
         cacheStack += Fir2IrScopeCache()
@@ -32,14 +31,14 @@ class Fir2IrLocalStorage {
         return null
     }
 
-    fun getVariable(variable: FirVariable<*>): IrVariable? =
+    fun getVariable(variable: FirVariable): IrVariable? =
         last { getVariable(variable) }
 
-    fun getLocalClass(localClass: FirClass<*>): IrClass? {
+    fun getLocalClass(localClass: FirClass): IrClass? {
         return localClassCache[localClass]
     }
 
-    fun getLocalFunction(localFunction: FirFunction<*>): IrSimpleFunction? =
+    fun getLocalFunction(localFunction: FirFunction): IrSimpleFunction? =
         last { getLocalFunction(localFunction) }
 
     fun getDelegatedProperty(property: FirProperty): IrLocalDelegatedProperty? =
@@ -56,15 +55,15 @@ class Fir2IrLocalStorage {
         cacheStack.last().putParameter(firParameter, irParameter)
     }
 
-    fun putVariable(firVariable: FirVariable<*>, irVariable: IrVariable) {
+    fun putVariable(firVariable: FirVariable, irVariable: IrVariable) {
         cacheStack.last().putVariable(firVariable, irVariable)
     }
 
-    fun putLocalClass(firClass: FirClass<*>, irClass: IrClass) {
+    fun putLocalClass(firClass: FirClass, irClass: IrClass) {
         localClassCache[firClass] = irClass
     }
 
-    fun putLocalFunction(firFunction: FirFunction<*>, irFunction: IrSimpleFunction) {
+    fun putLocalFunction(firFunction: FirFunction, irFunction: IrSimpleFunction) {
         cacheStack.last().putLocalFunction(firFunction, irFunction)
     }
 

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

@@ -16,9 +16,9 @@ import org.jetbrains.kotlin.ir.declarations.IrVariable
 class Fir2IrScopeCache {
     private val parameterCache = mutableMapOf<FirValueParameter, IrValueParameter>()
 
-    private val variableCache = mutableMapOf<FirVariable<*>, IrVariable>()
+    private val variableCache = mutableMapOf<FirVariable, IrVariable>()
 
-    private val localFunctionCache = mutableMapOf<FirFunction<*>, IrSimpleFunction>()
+    private val localFunctionCache = mutableMapOf<FirFunction, IrSimpleFunction>()
 
     private val delegatedPropertyCache = mutableMapOf<FirProperty, IrLocalDelegatedProperty>()
 
@@ -28,15 +28,15 @@ class Fir2IrScopeCache {
         parameterCache[firParameter] = irParameter
     }
 
-    fun getVariable(variable: FirVariable<*>): IrVariable? = variableCache[variable]
+    fun getVariable(variable: FirVariable): IrVariable? = variableCache[variable]
 
-    fun putVariable(firVariable: FirVariable<*>, irVariable: IrVariable) {
+    fun putVariable(firVariable: FirVariable, irVariable: IrVariable) {
         variableCache[firVariable] = irVariable
     }
 
-    fun getLocalFunction(localFunction: FirFunction<*>): IrSimpleFunction? = localFunctionCache[localFunction]
+    fun getLocalFunction(localFunction: FirFunction): IrSimpleFunction? = localFunctionCache[localFunction]
 
-    fun putLocalFunction(localFunction: FirFunction<*>, irFunction: IrSimpleFunction) {
+    fun putLocalFunction(localFunction: FirFunction, irFunction: IrSimpleFunction) {
         require(localFunction !is FirSimpleFunction || localFunction.visibility == Visibilities.Local)
         localFunctionCache[localFunction] = irFunction
     }

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

@@ -90,7 +90,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

@@ -12,7 +12,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
@@ -28,9 +28,9 @@ sealed class FirMetadataSource : MetadataSource {
 
     class File(override val fir: FirFile) : FirMetadataSource(), MetadataSource.File
 
-    class Class(override val fir: FirClass<*>) : FirMetadataSource(), MetadataSource.Class
+    class Class(override val fir: FirClass) : FirMetadataSource(), MetadataSource.Class
 
-    class Function(override val fir: FirFunction<*>) : FirMetadataSource(), MetadataSource.Function
+    class Function(override val fir: FirFunction) : FirMetadataSource(), MetadataSource.Function
 
     class Property(override val fir: FirProperty) : FirMetadataSource(), MetadataSource.Property {
         override val isConst: Boolean get() = fir.isConst

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

@@ -11,7 +11,9 @@ 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.declarations.FirFunction
+import org.jetbrains.kotlin.fir.declarations.FirStatusOwner
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
@@ -170,7 +172,7 @@ internal class AdapterGenerator(
         callableReferenceAccess: FirCallableReferenceAccess,
         startOffset: Int,
         endOffset: Int,
-        firAdaptee: FirFunction<*>,
+        firAdaptee: FirFunction,
         adaptee: IrFunction,
         type: IrSimpleType,
         boundDispatchReceiver: IrExpression?,
@@ -260,7 +262,7 @@ internal class AdapterGenerator(
 
     private fun createAdapteeCallForCallableReference(
         callableReferenceAccess: FirCallableReferenceAccess,
-        firAdaptee: FirFunction<*>,
+        firAdaptee: FirFunction,
         adapteeSymbol: IrFunctionSymbol,
         adapterFunction: IrFunction,
         boundDispatchReceiver: IrExpression?,

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

@@ -39,7 +39,9 @@ import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.symbols.*
 import org.jetbrains.kotlin.ir.symbols.impl.IrFieldSymbolImpl
 import org.jetbrains.kotlin.ir.types.*
-import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.ir.util.isFunctionTypeOrSubtype
+import org.jetbrains.kotlin.ir.util.isInterface
+import org.jetbrains.kotlin.ir.util.render
 import org.jetbrains.kotlin.psi2ir.generators.hasNoSideEffects
 import org.jetbrains.kotlin.types.AbstractTypeChecker
 
@@ -388,7 +390,7 @@ class CallAndReferenceGenerator(
                         this.declarationStorage.getIrConstructorSymbol(it)
                     } ?: run {
                         // Fallback for FirReferencePlaceholderForResolvedAnnotations from jar
-                        val fir = coneType.lookupTag.toSymbol(session)?.fir as? FirClass<*>
+                        val fir = coneType.lookupTag.toSymbol(session)?.fir as? FirClass
                         var constructorSymbol: FirConstructorSymbol? = null
                         fir?.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = true)?.processDeclaredConstructors {
                             if (it.fir.isPrimary && constructorSymbol == null) {
@@ -463,7 +465,7 @@ class CallAndReferenceGenerator(
         }
     }
 
-    private fun FirFunctionCall.buildSubstitutorByCalledFunction(function: FirFunction<*>?): ConeSubstitutor? {
+    private fun FirFunctionCall.buildSubstitutorByCalledFunction(function: FirFunction?): ConeSubstitutor? {
         if (function == null) return null
         val map = mutableMapOf<FirTypeParameterSymbol, ConeKotlinType>()
         for ((index, typeParameter) in function.typeParameters.withIndex()) {

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

@@ -45,7 +45,7 @@ internal class ClassMemberGenerator(
 
     private fun <T : IrDeclaration> applyParentFromStackTo(declaration: T): T = conversionScope.applyParentFromStackTo(declaration)
 
-    fun convertClassContent(irClass: IrClass, klass: FirClass<*>) {
+    fun convertClassContent(irClass: IrClass, klass: FirClass) {
         declarationStorage.enterScope(irClass)
         conversionScope.withClass(irClass) {
             val primaryConstructor = klass.primaryConstructor
@@ -82,7 +82,7 @@ internal class ClassMemberGenerator(
         declarationStorage.leaveScope(irClass)
     }
 
-    fun <T : IrFunction> convertFunctionContent(irFunction: T, firFunction: FirFunction<*>?, containingClass: FirClass<*>?): T {
+    fun <T : IrFunction> convertFunctionContent(irFunction: T, firFunction: FirFunction?, containingClass: FirClass?): T {
         conversionScope.withParent(irFunction) {
             if (firFunction != null) {
                 if (irFunction !is IrConstructor || !irFunction.isPrimary) {
@@ -155,7 +155,7 @@ internal class ClassMemberGenerator(
         return irFunction
     }
 
-    fun convertPropertyContent(irProperty: IrProperty, property: FirProperty, containingClass: FirClass<*>?): IrProperty {
+    fun convertPropertyContent(irProperty: IrProperty, property: FirProperty, containingClass: FirClass?): IrProperty {
         val initializer = property.initializer
         val delegate = property.delegate
         val propertyType = property.returnTypeRef.toIrType()
@@ -229,7 +229,7 @@ internal class ClassMemberGenerator(
         propertyType: IrType,
         isDefault: Boolean,
         isGetter: Boolean,
-        containingClass: FirClass<*>?
+        containingClass: FirClass?
     ) {
         conversionScope.withFunction(this) {
             applyParentFromStackTo(this)

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

@@ -62,10 +62,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) =
@@ -179,14 +179,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/DelegatedMemberGenerator.kt

@@ -5,19 +5,26 @@
 
 package org.jetbrains.kotlin.fir.backend.generators
 
-import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
-import org.jetbrains.kotlin.fir.backend.*
+import org.jetbrains.kotlin.fir.backend.generateOverriddenAccessorSymbols
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.backend.generateOverriddenFunctionSymbols
+import org.jetbrains.kotlin.fir.backend.generateOverriddenPropertySymbols
+import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirField
+import org.jetbrains.kotlin.fir.declarations.FirProperty
+import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
+import org.jetbrains.kotlin.fir.isJavaDefault
 import org.jetbrains.kotlin.fir.scopes.*
 import org.jetbrains.kotlin.fir.scopes.impl.unwrapDelegateTarget
-import org.jetbrains.kotlin.fir.symbols.impl.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrBlockBody
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrGetFieldImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrReturnImpl
-import org.jetbrains.kotlin.ir.types.*
+import org.jetbrains.kotlin.ir.types.isNothing
+import org.jetbrains.kotlin.ir.types.isUnit
 
 /**
  * A generator for delegated members from implementation by delegation.
@@ -31,7 +38,7 @@ internal class DelegatedMemberGenerator(
 ) : Fir2IrComponents by components {
 
     // Generate delegated members for [subClass]. The synthetic field [irField] has the super interface type.
-    fun generate(irField: IrField, firField: FirField, firSubClass: FirClass<*>, subClass: IrClass) {
+    fun generate(irField: IrField, firField: FirField, firSubClass: FirClass, subClass: IrClass) {
         val subClassLookupTag = firSubClass.symbol.toLookupTag()
 
         val subClassScope = firSubClass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = true)
@@ -79,7 +86,7 @@ internal class DelegatedMemberGenerator(
 
     private fun generateDelegatedFunction(
         subClass: IrClass,
-        firSubClass: FirClass<*>,
+        firSubClass: FirClass,
         irField: IrField,
         superFunction: IrSimpleFunction,
         delegateOverride: FirSimpleFunction
@@ -151,7 +158,7 @@ internal class DelegatedMemberGenerator(
 
     private fun generateDelegatedProperty(
         subClass: IrClass,
-        firSubClass: FirClass<*>,
+        firSubClass: FirClass,
         irField: IrField,
         superProperty: IrProperty,
         firDelegateProperty: FirProperty

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

@@ -7,7 +7,10 @@ package org.jetbrains.kotlin.fir.backend.generators
 
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.*
-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.Fir2IrDeclarationStorage
+import org.jetbrains.kotlin.fir.backend.unwrapSubstitutionAndIntersectionOverrides
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.allowsToHaveFakeOverride
 import org.jetbrains.kotlin.fir.declarations.utils.isExpect
@@ -15,9 +18,12 @@ import org.jetbrains.kotlin.fir.declarations.utils.isLocal
 import org.jetbrains.kotlin.fir.declarations.utils.visibility
 import org.jetbrains.kotlin.fir.resolve.defaultType
 import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.fir.scopes.*
+import org.jetbrains.kotlin.fir.scopes.FirTypeScope
+import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenFunctions
+import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenProperties
 import org.jetbrains.kotlin.fir.scopes.impl.FirFakeOverrideGenerator
 import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData
+import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
@@ -49,7 +55,7 @@ class FakeOverrideGenerator(
         return conversionScope.withProperty(this, firProperty = null, f)
     }
 
-    private fun FirCallableMemberDeclaration<*>.allowsToHaveFakeOverrideIn(klass: FirClass<*>): Boolean {
+    private fun FirCallableMemberDeclaration.allowsToHaveFakeOverrideIn(klass: FirClass): Boolean {
         if (!allowsToHaveFakeOverride) return false
         if (this.visibility != JavaDescriptorVisibilities.PACKAGE_VISIBILITY) return true
         return this.symbol.callableId.packageName == klass.symbol.classId.packageFqName
@@ -63,18 +69,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.mapTo(mutableSetOf(), FirDeclaration<*>::symbol)
+        val realDeclarationSymbols = realDeclarations.mapTo(mutableSetOf(), FirDeclaration::symbol)
 
         for (name in superTypesCallableNames) {
             generateFakeOverridesForName(this, useSiteMemberScope, name, klass, result, realDeclarationSymbols)
@@ -86,7 +92,7 @@ class FakeOverrideGenerator(
     fun generateFakeOverridesForName(
         irClass: IrClass,
         name: Name,
-        firClass: FirClass<*>
+        firClass: FirClass
     ): List<IrDeclaration> = buildList {
         val useSiteMemberScope = firClass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = true)
         generateFakeOverridesForName(
@@ -100,7 +106,7 @@ class FakeOverrideGenerator(
         irClass: IrClass,
         useSiteMemberScope: FirTypeScope,
         name: Name,
-        firClass: FirClass<*>,
+        firClass: FirClass,
         result: MutableList<IrDeclaration>,
         realDeclarationSymbols: Set<FirBasedSymbol<*>>
     ) {
@@ -156,7 +162,7 @@ class FakeOverrideGenerator(
     }
 
     internal fun calcBaseSymbolsForFakeOverrideFunction(
-        klass: FirClass<*>,
+        klass: FirClass,
         fakeOverride: IrSimpleFunction,
         originalSymbol: FirNamedFunctionSymbol,
     ) {
@@ -174,8 +180,8 @@ class FakeOverrideGenerator(
     private fun FirCallableSymbol<*>.shouldHaveComputedBaseSymbolsForClass(classLookupTag: ConeClassLikeLookupTag): Boolean =
         fir.origin.fromSupertypes && dispatchReceiverClassOrNull() == classLookupTag
 
-    private inline fun <reified D : FirCallableMemberDeclaration<D>, reified S : FirCallableSymbol<D>, reified I : IrDeclaration> createFakeOverriddenIfNeeded(
+    private inline fun <reified D : FirCallableMemberDeclaration, reified S : FirCallableSymbol<D>, reified I : IrDeclaration> createFakeOverriddenIfNeeded(
-        klass: FirClass<*>,
+        klass: FirClass,
         irClass: IrClass,
         isLocal: Boolean,
         originalSymbol: FirCallableSymbol<*>,
@@ -312,7 +318,7 @@ class FakeOverrideGenerator(
         irProducer: (F) -> S
     ): List<S> {
         val overriddenContainingClass =
-            overridden.containingClass()?.toSymbol(session)?.fir as? FirClass<*> ?: return emptyList()
+            overridden.containingClass()?.toSymbol(session)?.fir as? FirClass ?: return emptyList()
 
         val overriddenContainingIrClass =
             declarationStorage.classifierStorage.getIrClassSymbol(overriddenContainingClass.symbol).owner as? IrClass

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

@@ -10,7 +10,8 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
 import org.jetbrains.kotlin.fir.backend.declareThisReceiverParameter
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirCallableMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.hasAnnotation
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.symbols.Fir2IrSimpleFunctionSymbol
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
@@ -28,7 +29,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 : FirCallableMemberDeclaration<*>>(
+abstract class AbstractFir2IrLazyFunction<F : FirCallableMemberDeclaration>(
     components: Fir2IrComponents,
     override val startOffset: Int,
     override val endOffset: Int,
@@ -86,7 +87,7 @@ abstract class AbstractFir2IrLazyFunction<F : FirCallableMemberDeclaration<*>>(
 
     protected fun shouldHaveDispatchReceiver(
         containingClass: IrClass,
-        staticOwner: FirCallableMemberDeclaration<*>
+        staticOwner: FirCallableMemberDeclaration
     ): Boolean {
         return !staticOwner.isStatic &&
                 (!containingClass.isObject || containingClass.isCompanion || !staticOwner.hasAnnotation(JVM_STATIC_CLASS_ID))

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

@@ -9,7 +9,10 @@ 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.FirCallableMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirProperty
+import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.utils.isInline
 import org.jetbrains.kotlin.fir.symbols.Fir2IrSimpleFunctionSymbol
@@ -35,12 +38,12 @@ class Fir2IrLazyPropertyAccessor(
     firParentClass: FirRegularClass,
     symbol: Fir2IrSimpleFunctionSymbol,
     isFakeOverride: Boolean
-) : AbstractFir2IrLazyFunction<FirCallableMemberDeclaration<*>>(components, startOffset, endOffset, origin, symbol, isFakeOverride) {
+) : AbstractFir2IrLazyFunction<FirCallableMemberDeclaration>(components, startOffset, endOffset, origin, symbol, isFakeOverride) {
     init {
         symbol.bind(this)
     }
 
-    override val fir: FirCallableMemberDeclaration<*>
+    override val fir: FirCallableMemberDeclaration
         get() = firAccessor ?: firParentProperty
 
     // TODO: investigate why some deserialized properties are inline

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

@@ -5,11 +5,18 @@
 
 package org.jetbrains.kotlin.fir.lazy
 
-import org.jetbrains.kotlin.fir.backend.*
+import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.backend.generateOverriddenFunctionSymbols
+import org.jetbrains.kotlin.fir.backend.toIrType
+import org.jetbrains.kotlin.fir.declarations.FirFunction
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.initialSignatureAttr
 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
@@ -79,7 +86,7 @@ class Fir2IrLazySimpleFunction(
     }
 
     override val initialSignatureFunction: IrFunction? by lazy {
-        (fir.initialSignatureAttr as? FirFunction<*>)?.symbol?.let { declarationStorage.getIrFunctionSymbol(it).owner }
+        (fir.initialSignatureAttr as? FirFunction)?.symbol?.let { declarationStorage.getIrFunctionSymbol(it).owner }
     }
 
     override val containerSource: DeserializedContainerSource?

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

@@ -59,10 +59,10 @@ 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<*>) {
+        if (declaration is FirCallableMemberDeclaration) {
             if (declaration.visibility == Visibilities.Local) return null
             if (declaration.dispatchReceiverClassOrNull()?.classId?.isLocal == true || containingClass?.classId?.isLocal == true) return null
         }
@@ -87,7 +87,7 @@ class FirBasedSignatureComposer(private val mangler: FirMangler) : Fir2IrSignatu
                     classId.packageFqName.asString(), classId.relativeClassName.asString(), builder.hashId, builder.mask
                 )
             }
-            is FirCallableMemberDeclaration<*> -> {
+            is FirCallableMemberDeclaration -> {
                 if (declaration.visibility == Visibilities.Private) return null
                 val containingClassId = containingClass?.classId
 

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/JavaScopeProvider.kt

@@ -7,24 +7,28 @@ package org.jetbrains.kotlin.fir.java
 
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.utils.classId
 import org.jetbrains.kotlin.fir.declarations.utils.isJava
 import org.jetbrains.kotlin.fir.declarations.utils.superConeTypes
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
 import org.jetbrains.kotlin.fir.java.scopes.*
 import org.jetbrains.kotlin.fir.resolve.*
-import org.jetbrains.kotlin.fir.scopes.*
+import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
+import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.scopes.impl.*
-import org.jetbrains.kotlin.name.StandardClassIds
+import org.jetbrains.kotlin.fir.scopes.scopeForSupertype
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
+import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.utils.DFS
 
 class JavaScopeProvider(
     val symbolProvider: JavaSymbolProvider
 ) : FirScopeProvider() {
     override fun getUseSiteMemberScope(
-        klass: FirClass<*>,
+        klass: FirClass,
         useSiteSession: FirSession,
         scopeSession: ScopeSession
     ): FirTypeScope {
@@ -106,7 +110,7 @@ class JavaScopeProvider(
     }
 
     override fun getStaticMemberScopeForCallables(
-        klass: FirClass<*>,
+        klass: FirClass,
         useSiteSession: FirSession,
         scopeSession: ScopeSession
     ): FirScope? {
@@ -115,7 +119,7 @@ class JavaScopeProvider(
     }
 
     private fun getStaticMemberScopeForCallables(
-        klass: FirClass<*>,
+        klass: FirClass,
         useSiteSession: FirSession,
         scopeSession: ScopeSession,
         visitedClasses: MutableSet<FirRegularClass>
@@ -190,7 +194,7 @@ class JavaScopeProvider(
         return result
     }
 
-    override fun getNestedClassifierScope(klass: FirClass<*>, useSiteSession: FirSession, scopeSession: ScopeSession): FirScope? {
+    override fun getNestedClassifierScope(klass: FirClass, useSiteSession: FirSession, scopeSession: ScopeSession): FirScope? {
         return lazyNestedClassifierScope(
             klass.classId,
             (klass as FirJavaClass).existingNestedClassifierNames,