From 41a8b02202a23762d379fb34018976a25c2ea868 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Tue, 5 Mar 2024 14:24:38 +0100 Subject: [PATCH] IR: do not use DeepCopyIrTreeWithSymbols in FakeOverrideCopier #KT-66281 --- .../CopyIrTreeWithSymbolsForFakeOverrides.kt | 11 +-- .../kotlin/ir/overrides/FakeOverrideCopier.kt | 82 +++++++++---------- 2 files changed, 45 insertions(+), 48 deletions(-) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/overrides/CopyIrTreeWithSymbolsForFakeOverrides.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/overrides/CopyIrTreeWithSymbolsForFakeOverrides.kt index 95523cc1563..c2c5800257d 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/overrides/CopyIrTreeWithSymbolsForFakeOverrides.kt +++ b/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() } } } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/overrides/FakeOverrideCopier.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/overrides/FakeOverrideCopier.kt index 32b8848fb8e..6235ac977e0 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/overrides/FakeOverrideCopier.kt +++ b/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) { - - override fun visitSimpleFunction(declaration: IrSimpleFunction): IrSimpleFunction { +) { + fun copySimpleFunction(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) - copyTypeParametersFrom(declaration) - typeRemapper.withinScope(this) { - // This is the more correct way to produce dispatch receiver for a fake override, - // but some lowerings still expect the below behavior as produced by the current psi2ir. - /* - 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() + annotations = declaration.copyAnnotations() + typeParameters = declaration.typeParameters.map(::copyTypeParameter) + for ((i, thisTypeParameter) in typeParameters.withIndex()) { + val otherTypeParameter = declaration.typeParameters[i] + thisTypeParameter.superTypes = otherTypeParameter.superTypes.map(typeRemapper::remapType) } + 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) - this.getter = declaration.getter?.transform() - this.setter = declaration.setter?.transform() + annotations = declaration.copyAnnotations() + this.getter = declaration.getter?.let(::copySimpleFunction) + 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), - type = declaration.type.remapType(), + name = declaration.name, + 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() + } }