[FIR2IR] Use FIR-specific methods to search for overridden functions

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

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.fir.backend
 
+import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.expressions.FirReturnExpression
 import org.jetbrains.kotlin.ir.declarations.*
@@ -13,6 +14,8 @@ import org.jetbrains.kotlin.ir.util.parentClassOrNull
 class Fir2IrConversionScope {
     private val parentStack = mutableListOf<IrDeclarationParent>()
 
+    private val containingFirClassStack = mutableListOf<FirClass<*>>()
+
     fun <T : IrDeclarationParent?> withParent(parent: T, f: T.() -> Unit): T {
         if (parent == null) return parent
         parentStack += parent
@@ -21,6 +24,12 @@ class Fir2IrConversionScope {
         return parent
     }
 
+    fun withContainingFirClass(containingFirClass: FirClass<*>, f: () -> Unit) {
+        containingFirClassStack += containingFirClass
+        f()
+        containingFirClassStack.removeAt(containingFirClassStack.size - 1)
+    }
+
     fun parentFromStack(): IrDeclarationParent = parentStack.last()
 
     fun parentAccessorOfPropertyFromStack(property: IrProperty): IrSimpleFunction? {
@@ -38,6 +47,8 @@ class Fir2IrConversionScope {
         return declaration
     }
 
+    fun containerFirClass(): FirClass<*>? = containingFirClassStack.lastOrNull()
+
     private val functionStack = mutableListOf<IrFunction>()
 
     fun <T : IrFunction> withFunction(function: T, f: T.() -> Unit): T {

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

@@ -75,7 +75,7 @@ class Fir2IrConverter(
     fun processFileAndClassMembers(file: FirFile) {
         val irFile = declarationStorage.getIrFile(file)
         for (declaration in file.declarations) {
-            val irDeclaration = processMemberDeclaration(declaration, irFile) ?: continue
+            val irDeclaration = processMemberDeclaration(declaration, null, irFile) ?: continue
             irFile.declarations += irDeclaration
         }
     }
@@ -92,7 +92,7 @@ class Fir2IrConverter(
                 registerClassAndNestedClasses(declaration, irClass)
                 processClassAndNestedClassHeaders(declaration)
             }
-            val irDeclaration = processMemberDeclaration(declaration, irClass) ?: continue
+            val irDeclaration = processMemberDeclaration(declaration, anonymousObject, irClass) ?: continue
             irClass.declarations += irDeclaration
         }
         return irClass
@@ -113,7 +113,7 @@ class Fir2IrConverter(
             irClass.declarations += declarationStorage.createIrConstructor(it, irClass)
         }
         for (declaration in sortBySynthetic(regularClass.declarations)) {
-            val irDeclaration = processMemberDeclaration(declaration, irClass) ?: continue
+            val irDeclaration = processMemberDeclaration(declaration, regularClass, irClass) ?: continue
             irClass.declarations += irDeclaration
         }
         return irClass
@@ -138,7 +138,11 @@ class Fir2IrConverter(
         }
     }
 
-    private fun processMemberDeclaration(declaration: FirDeclaration, parent: IrDeclarationParent): IrDeclaration? {
+    private fun processMemberDeclaration(
+        declaration: FirDeclaration,
+        containingClass: FirClass<*>?,
+        parent: IrDeclarationParent
+    ): IrDeclaration? {
         return when (declaration) {
             is FirRegularClass -> {
                 processClassMembers(declaration)

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

@@ -420,9 +420,6 @@ class Fir2IrDeclarationStorage(
                 created.overriddenSymbols += getIrFunctionSymbol(it) as IrSimpleFunctionSymbol
             }
         }
-        if (!created.isFakeOverride && thisReceiverOwner != null) {
-            created.populateOverriddenSymbols(thisReceiverOwner)
-        }
         functionCache[function] = created
         return created
     }

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

@@ -109,9 +109,12 @@ class Fir2IrVisitor(
         val correspondingClass = irEnumEntry.correspondingClass ?: return irEnumEntry
         declarationStorage.enterScope(irEnumEntry)
         classifierStorage.putEnumEntryClassInScope(enumEntry, correspondingClass)
-        converter.processAnonymousObjectMembers(enumEntry.initializer as FirAnonymousObject, correspondingClass)
+        val anonymousObject = enumEntry.initializer as FirAnonymousObject
+        converter.processAnonymousObjectMembers(anonymousObject, correspondingClass)
         conversionScope.withParent(correspondingClass) {
-            memberGenerator.convertClassContent(correspondingClass, enumEntry.initializer as FirAnonymousObject)
+            conversionScope.withContainingFirClass(anonymousObject) {
+                memberGenerator.convertClassContent(correspondingClass, anonymousObject)
+            }
             val constructor = correspondingClass.constructors.first()
             irEnumEntry.initializerExpression = IrExpressionBodyImpl(
                 IrEnumConstructorCallImpl(
@@ -141,7 +144,9 @@ class Fir2IrVisitor(
         }
         val irClass = classifierStorage.getCachedIrClass(regularClass)!!
         return conversionScope.withParent(irClass) {
-            memberGenerator.convertClassContent(irClass, regularClass)
+            conversionScope.withContainingFirClass(regularClass) {
+                memberGenerator.convertClassContent(irClass, regularClass)
+            }
         }
     }
 
@@ -152,7 +157,9 @@ class Fir2IrVisitor(
             ?: classifierStorage.createIrAnonymousObject(anonymousObject, irParent = irParent)
         converter.processAnonymousObjectMembers(anonymousObject, irAnonymousObject)
         conversionScope.withParent(irAnonymousObject) {
-            memberGenerator.convertClassContent(irAnonymousObject, anonymousObject)
+            conversionScope.withContainingFirClass(anonymousObject) {
+                memberGenerator.convertClassContent(irAnonymousObject, anonymousObject)
+            }
         }
         val anonymousClassType = irAnonymousObject.thisReceiver!!.type
         return anonymousObject.convertWithOffsets { startOffset, endOffset ->
@@ -178,7 +185,7 @@ class Fir2IrVisitor(
     override fun visitConstructor(constructor: FirConstructor, data: Any?): IrElement {
         val irConstructor = declarationStorage.getCachedIrConstructor(constructor)!!
         return conversionScope.withFunction(irConstructor) {
-            memberGenerator.convertFunctionContent(irConstructor, constructor)
+            memberGenerator.convertFunctionContent(irConstructor, constructor, containingClass = conversionScope.containerFirClass())
         }
     }
 
@@ -192,21 +199,26 @@ class Fir2IrVisitor(
 
     override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: Any?): IrElement {
         val irFunction = if (simpleFunction.visibility == Visibilities.LOCAL) {
-            val irParent = conversionScope.parent()
+            declarationStorage.createIrFunction(
-            declarationStorage.createIrFunction(simpleFunction, irParent)
+                simpleFunction, irParent = conversionScope.parent()
+            )
         } else {
             declarationStorage.getCachedIrFunction(simpleFunction)!!
         }
         return conversionScope.withFunction(irFunction) {
-            memberGenerator.convertFunctionContent(irFunction, simpleFunction)
+            memberGenerator.convertFunctionContent(
+                irFunction, simpleFunction, containingClass = conversionScope.containerFirClass()
+            )
         }
     }
 
     override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: Any?): IrElement {
         return anonymousFunction.convertWithOffsets { startOffset, endOffset ->
-            val irFunction = declarationStorage.createIrFunction(anonymousFunction, conversionScope.parent())
+            val irFunction = declarationStorage.createIrFunction(
+                anonymousFunction, irParent = conversionScope.parent()
+            )
             conversionScope.withFunction(irFunction) {
-                memberGenerator.convertFunctionContent(irFunction, anonymousFunction)
+                memberGenerator.convertFunctionContent(irFunction, anonymousFunction, containingClass = null)
             }
 
             val type = anonymousFunction.typeRef.toIrType()

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

@@ -15,6 +15,8 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
+import org.jetbrains.kotlin.fir.scopes.ProcessorAction
+import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
 import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.ir.declarations.*
@@ -22,6 +24,7 @@ import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrFieldAccessExpression
 import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
+import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.util.*
 
@@ -49,7 +52,7 @@ internal class ClassMemberGenerator(
                     enterScope(irPrimaryConstructor)
                     irPrimaryConstructor.valueParameters.forEach { symbolTable.introduceValueParameter(it) }
                     irPrimaryConstructor.putParametersInScope(primaryConstructor)
-                    convertFunctionContent(irPrimaryConstructor, primaryConstructor)
+                    convertFunctionContent(irPrimaryConstructor, primaryConstructor, containingClass = klass)
                 }
             }
             val processedCallableNames = klass.declarations.mapNotNullTo(mutableSetOf()) {
@@ -102,7 +105,7 @@ internal class ClassMemberGenerator(
         declarationStorage.leaveScope(irClass)
     }
 
-    fun <T : IrFunction> convertFunctionContent(irFunction: T, firFunction: FirFunction<*>?): T {
+    fun <T : IrFunction> convertFunctionContent(irFunction: T, firFunction: FirFunction<*>?, containingClass: FirClass<*>?): T {
         conversionScope.withParent(irFunction) {
             if (firFunction != null) {
                 if (irFunction !is IrConstructor || !irFunction.isPrimary) {
@@ -167,6 +170,20 @@ internal class ClassMemberGenerator(
                 // Scope for primary constructor should be left after class declaration
                 declarationStorage.leaveScope(irFunction)
             }
+            if (irFunction is IrSimpleFunction && firFunction != null && containingClass != null) {
+                val scope = containingClass.unsubstitutedScope(session, scopeSession)
+                scope.processFunctionsByName(name) {}
+                val overriddenSet = mutableSetOf<IrSimpleFunctionSymbol>()
+                scope.processDirectlyOverriddenFunctions(firFunction.symbol) {
+                    if ((it.fir as FirSimpleFunction).visibility == Visibilities.PRIVATE) {
+                        return@processDirectlyOverriddenFunctions ProcessorAction.NEXT
+                    }
+                    val overridden = declarationStorage.getIrFunctionSymbol(it)
+                    overriddenSet += overridden as IrSimpleFunctionSymbol
+                    ProcessorAction.NEXT
+                }
+                irFunction.overriddenSymbols = overriddenSet.toList()
+            }
         }
         return irFunction
     }
@@ -213,7 +230,7 @@ internal class ClassMemberGenerator(
     ) {
         conversionScope.withFunction(this) {
             applyParentFromStackTo(this)
-            convertFunctionContent(this, propertyAccessor)
+            convertFunctionContent(this, propertyAccessor, containingClass = null)
             if (isDefault) {
                 conversionScope.withParent(this) {
                     declarationStorage.enterScope(this)

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

@@ -88,7 +88,8 @@ class FakeOverrideGenerator(
                         // That's why we must check parent during caching...
                         val irFunction = declarationStorage.getCachedIrFunction(originalFunction)?.takeIf { it.parent == this }
                             ?: declarationStorage.createIrFunction(
-                                originalFunction, irParent = this,
+                                originalFunction,
+                                irParent = this,
                                 thisReceiverOwner = declarationStorage.findIrParent(baseSymbol.fir) as? IrClass,
                                 origin = origin
                             )
@@ -111,7 +112,8 @@ class FakeOverrideGenerator(
 
                         classifierStorage.preCacheTypeParameters(originalFunction)
                         val irFunction = declarationStorage.createIrFunction(
-                            fakeOverrideFunction, irParent = this,
+                            fakeOverrideFunction,
+                            irParent = this,
                             thisReceiverOwner = declarationStorage.findIrParent(originalFunction) as? IrClass,
                             origin = origin
                         )
@@ -136,7 +138,7 @@ class FakeOverrideGenerator(
                     ) {
                         // Substitution case
                         // NB: see comment above about substituted function' parent
-                        val irProperty = declarationStorage.getCachedIrProperty(originalProperty)?.takeIf { it.parent == this}
+                        val irProperty = declarationStorage.getCachedIrProperty(originalProperty)?.takeIf { it.parent == this }
                             ?: declarationStorage.createIrProperty(
                                 originalProperty, irParent = this,
                                 thisReceiverOwner = declarationStorage.findIrParent(baseSymbol.fir) as? IrClass,

compiler/testData/codegen/box/builtinStubMethods/substitutedListWithExtraSuperInterface.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 // TARGET_BACKEND: JVM
 
 // FILE: Test.java

compiler/testData/codegen/box/collections/noStubsInJavaSuperClass.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 // TARGET_BACKEND: JVM
 
 // FILE: B.java

compiler/testData/codegen/box/collections/strList.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 // TARGET_BACKEND: JVM
 
 // FILE: J.java

compiler/testData/codegen/box/coroutines/createCoroutinesOnManualInstances.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 // KJS_WITH_FULL_RUNTIME
 // IGNORE_BACKEND: JS_IR
 // IGNORE_BACKEND: JS_IR_ES6

compiler/testData/codegen/box/inlineClasses/functionNameMangling/overridingMethodInGenericClass2.kt

@@ -1,5 +1,4 @@
 // !LANGUAGE: +InlineClasses
-// IGNORE_BACKEND_FIR: JVM_IR
 
 abstract class GenericBase<T> {
     abstract fun foo(x: T): T

compiler/testData/codegen/box/inlineClasses/inlineClassImplementsCollection.kt

@@ -1,5 +1,4 @@
 // !LANGUAGE: +InlineClasses
-// IGNORE_BACKEND_FIR: JVM_IR
 // WITH_RUNTIME
 // TARGET_BACKEND: JVM
 

compiler/testData/codegen/box/sam/partialSam.kt

@@ -1,5 +1,4 @@
 // !LANGUAGE: +NewInference +SamConversionPerArgument
-// IGNORE_BACKEND_FIR: JVM_IR
 // TARGET_BACKEND: JVM
 // WITH_RUNTIME
 // FILE: Fn.java

compiler/testData/codegen/box/sam/partialSamKT.kt

@@ -1,5 +1,4 @@
 // !LANGUAGE: +NewInference +SamConversionForKotlinFunctions +SamConversionPerArgument
-// IGNORE_BACKEND_FIR: JVM_IR
 // TARGET_BACKEND: JVM
 // WITH_RUNTIME
 // FILE: Fn.java

compiler/testData/codegen/box/specialBuiltins/removeSetInt.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 // KJS_WITH_FULL_RUNTIME
 // IGNORE_BACKEND: NATIVE
 class MySet : HashSet<Int>() {

compiler/testData/ir/irText/classes/implicitNotNullOnDelegatedImplementation.fir.txt

@@ -97,8 +97,8 @@ FILE fqName:<root> fileName:/implicitNotNullOnDelegatedImplementation.kt
         INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:K4 modality:FINAL visibility:public superTypes:[<root>.JUnrelatedFoo; <root>.IFoo]'
     FUN name:foo visibility:public modality:FINAL <> ($this:<root>.K4) returnType:kotlin.String?
       overridden:
-        public open fun foo (): kotlin.String? declared in <root>.JUnrelatedFoo
         public abstract fun foo (): kotlin.String declared in <root>.IFoo
+        public open fun foo (): kotlin.String? declared in <root>.JUnrelatedFoo
       $this: VALUE_PARAMETER name:<this> type:<root>.K4
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public final fun foo (): kotlin.String? declared in <root>.K4'

compiler/testData/ir/irText/declarations/multiplatform/expectClassInherited.fir.txt

@@ -22,6 +22,8 @@ FILE fqName:<root> fileName:/expectClassInherited.kt
     CONSTRUCTOR visibility:public <> (i:kotlin.Int) returnType:<root>.B [primary,expect]
       VALUE_PARAMETER name:i index:0 type:kotlin.Int
     FUN name:foo visibility:public modality:OPEN <> ($this:<root>.B) returnType:kotlin.Unit [expect]
+      overridden:
+        public abstract fun foo (): kotlin.Unit declared in <root>.A
       $this: VALUE_PARAMETER name:<this> type:<root>.B
     FUN name:bar visibility:public modality:OPEN <> ($this:<root>.B, s:kotlin.String) returnType:kotlin.Unit [expect]
       $this: VALUE_PARAMETER name:<this> type:<root>.B

compiler/testData/ir/irText/types/castsInsideCoroutineInference.fir.txt

@@ -171,6 +171,8 @@ FILE fqName:<root> fileName:/castsInsideCoroutineInference.kt
             GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:collector type:<root>.FlowCollector<T of <root>.SafeCollector> visibility:private [final]' type=<root>.FlowCollector<T of <root>.SafeCollector> origin=null
               receiver: GET_VAR '<this>: <root>.SafeCollector<T of <root>.SafeCollector> declared in <root>.SafeCollector.<get-collector>' type=<root>.SafeCollector<T of <root>.SafeCollector> origin=null
     FUN name:emit visibility:public modality:FINAL <> ($this:<root>.SafeCollector<T of <root>.SafeCollector>, value:T of <root>.SafeCollector) returnType:kotlin.Unit [suspend]
+      overridden:
+        public abstract fun emit (value: T of <root>.FlowCollector): kotlin.Unit [suspend] declared in <root>.FlowCollector
       $this: VALUE_PARAMETER name:<this> type:<root>.SafeCollector<T of <root>.SafeCollector>
       VALUE_PARAMETER name:value index:0 type:T of <root>.SafeCollector
       BLOCK_BODY

compiler/testData/ir/irText/types/nullChecks/implicitNotNullOnPlatformType.fir.txt

@@ -26,6 +26,8 @@ FILE fqName:<root> fileName:/implicitNotNullOnPlatformType.kt
         RETURN type=kotlin.Nothing from='public final fun contains (element: kotlin.String): kotlin.Boolean declared in <root>.MySet'
           CALL 'public final fun TODO (): kotlin.Nothing [inline] declared in kotlin' type=kotlin.Nothing origin=null
     FUN name:containsAll visibility:public modality:FINAL <> ($this:<root>.MySet, elements:kotlin.collections.Collection<kotlin.String>) returnType:kotlin.Boolean
+      overridden:
+        public abstract fun containsAll (elements: kotlin.collections.Collection<E of kotlin.collections.Set>): kotlin.Boolean declared in kotlin.collections.Set
       $this: VALUE_PARAMETER name:<this> type:<root>.MySet
       VALUE_PARAMETER name:elements index:0 type:kotlin.collections.Collection<kotlin.String>
       BLOCK_BODY