[FIR] Add symbol to FirFunction and all it's inheritors

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

@@ -8,7 +8,10 @@ package org.jetbrains.kotlin.fir.backend
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirVariable
-import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
+import org.jetbrains.kotlin.ir.declarations.IrValueParameter
+import org.jetbrains.kotlin.ir.declarations.IrVariable
 
 class Fir2IrCallableCache {
     private val parameterCache = mutableMapOf<FirValueParameter, IrValueParameter>()
@@ -17,7 +20,7 @@ class Fir2IrCallableCache {
 
     private val localClassCache = mutableMapOf<FirClass, IrClass>()
 
-    private val localFunctionCache = mutableMapOf<FirFunction, IrSimpleFunction>()
+    private val localFunctionCache = mutableMapOf<FirFunction<*>, IrSimpleFunction>()
 
     fun getParameter(parameter: FirValueParameter): IrValueParameter? = parameterCache[parameter]
 
@@ -38,9 +41,9 @@ class Fir2IrCallableCache {
         localClassCache[localClass] = irClass
     }
 
-    fun getLocalFunction(localFunction: FirFunction): IrSimpleFunction? = localFunctionCache[localFunction]
+    fun getLocalFunction(localFunction: FirFunction<*>): IrSimpleFunction? = localFunctionCache[localFunction]
 
-    fun putLocalFunction(localFunction: FirFunction, irFunction: IrSimpleFunction) {
+    fun putLocalFunction(localFunction: FirFunction<*>, irFunction: IrSimpleFunction) {
         require(localFunction !is FirNamedFunction || localFunction.visibility == Visibilities.LOCAL)
         localFunctionCache[localFunction] = irFunction
     }

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

@@ -18,7 +18,10 @@ import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.getOrPut
 import org.jetbrains.kotlin.fir.service
-import org.jetbrains.kotlin.fir.symbols.impl.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.*
 import org.jetbrains.kotlin.ir.expressions.IrExpression
@@ -226,7 +229,7 @@ class Fir2IrDeclarationStorage(
         }
     }
 
-    fun <T : IrFunction> T.declareParameters(function: FirFunction, containingClass: IrClass?) {
+    fun <T : IrFunction> T.declareParameters(function: FirFunction<*>, containingClass: IrClass?) {
         val parent = this
         for ((index, valueParameter) in function.valueParameters.withIndex()) {
             valueParameters += createAndSaveIrParameter(valueParameter, index).apply { this.parent = parent }
@@ -272,7 +275,7 @@ class Fir2IrDeclarationStorage(
     }
 
     private fun <T : IrFunction> T.bindAndDeclareParameters(
-        function: FirFunction,
+        function: FirFunction<*>,
         descriptor: WrappedCallableDescriptor<T>,
         irParent: IrDeclarationParent?,
         shouldLeaveScope: Boolean
@@ -286,7 +289,7 @@ class Fir2IrDeclarationStorage(
         return this
     }
 
-    private fun <T : IrFunction> T.enterLocalScope(function: FirFunction): T {
+    private fun <T : IrFunction> T.enterLocalScope(function: FirFunction<*>): T {
         enterScope(descriptor)
         for ((firParameter, irParameter) in function.valueParameters.zip(valueParameters)) {
             irSymbolTable.introduceValueParameter(irParameter)

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

@@ -9,7 +9,10 @@ import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirVariable
-import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
+import org.jetbrains.kotlin.ir.declarations.IrValueParameter
+import org.jetbrains.kotlin.ir.declarations.IrVariable
 
 class Fir2IrLocalStorage {
 
@@ -48,7 +51,7 @@ class Fir2IrLocalStorage {
         return null
     }
 
-    fun getLocalFunction(localFunction: FirFunction): IrSimpleFunction? {
+    fun getLocalFunction(localFunction: FirFunction<*>): IrSimpleFunction? {
         for (cache in cacheStack.asReversed()) {
             val local = cache.getLocalFunction(localFunction)
             if (local != null) return local
@@ -68,7 +71,7 @@ class Fir2IrLocalStorage {
         cacheStack.last().putLocalClass(firClass, irClass)
     }
 
-    fun putLocalFunction(firFunction: FirFunction, irFunction: IrSimpleFunction) {
+    fun putLocalFunction(firFunction: FirFunction<*>, irFunction: IrSimpleFunction) {
         cacheStack.last().putLocalFunction(firFunction, irFunction)
     }
 }

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

@@ -280,7 +280,7 @@ internal class Fir2IrVisitor(
 
     private fun <T : IrFunction> T.setFunctionContent(
         descriptor: FunctionDescriptor,
-        firFunction: FirFunction,
+        firFunction: FirFunction<*>,
         firOverriddenSymbol: FirNamedFunctionSymbol? = null
     ): T {
         setParentByParentStack()

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

@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
-import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.declarations.impl.FirAbstractCallableMember
@@ -55,7 +54,7 @@ class FirJavaConstructor(
 
     override val valueParameters = mutableListOf<FirValueParameter>()
 
-    override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirFunction {
+    override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirJavaConstructor {
         valueParameters.transformInplace(transformer, data)
         return this
     }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt

@@ -14,13 +14,13 @@ import org.jetbrains.kotlin.fir.expressions.impl.FirConstExpressionImpl
 import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
 import org.jetbrains.kotlin.fir.java.declarations.*
 import org.jetbrains.kotlin.fir.java.enhancement.*
-import org.jetbrains.kotlin.fir.java.enhancement.EnhancementSignatureParts
 import org.jetbrains.kotlin.fir.java.toNotNullConeKotlinType
 import org.jetbrains.kotlin.fir.java.types.FirJavaTypeRef
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
-import org.jetbrains.kotlin.fir.symbols.*
+import org.jetbrains.kotlin.fir.symbols.CallableId
+import org.jetbrains.kotlin.fir.symbols.ConePropertySymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.ir.expressions.IrConstKind
@@ -122,6 +122,7 @@ class JavaClassEnhancementScope(
         if (firMethod !is FirJavaMethod && firMethod !is FirJavaConstructor) {
             return original
         }
+        if (firMethod !is FirMemberFunction<*>) throw AssertionError()
         return enhanceMethod(firMethod, original.callableId, name)
     }
 
@@ -222,7 +223,7 @@ class JavaClassEnhancementScope(
         return function.symbol
     }
 
-    private fun FirFunction.computeJvmDescriptor(): String = buildString {
+    private fun FirFunction<*>.computeJvmDescriptor(): String = buildString {
         if (this@computeJvmDescriptor is FirJavaMethod) {
             append(name.asString())
         } else {
@@ -364,7 +365,7 @@ class JavaClassEnhancementScope(
                 if (hasReceiver && member is FirJavaMethod) {
                     return member.valueParameters[index + 1].returnTypeRef
                 }
-                return (member as FirFunction).valueParameters[index].returnTypeRef
+                return (member as FirFunction<*>).valueParameters[index].returnTypeRef
             }
         }
     }

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt

@@ -16,6 +16,8 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.builder.Context
 import org.jetbrains.kotlin.fir.builder.generateAccessorsByDelegate
+import org.jetbrains.kotlin.fir.builder.generateComponentFunctions
+import org.jetbrains.kotlin.fir.builder.generateCopyFunction
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.*
 import org.jetbrains.kotlin.fir.expressions.*
@@ -37,8 +39,6 @@ import org.jetbrains.kotlin.lexer.KtTokens.*
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.SpecialNames
-import org.jetbrains.kotlin.fir.builder.generateCopyFunction
-import org.jetbrains.kotlin.fir.builder.generateComponentFunctions
 
 class DeclarationsConverter(
     session: FirSession,
@@ -888,7 +888,8 @@ class DeclarationsConverter(
             null,
             isGetter,
             modifiers.getVisibility(),
-            returnType ?: if (isGetter) propertyTypeRef else implicitUnitType
+            returnType ?: if (isGetter) propertyTypeRef else implicitUnitType,
+            FirPropertyAccessorSymbol()
         )
         context.firFunctions += firAccessor
         firAccessor.annotations += modifiers.annotations
@@ -971,7 +972,7 @@ class DeclarationsConverter(
         val parentNode = functionDeclaration.getParent()
         val isLocal = !(parentNode?.tokenType == KT_FILE || parentNode?.tokenType == CLASS_BODY)
         val firFunction = if (identifier == null) {
-            FirAnonymousFunctionImpl(session, null, returnType!!, receiverType)
+            FirAnonymousFunctionImpl(session, null, returnType!!, receiverType, FirAnonymousFunctionSymbol())
         } else {
             val functionName = identifier.nameAsSafeName()
             FirMemberFunctionImpl(

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt

@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.fir.references.FirExplicitSuperReference
 import org.jetbrains.kotlin.fir.references.FirExplicitThisReference
 import org.jetbrains.kotlin.fir.references.FirSimpleNamedReference
 import org.jetbrains.kotlin.fir.render
+import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousFunctionSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
@@ -115,7 +116,7 @@ class ExpressionsConverter(
             }
         }
 
-        return FirAnonymousFunctionImpl(session, null, implicitType, implicitType).apply {
+        return FirAnonymousFunctionImpl(session, null, implicitType, implicitType, FirAnonymousFunctionSymbol()).apply {
             context.firFunctions += this
             var destructuringBlock: FirExpression? = null
             for (valueParameter in valueParameterList) {

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/Context.kt

@@ -17,7 +17,7 @@ class Context {
     var className: FqName = FqName.ROOT
     val currentClassId get() = ClassId(packageFqName, className, false)
 
-    val firFunctions = mutableListOf<FirFunction>()
+    val firFunctions = mutableListOf<FirFunction<*>>()
     val firFunctionCalls = mutableListOf<FirFunctionCall>()
     val firLabels = mutableListOf<FirLabel>()
     val firLoops = mutableListOf<FirLoop>()

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt

@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.fir.references.FirDelegateFieldReferenceImpl
 import org.jetbrains.kotlin.fir.references.FirExplicitThisReference
 import org.jetbrains.kotlin.fir.references.FirResolvedCallableReferenceImpl
 import org.jetbrains.kotlin.fir.references.FirSimpleNamedReference
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertyAccessorSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.types.ConeStarProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -317,7 +318,7 @@ fun FirModifiableAccessorsOwner.generateAccessorsByDelegate(session: FirSession,
     }
     if (stubMode) return
     getter = (getter as? FirPropertyAccessorImpl)
-        ?: FirPropertyAccessorImpl(session, null, true, Visibilities.UNKNOWN, FirImplicitTypeRefImpl(null)).apply Accessor@{
+        ?: FirPropertyAccessorImpl(session, null, true, Visibilities.UNKNOWN, FirImplicitTypeRefImpl(null), FirPropertyAccessorSymbol()).apply Accessor@{
             body = FirSingleExpressionBlock(
                 FirReturnExpressionImpl(
                     null,
@@ -334,7 +335,7 @@ fun FirModifiableAccessorsOwner.generateAccessorsByDelegate(session: FirSession,
             )
         }
     setter = (setter as? FirPropertyAccessorImpl)
-        ?: FirPropertyAccessorImpl(session, null, false, Visibilities.UNKNOWN, FirImplicitUnitTypeRef(null)).apply {
+        ?: FirPropertyAccessorImpl(session, null, false, Visibilities.UNKNOWN, FirImplicitUnitTypeRef(null), FirPropertyAccessorSymbol()).apply {
             val parameter = FirValueParameterImpl(
                 session, null, DELEGATED_SETTER_PARAM,
                 FirImplicitTypeRefImpl(null),

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

@@ -11,20 +11,21 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirWhenSubject
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.*
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.*
 import org.jetbrains.kotlin.fir.labels.FirLabelImpl
 import org.jetbrains.kotlin.fir.references.*
-import org.jetbrains.kotlin.fir.symbols.CallableId
+import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.FirTypeProjection
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.*
 import org.jetbrains.kotlin.lexer.KtTokens.*
-import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
@@ -205,7 +206,8 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                     returnTypeReference?.convertSafe() ?: propertyTypeRef
                 } else {
                     returnTypeReference.toFirOrUnitType()
-                }
+                },
+                FirPropertyAccessorSymbol()
             )
             this@RawFirBuilder.context.firFunctions += firAccessor
             extractAnnotationsTo(firAccessor)
@@ -284,7 +286,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
         }
 
         private fun KtDeclarationWithBody.extractValueParametersTo(
-            container: FirFunction,
+            container: FirFunction<*>,
             defaultTypeRef: FirTypeRef? = null
         ) {
             for (valueParameter in valueParameters) {
@@ -543,7 +545,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
             }
             val receiverType = function.receiverTypeReference.convertSafe<FirTypeRef>()
             val firFunction = if (function.name == null) {
-                FirAnonymousFunctionImpl(session, function, returnType, receiverType)
+                FirAnonymousFunctionImpl(session, function, returnType, receiverType, FirAnonymousFunctionSymbol())
             } else {
 
                 FirMemberFunctionImpl(
@@ -583,7 +585,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
             val literal = expression.functionLiteral
             val returnType = FirImplicitTypeRefImpl(literal)
             val receiverType = FirImplicitTypeRefImpl(literal)
-            return FirAnonymousFunctionImpl(session, literal, returnType, receiverType).apply {
+            return FirAnonymousFunctionImpl(session, literal, returnType, receiverType, FirAnonymousFunctionSymbol()).apply {
                 context.firFunctions += this
                 var destructuringBlock: FirExpression? = null
                 for (valueParameter in literal.valueParameters) {

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

@@ -52,7 +52,7 @@ fun FirAnonymousFunction.copy(
     typeRef: FirTypeRef = this.typeRef,
     label: FirLabel? = this.label
 ): FirAnonymousFunction {
-    return FirAnonymousFunctionImpl(session, psi, returnTypeRef, receiverTypeRef).apply {
+    return FirAnonymousFunctionImpl(session, psi, returnTypeRef, receiverTypeRef, symbol).apply {
         this.valueParameters.addAll(valueParameters)
         this.body = body
         this.annotations.addAll(annotations)

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

@@ -8,8 +8,8 @@ package org.jetbrains.kotlin.fir.resolve
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.expressions.FirResolvable
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
+import org.jetbrains.kotlin.fir.expressions.FirResolvable
 import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate
@@ -192,7 +192,7 @@ fun <T : ConeKotlinType> T.withArguments(arguments: Array<out ConeKotlinTypeProj
     }
 }
 
-fun FirFunction.constructFunctionalTypeRef(session: FirSession): FirResolvedTypeRef {
+fun FirFunction<*>.constructFunctionalTypeRef(session: FirSession): FirResolvedTypeRef {
     val receiverTypeRef = when (this) {
         is FirNamedFunction -> receiverTypeRef
         is FirAnonymousFunction -> receiverTypeRef

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

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.expressions.FirWrappedArgumentExpression
 import org.jetbrains.kotlin.fir.render
 
 class FirCallArgumentsProcessor(
-    private val function: FirFunction,
+    private val function: FirFunction<*>,
     private val arguments: List<FirExpression>
 ) {
     class Result(val argumentMapping: Map<FirExpression, FirValueParameter>, val isSuccess: Boolean)

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

@@ -545,7 +545,7 @@ open class FirBodyResolveTransformer(
         return (annotationCall.transformChildren(this, data) as FirStatement).compose()
     }
 
-    override fun transformFunction(function: FirFunction, data: Any?): CompositeTransformResult<FirDeclaration> {
+    override fun <F : FirFunction<F>> transformFunction(function: FirFunction<F>, data: Any?): CompositeTransformResult<FirDeclaration> {
         return withScopeCleanup(localScopes) {
             localScopes += FirLocalScope()
             super.transformFunction(function, data)
@@ -553,7 +553,7 @@ open class FirBodyResolveTransformer(
     }
 
     private fun transformFunctionWithGivenSignature(
-        function: FirFunction,
+        function: FirFunction<*>,
         returnTypeRef: FirTypeRef,
         receiverTypeRef: FirTypeRef? = null
     ): CompositeTransformResult<FirDeclaration> {
@@ -563,7 +563,7 @@ open class FirBodyResolveTransformer(
         return withScopeCleanup(scopes) {
             scopes.addIfNotNull(receiverTypeRef?.coneTypeSafe<ConeKotlinType>()?.scope(session, scopeSession))
 
-            val result = transformFunction(function, returnTypeRef).single as FirFunction
+            val result = transformFunction(function, returnTypeRef).single as FirFunction<*>
             val body = result.body
             if (result is FirTypedDeclaration && result.returnTypeRef is FirImplicitTypeRef && body != null) {
                 result.transformReturnTypeRef(this, body.resultType)
@@ -782,7 +782,7 @@ open class FirBodyResolveTransformer(
         labels.put(labelName, type)
         when (owner) {
             is FirRegularClass -> implicitReceiverStack += ImplicitDispatchReceiverValue(owner.symbol, type)
-            is FirFunction -> implicitReceiverStack += ImplicitExtensionReceiverValue(type)
+            is FirFunction<*> -> implicitReceiverStack += ImplicitExtensionReceiverValue(type)
             else -> throw IllegalArgumentException("Incorrect label & receiver owner: ${owner.javaClass}")
         }
         val result = block()

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

@@ -60,7 +60,7 @@ class FirClassSubstitutionScope(
         val member = when (original) {
             is FirNamedFunctionSymbol -> original.fir
             is FirConstructorSymbol -> return original
-            is FirAccessorSymbol -> throw AssertionError("Should not be here")
+            else -> throw AssertionError("Should not be here")
         }
 
         val receiverType = member.receiverTypeRef?.coneTypeUnsafe<ConeKotlinType>()

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

@@ -9,4 +9,4 @@ import org.jetbrains.kotlin.fir.declarations.FirFunction
 
 class FirFunctionTarget(
     labelName: String?
-) : FirAbstractTarget<FirFunction>(labelName)
+) : FirAbstractTarget<FirFunction<*>>(labelName)

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

@@ -127,7 +127,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
             print(callableDeclaration.name)
         }
 
-        if (callableDeclaration is FirFunction) {
+        if (callableDeclaration is FirFunction<*>) {
             callableDeclaration.valueParameters.renderParameters()
         }
         print(": ")
@@ -382,7 +382,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         anonymousFunction.body?.renderBody()
     }
 
-    override fun visitFunction(function: FirFunction) {
+    override fun <F : FirFunction<F>> visitFunction(function: FirFunction<F>) {
         function.valueParameters.renderParameters()
         visitDeclarationWithBody(function)
     }

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

@@ -10,26 +10,24 @@ import org.jetbrains.kotlin.fir.FirLabeledElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.VisitedSupertype
 import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
+import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousFunctionSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 abstract class FirAnonymousFunction(
     final override val session: FirSession,
     psi: PsiElement?
-) : @VisitedSupertype FirFunction, FirUnknownTypeExpression(psi), FirTypedDeclaration, FirLabeledElement {
+) : @VisitedSupertype FirFunction<FirAnonymousFunction>, FirUnknownTypeExpression(psi), FirLabeledElement {
-    abstract val receiverTypeRef: FirTypeRef?
+    abstract override val receiverTypeRef: FirTypeRef?
+
+    abstract override val symbol: FirAnonymousFunctionSymbol
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitAnonymousFunction(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        super<FirTypedDeclaration>.acceptChildren(visitor, data)
+        super<FirFunction>.acceptChildren(visitor, data)
         super<FirLabeledElement>.acceptChildren(visitor, data)
-        receiverTypeRef?.accept(visitor, data)
-        for (parameter in valueParameters) {
-            parameter.accept(visitor, data)
-        }
-        body?.accept(visitor, data)
         typeRef.accept(visitor, data)
         // Don't call super<FirExpression>.acceptChildren (annotations & typeRef are already processed)
     }

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

@@ -9,23 +9,29 @@ import org.jetbrains.kotlin.fir.FirTargetElement
 import org.jetbrains.kotlin.fir.VisitedSupertype
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.expressions.FirStatement
+import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 // May be should inherit FirTypeParameterContainer
-interface FirFunction : @VisitedSupertype FirDeclarationWithBody, FirAnnotationContainer, FirTargetElement, FirStatement {
+interface FirFunction<F : FirFunction<F>> : @VisitedSupertype FirDeclarationWithBody, FirCallableDeclaration<F>, FirAnnotationContainer,
+    FirTargetElement, FirStatement, FirSymbolOwner<F> {
+
     val valueParameters: List<FirValueParameter>
 
+    override val symbol: FirFunctionSymbol<F>
+
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitFunction(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        acceptAnnotations(visitor, data)
+        super<FirCallableDeclaration>.acceptChildren(visitor, data)
         for (parameter in valueParameters) {
             parameter.accept(visitor, data)
         }
         super<FirDeclarationWithBody>.acceptChildren(visitor, data)
     }
 
-    fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirFunction
+    fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirFunction<F>
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirMemberFunction.kt

@@ -6,12 +6,11 @@
 package org.jetbrains.kotlin.fir.declarations
 
 import org.jetbrains.kotlin.fir.VisitedSupertype
-import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 interface FirMemberFunction<F : FirMemberFunction<F>> :
-    @VisitedSupertype FirFunction, FirCallableMemberDeclaration<F> {
+    @VisitedSupertype FirFunction<F>, FirCallableMemberDeclaration<F> {
 
     override val symbol: FirFunctionSymbol<F>
 

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

@@ -7,9 +7,10 @@ package org.jetbrains.kotlin.fir.declarations
 
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.VisitedSupertype
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertyAccessorSymbol
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirPropertyAccessor : @VisitedSupertype FirFunction, FirTypedDeclaration {
+interface FirPropertyAccessor : @VisitedSupertype FirFunction<FirPropertyAccessor> {
     val isGetter: Boolean
 
     val isSetter: Boolean get() = !isGetter
@@ -18,15 +19,13 @@ interface FirPropertyAccessor : @VisitedSupertype FirFunction, FirTypedDeclarati
 
     val visibility: Visibility get() = status.visibility
 
+    override val symbol: FirPropertyAccessorSymbol
+
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitPropertyAccessor(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        super<FirTypedDeclaration>.acceptChildren(visitor, data)
+        super.acceptChildren(visitor, data)
-        for (parameter in valueParameters) {
-            parameter.accept(visitor, data)
-        }
-        body?.accept(visitor, data)
         status.accept(visitor, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractPropertyAccessor.kt

@@ -8,25 +8,24 @@ package org.jetbrains.kotlin.fir.declarations.impl
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirFunction
+import org.jetbrains.kotlin.fir.VisitedSupertype
-import org.jetbrains.kotlin.fir.declarations.FirValueParameter
+import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
-import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertyAccessorSymbol
-import org.jetbrains.kotlin.fir.transformInplace
+import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
-abstract class FirAbstractFunction(
+abstract class FirAbstractPropertyAccessor(
     session: FirSession,
-    psi: PsiElement?
+    psi: PsiElement?,
-) : FirAbstractAnnotatedDeclaration(session, psi), FirFunction {
+    final override val symbol: FirPropertyAccessorSymbol
-    final override val valueParameters = mutableListOf<FirValueParameter>()
+) : FirAbstractAnnotatedDeclaration(session, psi), @VisitedSupertype FirPropertyAccessor {
+    init {
+        symbol.bind(this)
+    }
 
-    final override var body: FirBlock? = null
+    final override val receiverTypeRef: FirTypeRef? get() = null
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        valueParameters.transformInplace(transformer, data)
-        body = body?.transformSingle(transformer, data)
-
         return super<FirAbstractAnnotatedDeclaration>.transformChildren(transformer, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousFunctionImpl.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousFunctionSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
@@ -18,8 +19,13 @@ class FirAnonymousFunctionImpl(
     session: FirSession,
     psi: PsiElement?,
     override var returnTypeRef: FirTypeRef,
-    override var receiverTypeRef: FirTypeRef?
+    override var receiverTypeRef: FirTypeRef?,
-) : FirAnonymousFunction(session, psi), FirModifiableFunction {
+    override val symbol: FirAnonymousFunctionSymbol
+) : FirAnonymousFunction(session, psi), FirModifiableFunction<FirAnonymousFunction> {
+    init {
+        symbol.bind(this)
+    }
+
     override var label: FirLabel? = null
 
     override val valueParameters = mutableListOf<FirValueParameter>()

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultPropertyAccessor.kt

@@ -8,13 +8,13 @@ package org.jetbrains.kotlin.fir.declarations.impl
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.symbols.CallableId
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertyAccessorSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.transformInplace
 import org.jetbrains.kotlin.fir.transformSingle
@@ -25,20 +25,17 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 
 abstract class FirDefaultPropertyAccessor(
-    final override val session: FirSession,
+    session: FirSession,
     psi: PsiElement?,
     final override val isGetter: Boolean,
-    visibility: Visibility
+    visibility: Visibility,
-) : FirAbstractElement(psi), FirPropertyAccessor {
+    symbol: FirPropertyAccessorSymbol
+) : FirAbstractPropertyAccessor(session, psi, symbol) {
     override var status = FirDeclarationStatusImpl(visibility, Modality.FINAL)
 
     override var resolvePhase = FirResolvePhase.BODY_RESOLVE
 
-    final override val body: FirBlock? =
+    final override val body: FirBlock? = null
-        null
-
-    final override val annotations: List<FirAnnotationCall>
-        get() = emptyList()
 
     abstract override var returnTypeRef: FirTypeRef
 
@@ -55,8 +52,9 @@ class FirDefaultPropertyGetter(
     session: FirSession,
     psi: PsiElement?,
     propertyTypeRef: FirTypeRef,
-    visibility: Visibility
+    visibility: Visibility,
-) : FirDefaultPropertyAccessor(session, psi, isGetter = true, visibility = visibility) {
+    symbol: FirPropertyAccessorSymbol = FirPropertyAccessorSymbol()
+) : FirDefaultPropertyAccessor(session, psi, isGetter = true, visibility = visibility, symbol = symbol) {
     override val valueParameters: List<FirValueParameter> = emptyList()
 
     override var returnTypeRef: FirTypeRef = propertyTypeRef
@@ -73,8 +71,9 @@ class FirDefaultPropertySetter(
     session: FirSession,
     psi: PsiElement?,
     propertyTypeRef: FirTypeRef,
-    visibility: Visibility
+    visibility: Visibility,
-) : FirDefaultPropertyAccessor(session, psi, isGetter = false, visibility = visibility) {
+    symbol: FirPropertyAccessorSymbol = FirPropertyAccessorSymbol()
+) : FirDefaultPropertyAccessor(session, psi, isGetter = false, visibility = visibility, symbol = symbol) {
     override val valueParameters = mutableListOf(
         FirDefaultSetterValueParameter(
             session, psi, propertyTypeRef, FirVariableSymbol(

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirErrorFunction.kt

@@ -14,14 +14,27 @@ import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner
+import org.jetbrains.kotlin.fir.symbols.impl.FirErrorFunctionSymbol
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 class FirErrorFunction(
     override val session: FirSession,
     psi: PsiElement?,
-    override val reason: String
+    override val reason: String,
-) : FirAbstractElement(psi), FirErrorDeclaration, FirFunction {
+    override val symbol: FirErrorFunctionSymbol = FirErrorFunctionSymbol()
+) : FirAbstractElement(psi), FirErrorDeclaration, FirFunction<FirErrorFunction>, FirSymbolOwner<FirErrorFunction> {
+    init {
+        symbol.bind(this)
+    }
+
+    override val receiverTypeRef: FirTypeRef? get() = null
+
+    override val returnTypeRef: FirTypeRef
+        get() = TODO("not implemented")
+
     override val annotations: List<FirAnnotationCall>
         get() = emptyList()
 
@@ -36,7 +49,9 @@ class FirErrorFunction(
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         super<FirFunction>.accept(visitor, data)
 
-    override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirFunction {
+    override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirErrorFunction {
         return this
     }
+
+    override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D) {}
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberFunctionImpl.kt

@@ -10,8 +10,8 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirFunction
+import org.jetbrains.kotlin.fir.declarations.FirNamedFunction
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.name.Name
 
-open class FirMemberFunctionImpl : FirAbstractCallableMember<FirNamedFunction>, FirNamedFunction, FirModifiableFunction {
+open class FirMemberFunctionImpl : FirAbstractCallableMember<FirNamedFunction>, FirNamedFunction, FirModifiableFunction<FirNamedFunction> {
 
     // NB: FirAccessorSymbol can be here
     override val symbol: FirFunctionSymbol<FirNamedFunction>
@@ -81,7 +81,7 @@ open class FirMemberFunctionImpl : FirAbstractCallableMember<FirNamedFunction>,
         return super<FirAbstractCallableMember>.transformChildren(transformer, data)
     }
 
-    override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirFunction {
+    override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirMemberFunctionImpl {
         valueParameters.transformInplace(transformer, data)
         return this
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableFunction.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 
-interface FirModifiableFunction : FirFunction {
+interface FirModifiableFunction<F : FirFunction<F>> : FirFunction<F> {
     override var body: FirBlock?
 
     override val valueParameters: MutableList<FirValueParameter>

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPropertyAccessorImpl.kt

@@ -10,8 +10,10 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirFunction
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
-import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertyAccessorSymbol
+import org.jetbrains.kotlin.fir.transformInplace
 import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
@@ -21,22 +23,29 @@ class FirPropertyAccessorImpl(
     psi: PsiElement?,
     override val isGetter: Boolean,
     visibility: Visibility,
-    override var returnTypeRef: FirTypeRef
+    override var returnTypeRef: FirTypeRef,
-) : FirAbstractFunction(session, psi), FirPropertyAccessor {
+    symbol: FirPropertyAccessorSymbol
+) : FirAbstractPropertyAccessor(session, psi, symbol) {
     override var status = FirDeclarationStatusImpl(visibility, Modality.FINAL)
 
+    override var body: FirBlock? = null
+
+    override val valueParameters = mutableListOf<FirValueParameter>()
+
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         returnTypeRef = returnTypeRef.transformSingle(transformer, data)
+        valueParameters.transformInplace(transformer, data)
+        body = body?.transformSingle(transformer, data)
         status = status.transformSingle(transformer, data)
 
-        return super<FirAbstractFunction>.transformChildren(transformer, data)
+        return super.transformChildren(transformer, data)
     }
 
     override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D) {
         returnTypeRef = returnTypeRef.transformSingle(transformer, data)
     }
 
-    override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirFunction {
+    override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirPropertyAccessorImpl {
         return this
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirReturnExpression.kt

@@ -9,7 +9,7 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-abstract class FirReturnExpression(psi: PsiElement?) : FirJump<FirFunction>(psi) {
+abstract class FirReturnExpression(psi: PsiElement?) : FirJump<FirFunction<*>>(psi) {
     abstract val result: FirExpression
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirReturnExpressionImpl.kt

@@ -6,10 +6,12 @@
 package org.jetbrains.kotlin.fir.expressions.impl
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirTarget
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirReturnExpression
+import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitNothingTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
@@ -18,7 +20,7 @@ class FirReturnExpressionImpl(
     psi: PsiElement?,
     override var result: FirExpression
 ) : FirReturnExpression(psi) {
-    override lateinit var target: FirTarget<FirFunction>
+    override lateinit var target: FirTarget<FirFunction<*>>
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         result = result.transformSingle(transformer, data)

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

@@ -6,18 +6,23 @@
 package org.jetbrains.kotlin.fir.symbols.impl
 
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.impl.FirErrorFunction
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.ConeFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.ConePropertySymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
 
-sealed class FirFunctionSymbol<D : FirMemberFunction<D>>(
+sealed class FirFunctionSymbol<D : FirFunction<D>>(
     override val callableId: CallableId
 ) : ConeFunctionSymbol, FirCallableSymbol<D>() {
     override val parameters: List<ConeKotlinType>
         get() = emptyList()
 }
 
+// ------------------------ named ------------------------
+
 open class FirNamedFunctionSymbol(
     callableId: CallableId,
     val isFakeOverride: Boolean = false,
@@ -32,4 +37,19 @@ class FirConstructorSymbol(
 class FirAccessorSymbol(
     callableId: CallableId,
     val accessorId: CallableId
-) : ConePropertySymbol, FirFunctionSymbol<FirNamedFunction>(callableId)
+) : ConePropertySymbol, FirFunctionSymbol<FirNamedFunction>(callableId)
+
+// ------------------------ unnamed ------------------------
+
+sealed class FirFunctionWithoutNameSymbol<F : FirFunction<F>>(
+    stubName: Name
+) : FirFunctionSymbol<F>(CallableId(FqName("special"), stubName)) {
+    override val parameters: List<ConeKotlinType>
+        get() = emptyList()
+}
+
+class FirAnonymousFunctionSymbol : FirFunctionWithoutNameSymbol<FirAnonymousFunction>(Name.identifier("anonymous"))
+
+class FirPropertyAccessorSymbol : FirFunctionWithoutNameSymbol<FirPropertyAccessor>(Name.identifier("accessor"))
+
+class FirErrorFunctionSymbol : FirFunctionWithoutNameSymbol<FirErrorFunction>(Name.identifier("error"))

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt

@@ -6,9 +6,7 @@ package org.jetbrains.kotlin.fir.visitors
 
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
+import org.jetbrains.kotlin.fir.declarations.impl.*
-import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableClass
-import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableFunction
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.*
 import org.jetbrains.kotlin.fir.types.*
@@ -42,7 +40,7 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformDeclarationWithBody(anonymousInitializer, data)
     }
 
-    open fun transformFunction(function: FirFunction, data: D): CompositeTransformResult<FirDeclaration> {
+    open fun <F : FirFunction<F>> transformFunction(function: FirFunction<F>, data: D): CompositeTransformResult<FirDeclaration> {
         return transformDeclarationWithBody(function, data)
     }
 
@@ -62,7 +60,7 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformMemberFunction(namedFunction, data)
     }
 
-    open fun transformModifiableFunction(modifiableFunction: FirModifiableFunction, data: D): CompositeTransformResult<FirDeclaration> {
+    open fun <F : FirFunction<F>> transformModifiableFunction(modifiableFunction: FirModifiableFunction<F>, data: D): CompositeTransformResult<FirDeclaration> {
         return transformFunction(modifiableFunction, data)
     }
 
@@ -70,10 +68,6 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformFunction(propertyAccessor, data)
     }
 
-    open fun transformDefaultPropertyAccessor(defaultPropertyAccessor: FirDefaultPropertyAccessor, data: D): CompositeTransformResult<FirDeclaration> {
-        return transformPropertyAccessor(defaultPropertyAccessor, data)
-    }
-
     open fun transformErrorDeclaration(errorDeclaration: FirErrorDeclaration, data: D): CompositeTransformResult<FirDeclaration> {
         return transformDeclaration(errorDeclaration, data)
     }
@@ -582,10 +576,6 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformDeclarationWithBody(declarationWithBody, data)
     }
 
-    final override fun visitDefaultPropertyAccessor(defaultPropertyAccessor: FirDefaultPropertyAccessor, data: D): CompositeTransformResult<FirElement> {
-        return transformDefaultPropertyAccessor(defaultPropertyAccessor, data)
-    }
-
     final override fun visitDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference, data: D): CompositeTransformResult<FirElement> {
         return transformDelegateFieldReference(delegateFieldReference, data)
     }
@@ -638,7 +628,7 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformFile(file, data)
     }
 
-    final override fun visitFunction(function: FirFunction, data: D): CompositeTransformResult<FirElement> {
+    final override fun <F : FirFunction<F>> visitFunction(function: FirFunction<F>, data: D): CompositeTransformResult<FirElement> {
         return transformFunction(function, data)
     }
 
@@ -698,7 +688,7 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformModifiableClass(modifiableClass, data)
     }
 
-    final override fun visitModifiableFunction(modifiableFunction: FirModifiableFunction, data: D): CompositeTransformResult<FirElement> {
+    final override fun <F : FirFunction<F>> visitModifiableFunction(modifiableFunction: FirModifiableFunction<F>, data: D): CompositeTransformResult<FirElement> {
         return transformModifiableFunction(modifiableFunction, data)
     }
 

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt

@@ -6,9 +6,7 @@ package org.jetbrains.kotlin.fir.visitors
 
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
+import org.jetbrains.kotlin.fir.declarations.impl.*
-import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableClass
-import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableFunction
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.*
 import org.jetbrains.kotlin.fir.types.*
@@ -42,7 +40,7 @@ abstract class FirVisitor<out R, in D> {
         return visitDeclarationWithBody(anonymousInitializer, data)
     }
 
-    open fun visitFunction(function: FirFunction, data: D): R {
+    open fun <F : FirFunction<F>> visitFunction(function: FirFunction<F>, data: D): R {
         return visitDeclarationWithBody(function, data)
     }
 
@@ -62,7 +60,7 @@ abstract class FirVisitor<out R, in D> {
         return visitMemberFunction(namedFunction, data)
     }
 
-    open fun visitModifiableFunction(modifiableFunction: FirModifiableFunction, data: D): R {
+    open fun <F : FirFunction<F>> visitModifiableFunction(modifiableFunction: FirModifiableFunction<F>, data: D): R {
         return visitFunction(modifiableFunction, data)
     }
 
@@ -70,10 +68,6 @@ abstract class FirVisitor<out R, in D> {
         return visitFunction(propertyAccessor, data)
     }
 
-    open fun visitDefaultPropertyAccessor(defaultPropertyAccessor: FirDefaultPropertyAccessor, data: D): R {
-        return visitPropertyAccessor(defaultPropertyAccessor, data)
-    }
-
     open fun visitErrorDeclaration(errorDeclaration: FirErrorDeclaration, data: D): R {
         return visitDeclaration(errorDeclaration, data)
     }

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt

@@ -6,9 +6,7 @@ package org.jetbrains.kotlin.fir.visitors
 
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
+import org.jetbrains.kotlin.fir.declarations.impl.*
-import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableClass
-import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableFunction
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.*
 import org.jetbrains.kotlin.fir.types.*
@@ -42,7 +40,7 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitDeclarationWithBody(anonymousInitializer, null)
     }
 
-    open fun visitFunction(function: FirFunction) {
+    open fun <F : FirFunction<F>> visitFunction(function: FirFunction<F>) {
         visitDeclarationWithBody(function, null)
     }
 
@@ -62,7 +60,7 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitMemberFunction(namedFunction, null)
     }
 
-    open fun visitModifiableFunction(modifiableFunction: FirModifiableFunction) {
+    open fun <F : FirFunction<F>> visitModifiableFunction(modifiableFunction: FirModifiableFunction<F>) {
         visitFunction(modifiableFunction, null)
     }
 
@@ -70,10 +68,6 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitFunction(propertyAccessor, null)
     }
 
-    open fun visitDefaultPropertyAccessor(defaultPropertyAccessor: FirDefaultPropertyAccessor) {
-        visitPropertyAccessor(defaultPropertyAccessor, null)
-    }
-
     open fun visitErrorDeclaration(errorDeclaration: FirErrorDeclaration) {
         visitDeclaration(errorDeclaration, null)
     }
@@ -582,10 +576,6 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitDeclarationWithBody(declarationWithBody)
     }
 
-    final override fun visitDefaultPropertyAccessor(defaultPropertyAccessor: FirDefaultPropertyAccessor, data: Nothing?) {
-        visitDefaultPropertyAccessor(defaultPropertyAccessor)
-    }
-
     final override fun visitDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference, data: Nothing?) {
         visitDelegateFieldReference(delegateFieldReference)
     }
@@ -638,7 +628,7 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitFile(file)
     }
 
-    final override fun visitFunction(function: FirFunction, data: Nothing?) {
+    final override fun <F : FirFunction<F>> visitFunction(function: FirFunction<F>, data: Nothing?) {
         visitFunction(function)
     }
 
@@ -698,7 +688,7 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitModifiableClass(modifiableClass)
     }
 
-    final override fun visitModifiableFunction(modifiableFunction: FirModifiableFunction, data: Nothing?) {
+    final override fun <F : FirFunction<F>> visitModifiableFunction(modifiableFunction: FirModifiableFunction<F>, data: Nothing?) {
         visitModifiableFunction(modifiableFunction)
     }