[IR] Rename classes after refactoring

^KT-61934

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/pipeline/convertToIr.kt

@@ -168,7 +168,7 @@ fun FirResult.convertToIrAndActualize(
                 actualizerTypeContextProvider(fir2IrResult.irModuleFragment.irBuiltins),
                 fir2IrConfiguration.languageVersionSettings,
                 commonMemberStorage.symbolTable,
-                fir2IrResult.components.irOverridingUtil,
+                fir2IrResult.components.fakeOverrideBuilder,
                 fir2IrConfiguration.useIrFakeOverrideBuilder,
                 fir2IrConfiguration.expectActualTracker,
             )

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

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.signaturer.FirBasedSignatureComposer
 import org.jetbrains.kotlin.ir.IrLock
 import org.jetbrains.kotlin.ir.declarations.IrFactory
 import org.jetbrains.kotlin.ir.linkage.IrProvider
-import org.jetbrains.kotlin.ir.overrides.IrOverridingUtil
+import org.jetbrains.kotlin.ir.overrides.IrFakeOverrideBuilder
 import org.jetbrains.kotlin.ir.util.SymbolTable
 
 interface Fir2IrComponents {
@@ -43,7 +43,7 @@ interface Fir2IrComponents {
     val callGenerator: CallAndReferenceGenerator
     val fakeOverrideGenerator: FakeOverrideGenerator
     val delegatedMemberGenerator: DelegatedMemberGenerator
-    val irOverridingUtil: IrOverridingUtil
+    val fakeOverrideBuilder: IrFakeOverrideBuilder
 
     val extensions: Fir2IrExtensions
     val configuration: Fir2IrConfiguration

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

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrLock
 import org.jetbrains.kotlin.ir.declarations.IrFactory
 import org.jetbrains.kotlin.ir.linkage.IrProvider
-import org.jetbrains.kotlin.ir.overrides.IrOverridingUtil
+import org.jetbrains.kotlin.ir.overrides.IrFakeOverrideBuilder
 import org.jetbrains.kotlin.ir.util.KotlinMangler
 import org.jetbrains.kotlin.ir.util.SymbolTable
 
@@ -25,7 +25,7 @@ class Fir2IrComponentsStorage(
     override val extensions: Fir2IrExtensions,
     override val configuration: Fir2IrConfiguration,
     override val visibilityConverter: Fir2IrVisibilityConverter,
-    irOverridingUtilProvider: (IrBuiltIns) -> IrOverridingUtil,
+    irFakeOverrideBuilderProvider: (IrBuiltIns) -> IrFakeOverrideBuilder,
     moduleDescriptor: FirModuleDescriptor,
     commonMemberStorage: Fir2IrCommonMemberStorage,
     irMangler: KotlinMangler.IrMangler,
@@ -49,7 +49,7 @@ class Fir2IrComponentsStorage(
         this, configuration.languageVersionSettings, moduleDescriptor, irMangler
     )
     override val builtIns: Fir2IrBuiltIns = Fir2IrBuiltIns(this, specialSymbolProvider)
-    override val irOverridingUtil: IrOverridingUtil = irOverridingUtilProvider(irBuiltIns)
+    override val fakeOverrideBuilder: IrFakeOverrideBuilder = irFakeOverrideBuilderProvider(irBuiltIns)
 
     override val irProviders: List<IrProvider> = listOf(FirIrProvider(this))
 

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

@@ -43,7 +43,7 @@ import org.jetbrains.kotlin.ir.interpreter.IrInterpreterConfiguration
 import org.jetbrains.kotlin.ir.interpreter.IrInterpreterEnvironment
 import org.jetbrains.kotlin.ir.interpreter.checker.EvaluationMode
 import org.jetbrains.kotlin.ir.interpreter.transformer.transformConst
-import org.jetbrains.kotlin.ir.overrides.IrOverridingUtil
+import org.jetbrains.kotlin.ir.overrides.IrFakeOverrideBuilder
 import org.jetbrains.kotlin.ir.types.IrTypeSystemContext
 import org.jetbrains.kotlin.ir.symbols.impl.IrConstructorPublicSymbolImpl
 import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionPublicSymbolImpl
@@ -558,7 +558,7 @@ class Fir2IrConverter(
             val components = Fir2IrComponentsStorage(
                 session, scopeSession, irFactory, fir2IrExtensions, fir2IrConfiguration, visibilityConverter,
                 { irBuiltins ->
-                    IrOverridingUtil(
+                    IrFakeOverrideBuilder(
                         typeContextProvider(irBuiltins),
                         Fir2IrFakeOverrideStrategy(friendModulesMap(session), commonMemberStorage.symbolTable, irMangler),
                         externalOverridabilityConditions = emptyList(), // TODO: KT-61370, KT-61804.
@@ -583,7 +583,7 @@ class Fir2IrConverter(
             )
 
             if (fir2IrConfiguration.useIrFakeOverrideBuilder) {
-                FakeOverrideRebuilder(commonMemberStorage.symbolTable, components.irOverridingUtil).rebuildFakeOverrides(irModuleFragment)
+                FakeOverrideRebuilder(commonMemberStorage.symbolTable, components.fakeOverrideBuilder).rebuildFakeOverrides(irModuleFragment)
             }
 
             return Fir2IrResult(irModuleFragment, components, moduleDescriptor)

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

@@ -9,8 +9,8 @@ import org.jetbrains.kotlin.backend.common.serialization.signature.PublicIdSigna
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.declarations.IrFunctionWithLateBinding
 import org.jetbrains.kotlin.ir.declarations.IrPropertyWithLateBinding
-import org.jetbrains.kotlin.ir.linkage.partial.IrUnimplementedOverridesStrategy.ProcessAsFakeOverrides
 import org.jetbrains.kotlin.ir.overrides.FakeOverrideBuilderStrategy
+import org.jetbrains.kotlin.ir.overrides.IrUnimplementedOverridesStrategy.ProcessAsFakeOverrides
 import org.jetbrains.kotlin.ir.symbols.impl.IrPropertyPublicSymbolImpl
 import org.jetbrains.kotlin.ir.symbols.impl.IrPropertySymbolImpl
 import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionPublicSymbolImpl

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/FakeOverrideRebuilder.kt

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.ir.expressions.IrCall
 import org.jetbrains.kotlin.ir.expressions.IrFunctionReference
 import org.jetbrains.kotlin.ir.expressions.IrLocalDelegatedPropertyReference
 import org.jetbrains.kotlin.ir.expressions.IrPropertyReference
-import org.jetbrains.kotlin.ir.overrides.IrOverridingUtil
+import org.jetbrains.kotlin.ir.overrides.IrFakeOverrideBuilder
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
@@ -52,7 +52,7 @@ import org.jetbrains.kotlin.utils.newHashSetWithExpectedSize
  */
 class FakeOverrideRebuilder(
     val symbolTable: SymbolTable,
-    val irOverridingUtil: IrOverridingUtil,
+    val fakeOverrideBuilder: IrFakeOverrideBuilder,
 ) {
     private val removedFakeOverrides = mutableMapOf<IrClassSymbol, List<IrSymbol>>()
     private val processedClasses = hashSetOf<IrClass>()
@@ -115,7 +115,7 @@ class FakeOverrideRebuilder(
         for (c in irClass.superTypes) {
             c.getClass()?.let { rebuildClassFakeOverrides(it) }
         }
-        irOverridingUtil.buildFakeOverridesForClass(irClass, false)
+        fakeOverrideBuilder.buildFakeOverridesForClass(irClass, false)
 
         val overriddenMap = mutableMapOf<IrSymbol, IrSymbol>()
 

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizer.kt

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.overrides.IrOverridingUtil
+import org.jetbrains.kotlin.ir.overrides.IrFakeOverrideBuilder
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.types.IrTypeSystemContext
 import org.jetbrains.kotlin.ir.util.*
@@ -27,7 +27,7 @@ object IrActualizer {
         typeSystemContext: IrTypeSystemContext,
         languageVersionSettings: LanguageVersionSettings,
         symbolTable: SymbolTable,
-        irOverridingUtil: IrOverridingUtil,
+        fakeOverrideBuilder: IrFakeOverrideBuilder,
         useIrFakeOverrideBuilder: Boolean,
         expectActualTracker: ExpectActualTracker?
     ): IrActualizedResult {
@@ -79,7 +79,7 @@ object IrActualizer {
 
         if (useIrFakeOverrideBuilder) {
             //   8. Rebuild fake overrides from stretch, as they could become invalid during actualization
-            FakeOverrideRebuilder(symbolTable, irOverridingUtil).rebuildFakeOverrides(mainFragment)
+            FakeOverrideRebuilder(symbolTable, fakeOverrideBuilder).rebuildFakeOverrides(mainFragment)
         }
 
         return IrActualizedResult(removedExpectDeclarations)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/overrides/CopyIrTreeWithSymbolsForFakeOverrides.kt

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrOverridableMember
 import org.jetbrains.kotlin.ir.declarations.IrTypeParametersContainer
 import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
-import org.jetbrains.kotlin.ir.linkage.partial.IrUnimplementedOverridesStrategy
 import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol
 import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
 import org.jetbrains.kotlin.ir.types.*

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/overrides/FakeOverrideBuilderStrategy.kt

@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.linkage.partial.IrUnimplementedOverridesStrategy
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
 import org.jetbrains.kotlin.ir.types.IrSimpleType
@@ -22,17 +21,40 @@ import org.jetbrains.kotlin.ir.util.hasAnnotation
 import org.jetbrains.kotlin.ir.util.render
 import org.jetbrains.kotlin.types.Variance
 
+/**
+ * This class is a customization point for IrFakeOverrideBuilder.
+ *
+ * While the main [IrFakeOverrideBuilder] class works on:
+ *   * Choosing for which functions fake overrides should be created.
+ *   * Handling merging overrides coming from different super types
+ *
+ * These class inheritors are responsible for:
+ *   * Actually creating the fake override for a single member of a single super type
+ *   * Creating and registering in appropriate storages of fake override member symbols
+ *
+ */
 abstract class FakeOverrideBuilderStrategy(
     private val friendModules: Map<String, Collection<String>>,
     private val unimplementedOverridesStrategy: IrUnimplementedOverridesStrategy
 ) {
+    /**
+     * Creates a fake override for [member] from [superType] to be added to the class [clazz]
+     */
     fun fakeOverrideMember(superType: IrType, member: IrOverridableMember, clazz: IrClass): IrOverridableMember =
         buildFakeOverrideMember(superType, member, clazz, friendModules, unimplementedOverridesStrategy)
 
+    /**
+     * This function is a callback for fake override creation finish.
+     *
+     * It can modify the created fake override, if needed.
+     */
     fun postProcessGeneratedFakeOverride(fakeOverride: IrOverridableMember, clazz: IrClass) {
         unimplementedOverridesStrategy.postProcessGeneratedFakeOverride(fakeOverride as IrOverridableDeclaration<*>, clazz)
     }
 
+    /**
+     * Create a symbol for the fake override.
+     */
     fun linkFakeOverride(fakeOverride: IrOverridableMember, compatibilityMode: Boolean) {
         when (fakeOverride) {
             is IrFunctionWithLateBinding -> linkFunctionFakeOverride(fakeOverride, compatibilityMode)
@@ -40,9 +62,35 @@ abstract class FakeOverrideBuilderStrategy(
             else -> error("Unexpected fake override: $fakeOverride")
         }
     }
+
+    /**
+     * Most implementations need [file] in which they are working now.
+     *
+     * It should be avoided in the future, but for now it's like this.
+     * For now, it's called with class file when class processing is started.
+     *
+     * Contract:
+     *  * must call [block] exactly once.
+     */
     abstract fun inFile(file: IrFile?, block: () -> Unit)
 
+    /**
+     * Callback for creating a symbol for fake override function.
+     *
+     * Contract:
+     *   * [IrFunctionWithLateBinding.acquireSymbol] must be called inside on [function] argument
+     */
     protected abstract fun linkFunctionFakeOverride(function: IrFunctionWithLateBinding, manglerCompatibleMode: Boolean)
+
+    /**
+     * Callback for creating a symbol for fake override property.
+     *
+     * Also, must create symbols for property's getter and setter.
+     *
+     * Contract:
+     *   * [IrPropertyWithLateBinding.acquireSymbol] must be called inside on [property] argument
+     *   * [IrFunctionWithLateBinding.acquireSymbol] must be called inside on getter and setter of [property] argument, if they exist
+     */
     protected abstract fun linkPropertyFakeOverride(property: IrPropertyWithLateBinding, manglerCompatibleMode: Boolean)
 }
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/overrides/FakeOverrideCopier.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.ir.overrides
 
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.linkage.partial.IrUnimplementedOverridesStrategy
 import org.jetbrains.kotlin.ir.util.*
 
 class FakeOverrideCopier(

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/overrides/IrFakeOverrideBuilder.kt

@@ -23,15 +23,9 @@ import org.jetbrains.kotlin.utils.filterIsInstanceAnd
 import org.jetbrains.kotlin.utils.memoryOptimizedMap
 import org.jetbrains.kotlin.utils.memoryOptimizedMapNotNull
 
-// TODO:
+class IrFakeOverrideBuilder(
-// The below pile of code is basically half of OverridingUtil.java
-// adapted to IR and converted to Kotlin.
-// Need to convert frontend's OverridingUtil to Kotlin and merge this codes
-// to use abstract overridable member interfaces.
-
-class IrOverridingUtil(
     private val typeSystem: IrTypeSystemContext,
-    private val fakeOverrideBuilder: FakeOverrideBuilderStrategy,
+    private val strategy: FakeOverrideBuilderStrategy,
     private val externalOverridabilityConditions: List<IrExternalOverridabilityCondition>,
 ) {
     private val overrideChecker = IrOverrideChecker(typeSystem, externalOverridabilityConditions)
@@ -61,8 +55,11 @@ class IrOverridingUtil(
             }
         }
 
+    /**
+     * This function builds all fake overrides for [clazz] and computes overridden symbols for all its members.
+     */
     fun buildFakeOverridesForClass(clazz: IrClass, oldSignatures: Boolean) {
-        fakeOverrideBuilder.inFile(clazz.fileOrNull) {
+        strategy.inFile(clazz.fileOrNull) {
             val superTypes = clazz.superTypes
 
             val fromCurrent = clazz.declarations.filterIsInstance<IrOverridableMember>()
@@ -73,7 +70,7 @@ class IrOverridingUtil(
                     .filter { it.isOverridableMemberOrAccessor() }
                     .map {
                         val overriddenMember = it as IrOverridableMember
-                        val fakeOverride = fakeOverrideBuilder.fakeOverrideMember(superType, overriddenMember, clazz)
+                        val fakeOverride = strategy.fakeOverrideMember(superType, overriddenMember, clazz)
                         FakeOverride(fakeOverride, overriddenMember)
                     }
             }
@@ -91,6 +88,12 @@ class IrOverridingUtil(
         }
     }
 
+    /**
+     * This function builds all missing fake overrides, assuming that already existing members have correct overriden symbols.
+     *
+     * In particular, if a member of super class can be overridden, but none of the members have it in their overriddenSymbols,
+     * fake override would be created.
+     */
     fun buildFakeOverridesForClassUsingOverriddenSymbols(
         clazz: IrClass,
         implementedMembers: List<IrOverridableMember> = emptyList(),
@@ -108,7 +111,7 @@ class IrOverridingUtil(
                     it !in overriddenMembers && it.symbol !in ignoredParentSymbols && !it.isStaticMember && !DescriptorVisibilities.isPrivate(it.visibility)
                 }
                 .map { overriddenMember ->
-                    val fakeOverride = fakeOverrideBuilder.fakeOverrideMember(superType, overriddenMember, clazz)
+                    val fakeOverride = strategy.fakeOverrideMember(superType, overriddenMember, clazz)
                     FakeOverride(fakeOverride, overriddenMember)
                 }
         }
@@ -333,8 +336,8 @@ class IrOverridingUtil(
         ) { "Overridden symbols should be set for fake override ${fakeOverride.render()}" }
 
         addedFakeOverrides.add(fakeOverride)
-        fakeOverrideBuilder.linkFakeOverride(fakeOverride, compatibilityMode)
+        strategy.linkFakeOverride(fakeOverride, compatibilityMode)
-        fakeOverrideBuilder.postProcessGeneratedFakeOverride(fakeOverride, currentClass)
+        strategy.postProcessGeneratedFakeOverride(fakeOverride, currentClass)
     }
 
     private fun isVisibilityMoreSpecific(

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/overrides/IrUnimplementedOverridesStrategy.kt

@@ -1,15 +1,15 @@
 /*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
-package org.jetbrains.kotlin.ir.linkage.partial
+package org.jetbrains.kotlin.ir.overrides
 
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
 import org.jetbrains.kotlin.ir.declarations.IrOverridableDeclaration
-import org.jetbrains.kotlin.ir.declarations.IrOverridableMember
+import org.jetbrains.kotlin.ir.overrides.IrUnimplementedOverridesStrategy.Customization.Companion.NO
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 
 interface IrUnimplementedOverridesStrategy {
@@ -23,6 +23,6 @@ interface IrUnimplementedOverridesStrategy {
     fun <S : IrSymbol, T : IrOverridableDeclaration<S>> postProcessGeneratedFakeOverride(overridableMember: T, parent: IrClass) {}
 
     object ProcessAsFakeOverrides : IrUnimplementedOverridesStrategy {
-        override fun <S : IrSymbol, T : IrOverridableDeclaration<S>> computeCustomization(overridableMember: T, parent: IrClass) = Customization.NO
+        override fun <S : IrSymbol, T : IrOverridableDeclaration<S>> computeCustomization(overridableMember: T, parent: IrClass) = NO
     }
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt

@@ -17,9 +17,9 @@ import org.jetbrains.kotlin.ir.builders.irImplicitCast
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
-import org.jetbrains.kotlin.ir.linkage.partial.IrUnimplementedOverridesStrategy.ProcessAsFakeOverrides
+import org.jetbrains.kotlin.ir.overrides.IrUnimplementedOverridesStrategy
 import org.jetbrains.kotlin.ir.overrides.FakeOverrideBuilderStrategy
-import org.jetbrains.kotlin.ir.overrides.IrOverridingUtil
+import org.jetbrains.kotlin.ir.overrides.IrFakeOverrideBuilder
 import org.jetbrains.kotlin.ir.symbols.*
 import org.jetbrains.kotlin.ir.symbols.impl.IrPropertySymbolImpl
 import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
@@ -1227,7 +1227,7 @@ val IrFunction.allParametersCount: Int
 
 private object BindToNewEmptySymbols : FakeOverrideBuilderStrategy(
     friendModules = emptyMap(), // TODO: this is probably not correct. Should be fixed by KT-61384. But it's not important for current usages
-    unimplementedOverridesStrategy = ProcessAsFakeOverrides
+    unimplementedOverridesStrategy = IrUnimplementedOverridesStrategy.ProcessAsFakeOverrides
 ) {
     override fun linkFunctionFakeOverride(function: IrFunctionWithLateBinding, manglerCompatibleMode: Boolean) {
         function.acquireSymbol(IrSimpleFunctionSymbolImpl())
@@ -1258,7 +1258,7 @@ fun IrClass.addFakeOverrides(
     implementedMembers: List<IrOverridableMember> = emptyList(),
     ignoredParentSymbols: List<IrSymbol> = emptyList()
 ) {
-    IrOverridingUtil(typeSystem, BindToNewEmptySymbols, emptyList())
+    IrFakeOverrideBuilder(typeSystem, BindToNewEmptySymbols, emptyList())
         .buildFakeOverridesForClassUsingOverriddenSymbols(this,
                                                           implementedMembers = implementedMembers,
                                                           compatibilityMode = false,

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/linkage/partial/IrUnimplementedOverridesStrategy.kt

@@ -7,8 +7,8 @@ package org.jetbrains.kotlin.backend.common.linkage.partial
 
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.linkage.partial.IrUnimplementedOverridesStrategy
 import org.jetbrains.kotlin.ir.linkage.partial.PartiallyLinkedDeclarationOrigin
+import org.jetbrains.kotlin.ir.overrides.IrUnimplementedOverridesStrategy
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.types.isNothing
 import org.jetbrains.kotlin.ir.util.collectRealOverrides

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/overrides/FakeOverrides.kt

@@ -28,11 +28,11 @@ import org.jetbrains.kotlin.ir.builders.declarations.buildFun
 import org.jetbrains.kotlin.ir.builders.declarations.buildProperty
 import org.jetbrains.kotlin.ir.builders.declarations.buildTypeParameter
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.linkage.partial.IrUnimplementedOverridesStrategy
-import org.jetbrains.kotlin.ir.linkage.partial.IrUnimplementedOverridesStrategy.ProcessAsFakeOverrides
 import org.jetbrains.kotlin.ir.overrides.FakeOverrideBuilderStrategy
 import org.jetbrains.kotlin.ir.overrides.IrExternalOverridabilityCondition
-import org.jetbrains.kotlin.ir.overrides.IrOverridingUtil
+import org.jetbrains.kotlin.ir.overrides.IrFakeOverrideBuilder
+import org.jetbrains.kotlin.ir.overrides.IrUnimplementedOverridesStrategy
+import org.jetbrains.kotlin.ir.overrides.IrUnimplementedOverridesStrategy.ProcessAsFakeOverrides
 import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
 import org.jetbrains.kotlin.ir.symbols.impl.IrPropertySymbolImpl
@@ -254,7 +254,7 @@ class IrLinkerFakeOverrideProvider(
     },
     externalOverridabilityConditions: List<IrExternalOverridabilityCondition> = emptyList(),
 ) {
-    private val irOverridingUtil = IrOverridingUtil(
+    private val irFakeOverrideBuilder = IrFakeOverrideBuilder(
         typeSystem,
         IrLinkerFakeOverrideBuilderStrategy(
             linker,
@@ -291,7 +291,7 @@ class IrLinkerFakeOverrideProvider(
 
         if (!platformSpecificClassFilter.needToConstructFakeOverrides(clazz)) return false
 
-        irOverridingUtil.buildFakeOverridesForClass(clazz, compatibilityMode.oldSignatures)
+        irFakeOverrideBuilder.buildFakeOverridesForClass(clazz, compatibilityMode.oldSignatures)
 
         return true
     }

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrActualizerAndPluginsFacade.kt

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.fir.pipeline.applyIrGenerationExtensions
 import org.jetbrains.kotlin.ir.types.IrTypeSystemContextImpl
-import org.jetbrains.kotlin.ir.util.SymbolTable
 import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.test.directives.CodegenTestDirectives
 import org.jetbrains.kotlin.test.model.*
@@ -37,7 +36,7 @@ class IrActualizerAndPluginsFacade(
                 typeSystemContext,
                 testServices.compilerConfigurationProvider.getCompilerConfiguration(module).languageVersionSettings,
                 inputArtifact.fir2IrComponents!!.symbolTable,
-                inputArtifact.fir2IrComponents!!.irOverridingUtil,
+                inputArtifact.fir2IrComponents!!.fakeOverrideBuilder,
                 useIrFakeOverrideBuilder = CodegenTestDirectives.ENABLE_IR_FAKE_OVERRIDE_GENERATION in module.directives,
                 expectActualTracker = null,
             )