[FIR] Squash AbstractFirBasedSymbol with FirBasedSymbol

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

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.PrivateForInline
 import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.model.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.lexer.KtKeywordToken
@@ -405,13 +405,13 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
             parameter<Collection<Symbol>>("candidates")
         }
         val ITERATOR_AMBIGUITY by error<PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
-            parameter<Collection<AbstractFirBasedSymbol<*>>>("candidates")
+            parameter<Collection<FirBasedSymbol<*>>>("candidates")
         }
         val HAS_NEXT_FUNCTION_AMBIGUITY by error<PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
-            parameter<Collection<AbstractFirBasedSymbol<*>>>("candidates")
+            parameter<Collection<FirBasedSymbol<*>>>("candidates")
         }
         val NEXT_AMBIGUITY by error<PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
-            parameter<Collection<AbstractFirBasedSymbol<*>>>("candidates")
+            parameter<Collection<FirBasedSymbol<*>>>("candidates")
         }
     }
 
@@ -893,10 +893,10 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
         val HAS_NEXT_MISSING by error<KtExpression>()
         val NEXT_MISSING by error<KtExpression>()
         val HAS_NEXT_FUNCTION_NONE_APPLICABLE by error<KtExpression> {
-            parameter<Collection<AbstractFirBasedSymbol<*>>>("candidates")
+            parameter<Collection<FirBasedSymbol<*>>>("candidates")
         }
         val NEXT_NONE_APPLICABLE by error<KtExpression> {
-            parameter<Collection<AbstractFirBasedSymbol<*>>>("candidates")
+            parameter<Collection<FirBasedSymbol<*>>>("candidates")
         }
         val DELEGATE_SPECIAL_FUNCTION_MISSING by error<KtExpression> {
             parameter<String>("expectedFunctionSignature")
@@ -905,11 +905,11 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
         }
         val DELEGATE_SPECIAL_FUNCTION_AMBIGUITY by error<KtExpression> {
             parameter<String>("expectedFunctionSignature")
-            parameter<Collection<AbstractFirBasedSymbol<*>>>("candidates")
+            parameter<Collection<FirBasedSymbol<*>>>("candidates")
         }
         val DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE by error<KtExpression> {
             parameter<String>("expectedFunctionSignature")
-            parameter<Collection<AbstractFirBasedSymbol<*>>>("candidates")
+            parameter<Collection<FirBasedSymbol<*>>>("candidates")
         }
         val DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH by error<KtExpression> {
             parameter<String>("delegateFunction")
@@ -1048,4 +1048,4 @@ private inline fun <reified P : PsiElement> AbstractDiagnosticGroup.exposedVisib
     return warning<P>(positioningStrategy, exposedVisibilityDiagnosticInit)
 }
 
