FIR: Get rid of FirCallableSymbol::isFakeOverride and isIntersectionOverride

compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirBuiltinSymbolProvider.kt

@@ -208,7 +208,7 @@ class FirBuiltinSymbolProvider(session: FirSession, val kotlinScopeProvider: Kot
                                 symbol = FirNamedFunctionSymbol(
                                     CallableId(packageFqName, relativeClassName, name),
                                     // set overriddenSymbol for "invoke" of KFunction/KSuspendFunction
-                                    superKind != null, superKind?.getInvoke(arity)
+                                    superKind?.getInvoke(arity)
                                 )
                                 resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
                                 valueParameters += typeArguments.dropLast(1).mapIndexed { index, typeArgument ->

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

@@ -218,7 +218,7 @@ internal tailrec fun FirCallableSymbol<*>.deepestOverriddenSymbol(): FirCallable
 }
 
 internal tailrec fun FirCallableSymbol<*>.deepestMatchingOverriddenSymbol(root: FirCallableSymbol<*> = this): FirCallableSymbol<*> {
-    if (isIntersectionOverride) return this
+    if (fir.isIntersectionOverride) return this
     val overriddenSymbol = overriddenSymbol?.takeIf {
         it.containingClass() == root.containingClass()
     } ?: return this

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

@@ -1033,8 +1033,8 @@ class Fir2IrDeclarationStorage(
                         val irFunction = firDeclaration.convertWithOffsets { startOffset, endOffset ->
                             symbolTable.declareSimpleFunction(signature, { symbol }) {
                                 val isFakeOverride =
-                                    firFunctionSymbol is FirNamedFunctionSymbol && firFunctionSymbol.isFakeOverride &&
+                                    firFunctionSymbol is FirNamedFunctionSymbol && firFunctionSymbol.fir.isSubstitutionOverride &&
-                                            firFunctionSymbol.callableId != firFunctionSymbol.overriddenSymbol?.callableId
+                                            firFunctionSymbol.dispatchReceiverClassOrNull() != firFunctionSymbol.overriddenSymbol?.dispatchReceiverClassOrNull()
                                 Fir2IrLazySimpleFunction(
                                     components, startOffset, endOffset, parentOrigin, firDeclaration, irParent.fir, symbol, isFakeOverride
                                 ).apply {
@@ -1065,7 +1065,7 @@ class Fir2IrDeclarationStorage(
         parentOrigin: IrDeclarationOrigin,
         irParent: IrDeclarationParent?
     ): IrDeclarationOrigin {
-        return if (irParent.isSourceClass() && symbol.isIntersectionOverride || (symbol.fir.origin as? PossiblyFirFakeOverrideSymbol<*, *>)?.isFakeOverride == true)
+        return if (irParent.isSourceClass() && symbol.fir.isIntersectionOverride)
             IrDeclarationOrigin.FAKE_OVERRIDE
         else
             parentOrigin
@@ -1100,7 +1100,7 @@ class Fir2IrDeclarationStorage(
                 val irProperty = fir.convertWithOffsets { startOffset, endOffset ->
                     symbolTable.declareProperty(signature, { symbol }) {
                         val isFakeOverride =
-                            firPropertySymbol.isFakeOverride &&
+                            firPropertySymbol.fir.isSubstitutionOverride &&
                                     firPropertySymbol.dispatchReceiverClassOrNull() != firPropertySymbol.overriddenSymbol?.dispatchReceiverClassOrNull()
                         Fir2IrLazyProperty(
                             components, startOffset, endOffset, declarationOrigin, fir, irParent.fir, symbol, isFakeOverride

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

@@ -8,6 +8,8 @@ package org.jetbrains.kotlin.fir.backend.generators
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.backend.*
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.isIntersectionOverride
+import org.jetbrains.kotlin.fir.isSubstitutionOverride
 import org.jetbrains.kotlin.fir.scopes.*
 import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
@@ -100,7 +102,7 @@ internal class DelegatedMemberGenerator(
         val wrappedSymbol = wrapped.symbol as? S ?: return null
 
         return when {
-            wrappedSymbol.isFakeOverride &&
+            wrappedSymbol.fir.isSubstitutionOverride &&
                     (wrappedSymbol.fir.dispatchReceiverType as? ConeClassLikeType)?.lookupTag == firSubClass.symbol.toLookupTag() ->
                 wrapped.symbol.overriddenSymbol!!.fir
             else -> wrapped
@@ -108,13 +110,13 @@ internal class DelegatedMemberGenerator(
     }
 
     private fun isJavaDefault(function: FirSimpleFunction): Boolean {
-        if (function.symbol.isIntersectionOverride) return isJavaDefault(function.symbol.overriddenSymbol!!.fir)
+        if (function.isIntersectionOverride) return isJavaDefault(function.symbol.overriddenSymbol!!.fir)
         return function.origin == FirDeclarationOrigin.Enhancement && function.modality == Modality.OPEN
     }
 
     private fun <S : FirCallableSymbol<*>> S.unwrapIntersectionOverride(directOverridden: S.() -> List<S>): S? {
         if (this !is PossiblyFirFakeOverrideSymbol<*, *>) return this
-        if (this.isIntersectionOverride) return directOverridden().firstOrNull { it.fir.delegatedWrapperData != null }
+        if (this.fir.isIntersectionOverride) return directOverridden().firstOrNull { it.fir.delegatedWrapperData != null }
         return this
     }
 

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

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.backend.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.dispatchReceiverClassOrNull
+import org.jetbrains.kotlin.fir.isSubstitutionOverride
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.defaultType
 import org.jetbrains.kotlin.fir.scopes.FirTypeScope
@@ -157,9 +158,7 @@ class FakeOverrideGenerator(
         val origin = IrDeclarationOrigin.FAKE_OVERRIDE
         val baseSymbol = originalSymbol.deepestOverriddenSymbol() as S
 
-        if ((originalSymbol.isFakeOverride || originalSymbol.isIntersectionOverride) &&
+        if (originalSymbol.fir.origin.fromSupertypes && originalSymbol.dispatchReceiverClassOrNull() == classLookupTag) {
-            originalSymbol.dispatchReceiverClassOrNull() == classLookupTag
-        ) {
             // Substitution case
             // NB: see comment above about substituted function' parent
             val irDeclaration = cachedIrDeclaration(originalDeclaration)?.takeIf { it.parent == irClass }
@@ -201,10 +200,10 @@ class FakeOverrideGenerator(
         scope: FirTypeScope,
         containingClass: ConeClassLikeLookupTag,
     ): List<S> {
-        if (!symbol.isIntersectionOverride) return listOf(basedSymbol)
+        if (symbol.fir.origin != FirDeclarationOrigin.IntersectionOverride) return listOf(basedSymbol)
         return scope.directOverridden(symbol).map {
             @Suppress("UNCHECKED_CAST")
-            if (it is PossiblyFirFakeOverrideSymbol<*, *> && it.isFakeOverride && it.dispatchReceiverClassOrNull() == containingClass)
+            if (it is PossiblyFirFakeOverrideSymbol<*, *> && it.fir.isSubstitutionOverride && it.dispatchReceiverClassOrNull() == containingClass)
                 it.overriddenSymbol!! as S
             else
                 it

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

@@ -211,13 +211,13 @@ private class ReturnTypeCalculatorWithJump(
             return tryCalculateReturnType(declaration.getter.delegate)
         }
 
-        if (declaration.origin == FirDeclarationOrigin.IntersectionOverride) {
+        if (declaration.isIntersectionOverride) {
             val result = tryCalculateReturnType(declaration.symbol.overriddenSymbol!!.fir)
             declaration.replaceReturnTypeRef(result)
             return result
         }
 
-        runIf(declaration.origin == FirDeclarationOrigin.SubstitutionOverride) {
+        runIf(declaration.isSubstitutionOverride) {
             val possiblyFirFakeOverrideSymbol = declaration.symbol as PossiblyFirFakeOverrideSymbol<*, *>
             val overriddenDeclaration = possiblyFirFakeOverrideSymbol.overriddenSymbol?.fir as FirTypedDeclaration? ?: return@runIf
             tryCalculateReturnType(overriddenDeclaration)

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

@@ -92,11 +92,11 @@ class FirDelegatedMemberScope(
             val delegatedSymbol = delegatedPropertyCache.getOrPut(propertySymbol) {
                 FirFakeOverrideGenerator.createCopyForFirProperty(
                     FirPropertySymbol(
-                        propertySymbol.callableId,
+                        propertySymbol.callableId
-                        overriddenSymbol = propertySymbol
                     ),
                     original,
                     session,
+                    FirDeclarationOrigin.Delegated,
                     newModality = Modality.OPEN,
                     newDispatchReceiverType = dispatchReceiverType,
                 ).apply {

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

@@ -43,7 +43,7 @@ object FirFakeOverrideGenerator {
     ): FirNamedFunctionSymbol {
         val symbol = FirNamedFunctionSymbol(
             CallableId(derivedClassId ?: baseSymbol.callableId.classId!!, baseFunction.name),
-            isFakeOverride = true, overriddenSymbol = baseSymbol
+            overriddenSymbol = baseSymbol
         )
         createFakeOverrideFunction(
             symbol, session, baseFunction, newDispatchReceiverType, newReceiverType, newReturnType,
@@ -250,10 +250,10 @@ object FirFakeOverrideGenerator {
     ): FirPropertySymbol {
         val symbol = FirPropertySymbol(
             CallableId(derivedClassId ?: baseSymbol.callableId.classId!!, baseProperty.name),
-            isFakeOverride = true, overriddenSymbol = baseSymbol
+            overriddenSymbol = baseSymbol
         )
         createCopyForFirProperty(
-            symbol, baseProperty, session, isExpect,
+            symbol, baseProperty, session, FirDeclarationOrigin.SubstitutionOverride, isExpect,
             newDispatchReceiverType, newTypeParameters, newReceiverType, newReturnType,
             fakeOverrideSubstitution = fakeOverrideSubstitution
         )
@@ -264,6 +264,7 @@ object FirFakeOverrideGenerator {
         newSymbol: FirPropertySymbol,
         baseProperty: FirProperty,
         session: FirSession,
+        origin: FirDeclarationOrigin,
         isExpect: Boolean = baseProperty.isExpect,
         newDispatchReceiverType: ConeKotlinType?,
         newTypeParameters: List<FirTypeParameter>? = null,
@@ -276,7 +277,7 @@ object FirFakeOverrideGenerator {
         return buildProperty {
             source = baseProperty.source
             this.session = session
-            origin = FirDeclarationOrigin.SubstitutionOverride
+            this.origin = origin
             name = baseProperty.name
             isVar = baseProperty.isVar
             this.symbol = newSymbol

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

@@ -5,8 +5,10 @@
 
 package org.jetbrains.kotlin.fir.scopes.impl
 
-import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
+import org.jetbrains.kotlin.fir.declarations.FirCallableMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirTypedDeclaration
+import org.jetbrains.kotlin.fir.isIntersectionOverride
+import org.jetbrains.kotlin.fir.isSubstitutionOverride
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.scopes.FakeOverrideTypeCalculator
 import org.jetbrains.kotlin.fir.scopes.FirTypeScope
@@ -73,7 +75,8 @@ class FirScopeWithFakeOverrideTypeCalculator(
     }
 
     private fun updateReturnType(declaration: FirTypedDeclaration) {
-        if (declaration.origin == FirDeclarationOrigin.SubstitutionOverride || declaration.origin == FirDeclarationOrigin.IntersectionOverride) {
+        if (declaration !is FirCallableMemberDeclaration<*>) return
+        if (declaration.isSubstitutionOverride || declaration.isIntersectionOverride) {
             fakeOverrideTypeCalculator.computeReturnType(declaration)
         }
     }

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

@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.fir.dispatchReceiverClassOrNull
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.scopes.*
 import org.jetbrains.kotlin.fir.symbols.CallableId
-import org.jetbrains.kotlin.fir.symbols.PossiblyFirFakeOverrideSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.name.Name
@@ -187,7 +186,7 @@ class FirTypeIntersectionScope private constructor(
         processDirectOverridden: FirTypeScope.(D, (D, FirTypeScope) -> ProcessorAction) -> ProcessorAction,
     ) {
         if (!visited.add(symbol)) return
-        if (!symbol.isIntersectionOverride && !(symbol as PossiblyFirFakeOverrideSymbol<*, *>).isFakeOverride) {
+        if (!symbol.fir.origin.fromSupertypes) {
             result.add(MemberWithBaseScope(symbol, scope))
             return
         }
@@ -265,9 +264,7 @@ class FirTypeIntersectionScope private constructor(
                     dispatchReceiverType.classId ?: mostSpecific.dispatchReceiverClassOrNull()?.classId!!,
                     mostSpecific.fir.name
                 ),
-                mostSpecific.isFakeOverride,
+                mostSpecific
-                mostSpecific,
-                isIntersectionOverride = true
             )
         val mostSpecificFunction = mostSpecific.fir
         FirFakeOverrideGenerator.createCopyForFirFunction(
@@ -286,10 +283,10 @@ class FirTypeIntersectionScope private constructor(
         newModality: Modality,
         newVisibility: Visibility,
     ): FirPropertySymbol {
-        val newSymbol = FirPropertySymbol(mostSpecific.callableId, mostSpecific.isFakeOverride, mostSpecific, isIntersectionOverride = true)
+        val newSymbol = FirPropertySymbol(mostSpecific.callableId, mostSpecific)
         val mostSpecificProperty = mostSpecific.fir
         FirFakeOverrideGenerator.createCopyForFirProperty(
-            newSymbol, mostSpecificProperty, mostSpecificProperty.session,
+            newSymbol, mostSpecificProperty, mostSpecificProperty.session, FirDeclarationOrigin.IntersectionOverride,
             newModality = newModality,
             newVisibility = newVisibility,
             newDispatchReceiverType = dispatchReceiverType,

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

@@ -5,10 +5,7 @@
 
 package org.jetbrains.kotlin.fir
 
-import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
+import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.FirCallableMemberDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirDeclarationDataKey
-import org.jetbrains.kotlin.fir.declarations.FirDeclarationDataRegistry
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
@@ -19,7 +16,7 @@ fun FirCallableSymbol<*>.dispatchReceiverClassOrNull(): ConeClassLikeLookupTag?
 
 fun FirCallableDeclaration<*>.dispatchReceiverClassOrNull(): ConeClassLikeLookupTag? {
     if (this !is FirCallableMemberDeclaration<*>) return null
-    if (dispatchReceiverType is ConeIntersectionType && symbol.isIntersectionOverride) return symbol.overriddenSymbol!!.fir.dispatchReceiverClassOrNull()
+    if (dispatchReceiverType is ConeIntersectionType && isIntersectionOverride) return symbol.overriddenSymbol!!.fir.dispatchReceiverClassOrNull()
 
     return (dispatchReceiverType as? ConeClassLikeType)?.lookupTag
 }
@@ -31,3 +28,7 @@ fun FirCallableDeclaration<*>.containingClass(): ConeClassLikeLookupTag? {
 
 private object ContainingClassKey : FirDeclarationDataKey()
 var FirCallableDeclaration<*>.containingClassAttr: ConeClassLikeLookupTag? by FirDeclarationDataRegistry.data(ContainingClassKey)
+
+
+val FirCallableDeclaration<*>.isIntersectionOverride get() = origin == FirDeclarationOrigin.IntersectionOverride
+val FirCallableDeclaration<*>.isSubstitutionOverride get() = origin == FirDeclarationOrigin.SubstitutionOverride

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

@@ -973,14 +973,10 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
     override fun visitResolvedNamedReference(resolvedNamedReference: FirResolvedNamedReference) {
         print("R|")
         val symbol = resolvedNamedReference.resolvedSymbol
-        val isFakeOverride = when (symbol) {
+        val isSubstitutionOverride = (symbol.fir as? FirCallableMemberDeclaration)?.isSubstitutionOverride == true
-            is FirNamedFunctionSymbol -> symbol.isFakeOverride
-            is FirPropertySymbol -> symbol.isFakeOverride
-            else -> false
-        }
 
-        if (isFakeOverride) {
+        if (isSubstitutionOverride) {
-            print("FakeOverride<")
+            print("SubstitutionOverride<")
         }
 
         print(symbol.unwrapIntersectionOverrides().render())
@@ -995,7 +991,7 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
             }
         }
 
-        if (isFakeOverride) {
+        if (isSubstitutionOverride) {
             when (symbol) {
                 is FirNamedFunctionSymbol -> {
                     print(": ")
@@ -1012,7 +1008,7 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
     }
 
     private fun AbstractFirBasedSymbol<*>.unwrapIntersectionOverrides(): AbstractFirBasedSymbol<*> {
-        if (this is FirCallableSymbol<*> && isIntersectionOverride) return overriddenSymbol!!.unwrapIntersectionOverrides()
+        if (this is FirCallableSymbol<*> && fir.isIntersectionOverride) return overriddenSymbol!!.unwrapIntersectionOverrides()
         return this
     }
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/scopes/FirTypeScope.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.fir.scopes
 
+import org.jetbrains.kotlin.fir.isIntersectionOverride
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
@@ -69,7 +70,7 @@ abstract class FirTypeScope : FirScope(), FirContainingNamesAwareScope {
                 ?: return baseScope.processDirectOverriddenCallables(callableSymbol, processor)
 
             for (overridden in directOverridden) {
-                if (overridden.isIntersectionOverride) {
+                if (overridden.fir.isIntersectionOverride) {
                     if (!baseScope.processDirectOverriddenCallables(overridden, processor)) return ProcessorAction.STOP
                 }
                 if (!processor(overridden, baseScope)) return ProcessorAction.STOP

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

@@ -9,7 +9,5 @@ import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 
 interface PossiblyFirFakeOverrideSymbol<E, S : FirBasedSymbol<E>> : FirBasedSymbol<E> where E : FirSymbolOwner<E>, E : FirDeclaration {
-    // contract isFakeOverride == true <=> overriddenSymbol != null
-    val isFakeOverride: Boolean
     val overriddenSymbol: S?
-}
+}

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

@@ -17,8 +17,6 @@ abstract class FirCallableSymbol<D : FirCallableDeclaration<D>> : AbstractFirBas
 
     open val overriddenSymbol: FirCallableSymbol<D>?
         get() = null
-
-    open val isIntersectionOverride: Boolean get() = false
 }
 
 val FirCallableSymbol<*>.isStatic: Boolean get() = (fir as? FirMemberDeclaration)?.status?.isStatic == true

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

@@ -24,10 +24,7 @@ sealed class FirFunctionSymbol<D : FirFunction<D>>(
 
 open class FirNamedFunctionSymbol(
     callableId: CallableId,
-    override val isFakeOverride: Boolean = false,
-    // Actual for fake override only
     override val overriddenSymbol: FirNamedFunctionSymbol? = null,
-    override val isIntersectionOverride: Boolean = false,
 ) : FirFunctionSymbol<FirSimpleFunction>(callableId), PossiblyFirFakeOverrideSymbol<FirSimpleFunction, FirNamedFunctionSymbol>
 
 class FirConstructorSymbol(

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

@@ -23,10 +23,7 @@ open class FirVariableSymbol<D : FirVariable<D>>(override val callableId: Callab
 
 open class FirPropertySymbol(
     callableId: CallableId,
-    override val isFakeOverride: Boolean = false,
-    // Actual for fake override only
     override val overriddenSymbol: FirPropertySymbol? = null,
-    override val isIntersectionOverride: Boolean = false,
 ) : FirVariableSymbol<FirProperty>(callableId), PossiblyFirFakeOverrideSymbol<FirProperty, FirPropertySymbol> {
     // TODO: should we use this constructor for local variables?
     constructor(name: Name) : this(CallableId(name))

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/fir/FirUtils.kt

@@ -6,10 +6,12 @@
 package org.jetbrains.kotlin.idea.fir
 
 import org.jetbrains.kotlin.fir.FirSymbolOwner
+import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
+import org.jetbrains.kotlin.fir.isIntersectionOverride
+import org.jetbrains.kotlin.fir.isSubstitutionOverride
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
@@ -50,6 +52,6 @@ internal inline fun <reified D> D.unrollFakeOverrides(): D where D : FirDeclarat
 
 private inline val FirBasedSymbol<*>.isFakeOrIntersectionOverride: Boolean
     get() {
-        val origin = (fir as? FirDeclaration)?.origin ?: return false
+        val declaration = fir as? FirCallableDeclaration<*> ?: return false
-        return origin == FirDeclarationOrigin.SubstitutionOverride || origin == FirDeclarationOrigin.IntersectionOverride
+        return declaration.isSubstitutionOverride || declaration.isIntersectionOverride
     }

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/scopes/KtFirDelegatingScope.kt

@@ -5,7 +5,8 @@
 
 package org.jetbrains.kotlin.idea.frontend.api.fir.scopes
 
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
+import org.jetbrains.kotlin.fir.isSubstitutionOverride
 import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.processClassifiersByName
@@ -65,7 +66,7 @@ internal fun FirScope.getCallableSymbols(callableNames: Collection<Name>, builde
         }
         processPropertiesByName(name) { firSymbol ->
             val symbol = when {
-                firSymbol is FirPropertySymbol && firSymbol.isFakeOverride -> {
+                firSymbol is FirPropertySymbol && firSymbol.fir.isSubstitutionOverride -> {
                     builder.buildVariableSymbol(firSymbol.fir)
                 }
                 else -> builder.buildCallableSymbol(firSymbol.fir)
@@ -85,4 +86,4 @@ internal fun FirScope.getClassifierSymbols(classLikeNames: Collection<Name>, bui
             }
             yieldAll(classifierSymbols)
         }
-    }
+    }

plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/AllOpenMemberGenerator.kt

@@ -46,7 +46,7 @@ class AllOpenMemberGenerator(session: FirSession) : FirDeclarationGenerationExte
             returnTypeRef = annotatedDeclaration.returnTypeRef
             status = annotatedDeclaration.status
             name = Name.identifier("hello${propertyName.capitalize()}")
-            symbol = FirNamedFunctionSymbol(CallableId(owner.classId, name), isFakeOverride = false)
+            symbol = FirNamedFunctionSymbol(CallableId(owner.classId, name))
         }
         return listOf(GeneratedDeclaration(function, owner))
     }
@@ -55,4 +55,4 @@ class AllOpenMemberGenerator(session: FirSession) : FirDeclarationGenerationExte
 
     override val key: FirPluginKey
         get() = AllOpenPluginKey
-}
+}

plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/AllOpenNestedClassGenerator.kt

@@ -81,7 +81,7 @@ class AllOpenNestedClassGenerator(session: FirSession) : FirDeclarationGeneratio
                 Modality.FINAL
             )
             name = Name.identifier("hello")
-            symbol = FirNamedFunctionSymbol(CallableId(classId, name), isFakeOverride = false)
+            symbol = FirNamedFunctionSymbol(CallableId(classId, name))
         }
         return listOf(constructor, function)
     }

plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/AllOpenTopLevelDeclarationsGenerator.kt

@@ -59,7 +59,7 @@ class AllOpenTopLevelDeclarationsGenerator(session: FirSession) : FirDeclaration
                 Modality.FINAL
             )
             name = Name.identifier("hello")
-            symbol = FirNamedFunctionSymbol(CallableId(klass.symbol.classId, name), isFakeOverride = false)
+            symbol = FirNamedFunctionSymbol(CallableId(klass.symbol.classId, name))
         }
         return listOf(function)
     }