[IR] Rename classes after refactoring

^KT-61934
2023-09-18 16:41:21 +02:00
parent ed7e458828
commit 03914e353f
16 changed files with 96 additions and 48 deletions
@@ -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>()

@@ -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)
@@ -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.*
@@ -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)
 }

@@ -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(
@@ -23,15 +23,9 @@ import org.jetbrains.kotlin.utils.filterIsInstanceAnd
 import org.jetbrains.kotlin.utils.memoryOptimizedMap
 import org.jetbrains.kotlin.utils.memoryOptimizedMapNotNull

-// TODO:
-// 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(
+class IrFakeOverrideBuilder(
    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)
-        fakeOverrideBuilder.postProcessGeneratedFakeOverride(fakeOverride, currentClass)
+        strategy.linkFakeOverride(fakeOverride, compatibilityMode)
+        strategy.postProcessGeneratedFakeOverride(fakeOverride, currentClass)
    }

    private fun isVisibilityMoreSpecific(
@@ -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
    }
 }
@@ -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,
@@ -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
@@ -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
    }