-typealias Symbol = AbstractFirBasedSymbol<*>
+typealias Symbol = FirBasedSymbol<*>

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

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
@@ -108,7 +108,7 @@ object FirErrors {
     val VAL_OR_VAR_ON_SECONDARY_CONSTRUCTOR_PARAMETER by warning1<KtParameter, KtKeywordToken>(SourceElementPositioningStrategies.VAL_OR_VAR_NODE)
 
     // Unresolved
-    val INVISIBLE_REFERENCE by error1<PsiElement, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val INVISIBLE_REFERENCE by error1<PsiElement, FirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
     val UNRESOLVED_REFERENCE by error1<PsiElement, String>(SourceElementPositioningStrategies.REFERENCED_NAME_BY_QUALIFIED)
     val UNRESOLVED_LABEL by error0<PsiElement>()
     val DESERIALIZATION_ERROR by error0<PsiElement>()
@@ -257,8 +257,8 @@ object FirErrors {
     val VALUE_CLASS_CANNOT_BE_CLONEABLE by error0<KtDeclaration>(SourceElementPositioningStrategies.INLINE_OR_VALUE_MODIFIER)
 
     // Applicability
-    val NONE_APPLICABLE by error1<PsiElement, Collection<AbstractFirBasedSymbol<*>>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val NONE_APPLICABLE by error1<PsiElement, Collection<FirBasedSymbol<*>>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
-    val INAPPLICABLE_CANDIDATE by error1<PsiElement, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val INAPPLICABLE_CANDIDATE by error1<PsiElement, FirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
     val TYPE_MISMATCH by error2<PsiElement, ConeKotlinType, ConeKotlinType>()
     val THROWABLE_TYPE_MISMATCH by error1<PsiElement, ConeKotlinType>()
     val CONDITION_TYPE_MISMATCH by error1<PsiElement, ConeKotlinType>()
@@ -278,11 +278,11 @@ object FirErrors {
     val NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER by error1<KtElement, String>()
 
     // Ambiguity
-    val OVERLOAD_RESOLUTION_AMBIGUITY by error1<PsiElement, Collection<AbstractFirBasedSymbol<*>>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val OVERLOAD_RESOLUTION_AMBIGUITY by error1<PsiElement, Collection<FirBasedSymbol<*>>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
-    val ASSIGN_OPERATOR_AMBIGUITY by error1<PsiElement, Collection<AbstractFirBasedSymbol<*>>>()
+    val ASSIGN_OPERATOR_AMBIGUITY by error1<PsiElement, Collection<FirBasedSymbol<*>>>()
-    val ITERATOR_AMBIGUITY by error1<PsiElement, Collection<AbstractFirBasedSymbol<*>>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val ITERATOR_AMBIGUITY by error1<PsiElement, Collection<FirBasedSymbol<*>>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
-    val HAS_NEXT_FUNCTION_AMBIGUITY by error1<PsiElement, Collection<AbstractFirBasedSymbol<*>>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val HAS_NEXT_FUNCTION_AMBIGUITY by error1<PsiElement, Collection<FirBasedSymbol<*>>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
-    val NEXT_AMBIGUITY by error1<PsiElement, Collection<AbstractFirBasedSymbol<*>>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val NEXT_AMBIGUITY by error1<PsiElement, Collection<FirBasedSymbol<*>>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
 
     // Types & type parameters
     val RECURSION_IN_IMPLICIT_TYPES by error0<PsiElement>()
@@ -360,8 +360,8 @@ object FirErrors {
 
     // Redeclarations
     val MANY_COMPANION_OBJECTS by error0<KtObjectDeclaration>(SourceElementPositioningStrategies.COMPANION_OBJECT)
-    val CONFLICTING_OVERLOADS by error1<PsiElement, Collection<AbstractFirBasedSymbol<*>>>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE_OR_DEFAULT)
+    val CONFLICTING_OVERLOADS by error1<PsiElement, Collection<FirBasedSymbol<*>>>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE_OR_DEFAULT)
-    val REDECLARATION by error1<PsiElement, Collection<AbstractFirBasedSymbol<*>>>()
+    val REDECLARATION by error1<PsiElement, Collection<FirBasedSymbol<*>>>()
     val METHOD_OF_ANY_IMPLEMENTED_IN_INTERFACE by error0<PsiElement>()
 
     // Invalid local declarations
@@ -435,7 +435,7 @@ object FirErrors {
     // Destructuring declaration
     val INITIALIZER_REQUIRED_FOR_DESTRUCTURING_DECLARATION by error0<KtDestructuringDeclaration>()
     val COMPONENT_FUNCTION_MISSING by error2<PsiElement, Name, ConeKotlinType>()
-    val COMPONENT_FUNCTION_AMBIGUITY by error2<PsiElement, Name, Collection<AbstractFirBasedSymbol<*>>>()
+    val COMPONENT_FUNCTION_AMBIGUITY by error2<PsiElement, Name, Collection<FirBasedSymbol<*>>>()
     val COMPONENT_FUNCTION_ON_NULLABLE by error1<KtExpression, Name>()
     val COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH by error3<KtExpression, Name, ConeKotlinType, ConeKotlinType>()
 
@@ -449,8 +449,8 @@ object FirErrors {
     val VAL_REASSIGNMENT_VIA_BACKING_FIELD_ERROR by error1<KtExpression, FirPropertySymbol>()
     val CAPTURED_VAL_INITIALIZATION by error1<KtExpression, FirPropertySymbol>()
     val CAPTURED_MEMBER_VAL_INITIALIZATION by error1<KtExpression, FirPropertySymbol>()
-    val WRONG_INVOCATION_KIND by warning3<PsiElement, AbstractFirBasedSymbol<*>, EventOccurrencesRange, EventOccurrencesRange>()
+    val WRONG_INVOCATION_KIND by warning3<PsiElement, FirBasedSymbol<*>, EventOccurrencesRange, EventOccurrencesRange>()
-    val LEAKED_IN_PLACE_LAMBDA by error1<PsiElement, AbstractFirBasedSymbol<*>>()
+    val LEAKED_IN_PLACE_LAMBDA by error1<PsiElement, FirBasedSymbol<*>>()
     val WRONG_IMPLIES_CONDITION by warning0<PsiElement>()
 
     // Nullability
@@ -491,11 +491,11 @@ object FirErrors {
     val ITERATOR_MISSING by error0<KtExpression>()
     val HAS_NEXT_MISSING by error0<KtExpression>()
     val NEXT_MISSING by error0<KtExpression>()
-    val HAS_NEXT_FUNCTION_NONE_APPLICABLE by error1<KtExpression, Collection<AbstractFirBasedSymbol<*>>>()
+    val HAS_NEXT_FUNCTION_NONE_APPLICABLE by error1<KtExpression, Collection<FirBasedSymbol<*>>>()
-    val NEXT_NONE_APPLICABLE by error1<KtExpression, Collection<AbstractFirBasedSymbol<*>>>()
+    val NEXT_NONE_APPLICABLE by error1<KtExpression, Collection<FirBasedSymbol<*>>>()
     val DELEGATE_SPECIAL_FUNCTION_MISSING by error3<KtExpression, String, ConeKotlinType, String>()
-    val DELEGATE_SPECIAL_FUNCTION_AMBIGUITY by error2<KtExpression, String, Collection<AbstractFirBasedSymbol<*>>>()
+    val DELEGATE_SPECIAL_FUNCTION_AMBIGUITY by error2<KtExpression, String, Collection<FirBasedSymbol<*>>>()
-    val DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE by error2<KtExpression, String, Collection<AbstractFirBasedSymbol<*>>>()
+    val DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE by error2<KtExpression, String, Collection<FirBasedSymbol<*>>>()
     val DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH by error3<KtExpression, String, ConeKotlinType, ConeKotlinType>()
     val UNDERSCORE_IS_RESERVED by error0<KtElement>(SourceElementPositioningStrategies.RESERVED_UNDERSCORE)
     val UNDERSCORE_USAGE_WITHOUT_BACKTICKS by error0<KtElement>(SourceElementPositioningStrategies.RESERVED_UNDERSCORE)
@@ -531,15 +531,15 @@ object FirErrors {
     val RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY by error0<KtReturnExpression>(SourceElementPositioningStrategies.RETURN_WITH_LABEL)
 
     // Inline
-    val USAGE_IS_NOT_INLINABLE by error1<KtElement, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val USAGE_IS_NOT_INLINABLE by error1<KtElement, FirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
-    val NON_LOCAL_RETURN_NOT_ALLOWED by error1<KtElement, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val NON_LOCAL_RETURN_NOT_ALLOWED by error1<KtElement, FirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
-    val RECURSION_IN_INLINE by error1<KtElement, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val RECURSION_IN_INLINE by error1<KtElement, FirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
-    val NON_PUBLIC_CALL_FROM_PUBLIC_INLINE by error2<KtElement, AbstractFirBasedSymbol<*>, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val NON_PUBLIC_CALL_FROM_PUBLIC_INLINE by error2<KtElement, FirBasedSymbol<*>, FirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
-    val PROTECTED_CONSTRUCTOR_CALL_FROM_PUBLIC_INLINE by error2<KtElement, AbstractFirBasedSymbol<*>, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val PROTECTED_CONSTRUCTOR_CALL_FROM_PUBLIC_INLINE by error2<KtElement, FirBasedSymbol<*>, FirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
-    val PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR by error2<KtElement, AbstractFirBasedSymbol<*>, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR by error2<KtElement, FirBasedSymbol<*>, FirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
-    val PROTECTED_CALL_FROM_PUBLIC_INLINE by warning2<KtElement, AbstractFirBasedSymbol<*>, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val PROTECTED_CALL_FROM_PUBLIC_INLINE by warning2<KtElement, FirBasedSymbol<*>, FirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
-    val PRIVATE_CLASS_MEMBER_FROM_INLINE by error2<KtElement, AbstractFirBasedSymbol<*>, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val PRIVATE_CLASS_MEMBER_FROM_INLINE by error2<KtElement, FirBasedSymbol<*>, FirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
-    val SUPER_CALL_FROM_PUBLIC_INLINE by warning1<KtElement, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val SUPER_CALL_FROM_PUBLIC_INLINE by warning1<KtElement, FirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
 
     // Imports
     val CANNOT_ALL_UNDER_IMPORT_FROM_SINGLETON by error1<KtImportDirective, Name>(SourceElementPositioningStrategies.IMPORT_LAST_NAME)

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

@@ -32,7 +32,6 @@ import org.jetbrains.kotlin.fir.references.FirThisReference
 import org.jetbrains.kotlin.fir.resolve.dfa.cfg.*
 import org.jetbrains.kotlin.fir.resolve.inference.isBuiltinFunctionalType
 import org.jetbrains.kotlin.fir.resolve.isInvoke
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -50,7 +49,7 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() {
         if (function !is FirContractDescriptionOwner) return
         if (function.contractDescription.coneEffects?.any { it is ConeCallsEffectDeclaration } != true) return
 
-        val functionalTypeEffects = mutableMapOf<AbstractFirBasedSymbol<*>, ConeCallsEffectDeclaration>()
+        val functionalTypeEffects = mutableMapOf<FirBasedSymbol<*>, ConeCallsEffectDeclaration>()
 
         function.valueParameters.forEachIndexed { index, parameter ->
             if (parameter.returnTypeRef.isFunctionalTypeRef(session)) {
@@ -66,7 +65,7 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() {
 
         if (functionalTypeEffects.isEmpty()) return
 
-        val leakedSymbols = mutableMapOf<AbstractFirBasedSymbol<*>, MutableList<FirSourceElement>>()
+        val leakedSymbols = mutableMapOf<FirBasedSymbol<*>, MutableList<FirSourceElement>>()
         graph.traverse(
             TraverseDirection.Forward,
             CapturedLambdaFinder(function),
@@ -102,7 +101,7 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() {
 
     private fun investigate(
         info: LambdaInvocationInfo,
-        symbol: AbstractFirBasedSymbol<*>,
+        symbol: FirBasedSymbol<*>,
         requiredRange: EventOccurrencesRange,
         function: FirContractDescriptionOwner,
         reporter: DiagnosticReporter,
@@ -124,8 +123,8 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() {
     }
 
     private class IllegalScopeContext(
-        private val functionalTypeSymbols: Set<AbstractFirBasedSymbol<*>>,
+        private val functionalTypeSymbols: Set<FirBasedSymbol<*>>,
-        private val leakedSymbols: MutableMap<AbstractFirBasedSymbol<*>, MutableList<FirSourceElement>>,
+        private val leakedSymbols: MutableMap<FirBasedSymbol<*>, MutableList<FirSourceElement>>,
     ) {
         private var scopeDepth: Int = 0
         private var illegalScopeDepth: Int? = null
@@ -237,7 +236,7 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() {
     }
 
     private class InvocationDataCollector(
-        val functionalTypeSymbols: Set<AbstractFirBasedSymbol<*>>
+        val functionalTypeSymbols: Set<FirBasedSymbol<*>>
     ) : ControlFlowGraphVisitor<PathAwareLambdaInvocationInfo, Collection<Pair<EdgeLabel, PathAwareLambdaInvocationInfo>>>() {
 
         override fun visitNode(
@@ -334,7 +333,7 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() {
 
     private fun FirExpression?.toQualifiedReference(): FirReference? = (this as? FirQualifiedAccess)?.calleeReference
 
-    private fun referenceToSymbol(reference: FirReference?): AbstractFirBasedSymbol<*>? = when (reference) {
+    private fun referenceToSymbol(reference: FirReference?): FirBasedSymbol<*>? = when (reference) {
         is FirResolvedNamedReference -> reference.resolvedSymbol
         is FirThisReference -> reference.boundSymbol
         else -> null

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

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.fir.resolve.dfa.cfg.BlockExitNode
 import org.jetbrains.kotlin.fir.resolve.dfa.cfg.CFGNode
 import org.jetbrains.kotlin.fir.resolve.dfa.cfg.ControlFlowGraph
 import org.jetbrains.kotlin.fir.resolve.dfa.cfg.JumpNode
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertyAccessorSymbol
 import org.jetbrains.kotlin.fir.typeContext
 import org.jetbrains.kotlin.fir.types.*
@@ -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: AbstractFirBasedSymbol<*>, 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): AbstractFirBasedSymbol<*> {
+    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/declaration/FirConflictsChecker.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.scopes.PACKAGE_MEMBER
 import org.jetbrains.kotlin.fir.scopes.impl.FirPackageMemberScope
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
@@ -28,7 +28,7 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
 
     private class DeclarationInspector : FirDeclarationInspector() {
 
-        val declarationConflictingSymbols: HashMap<FirDeclaration, SmartSet<AbstractFirBasedSymbol<*>>> = hashMapOf()
+        val declarationConflictingSymbols: HashMap<FirDeclaration, SmartSet<FirBasedSymbol<*>>> = hashMapOf()
 
         override fun collectNonFunctionDeclaration(key: String, declaration: FirDeclaration): MutableList<FirDeclaration> =
             super.collectNonFunctionDeclaration(key, declaration).also {
@@ -41,7 +41,7 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
             }
 
         private fun collectLocalConflicts(declaration: FirDeclaration, conflicting: List<FirDeclaration>) {
-            val localConflicts = SmartSet.create<AbstractFirBasedSymbol<*>>()
+            val localConflicts = SmartSet.create<FirBasedSymbol<*>>()
             for (otherDeclaration in conflicting) {
                 if (otherDeclaration is FirSymbolOwner<*>) {
                     if (otherDeclaration != declaration && declaration is FirSymbolOwner<*> &&
@@ -75,7 +75,7 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
             declaration: FirDeclaration,
             declarationPresentation: String,
             containingFile: FirFile,
-            conflictingSymbol: AbstractFirBasedSymbol<*>,
+            conflictingSymbol: FirBasedSymbol<*>,
             conflictingPresentation: String?,
             conflictingFile: FirFile?,
             session: FirSession

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

@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeAmbiguityError
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeInapplicableCandidateError
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedNameError
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.typeContext
 import org.jetbrains.kotlin.fir.types.ConeKotlinErrorType
 import org.jetbrains.kotlin.fir.types.coneType
@@ -65,7 +65,7 @@ object FirDelegatedPropertyChecker : FirPropertyChecker() {
 
                 fun reportInapplicableDiagnostics(
                     candidateApplicability: CandidateApplicability,
-                    candidates: Collection<AbstractFirBasedSymbol<*>>
+                    candidates: Collection<FirBasedSymbol<*>>
                 ) {
                     if (candidateApplicability == CandidateApplicability.INAPPLICABLE_WRONG_RECEIVER) {
                         reporter.reportOn(

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

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.resolve.inference.isBuiltinFunctionalType
 import org.jetbrains.kotlin.fir.resolve.inference.isFunctionalType
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.resolve.transformers.publishedApiEffectiveVisibility
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
@@ -103,7 +103,7 @@ object FirInlineDeclarationChecker : FirMemberDeclarationChecker() {
 
         private fun checkReceiversOfQualifiedAccessExpression(
             qualifiedAccessExpression: FirQualifiedAccessExpression,
-            targetSymbol: AbstractFirBasedSymbol<*>?,
+            targetSymbol: FirBasedSymbol<*>?,
             context: CheckerContext
         ) {
             checkReceiver(qualifiedAccessExpression, qualifiedAccessExpression.dispatchReceiver, targetSymbol, context)
@@ -112,7 +112,7 @@ object FirInlineDeclarationChecker : FirMemberDeclarationChecker() {
 
         private fun checkArgumentsOfCall(
             functionCall: FirFunctionCall,
-            targetSymbol: AbstractFirBasedSymbol<*>?,
+            targetSymbol: FirBasedSymbol<*>?,
             context: CheckerContext
         ) {
             val calledFunction = (targetSymbol as? FirNamedFunctionSymbol)?.fir ?: return
@@ -140,7 +140,7 @@ object FirInlineDeclarationChecker : FirMemberDeclarationChecker() {
         private fun checkReceiver(
             qualifiedAccessExpression: FirQualifiedAccessExpression,
             receiverExpression: FirExpression,
-            targetSymbol: AbstractFirBasedSymbol<*>?,
+            targetSymbol: FirBasedSymbol<*>?,
             context: CheckerContext
         ) {
             val receiverSymbol = receiverExpression.toResolvedCallableSymbol() ?: return
@@ -157,7 +157,7 @@ object FirInlineDeclarationChecker : FirMemberDeclarationChecker() {
             }
         }
 
-        private fun isInvokeOrInlineExtension(targetSymbol: AbstractFirBasedSymbol<*>?): Boolean {
+        private fun isInvokeOrInlineExtension(targetSymbol: FirBasedSymbol<*>?): Boolean {
             if (targetSymbol !is FirNamedFunctionSymbol) return false
             val function = targetSymbol.fir
             if (function.isInline) return true
@@ -167,7 +167,7 @@ object FirInlineDeclarationChecker : FirMemberDeclarationChecker() {
 
         private fun checkQualifiedAccess(
             qualifiedAccess: FirQualifiedAccess,
-            targetSymbol: AbstractFirBasedSymbol<*>?,
+            targetSymbol: FirBasedSymbol<*>?,
             context: CheckerContext
         ) {
             val source = qualifiedAccess.source ?: return
@@ -280,7 +280,7 @@ object FirInlineDeclarationChecker : FirMemberDeclarationChecker() {
             }
         }
 
-        private fun AbstractFirBasedSymbol<*>.isDefinedInInlineFunction(): Boolean {
+        private fun FirBasedSymbol<*>.isDefinedInInlineFunction(): Boolean {
             return when (val fir = this.fir) {
                 is FirAnonymousFunction -> true
                 is FirMemberDeclaration -> fir.isLocalMember
@@ -291,7 +291,7 @@ object FirInlineDeclarationChecker : FirMemberDeclarationChecker() {
         }
 
         private fun checkRecursion(
-            targetSymbol: AbstractFirBasedSymbol<*>,
+            targetSymbol: FirBasedSymbol<*>,
             source: FirSourceElement,
             context: CheckerContext
         ) {

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

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.withSuppressedDiagnostics
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.name.StandardClassIds
@@ -110,7 +110,7 @@ object FirSupertypesChecker : FirClassChecker() {
     }
 
     private fun checkClassCannotBeExtendedDirectly(
-        symbol: AbstractFirBasedSymbol<*>?,
+        symbol: FirBasedSymbol<*>?,
         reporter: DiagnosticReporter,
         superTypeRef: FirTypeRef,
         context: CheckerContext
@@ -139,7 +139,7 @@ object FirSupertypesChecker : FirClassChecker() {
     }
 
     private fun checkExpandedTypeCannotBeInherited(
-        symbol: AbstractFirBasedSymbol<*>?,
+        symbol: FirBasedSymbol<*>?,
         fullyExpandedType: ConeKotlinType,
         reporter: DiagnosticReporter,
         superTypeRef: FirTypeRef,

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

@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.fir.resolve.calls.UnsafeCall
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeAmbiguityError
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeInapplicableCandidateError
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedNameError
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.resolve.calls.tower.isSuccess
 
@@ -93,9 +93,9 @@ object FirForLoopChecker : FirBlockChecker() {
         reporter: DiagnosticReporter,
         reportSource: FirSourceElement?,
         context: CheckerContext,
-        ambiguityFactory: FirDiagnosticFactory1<Collection<AbstractFirBasedSymbol<*>>>,
+        ambiguityFactory: FirDiagnosticFactory1<Collection<FirBasedSymbol<*>>>,
         missingFactory: FirDiagnosticFactory0,
-        noneApplicableFactory: FirDiagnosticFactory1<Collection<AbstractFirBasedSymbol<*>>>? = null,
+        noneApplicableFactory: FirDiagnosticFactory1<Collection<FirBasedSymbol<*>>>? = null,
         unsafeCallFactory: FirDiagnosticFactory0? = null,
     ): Boolean {
         when (val calleeReference = call.calleeReference) {

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

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirRenderer
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.render
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.types.render
 object FirDiagnosticRenderers {
     val NULLABLE_STRING = Renderer<String?> { it ?: "null" }
 
-    val SYMBOL = Renderer { symbol: AbstractFirBasedSymbol<*> ->
+    val SYMBOL = Renderer { symbol: FirBasedSymbol<*> ->
         when (symbol) {
             is FirClassLikeSymbol<*> -> symbol.classId.asString()
             is FirCallableSymbol<*> -> symbol.callableId.toString()
@@ -32,7 +32,7 @@ object FirDiagnosticRenderers {
         }
     }
 
-    val SYMBOLS = Renderer { symbols: Collection<AbstractFirBasedSymbol<*>> ->
+    val SYMBOLS = Renderer { symbols: Collection<FirBasedSymbol<*>> ->
         symbols.joinToString(prefix = "[", postfix = "]", separator = ", ", limit = 3, truncated = "...") { symbol ->
             SYMBOL.render(symbol)
         }
@@ -97,7 +97,7 @@ object FirDiagnosticRenderers {
         element.render(mode = FirRenderer.RenderMode.WithFqNamesExceptAnnotationAndBody)
     }
 
-    val AMBIGUOUS_CALLS = Renderer { candidates: Collection<AbstractFirBasedSymbol<*>> ->
+    val AMBIGUOUS_CALLS = Renderer { candidates: Collection<FirBasedSymbol<*>> ->
         candidates.joinToString(separator = "\n", prefix = "\n") { symbol ->
             SYMBOL.render(symbol)
         }

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

@@ -28,7 +28,6 @@ import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeInapplicableCandidateErr
 import org.jetbrains.kotlin.fir.resolve.directExpansionType
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
@@ -1631,7 +1630,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
         }
     }
 
-    private fun FlowContent.symbolAnchor(symbol: AbstractFirBasedSymbol<*>, body: FlowContent.() -> Unit) {
+    private fun FlowContent.symbolAnchor(symbol: FirBasedSymbol<*>, body: FlowContent.() -> Unit) {
         span(classes = "declaration") {
             id = linkResolver.symbolSignature(symbol)
             body()

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

@@ -29,7 +29,7 @@ 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.impl.delegatedWrapperData
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.AccessorSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
@@ -140,7 +140,7 @@ fun FirClassifierSymbol<*>.toSymbol(
     }
 }
 
-private fun AbstractFirBasedSymbol<*>.toSymbolForCall(
+private fun FirBasedSymbol<*>.toSymbolForCall(
     session: FirSession,
     classifierStorage: Fir2IrClassifierStorage,
     declarationStorage: Fir2IrDeclarationStorage,

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

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.scopes.*
 import org.jetbrains.kotlin.fir.scopes.impl.FirFakeOverrideGenerator
 import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
@@ -98,7 +98,7 @@ class FakeOverrideGenerator(
         name: Name,
         firClass: FirClass<*>,
         result: MutableList<IrDeclaration>,
-        realDeclarationSymbols: Set<AbstractFirBasedSymbol<*>>
+        realDeclarationSymbols: Set<FirBasedSymbol<*>>
     ) {
         val isLocal = firClass !is FirRegularClass || firClass.isLocal
         useSiteMemberScope.processFunctionsByName(name) { functionSymbol ->
@@ -181,7 +181,7 @@ class FakeOverrideGenerator(
         baseSymbols: MutableMap<I, List<S>>,
         result: MutableList<in I>,
         containsErrorTypes: (I) -> Boolean,
-        realDeclarationSymbols: Set<AbstractFirBasedSymbol<*>>,
+        realDeclarationSymbols: Set<FirBasedSymbol<*>>,
         computeDirectOverridden: FirTypeScope.(S) -> List<S>,
         scope: FirTypeScope,
     ) {

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

@@ -14,13 +14,13 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.getOwnerId
 import org.jetbrains.kotlin.fir.resolve.calls.ReceiverValue
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 
 @NoMutableState
 object FirJavaVisibilityChecker : FirVisibilityChecker() {
     override fun platformVisibilityCheck(
         declarationVisibility: Visibility,
-        symbol: AbstractFirBasedSymbol<*>,
+        symbol: FirBasedSymbol<*>,
         useSiteFile: FirFile,
         containingDeclarations: List<FirDeclaration>,
         dispatchReceiver: ReceiverValue?,

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

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.lookupSuperTypes
 import org.jetbrains.kotlin.fir.resolve.symbolProvider
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
@@ -32,7 +32,7 @@ abstract class FirVisibilityChecker : FirSessionComponent {
     object Default : FirVisibilityChecker() {
         override fun platformVisibilityCheck(
             declarationVisibility: Visibility,
-            symbol: AbstractFirBasedSymbol<*>,
+            symbol: FirBasedSymbol<*>,
             useSiteFile: FirFile,
             containingDeclarations: List<FirDeclaration>,
             dispatchReceiver: ReceiverValue?,
@@ -122,7 +122,7 @@ abstract class FirVisibilityChecker : FirSessionComponent {
 
     protected abstract fun platformVisibilityCheck(
         declarationVisibility: Visibility,
-        symbol: AbstractFirBasedSymbol<*>,
+        symbol: FirBasedSymbol<*>,
         useSiteFile: FirFile,
         containingDeclarations: List<FirDeclaration>,
         dispatchReceiver: ReceiverValue?,
@@ -210,7 +210,7 @@ abstract class FirVisibilityChecker : FirSessionComponent {
         return false
     }
 
-    protected fun AbstractFirBasedSymbol<*>.packageFqName(): FqName {
+    protected fun FirBasedSymbol<*>.packageFqName(): FqName {
         return when (this) {
             is FirClassLikeSymbol<*> -> classId.packageFqName
             is FirCallableSymbol<*> -> callableId.packageName
@@ -222,7 +222,7 @@ abstract class FirVisibilityChecker : FirSessionComponent {
 val FirSession.moduleVisibilityChecker: FirModuleVisibilityChecker? by FirSession.nullableSessionComponentAccessor()
 val FirSession.visibilityChecker: FirVisibilityChecker by FirSession.sessionComponentAccessor()
 
-fun AbstractFirBasedSymbol<*>.getOwnerId(): ClassId? {
+fun FirBasedSymbol<*>.getOwnerId(): ClassId? {
     return when (this) {
         is FirClassLikeSymbol<*> -> {
             val ownerId = classId.outerClassId

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

@@ -220,7 +220,7 @@ fun <T : FirResolvable> BodyResolveComponents.typeFromCallee(access: T): FirReso
     }
 }
 
-private fun BodyResolveComponents.typeFromSymbol(symbol: AbstractFirBasedSymbol<*>, makeNullable: Boolean): FirResolvedTypeRef {
+private fun BodyResolveComponents.typeFromSymbol(symbol: FirBasedSymbol<*>, makeNullable: Boolean): FirResolvedTypeRef {
     return when (symbol) {
         is FirCallableSymbol<*> -> {
             val returnTypeRef = returnTypeCalculator.tryCalculateReturnType(symbol.fir)

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

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents
 import org.jetbrains.kotlin.fir.resolve.inference.PostponedResolvedAtom
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.ConeTypeVariable
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
@@ -77,7 +77,7 @@ data class CallInfo(
 }
 
 class Candidate(
-    val symbol: AbstractFirBasedSymbol<*>,
+    val symbol: FirBasedSymbol<*>,
     val dispatchReceiverValue: ReceiverValue?,
     val extensionReceiverValue: ReceiverValue?,
     val explicitReceiverKind: ExplicitReceiverKind,

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

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.moduleData
 import org.jetbrains.kotlin.fir.returnExpressions
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirErrorFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirErrorPropertySymbol
 import org.jetbrains.kotlin.fir.types.classId
@@ -44,7 +44,7 @@ class CandidateFactory private constructor(
 
     fun createCandidate(
         callInfo: CallInfo,
-        symbol: AbstractFirBasedSymbol<*>,
+        symbol: FirBasedSymbol<*>,
         explicitReceiverKind: ExplicitReceiverKind,
         scope: FirScope?,
         dispatchReceiverValue: ReceiverValue? = null,
@@ -75,7 +75,7 @@ class CandidateFactory private constructor(
     }
 
     fun createErrorCandidate(callInfo: CallInfo, diagnostic: ConeDiagnostic): Candidate {
-        val symbol: AbstractFirBasedSymbol<*> = when (callInfo.callKind) {
+        val symbol: FirBasedSymbol<*> = when (callInfo.callKind) {
             is CallKind.VariableAccess -> createErrorPropertySymbol(diagnostic)
             is CallKind.Function,
             is CallKind.DelegatingConstructorCall,

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

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.FirImplementationDetail
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.name.Name
 
 @OptIn(FirImplementationDetail::class)
@@ -18,7 +18,7 @@ open class FirNamedReferenceWithCandidate(
     name: Name,
     val candidate: Candidate
 ) : FirSimpleNamedReference(source, name, candidate.symbol) {
-    override val candidateSymbol: AbstractFirBasedSymbol<*>
+    override val candidateSymbol: FirBasedSymbol<*>
         get() = candidate.symbol
 
     open val isError: Boolean get() = false

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

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.resolve.smartcastScope
 import org.jetbrains.kotlin.fir.resolvedTypeFromPrototype
 import org.jetbrains.kotlin.fir.scopes.FakeOverrideTypeCalculator
 import org.jetbrains.kotlin.fir.scopes.FirTypeScope
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinErrorType
@@ -65,7 +65,7 @@ class ExpressionReceiverValue(
             ?: type.scope(useSiteSession, scopeSession, FakeOverrideTypeCalculator.DoNothing)
 }
 
-sealed class ImplicitReceiverValue<S : AbstractFirBasedSymbol<*>>(
+sealed class ImplicitReceiverValue<S : FirBasedSymbol<*>>(
     val boundSymbol: S,
     type: ConeKotlinType,
     protected val useSiteSession: FirSession,
@@ -105,7 +105,7 @@ sealed class ImplicitReceiverValue<S : AbstractFirBasedSymbol<*>>(
     }
 }
 
-private fun receiverExpression(symbol: AbstractFirBasedSymbol<*>, type: ConeKotlinType): FirThisReceiverExpression =
+private fun receiverExpression(symbol: FirBasedSymbol<*>, type: ConeKotlinType): FirThisReceiverExpression =
     buildThisReceiverExpression {
         // NB: we can't use `symbol.fir.source` as the source of `this` receiver. For instance, if this is an implicit receiver for a class,
         // the entire class itself will be set as a source. If combined with an implicit type operation, a certain assertion, like null

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/TowerLevelHandler.kt

@@ -7,8 +7,7 @@ package org.jetbrains.kotlin.fir.resolve.calls.tower
 
 import org.jetbrains.kotlin.fir.resolve.calls.*
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
 
@@ -71,9 +70,9 @@ private class TowerScopeLevelProcessor(
     val resultCollector: CandidateCollector,
     val candidateFactory: CandidateFactory,
     val group: TowerGroup
-) : TowerScopeLevel.TowerScopeLevelProcessor<AbstractFirBasedSymbol<*>> {
+) : TowerScopeLevel.TowerScopeLevelProcessor<FirBasedSymbol<*>> {
     override fun consumeCandidate(
-        symbol: AbstractFirBasedSymbol<*>,
+        symbol: FirBasedSymbol<*>,
         dispatchReceiverValue: ReceiverValue?,
         extensionReceiverValue: ReceiverValue?,
         scope: FirScope,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/TowerLevels.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirDefaultStarImportingScope
 import org.jetbrains.kotlin.fir.scopes.impl.importedFromObjectData
 import org.jetbrains.kotlin.fir.scopes.processClassifiersByName
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.types.AbstractTypeChecker
@@ -34,19 +34,19 @@ enum class ProcessResult {
 
 abstract class TowerScopeLevel {
 
-    sealed class Token<out T : AbstractFirBasedSymbol<*>> {
+    sealed class Token<out T : FirBasedSymbol<*>> {
         object Properties : Token<FirVariableSymbol<*>>()
         object Functions : Token<FirFunctionSymbol<*>>()
-        object Objects : Token<AbstractFirBasedSymbol<*>>()
+        object Objects : Token<FirBasedSymbol<*>>()
     }
 
     abstract fun processFunctionsByName(info: CallInfo, processor: TowerScopeLevelProcessor<FirFunctionSymbol<*>>): ProcessResult
 
     abstract fun processPropertiesByName(info: CallInfo, processor: TowerScopeLevelProcessor<FirVariableSymbol<*>>): ProcessResult
 
-    abstract fun processObjectsByName(info: CallInfo, processor: TowerScopeLevelProcessor<AbstractFirBasedSymbol<*>>): ProcessResult
+    abstract fun processObjectsByName(info: CallInfo, processor: TowerScopeLevelProcessor<FirBasedSymbol<*>>): ProcessResult
 
-    interface TowerScopeLevelProcessor<in T : AbstractFirBasedSymbol<*>> {
+    interface TowerScopeLevelProcessor<in T : FirBasedSymbol<*>> {
         fun consumeCandidate(
             symbol: T,
             dispatchReceiverValue: ReceiverValue?,
@@ -79,7 +79,7 @@ class MemberScopeTowerLevel(
     private val implicitExtensionInvokeMode: Boolean = false,
     private val scopeSession: ScopeSession
 ) : SessionBasedTowerLevel(session) {
-    private fun <T : AbstractFirBasedSymbol<*>> processMembers(
+    private fun <T : FirBasedSymbol<*>> processMembers(
         output: TowerScopeLevelProcessor<T>,
         processScopeMembers: FirScope.(processor: (T) -> Unit) -> Unit
     ): ProcessResult {
@@ -169,7 +169,7 @@ class MemberScopeTowerLevel(
 
     override fun processObjectsByName(
         info: CallInfo,
-        processor: TowerScopeLevelProcessor<AbstractFirBasedSymbol<*>>
+        processor: TowerScopeLevelProcessor<FirBasedSymbol<*>>
     ): ProcessResult {
         return ProcessResult.FOUND
     }
@@ -273,7 +273,7 @@ class ScopeTowerLevel(
         return false
     }
 
-    private fun <T : AbstractFirBasedSymbol<*>> consumeCallableCandidate(
+    private fun <T : FirBasedSymbol<*>> consumeCallableCandidate(
         candidate: FirCallableSymbol<*>,
         processor: TowerScopeLevelProcessor<T>
     ) {
@@ -326,7 +326,7 @@ class ScopeTowerLevel(
 
     override fun processObjectsByName(
         info: CallInfo,
-        processor: TowerScopeLevelProcessor<AbstractFirBasedSymbol<*>>
+        processor: TowerScopeLevelProcessor<FirBasedSymbol<*>>
     ): ProcessResult {
         var empty = true
         session.lookupTracker?.recordCallLookup(info, scope.scopeOwnerLookupNames)

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

@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.types.*
@@ -175,7 +175,7 @@ abstract class FirDataFlowAnalyzer<FLOW : Flow>(
          * DataFlowAnalyzer holds variables only for declarations that have some smartcast (or can have)
          * If there is no useful information there is no data flow variable also
          */
-        val symbol: AbstractFirBasedSymbol<*> = qualifiedAccessExpression.symbol ?: return null
+        val symbol: FirBasedSymbol<*> = qualifiedAccessExpression.symbol ?: return null
         val flow = graphBuilder.lastNode.flow
         var variable = variableStorage.getRealVariableWithoutUnwrappingAlias(symbol, qualifiedAccessExpression, flow) ?: return null
         val stability = variable.stability

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

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.FirThisReference
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.coneTypeSafe
@@ -38,7 +38,7 @@ class VariableStorage(private val session: FirSession) {
 
     fun getOrCreateRealVariableWithoutUnwrappingAlias(
         flow: Flow,
-        symbol: AbstractFirBasedSymbol<*>,
+        symbol: FirBasedSymbol<*>,
         fir: FirElement,
         stability: PropertyStability
     ): RealVariable {
@@ -49,7 +49,7 @@ class VariableStorage(private val session: FirSession) {
 
     private fun getOrCreateRealVariable(
         flow: Flow,
-        symbol: AbstractFirBasedSymbol<*>,
+        symbol: FirBasedSymbol<*>,
         fir: FirElement,
         stability: PropertyStability
     ): RealVariable {
@@ -67,7 +67,7 @@ class VariableStorage(private val session: FirSession) {
 
     private fun getIdentifierBySymbol(
         flow: Flow,
-        symbol: AbstractFirBasedSymbol<*>,
+        symbol: FirBasedSymbol<*>,
         fir: FirElement,
     ): Identifier {
         val expression = fir as? FirQualifiedAccess
@@ -109,7 +109,7 @@ class VariableStorage(private val session: FirSession) {
     }
 
     @JvmName("getOrCreateRealVariableOrNull")
-    fun getOrCreateRealVariable(flow: Flow, symbol: AbstractFirBasedSymbol<*>?, fir: FirElement): RealVariable? =
+    fun getOrCreateRealVariable(flow: Flow, symbol: FirBasedSymbol<*>?, fir: FirElement): RealVariable? =
         symbol.getStability(fir)?.let { getOrCreateRealVariable(flow, symbol!!, fir, it) }
 
     fun createSyntheticVariable(fir: FirElement): SyntheticVariable =
@@ -126,14 +126,14 @@ class VariableStorage(private val session: FirSession) {
         }
     }
 
-    fun getRealVariableWithoutUnwrappingAlias(symbol: AbstractFirBasedSymbol<*>?, fir: FirElement, flow: Flow): RealVariable? {
+    fun getRealVariableWithoutUnwrappingAlias(symbol: FirBasedSymbol<*>?, fir: FirElement, flow: Flow): RealVariable? {
         val realFir = fir.unwrapElement()
         return symbol.takeIf { it.getStability(realFir) != null }?.let {
             _realVariables[getIdentifierBySymbol(flow, it, realFir.unwrapElement())]
         }
     }
 
-    fun getRealVariable(symbol: AbstractFirBasedSymbol<*>?, fir: FirElement, flow: Flow): RealVariable? {
+    fun getRealVariable(symbol: FirBasedSymbol<*>?, fir: FirElement, flow: Flow): RealVariable? {
         return getRealVariableWithoutUnwrappingAlias(symbol, fir, flow)?.let { flow.unwrapVariable(it) }
     }
 
@@ -152,7 +152,7 @@ class VariableStorage(private val session: FirSession) {
         }
     }
 
-    fun removeRealVariable(symbol: AbstractFirBasedSymbol<*>) {
+    fun removeRealVariable(symbol: FirBasedSymbol<*>) {
         _realVariables.remove(Identifier(symbol, null, null))
     }
 
@@ -162,7 +162,7 @@ class VariableStorage(private val session: FirSession) {
     }
 
     @OptIn(ExperimentalContracts::class)
-    fun AbstractFirBasedSymbol<*>?.getStability(originalFir: FirElement): PropertyStability? {
+    fun FirBasedSymbol<*>?.getStability(originalFir: FirElement): PropertyStability? {
         contract {
             returnsNotNull() implies (this@getStability != null)
         }

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

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.dfa.*
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.types.isNothing
 import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor
@@ -67,7 +67,7 @@ class ControlFlowGraphBuilder {
     private val exitTargetsForReturn: SymbolBasedNodeStorage<FirFunction<*>, FunctionExitNode> = SymbolBasedNodeStorage()
     private val exitTargetsForTry: Stack<CFGNode<*>> = stackOf()
     private val exitsOfAnonymousFunctions: MutableMap<FirFunctionSymbol<*>, FunctionExitNode> = mutableMapOf()
-    private val enterToLocalClassesMembers: MutableMap<AbstractFirBasedSymbol<*>, CFGNode<*>?> = mutableMapOf()
+    private val enterToLocalClassesMembers: MutableMap<FirBasedSymbol<*>, CFGNode<*>?> = mutableMapOf()
 
     private val postponedLambdas: MutableSet<FirFunctionSymbol<*>> = mutableSetOf()
     private val entersToPostponedAnonymousFunctions: MutableMap<FirFunctionSymbol<*>, PostponedLambdaEnterNode> = mutableMapOf()

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

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.resolve.dfa
 
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassErrorType
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -18,7 +18,7 @@ import kotlin.contracts.contract
 // --------------------------------------- Variables ---------------------------------------
 
 data class Identifier(
-    val symbol: AbstractFirBasedSymbol<*>,
+    val symbol: FirBasedSymbol<*>,
     val dispatchReceiver: DataFlowVariable?,
     val extensionReceiver: DataFlowVariable?
 ) {

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

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.references.FirThisReference
 import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirAccessorSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
@@ -92,7 +92,7 @@ internal val FirExpression.coneType: ConeKotlinType
     get() = typeRef.coneType
 
 @DfaInternals
-internal val FirElement.symbol: AbstractFirBasedSymbol<*>?
+internal val FirElement.symbol: FirBasedSymbol<*>?
     get() = when (this) {
         is FirResolvable -> symbol
         is FirSymbolOwner<*> -> symbol
@@ -105,7 +105,7 @@ internal val FirElement.symbol: AbstractFirBasedSymbol<*>?
     }
 
 @DfaInternals
-internal val FirResolvable.symbol: AbstractFirBasedSymbol<*>?
+internal val FirResolvable.symbol: FirBasedSymbol<*>?
     get() = when (val reference = calleeReference) {
         is FirThisReference -> reference.boundSymbol
         is FirResolvedNamedReference -> reference.resolvedSymbol

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/diagnostics/FirDiagnostics.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.calls.Candidate
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
@@ -45,7 +45,7 @@ class ConeUnresolvedNameError(val name: Name) : ConeUnresolvedError() {
 }
 
 class ConeHiddenCandidateError(
-    val candidateSymbol: AbstractFirBasedSymbol<*>
+    val candidateSymbol: FirBasedSymbol<*>
 ) : ConeDiagnostic() {
     override val reason: String get() = "HIDDEN: ${describeSymbol(candidateSymbol)} is invisible"
 }
@@ -75,7 +75,7 @@ class ConeAmbiguityError(val name: Name, val applicability: CandidateApplicabili
     override val reason: String get() = "Ambiguity: $name, ${candidates.map { describeSymbol(it.symbol) }}"
 }
 
-class ConeOperatorAmbiguityError(val candidates: Collection<AbstractFirBasedSymbol<*>>) : ConeDiagnostic() {
+class ConeOperatorAmbiguityError(val candidates: Collection<FirBasedSymbol<*>>) : ConeDiagnostic() {
     override val reason: String get() = "Operator overload ambiguity. Compatible candidates: ${candidates.map { describeSymbol(it) }}"
 }
 
@@ -137,7 +137,7 @@ class ConeUnsupportedDynamicType() : ConeDiagnostic() {
     override val reason: String get() = "Dynamic types are not supported in this context"
 }
 
-private fun describeSymbol(symbol: AbstractFirBasedSymbol<*>): String {
+private fun describeSymbol(symbol: FirBasedSymbol<*>): String {
     return when (symbol) {
         is FirClassLikeSymbol<*> -> symbol.classId.asString()
         is FirCallableSymbol<*> -> symbol.callableId.toString()

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

@@ -75,7 +75,7 @@ fun FirSymbolProvider.getClassDeclaredPropertySymbols(classId: ClassId, name: Na
     return classMemberScope?.getProperties(name).orEmpty()
 }
 
-inline fun <reified T : AbstractFirBasedSymbol<*>> FirSymbolProvider.getSymbolByTypeRef(typeRef: FirTypeRef): T? {
+inline fun <reified T : FirBasedSymbol<*>> FirSymbolProvider.getSymbolByTypeRef(typeRef: FirTypeRef): T? {
     val lookupTag = typeRef.coneTypeSafe<ConeLookupTagBasedType>()?.lookupTag ?: return null
     return getSymbolByLookupTag(lookupTag) as? T
 }

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

@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.remapArguments
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.writeResultType
 import org.jetbrains.kotlin.fir.scopes.impl.FirIntegerOperatorCall
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.types.*
@@ -225,7 +225,7 @@ class FirCallCompletionResultsWriterTransformer(
         return result
     }
 
-    private val AbstractFirBasedSymbol<*>.isArrayConstructorWithLambda: Boolean
+    private val FirBasedSymbol<*>.isArrayConstructorWithLambda: Boolean
         get() {
             val constructor = (this as? FirConstructorSymbol)?.fir ?: return false
             if (constructor.valueParameters.size != 2) return false

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

@@ -9,10 +9,10 @@ import org.jetbrains.kotlin.fir.FirRenderer
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.render
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 
 object FirPhaseCheckingPhaseManager : FirPhaseManager() {
-    override fun ensureResolved(symbol: AbstractFirBasedSymbol<*>, requiredPhase: FirResolvePhase) {
+    override fun ensureResolved(symbol: FirBasedSymbol<*>, requiredPhase: FirResolvePhase) {
         val fir = symbol.fir as FirDeclaration
         val availablePhase = fir.resolvePhase
         require(availablePhase >= requiredPhase) {

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

@@ -8,11 +8,11 @@ package org.jetbrains.kotlin.fir.resolve.transformers
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSessionComponent
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 
 abstract class FirPhaseManager : FirSessionComponent {
     abstract fun ensureResolved(
-        symbol: AbstractFirBasedSymbol<*>,
+        symbol: FirBasedSymbol<*>,
         requiredPhase: FirResolvePhase = FirResolvePhase.DECLARATIONS
     )
 }

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

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.expressions.impl.FirElseIfTrueCondition
 import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.symbolProvider
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
@@ -306,7 +306,7 @@ private object WhenOnSealedClassExhaustivenessChecker : WhenExhaustivenessChecke
         destination: MutableCollection<WhenMissingCase>
     ) {
         val allSubclasses = subjectType.toSymbol(session)?.collectAllSubclasses(session) ?: return
-        val checkedSubclasses = mutableSetOf<AbstractFirBasedSymbol<*>>()
+        val checkedSubclasses = mutableSetOf<FirBasedSymbol<*>>()
         whenExpression.accept(ConditionChecker, Flags(allSubclasses, checkedSubclasses, session))
         (allSubclasses - checkedSubclasses).mapNotNullTo(destination) {
             when (it) {
@@ -318,8 +318,8 @@ private object WhenOnSealedClassExhaustivenessChecker : WhenExhaustivenessChecke
     }
 
     private class Flags(
-        val allSubclasses: Set<AbstractFirBasedSymbol<*>>,
+        val allSubclasses: Set<FirBasedSymbol<*>>,
-        val checkedSubclasses: MutableSet<AbstractFirBasedSymbol<*>>,
+        val checkedSubclasses: MutableSet<FirBasedSymbol<*>>,
         val session: FirSession
     )
 
@@ -357,7 +357,7 @@ private object WhenOnSealedClassExhaustivenessChecker : WhenExhaustivenessChecke
             processBranch(symbol, isNegated, data)
         }
 
-        private fun processBranch(symbolToCheck: AbstractFirBasedSymbol<*>, isNegated: Boolean, flags: Flags) {
+        private fun processBranch(symbolToCheck: FirBasedSymbol<*>, isNegated: Boolean, flags: Flags) {
             val subclassesOfType = symbolToCheck.collectAllSubclasses(flags.session)
             if (subclassesOfType.none { it in flags.allSubclasses }) {
                 return
@@ -368,11 +368,11 @@ private object WhenOnSealedClassExhaustivenessChecker : WhenExhaustivenessChecke
     }
 
 
-    private fun AbstractFirBasedSymbol<*>.collectAllSubclasses(session: FirSession): Set<AbstractFirBasedSymbol<*>> {
+    private fun FirBasedSymbol<*>.collectAllSubclasses(session: FirSession): Set<FirBasedSymbol<*>> {
-        return mutableSetOf<AbstractFirBasedSymbol<*>>().apply { collectAllSubclassesTo(this, session) }
+        return mutableSetOf<FirBasedSymbol<*>>().apply { collectAllSubclassesTo(this, session) }
     }
 
-    private fun AbstractFirBasedSymbol<*>.collectAllSubclassesTo(destination: MutableSet<AbstractFirBasedSymbol<*>>, session: FirSession) {
+    private fun FirBasedSymbol<*>.collectAllSubclassesTo(destination: MutableSet<FirBasedSymbol<*>>, session: FirSession) {
         if (this !is FirRegularClassSymbol) {
             destination.add(this)
             return

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

@@ -11,13 +11,13 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.coneTypeSafe
 
-fun AbstractFirBasedSymbol<*>.ensureResolved(
+fun FirBasedSymbol<*>.ensureResolved(
     requiredPhase: FirResolvePhase,
     // TODO: Currently, the parameter is unused but it's needed to guarantee that all call-sites are able to supply use-site session
     // TODO: Decide which one session should be used and probably get rid of the parameter if use-site session is not needed
@@ -35,7 +35,7 @@ fun FirSymbolOwner<*>.ensureResolved(
     symbol.ensureResolved(requiredPhase, useSiteSession)
 }
 
-fun AbstractFirBasedSymbol<*>.ensureResolvedForCalls(
+fun FirBasedSymbol<*>.ensureResolvedForCalls(
     useSiteSession: FirSession,
 ) {
     val fir = fir as FirDeclaration

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

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.expressions.builder.buildArgumentList
 import org.jetbrains.kotlin.fir.expressions.builder.buildArrayOfCall
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.types.isArrayType
 
 /**
@@ -68,7 +68,7 @@ internal class FirArrayOfCallTransformer {
 }
 
 private fun FirFunctionCall.getOriginalFunction(): FirCallableDeclaration<*>? {
-    val symbol: AbstractFirBasedSymbol<*>? = when (val reference = calleeReference) {
+    val symbol: FirBasedSymbol<*>? = when (val reference = calleeReference) {
         is FirResolvedNamedReference -> reference.resolvedSymbol
         is FirNamedReferenceWithCandidate -> reference.candidateSymbol
         else -> null

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/FakeOverrideTypeCalculator.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclarationDataRegistry
 import org.jetbrains.kotlin.fir.declarations.FirTypedDeclaration
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolvedTypeFromPrototype
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 
@@ -49,5 +49,5 @@ var FirDeclarationAttributes.fakeOverrideSubstitution: FakeOverrideSubstitution?
 
 data class FakeOverrideSubstitution(
     val substitutor: ConeSubstitutor,
-    val baseSymbol: AbstractFirBasedSymbol<*>
+    val baseSymbol: FirBasedSymbol<*>
 )

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

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.scopes.FirOverrideChecker
 import org.jetbrains.kotlin.fir.scopes.FirTypeScope
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 
 abstract class AbstractFirOverrideScope(
@@ -49,9 +49,9 @@ abstract class AbstractFirOverrideScope(
     protected open fun FirCallableSymbol<*>.getOverridden(overrideCandidates: Set<FirCallableSymbol<*>>): FirCallableSymbol<*>? {
         if (overrideByBase.containsKey(this)) return overrideByBase[this]
 
-        val baseDeclaration = (this as AbstractFirBasedSymbol<*>).fir as FirCallableMemberDeclaration<*>
+        val baseDeclaration = (this as FirBasedSymbol<*>).fir as FirCallableMemberDeclaration<*>
         val override = overrideCandidates.firstOrNull {
-            val overrideCandidate = (it as AbstractFirBasedSymbol<*>).fir as FirCallableMemberDeclaration<*>
+            val overrideCandidate = (it as FirBasedSymbol<*>).fir as FirCallableMemberDeclaration<*>
             baseDeclaration.modality != Modality.FINAL && similarFunctionsOrBothProperties(overrideCandidate, baseDeclaration)
         } // TODO: two or more overrides for one fun?
         overrideByBase[this] = override

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/TypeUtils.kt

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
 import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLookupTagWithFixedSymbol
 import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
@@ -188,7 +188,7 @@ fun ConeKotlinType.isUnsafeVarianceType(session: FirSession): Boolean {
     return type.attributes.unsafeVarianceType != null
 }
 
-fun ConeKotlinType.toSymbol(session: FirSession): AbstractFirBasedSymbol<*>? {
+fun ConeKotlinType.toSymbol(session: FirSession): FirBasedSymbol<*>? {
     return (this as? ConeLookupTagBasedType)?.lookupTag?.toSymbol(session)
 }
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/FirSymbolOwner.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir
 
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.visitors.*
 
 /*
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 
 interface FirSymbolOwner<E> : FirElement where E : FirSymbolOwner<E>, E : FirDeclaration {
     override val source: FirSourceElement?
-    val symbol: AbstractFirBasedSymbol<E>
+    val symbol: FirBasedSymbol<E>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitSymbolOwner(this, data)
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/FirBackingFieldReference.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.references
 
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 abstract class FirBackingFieldReference : FirResolvedNamedReference() {
     abstract override val source: FirSourceElement?
     abstract override val name: Name
-    abstract override val candidateSymbol: AbstractFirBasedSymbol<*>?
+    abstract override val candidateSymbol: FirBasedSymbol<*>?
     abstract override val resolvedSymbol: FirBackingFieldSymbol
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitBackingFieldReference(this, data)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/FirDelegateFieldReference.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.references
 
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirDelegateFieldSymbol
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 abstract class FirDelegateFieldReference : FirResolvedNamedReference() {
     abstract override val source: FirSourceElement?
     abstract override val name: Name
-    abstract override val candidateSymbol: AbstractFirBasedSymbol<*>?
+    abstract override val candidateSymbol: FirBasedSymbol<*>?
     abstract override val resolvedSymbol: FirDelegateFieldSymbol<*>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitDelegateFieldReference(this, data)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/FirErrorNamedReference.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 abstract class FirErrorNamedReference : FirNamedReference(), FirDiagnosticHolder {
     abstract override val source: FirSourceElement?
     abstract override val name: Name
-    abstract override val candidateSymbol: AbstractFirBasedSymbol<*>?
+    abstract override val candidateSymbol: FirBasedSymbol<*>?
     abstract override val diagnostic: ConeDiagnostic
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorNamedReference(this, data)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/FirNamedReference.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.references
 
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 abstract class FirNamedReference : FirReference() {
     abstract override val source: FirSourceElement?
     abstract val name: Name
-    abstract val candidateSymbol: AbstractFirBasedSymbol<*>?
+    abstract val candidateSymbol: FirBasedSymbol<*>?
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitNamedReference(this, data)
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/FirResolvedCallableReference.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.references
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.resolve.calls.CallableReferenceMappedArguments
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
@@ -21,8 +21,8 @@ import org.jetbrains.kotlin.fir.visitors.*
 abstract class FirResolvedCallableReference : FirResolvedNamedReference() {
     abstract override val source: FirSourceElement?
     abstract override val name: Name
-    abstract override val candidateSymbol: AbstractFirBasedSymbol<*>?
+    abstract override val candidateSymbol: FirBasedSymbol<*>?
-    abstract override val resolvedSymbol: AbstractFirBasedSymbol<*>
+    abstract override val resolvedSymbol: FirBasedSymbol<*>
     abstract val inferredTypeArguments: List<ConeKotlinType>
     abstract val mappedArguments: CallableReferenceMappedArguments
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/FirResolvedNamedReference.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.references
 
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -19,8 +19,8 @@ import org.jetbrains.kotlin.fir.visitors.*
 abstract class FirResolvedNamedReference : FirNamedReference() {
     abstract override val source: FirSourceElement?
     abstract override val name: Name
-    abstract override val candidateSymbol: AbstractFirBasedSymbol<*>?
+    abstract override val candidateSymbol: FirBasedSymbol<*>?
-    abstract val resolvedSymbol: AbstractFirBasedSymbol<*>
+    abstract val resolvedSymbol: FirBasedSymbol<*>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitResolvedNamedReference(this, data)
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/FirThisReference.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.references
 
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.visitors.*
 
 /*
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 abstract class FirThisReference : FirReference() {
     abstract override val source: FirSourceElement?
     abstract val labelName: String?
-    abstract val boundSymbol: AbstractFirBasedSymbol<*>?
+    abstract val boundSymbol: FirBasedSymbol<*>?
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitThisReference(this, data)
 
@@ -26,5 +26,5 @@ abstract class FirThisReference : FirReference() {
     override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
         transformer.transformThisReference(this, data) as E
 
-    abstract fun replaceBoundSymbol(newBoundSymbol: AbstractFirBasedSymbol<*>?)
+    abstract fun replaceBoundSymbol(newBoundSymbol: FirBasedSymbol<*>?)
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/builder/FirBackingFieldReferenceBuilder.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.references.FirBackingFieldReference
 import org.jetbrains.kotlin.fir.references.impl.FirBackingFieldReferenceImpl
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol
 import org.jetbrains.kotlin.fir.visitors.*
 import org.jetbrains.kotlin.name.Name
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.name.Name
 @FirBuilderDsl
 class FirBackingFieldReferenceBuilder {
     var source: FirSourceElement? = null
-    var candidateSymbol: AbstractFirBasedSymbol<*>? = null
+    var candidateSymbol: FirBasedSymbol<*>? = null
     lateinit var resolvedSymbol: FirBackingFieldSymbol
 
     fun build(): FirBackingFieldReference {

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/builder/FirDelegateFieldReferenceBuilder.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.references.FirDelegateFieldReference
 import org.jetbrains.kotlin.fir.references.impl.FirDelegateFieldReferenceImpl
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirDelegateFieldSymbol
 import org.jetbrains.kotlin.fir.visitors.*
 import org.jetbrains.kotlin.name.Name
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.name.Name
 @FirBuilderDsl
 class FirDelegateFieldReferenceBuilder {
     var source: FirSourceElement? = null
-    var candidateSymbol: AbstractFirBasedSymbol<*>? = null
+    var candidateSymbol: FirBasedSymbol<*>? = null
     lateinit var resolvedSymbol: FirDelegateFieldSymbol<*>
 
     fun build(): FirDelegateFieldReference {

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/builder/FirErrorNamedReferenceBuilder.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.visitors.*
 import org.jetbrains.kotlin.name.Name
 
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.name.Name
 @FirBuilderDsl
 class FirErrorNamedReferenceBuilder {
     var source: FirSourceElement? = null
-    var candidateSymbol: AbstractFirBasedSymbol<*>? = null
+    var candidateSymbol: FirBasedSymbol<*>? = null
     lateinit var diagnostic: ConeDiagnostic
 
     fun build(): FirErrorNamedReference {

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/builder/FirExplicitThisReferenceBuilder.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.references.FirThisReference
 import org.jetbrains.kotlin.fir.references.impl.FirExplicitThisReference
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.visitors.*
 
 /*

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/builder/FirImplicitThisReferenceBuilder.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.references.FirThisReference
 import org.jetbrains.kotlin.fir.references.impl.FirImplicitThisReference
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.visitors.*
 
 /*
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 
 @FirBuilderDsl
 class FirImplicitThisReferenceBuilder {
-    var boundSymbol: AbstractFirBasedSymbol<*>? = null
+    var boundSymbol: FirBasedSymbol<*>? = null
 
     fun build(): FirThisReference {
         return FirImplicitThisReference(

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/builder/FirPropertyFromParameterResolvedNamedReferenceBuilder.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.references.impl.FirPropertyFromParameterResolvedNamedReference
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.visitors.*
 import org.jetbrains.kotlin.name.Name
 
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.name.Name
 class FirPropertyFromParameterResolvedNamedReferenceBuilder {
     var source: FirSourceElement? = null
     lateinit var name: Name
-    lateinit var resolvedSymbol: AbstractFirBasedSymbol<*>
+    lateinit var resolvedSymbol: FirBasedSymbol<*>
 
     @OptIn(FirImplementationDetail::class)
     fun build(): FirResolvedNamedReference {

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/builder/FirResolvedCallableReferenceBuilder.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.references.FirResolvedCallableReference
 import org.jetbrains.kotlin.fir.references.impl.FirResolvedCallableReferenceImpl
 import org.jetbrains.kotlin.fir.resolve.calls.CallableReferenceMappedArguments
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.visitors.*
 import org.jetbrains.kotlin.name.Name
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.name.Name
 class FirResolvedCallableReferenceBuilder {
     var source: FirSourceElement? = null
     lateinit var name: Name
-    lateinit var resolvedSymbol: AbstractFirBasedSymbol<*>
+    lateinit var resolvedSymbol: FirBasedSymbol<*>
     val inferredTypeArguments: MutableList<ConeKotlinType> = mutableListOf()
     lateinit var mappedArguments: CallableReferenceMappedArguments
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/builder/FirResolvedNamedReferenceBuilder.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.references.impl.FirResolvedNamedReferenceImpl
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.visitors.*
 import org.jetbrains.kotlin.name.Name
 
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.name.Name
 class FirResolvedNamedReferenceBuilder {
     var source: FirSourceElement? = null
     lateinit var name: Name
-    lateinit var resolvedSymbol: AbstractFirBasedSymbol<*>
+    lateinit var resolvedSymbol: FirBasedSymbol<*>
 
     fun build(): FirResolvedNamedReference {
         return FirResolvedNamedReferenceImpl(

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/builder/FirSimpleNamedReferenceBuilder.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.visitors.*
 import org.jetbrains.kotlin.name.Name
 
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.name.Name
 class FirSimpleNamedReferenceBuilder {
     var source: FirSourceElement? = null
     lateinit var name: Name
-    var candidateSymbol: AbstractFirBasedSymbol<*>? = null
+    var candidateSymbol: FirBasedSymbol<*>? = null
 
     @OptIn(FirImplementationDetail::class)
     fun build(): FirNamedReference {

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/impl/FirBackingFieldReferenceImpl.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.references.impl
 
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.references.FirBackingFieldReference
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 
 internal class FirBackingFieldReferenceImpl(
     override val source: FirSourceElement?,
-    override val candidateSymbol: AbstractFirBasedSymbol<*>?,
+    override val candidateSymbol: FirBasedSymbol<*>?,
     override val resolvedSymbol: FirBackingFieldSymbol,
 ) : FirBackingFieldReference() {
     override val name: Name get() = Name.identifier("\$field")

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/impl/FirDelegateFieldReferenceImpl.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.references.impl
 
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.references.FirDelegateFieldReference
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirDelegateFieldSymbol
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 
 internal class FirDelegateFieldReferenceImpl(
     override val source: FirSourceElement?,
-    override val candidateSymbol: AbstractFirBasedSymbol<*>?,
+    override val candidateSymbol: FirBasedSymbol<*>?,
     override val resolvedSymbol: FirDelegateFieldSymbol<*>,
 ) : FirDelegateFieldReference() {
     override val name: Name get() = Name.identifier("\$delegate")

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/impl/FirErrorNamedReferenceImpl.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.references.impl
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 
 internal class FirErrorNamedReferenceImpl(
     override val source: FirSourceElement?,
-    override val candidateSymbol: AbstractFirBasedSymbol<*>?,
+    override val candidateSymbol: FirBasedSymbol<*>?,
     override val diagnostic: ConeDiagnostic,
 ) : FirErrorNamedReference() {
     override val name: Name = Name.special("<${diagnostic.reason}>")

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/impl/FirExplicitThisReference.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.references.impl
 
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.references.FirThisReference
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.visitors.*
 
 /*
@@ -19,7 +19,7 @@ internal class FirExplicitThisReference(
     override val source: FirSourceElement?,
     override val labelName: String?,
 ) : FirThisReference() {
-    override var boundSymbol: AbstractFirBasedSymbol<*>? = null
+    override var boundSymbol: FirBasedSymbol<*>? = null
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
 
@@ -27,7 +27,7 @@ internal class FirExplicitThisReference(
         return this
     }
 
-    override fun replaceBoundSymbol(newBoundSymbol: AbstractFirBasedSymbol<*>?) {
+    override fun replaceBoundSymbol(newBoundSymbol: FirBasedSymbol<*>?) {
         boundSymbol = newBoundSymbol
     }
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/impl/FirImplicitThisReference.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.references.impl
 
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.references.FirThisReference
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.visitors.*
 
 /*
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 internal class FirImplicitThisReference(
-    override val boundSymbol: AbstractFirBasedSymbol<*>?,
+    override val boundSymbol: FirBasedSymbol<*>?,
 ) : FirThisReference() {
     override val source: FirSourceElement? get() = null
     override val labelName: String? get() = null
@@ -27,5 +27,5 @@ internal class FirImplicitThisReference(
         return this
     }
 
-    override fun replaceBoundSymbol(newBoundSymbol: AbstractFirBasedSymbol<*>?) {}
+    override fun replaceBoundSymbol(newBoundSymbol: FirBasedSymbol<*>?) {}
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/impl/FirPropertyFromParameterResolvedNamedReference.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.references.impl
 import org.jetbrains.kotlin.fir.FirImplementationDetail
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -20,9 +20,9 @@ import org.jetbrains.kotlin.fir.visitors.*
 class FirPropertyFromParameterResolvedNamedReference @FirImplementationDetail constructor(
     override val source: FirSourceElement?,
     override val name: Name,
-    override val resolvedSymbol: AbstractFirBasedSymbol<*>,
+    override val resolvedSymbol: FirBasedSymbol<*>,
 ) : FirResolvedNamedReference() {
-    override val candidateSymbol: AbstractFirBasedSymbol<*>? get() = null
+    override val candidateSymbol: FirBasedSymbol<*>? get() = null
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/impl/FirResolvedCallableReferenceImpl.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.references.impl
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.references.FirResolvedCallableReference
 import org.jetbrains.kotlin.fir.resolve.calls.CallableReferenceMappedArguments
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
@@ -21,11 +21,11 @@ import org.jetbrains.kotlin.fir.visitors.*
 internal class FirResolvedCallableReferenceImpl(
     override val source: FirSourceElement?,
     override val name: Name,
-    override val resolvedSymbol: AbstractFirBasedSymbol<*>,
+    override val resolvedSymbol: FirBasedSymbol<*>,
     override val inferredTypeArguments: MutableList<ConeKotlinType>,
     override val mappedArguments: CallableReferenceMappedArguments,
 ) : FirResolvedCallableReference() {
-    override val candidateSymbol: AbstractFirBasedSymbol<*>? get() = null
+    override val candidateSymbol: FirBasedSymbol<*>? get() = null
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/impl/FirResolvedNamedReferenceImpl.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.references.impl
 
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -19,9 +19,9 @@ import org.jetbrains.kotlin.fir.visitors.*
 internal class FirResolvedNamedReferenceImpl(
     override val source: FirSourceElement?,
     override val name: Name,
-    override val resolvedSymbol: AbstractFirBasedSymbol<*>,
+    override val resolvedSymbol: FirBasedSymbol<*>,
 ) : FirResolvedNamedReference() {
-    override val candidateSymbol: AbstractFirBasedSymbol<*>? get() = null
+    override val candidateSymbol: FirBasedSymbol<*>? get() = null
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/impl/FirSimpleNamedReference.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.references.impl
 import org.jetbrains.kotlin.fir.FirImplementationDetail
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.references.FirNamedReference
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 open class FirSimpleNamedReference @FirImplementationDetail constructor(
     override val source: FirSourceElement?,
     override val name: Name,
-    override val candidateSymbol: AbstractFirBasedSymbol<*>?,
+    override val candidateSymbol: FirBasedSymbol<*>?,
 ) : FirNamedReference() {
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.*
 import org.jetbrains.kotlin.fir.references.*
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
@@ -1051,7 +1051,7 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
         print("*")
     }
 
-    private fun AbstractFirBasedSymbol<*>.render(): String {
+    private fun FirBasedSymbol<*>.render(): String {
         return when (this) {
             is FirCallableSymbol<*> -> callableId.toString()
             is FirClassLikeSymbol<*> -> classId.toString()
@@ -1117,7 +1117,7 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
         print("|")
     }
 
-    private fun AbstractFirBasedSymbol<*>.unwrapIntersectionOverrides(): AbstractFirBasedSymbol<*> {
+    private fun FirBasedSymbol<*>.unwrapIntersectionOverrides(): FirBasedSymbol<*> {
         (this as? FirCallableSymbol<*>)?.baseForIntersectionOverride?.let { return it.unwrapIntersectionOverrides() }
         return this
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/AbstractFirBasedSymbol.kt

@@ -1,21 +0,0 @@
-/*
- * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.fir.symbols
-
-import org.jetbrains.kotlin.fir.FirSymbolOwner
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-
-abstract class AbstractFirBasedSymbol<E> : FirBasedSymbol<E> where E : FirSymbolOwner<E>, E : FirDeclaration {
-    private var _fir: E? = null
-
-    override val fir: E
-        get() = _fir
-            ?: error("Fir is not initialized for $this")
-
-    override fun bind(e: E) {
-        _fir = e
-    }
-}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirBasedSymbol.kt

@@ -8,8 +8,14 @@ package org.jetbrains.kotlin.fir.symbols
 import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 
-interface FirBasedSymbol<E> where E : FirSymbolOwner<E>, E : FirDeclaration {
+abstract class FirBasedSymbol<E> where E : FirSymbolOwner<E>, E : FirDeclaration {
-    val fir: E
+    private var _fir: E? = null
 
-    fun bind(e: E)
+    val fir: E
+        get() = _fir
+            ?: error("Fir is not initialized for $this")
+
+    fun bind(e: E) {
+        _fir = e
+    }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirAnonymousInitializerSymbol.kt

@@ -6,8 +6,8 @@
 package org.jetbrains.kotlin.fir.symbols.impl
 
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 
-class FirAnonymousInitializerSymbol : AbstractFirBasedSymbol<FirAnonymousInitializer>() {
+class FirAnonymousInitializerSymbol : FirBasedSymbol<FirAnonymousInitializer>() {
     override fun toString(): String = "${this::class.simpleName} <init>"
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirCallableSymbol.kt

@@ -9,10 +9,10 @@ import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirProperty
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.name.CallableId
 
-abstract class FirCallableSymbol<D : FirCallableDeclaration<D>> : AbstractFirBasedSymbol<D>() {
+abstract class FirCallableSymbol<D : FirCallableDeclaration<D>> : FirBasedSymbol<D>() {
     abstract val callableId: CallableId
 
     override fun toString(): String = "${this::class.simpleName} $callableId"

compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassifierSymbol.kt

@@ -7,10 +7,10 @@ package org.jetbrains.kotlin.fir.symbols.impl
 
 import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeClassifierLookupTag
 
-sealed class FirClassifierSymbol<E> : AbstractFirBasedSymbol<E>()
+sealed class FirClassifierSymbol<E> : FirBasedSymbol<E>()
         where E : FirSymbolOwner<E>, E : FirDeclaration {
     abstract fun toLookupTag(): ConeClassifierLookupTag
 }

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt

@@ -48,7 +48,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
 
         symbolOwner.configure {
             withArg("E", symbolOwner, declaration)
-            +symbolWithPackage("fir.symbols", "AbstractFirBasedSymbol", "E")
+            +symbolWithPackage("fir.symbols", "FirBasedSymbol", "E")
         }
 
         typeParameterRef.configure {
@@ -560,11 +560,11 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
 
         namedReference.configure {
             +name
-            +field("candidateSymbol", abstractFirBasedSymbolType, "*", nullable = true)
+            +field("candidateSymbol", firBasedSymbolType, "*", nullable = true)
         }
 
         resolvedNamedReference.configure {
-            +field("resolvedSymbol", abstractFirBasedSymbolType, "*")
+            +field("resolvedSymbol", firBasedSymbolType, "*")
         }
 
         resolvedCallableReference.configure {
@@ -587,7 +587,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
 
         thisReference.configure {
             +stringField("labelName", nullable = true)
-            +field("boundSymbol", abstractFirBasedSymbolType, "*", nullable = true, withReplace = true)
+            +field("boundSymbol", firBasedSymbolType, "*", nullable = true, withReplace = true)
         }
 
         typeRef.configure {

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt

@@ -63,7 +63,7 @@ val implicitUnitTypeRefType = generatedType("types.impl", "FirImplicitUnitTypeRe
 val resolvePhaseType = type("fir.declarations", "FirResolvePhase")
 val stubReferenceType = generatedType("references.impl", "FirStubReference")
 
-val abstractFirBasedSymbolType = type("fir.symbols", "AbstractFirBasedSymbol")
+val firBasedSymbolType = type("fir.symbols", "FirBasedSymbol")
 val backingFieldSymbolType = type("fir.symbols.impl", "FirBackingFieldSymbol")
 val delegateFieldSymbolType = type("fir.symbols.impl", "FirDelegateFieldSymbol")
 val classSymbolType = type("fir.symbols.impl", "FirClassSymbol")

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticsHandler.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.FirSafeCallExpression
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
@@ -280,7 +280,7 @@ class FirDiagnosticsHandler(testServices: TestServices) : FirAnalysisHandler(tes
 
     private fun getTypeOfCall(
         reference: FirNamedReference,
-        resolvedSymbol: AbstractFirBasedSymbol<*>?
+        resolvedSymbol: FirBasedSymbol<*>?
     ): String {
         if (resolvedSymbol == null) return TypeOfCall.UNRESOLVED.nameToRender
 
@@ -307,7 +307,7 @@ class FirDiagnosticsHandler(testServices: TestServices) : FirAnalysisHandler(tes
         }
     }
 
-    private fun AbstractFirBasedSymbol<*>.fqNameUnsafe(): FqNameUnsafe? = when (this) {
+    private fun FirBasedSymbol<*>.fqNameUnsafe(): FqNameUnsafe? = when (this) {
         is FirClassLikeSymbol<*> -> classId.asSingleFqName().toUnsafe()
         is FirCallableSymbol<*> -> callableId.asFqNameForDebugInfo().toUnsafe()
         else -> null

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirScopeDumpHandler.kt

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.symbolProvider
 import org.jetbrains.kotlin.fir.scopes.*
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.types.render
@@ -66,10 +66,10 @@ class FirScopeDumpHandler(testServices: TestServices) : FirAnalysisHandler(testS
     }
 
     private class SymbolCounter {
-        private val map = mutableMapOf<AbstractFirBasedSymbol<*>, Int>()
+        private val map = mutableMapOf<FirBasedSymbol<*>, Int>()
         private var counter = 0
 
-        fun getIndex(symbol: AbstractFirBasedSymbol<*>): Int {
+        fun getIndex(symbol: FirBasedSymbol<*>): Int {
             return map.computeIfAbsent(symbol) { counter++ }
         }
     }

compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticTest.kt

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.dfa.cfg.FirControlFlowGraphRenderVisitor
 import org.jetbrains.kotlin.fir.resolve.transformers.createAllCompilerResolveProcessors
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
@@ -228,7 +228,7 @@ abstract class AbstractFirDiagnosticsTest : AbstractFirBaseDiagnosticsTest() {
         }
     }
 
-    private fun AbstractFirBasedSymbol<*>.fqNameUnsafe(): FqNameUnsafe? = when (this) {
+    private fun FirBasedSymbol<*>.fqNameUnsafe(): FqNameUnsafe? = when (this) {
         is FirClassLikeSymbol<*> -> classId.asSingleFqName().toUnsafe()
         is FirCallableSymbol<*> -> callableId.asFqNameForDebugInfo().toUnsafe()
         else -> null
@@ -236,7 +236,7 @@ abstract class AbstractFirDiagnosticsTest : AbstractFirBaseDiagnosticsTest() {
 
     private fun getTypeOfCall(
         reference: FirNamedReference,
-        resolvedSymbol: AbstractFirBasedSymbol<*>?
+        resolvedSymbol: FirBasedSymbol<*>?
     ): String {
         if (resolvedSymbol == null) return TypeOfCall.UNRESOLVED.nameToRender
 

compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.references.*
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.firUnsafe
 import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
@@ -465,7 +465,7 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() {
             return current
         }
 
-        private fun renderImplicitReceiver(symbol: AbstractFirBasedSymbol<*>, psi: PsiElement?) {
+        private fun renderImplicitReceiver(symbol: FirBasedSymbol<*>, psi: PsiElement?) {
             val receiverType = (symbol.fir as? FirCallableMemberDeclaration<*>)?.dispatchReceiverType ?: return
             val implicitReceiverIndex = implicitReceivers.indexOf(receiverType)
             if (implicitReceiverIndex != -1) addAnnotation("this@$implicitReceiverIndex", psi)
@@ -837,7 +837,7 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() {
             data.append("(vararg $valueParameter): $name${typeParameters.trim()}") // TODO change "T" to concrete type is array is primitive
         }
 
-        private fun AbstractFirBasedSymbol<*>.isLocalDeclaration(): Boolean {
+        private fun FirBasedSymbol<*>.isLocalDeclaration(): Boolean {
             return when (val fir = this.fir) {
                 is FirConstructor -> fir.returnTypeRef.coneType.isLocal()
                 is FirCallableDeclaration<*> -> {
@@ -853,7 +853,7 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() {
         }
 
         // id == packageName + className
-        private fun getSymbolId(symbol: AbstractFirBasedSymbol<*>?): String {
+        private fun getSymbolId(symbol: FirBasedSymbol<*>?): String {
             return when (symbol) {
                 is FirCallableSymbol<*> -> {
                     if (symbol.isLocalDeclaration()) {

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/IdeFirPhaseManager.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.FirPhaseManager
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.idea.fir.low.level.api.file.builder.ModuleFileCache
 import org.jetbrains.kotlin.idea.fir.low.level.api.lazy.resolve.FirLazyDeclarationResolver
 import org.jetbrains.kotlin.idea.fir.low.level.api.sessions.FirSessionInvalidator
@@ -22,7 +22,7 @@ internal class IdeFirPhaseManager(
     private val sessionInvalidator: FirSessionInvalidator,
 ) : FirPhaseManager() {
     override fun ensureResolved(
-        symbol: AbstractFirBasedSymbol<*>,
+        symbol: FirBasedSymbol<*>,
         requiredPhase: FirResolvePhase
     ) {
         val fir = symbol.fir as FirDeclaration

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/file/structure/FileStructureElement.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState
@@ -71,7 +71,7 @@ internal class KtToFirMapping(firElement: FirElement, recorder: FirElementsRecor
     }
 }
 
-internal sealed class ReanalyzableStructureElement<KT : KtDeclaration, S : AbstractFirBasedSymbol<*>>(
+internal sealed class ReanalyzableStructureElement<KT : KtDeclaration, S : FirBasedSymbol<*>>(
     firFile: FirFile,
     val firSymbol: S,
     lockProvider: LockProvider<FirFile>,

idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/firTestUtils.kt

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.render
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousInitializerSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
@@ -30,7 +30,7 @@ internal fun FirElement.renderWithClassName(renderMode: FirRenderer.RenderMode =
     "${this::class.simpleName} `${render(renderMode)}`"
 
 
-internal fun AbstractFirBasedSymbol<*>.name(): String = when (this) {
+internal fun FirBasedSymbol<*>.name(): String = when (this) {
     is FirCallableSymbol<*> -> callableId.callableName.asString()
     is FirClassLikeSymbol<*> -> classId.shortClassName.asString()
     is FirAnonymousInitializerSymbol -> "<init>"

idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/HLDiagnosticConverter.kt

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.model.DiagnosticP
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -136,7 +136,7 @@ private object FirToKtConversionCreator {
     )
 
     private val typeMapping: Map<KClass<*>, HLFunctionCallConversion> = mapOf(
-        AbstractFirBasedSymbol::class to HLFunctionCallConversion(
+        FirBasedSymbol::class to HLFunctionCallConversion(
             "firSymbolBuilder.buildSymbol({0}.fir as FirDeclaration)",
             KtSymbol::class.createType(),
             importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration")

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirSymbolDeclarationOverridesProvider.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.scopes.*
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirIntersectionOverrideFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirIntersectionOverridePropertySymbol
@@ -139,7 +139,7 @@ internal class KtFirSymbolDeclarationOverridesProvider(
         }
     }
 
-    private fun AbstractFirBasedSymbol<*>.getIntersectionOverriddenSymbols(): Collection<FirCallableSymbol<*>> {
+    private fun FirBasedSymbol<*>.getIntersectionOverriddenSymbols(): Collection<FirCallableSymbol<*>> {
         require(this is FirCallableSymbol<*>) {
             "Required FirCallableSymbol but ${this::class} found"
         }

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt

@@ -1079,8 +1079,8 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
     }
     add(FirErrors.NONE_APPLICABLE) { firDiagnostic ->
         NoneApplicableImpl(
-            firDiagnostic.a.map { abstractFirBasedSymbol ->
+            firDiagnostic.a.map { firBasedSymbol ->
-                firSymbolBuilder.buildSymbol(abstractFirBasedSymbol.fir as FirDeclaration)
+                firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration)
             },
             firDiagnostic as FirPsiDiagnostic,
             token,
@@ -1214,8 +1214,8 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
     }
     add(FirErrors.OVERLOAD_RESOLUTION_AMBIGUITY) { firDiagnostic ->
         OverloadResolutionAmbiguityImpl(
-            firDiagnostic.a.map { abstractFirBasedSymbol ->
+            firDiagnostic.a.map { firBasedSymbol ->
-                firSymbolBuilder.buildSymbol(abstractFirBasedSymbol.fir as FirDeclaration)
+                firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration)
             },
             firDiagnostic as FirPsiDiagnostic,
             token,
@@ -1223,8 +1223,8 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
     }
     add(FirErrors.ASSIGN_OPERATOR_AMBIGUITY) { firDiagnostic ->
         AssignOperatorAmbiguityImpl(
-            firDiagnostic.a.map { abstractFirBasedSymbol ->
+            firDiagnostic.a.map { firBasedSymbol ->
-                firSymbolBuilder.buildSymbol(abstractFirBasedSymbol.fir as FirDeclaration)
+                firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration)
             },
             firDiagnostic as FirPsiDiagnostic,
             token,
@@ -1232,8 +1232,8 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
     }
     add(FirErrors.ITERATOR_AMBIGUITY) { firDiagnostic ->
         IteratorAmbiguityImpl(
-            firDiagnostic.a.map { abstractFirBasedSymbol ->
+            firDiagnostic.a.map { firBasedSymbol ->
-                firSymbolBuilder.buildSymbol(abstractFirBasedSymbol.fir as FirDeclaration)
+                firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration)
             },
             firDiagnostic as FirPsiDiagnostic,
             token,
@@ -1241,8 +1241,8 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
     }
     add(FirErrors.HAS_NEXT_FUNCTION_AMBIGUITY) { firDiagnostic ->
         HasNextFunctionAmbiguityImpl(
-            firDiagnostic.a.map { abstractFirBasedSymbol ->
+            firDiagnostic.a.map { firBasedSymbol ->
-                firSymbolBuilder.buildSymbol(abstractFirBasedSymbol.fir as FirDeclaration)
+                firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration)
             },
             firDiagnostic as FirPsiDiagnostic,
             token,
@@ -1250,8 +1250,8 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
     }
     add(FirErrors.NEXT_AMBIGUITY) { firDiagnostic ->
         NextAmbiguityImpl(
-            firDiagnostic.a.map { abstractFirBasedSymbol ->
+            firDiagnostic.a.map { firBasedSymbol ->
-                firSymbolBuilder.buildSymbol(abstractFirBasedSymbol.fir as FirDeclaration)
+                firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration)
             },
             firDiagnostic as FirPsiDiagnostic,
             token,
@@ -1745,8 +1745,8 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
     }
     add(FirErrors.CONFLICTING_OVERLOADS) { firDiagnostic ->
         ConflictingOverloadsImpl(
-            firDiagnostic.a.map { abstractFirBasedSymbol ->
+            firDiagnostic.a.map { firBasedSymbol ->
-                firSymbolBuilder.buildSymbol(abstractFirBasedSymbol.fir as FirDeclaration)
+                firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration)
             },
             firDiagnostic as FirPsiDiagnostic,
             token,
@@ -1754,8 +1754,8 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
     }
     add(FirErrors.REDECLARATION) { firDiagnostic ->
         RedeclarationImpl(
-            firDiagnostic.a.map { abstractFirBasedSymbol ->
+            firDiagnostic.a.map { firBasedSymbol ->
-                firSymbolBuilder.buildSymbol(abstractFirBasedSymbol.fir as FirDeclaration)
+                firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration)
             },
             firDiagnostic as FirPsiDiagnostic,
             token,
@@ -2150,8 +2150,8 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
     add(FirErrors.COMPONENT_FUNCTION_AMBIGUITY) { firDiagnostic ->
         ComponentFunctionAmbiguityImpl(
             firDiagnostic.a,
-            firDiagnostic.b.map { abstractFirBasedSymbol ->
+            firDiagnostic.b.map { firBasedSymbol ->
-                firSymbolBuilder.buildSymbol(abstractFirBasedSymbol.fir as FirDeclaration)
+                firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration)
             },
             firDiagnostic as FirPsiDiagnostic,
             token,
@@ -2442,8 +2442,8 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
     }
     add(FirErrors.HAS_NEXT_FUNCTION_NONE_APPLICABLE) { firDiagnostic ->
         HasNextFunctionNoneApplicableImpl(
-            firDiagnostic.a.map { abstractFirBasedSymbol ->
+            firDiagnostic.a.map { firBasedSymbol ->
-                firSymbolBuilder.buildSymbol(abstractFirBasedSymbol.fir as FirDeclaration)
+                firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration)
             },
             firDiagnostic as FirPsiDiagnostic,
             token,
@@ -2451,8 +2451,8 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
     }
     add(FirErrors.NEXT_NONE_APPLICABLE) { firDiagnostic ->
         NextNoneApplicableImpl(
-            firDiagnostic.a.map { abstractFirBasedSymbol ->
+            firDiagnostic.a.map { firBasedSymbol ->
-                firSymbolBuilder.buildSymbol(abstractFirBasedSymbol.fir as FirDeclaration)
+                firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration)
             },
             firDiagnostic as FirPsiDiagnostic,
             token,
@@ -2470,8 +2470,8 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
     add(FirErrors.DELEGATE_SPECIAL_FUNCTION_AMBIGUITY) { firDiagnostic ->
         DelegateSpecialFunctionAmbiguityImpl(
             firDiagnostic.a,
-            firDiagnostic.b.map { abstractFirBasedSymbol ->
+            firDiagnostic.b.map { firBasedSymbol ->
-                firSymbolBuilder.buildSymbol(abstractFirBasedSymbol.fir as FirDeclaration)
+                firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration)
             },
             firDiagnostic as FirPsiDiagnostic,
             token,
@@ -2480,8 +2480,8 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
     add(FirErrors.DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE) { firDiagnostic ->
         DelegateSpecialFunctionNoneApplicableImpl(
             firDiagnostic.a,
-            firDiagnostic.b.map { abstractFirBasedSymbol ->
+            firDiagnostic.b.map { firBasedSymbol ->
-                firSymbolBuilder.buildSymbol(abstractFirBasedSymbol.fir as FirDeclaration)
+                firSymbolBuilder.buildSymbol(firBasedSymbol.fir as FirDeclaration)
             },
             firDiagnostic as FirPsiDiagnostic,
             token,

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/pointers/pointerUtils.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.renderWithType
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.idea.fir.low.level.api.ideSessionComponents
 import org.jetbrains.kotlin.ir.util.IdSignature
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.ir.util.IdSignature
 internal inline fun <reified D : FirDeclaration> FirScope.findDeclarationWithSignature(
     signature: IdSignature,
     firSession: FirSession,
-    processor: FirScope.((AbstractFirBasedSymbol<*>) -> Unit) -> Unit
+    processor: FirScope.((FirBasedSymbol<*>) -> Unit) -> Unit
 ): D? {
     val signatureComposer = firSession.ideSessionComponents.signatureComposer
     var foundSymbol: D? = null

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/references/FirReferenceResolveHelper.kt

@@ -25,7 +25,6 @@ import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.resolve.transformers.FirImportResolveTransformer
 import org.jetbrains.kotlin.fir.scopes.impl.FirExplicitSimpleImportingScope
 import org.jetbrains.kotlin.fir.scopes.processClassifiersByName
-import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.types.*
@@ -52,7 +51,7 @@ internal object FirReferenceResolveHelper {
     fun FirResolvedTypeRef.toTargetSymbol(session: FirSession, symbolBuilder: KtSymbolByFirBuilder): KtSymbol? {
 
         val type = getDeclaredType() as? ConeLookupTagBasedType
-        val resolvedSymbol = type?.lookupTag?.toSymbol(session) as? AbstractFirBasedSymbol<*>
+        val resolvedSymbol = type?.lookupTag?.toSymbol(session) as? FirBasedSymbol<*>
 
         val symbol = resolvedSymbol ?: run {
             val diagnostic = (this as? FirErrorTypeRef)?.diagnostic