IR: do not use DeepCopyIrTreeWithSymbols in FakeOverrideCopier

#KT-66281

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

@@ -7,8 +7,6 @@ package org.jetbrains.kotlin.ir.overrides
 
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrBlockBody
-import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
-import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol
 import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
@@ -34,7 +32,6 @@ class CopyIrTreeWithSymbolsForFakeOverrides(
     private val copier = FakeOverrideCopier(
         symbolRemapper,
         FakeOverrideTypeRemapper(symbolRemapper, typeArguments),
-        SymbolRenamer.DEFAULT,
         parent,
         unimplementedOverridesStrategy
     )
@@ -42,7 +39,11 @@ class CopyIrTreeWithSymbolsForFakeOverrides(
     fun copy(): IrOverridableMember {
         overridableMember.acceptVoid(symbolRemapper)
 
-        val result = overridableMember.transform(copier, null) as IrOverridableMember
+        val result = when (overridableMember) {
+            is IrSimpleFunction -> copier.copySimpleFunction(overridableMember)
+            is IrProperty -> copier.copyProperty(overridableMember)
+            else -> error("Unsupported member: ${overridableMember.render()}")
+        }
 
         result.patchDeclarationParents(parent)
 
@@ -89,7 +90,7 @@ class CopyIrTreeWithSymbolsForFakeOverrides(
                     kotlinType = null
                     classifier = symbolRemapper.getReferencedClassifier(type.classifier)
                     arguments = remapTypeArguments(type.arguments)
-                    annotations = type.annotations.memoryOptimizedMap { it.transform(copier, null) as IrConstructorCall }
+                    annotations = type.copyAnnotations()
                 }
             }
         }

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

@@ -6,24 +6,24 @@
 package org.jetbrains.kotlin.ir.overrides
 
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.ir.util.SymbolRemapper
+import org.jetbrains.kotlin.ir.util.TypeRemapper
+import org.jetbrains.kotlin.ir.util.copyAnnotations
 
-class FakeOverrideCopier(
+internal class FakeOverrideCopier(
     private val symbolRemapper: SymbolRemapper,
     private val typeRemapper: TypeRemapper,
-    private val symbolRenamer: SymbolRenamer,
     private val parent: IrClass,
     private val unimplementedOverridesStrategy: IrUnimplementedOverridesStrategy
-) : DeepCopyIrTreeWithSymbols(symbolRemapper, typeRemapper, symbolRenamer) {
+) {
-
+    fun copySimpleFunction(declaration: IrSimpleFunction): IrSimpleFunction {
-    override fun visitSimpleFunction(declaration: IrSimpleFunction): IrSimpleFunction {
         val customization = unimplementedOverridesStrategy.computeCustomization(declaration, parent)
 
         return declaration.factory.createFunctionWithLateBinding(
             startOffset = parent.startOffset,
             endOffset = parent.endOffset,
             origin = customization.origin ?: IrDeclarationOrigin.FAKE_OVERRIDE,
-            name = symbolRenamer.getFunctionName(declaration.symbol),
+            name = declaration.name,
             visibility = declaration.visibility,
             isInline = declaration.isInline,
             isExpect = declaration.isExpect,
@@ -36,38 +36,20 @@ class FakeOverrideCopier(
             isExternal = declaration.isExternal,
         ).apply {
             contextReceiverParametersCount = declaration.contextReceiverParametersCount
-            transformAnnotations(declaration)
+            annotations = declaration.copyAnnotations()
-            copyTypeParametersFrom(declaration)
+            typeParameters = declaration.typeParameters.map(::copyTypeParameter)
-            typeRemapper.withinScope(this) {
+            for ((i, thisTypeParameter) in typeParameters.withIndex()) {
-                // This is the more correct way to produce dispatch receiver for a fake override,
+                val otherTypeParameter = declaration.typeParameters[i]
-                // but some lowerings still expect the below behavior as produced by the current psi2ir.
+                thisTypeParameter.superTypes = otherTypeParameter.superTypes.map(typeRemapper::remapType)
-                /*
-                    val superDispatchReceiver = declaration.dispatchReceiverParameter!!
-                    val dispatchReceiverSymbol = IrValueParameterSymbolImpl(WrappedReceiverParameterDescriptor())
-                    val dispatchReceiverType = destinationClass.defaultType
-                    dispatchReceiverParameter = IrValueParameterImpl(
-                        superDispatchReceiver.startOffset,
-                        superDispatchReceiver.endOffset,
-                        superDispatchReceiver.origin,
-                        dispatchReceiverSymbol,
-                        superDispatchReceiver.name,
-                        superDispatchReceiver.index,
-                        dispatchReceiverType,
-                        null,
-                        superDispatchReceiver.isCrossinline,
-                        superDispatchReceiver.isNoinline
-                    )
-                    */
-                // Should fake override's receiver be the current class is an open question.
-                dispatchReceiverParameter = declaration.dispatchReceiverParameter?.transform()
-                extensionReceiverParameter = declaration.extensionReceiverParameter?.transform()
-                returnType = typeRemapper.remapType(declaration.returnType)
-                valueParameters = declaration.valueParameters.transform()
             }
+            dispatchReceiverParameter = declaration.dispatchReceiverParameter?.let(::copyValueParameter)
+            extensionReceiverParameter = declaration.extensionReceiverParameter?.let(::copyValueParameter)
+            returnType = typeRemapper.remapType(declaration.returnType)
+            valueParameters = declaration.valueParameters.map(::copyValueParameter)
         }
     }
 
-    override fun visitProperty(declaration: IrProperty): IrProperty {
+    fun copyProperty(declaration: IrProperty): IrProperty {
         val customization = unimplementedOverridesStrategy.computeCustomization(declaration, parent)
 
         return declaration.factory.createPropertyWithLateBinding(
@@ -83,28 +65,42 @@ class FakeOverrideCopier(
             isExpect = declaration.isExpect,
             isExternal = declaration.isExternal,
         ).apply {
-            transformAnnotations(declaration)
+            annotations = declaration.copyAnnotations()
-            this.getter = declaration.getter?.transform()
+            this.getter = declaration.getter?.let(::copySimpleFunction)
-            this.setter = declaration.setter?.transform()
+            this.setter = declaration.setter?.let(::copySimpleFunction)
         }
     }
 
-    override fun visitValueParameter(declaration: IrValueParameter): IrValueParameter =
+    private fun copyValueParameter(declaration: IrValueParameter): IrValueParameter =
         declaration.factory.createValueParameter(
             startOffset = parent.startOffset,
             endOffset = parent.endOffset,
             origin = IrDeclarationOrigin.DEFINED,
-            name = symbolRenamer.getValueParameterName(declaration.symbol),
+            name = declaration.name,
-            type = declaration.type.remapType(),
+            type = typeRemapper.remapType(declaration.type),
             isAssignable = declaration.isAssignable,
             symbol = symbolRemapper.getDeclaredValueParameter(declaration.symbol),
             index = declaration.index,
-            varargElementType = declaration.varargElementType?.remapType(),
+            varargElementType = declaration.varargElementType?.let(typeRemapper::remapType),
             isCrossinline = declaration.isCrossinline,
             isNoinline = declaration.isNoinline,
             isHidden = declaration.isHidden,
         ).apply {
-            transformAnnotations(declaration)
+            annotations = declaration.copyAnnotations()
             // Don't set the default value for fake overrides.
         }
+
+    private fun copyTypeParameter(declaration: IrTypeParameter): IrTypeParameter =
+        declaration.factory.createTypeParameter(
+            startOffset = declaration.startOffset,
+            endOffset = declaration.endOffset,
+            origin = declaration.origin,
+            name = declaration.name,
+            symbol = symbolRemapper.getDeclaredTypeParameter(declaration.symbol),
+            variance = declaration.variance,
+            index = declaration.index,
+            isReified = declaration.isReified,
+        ).apply {
+            annotations = declaration.copyAnnotations()
+        }
 }