From 1073797ed3b5ec68e6d6dd8bda79ad94e1bd9ace Mon Sep 17 00:00:00 2001 From: Ivan Kochurkin Date: Fri, 31 Mar 2023 22:47:11 +0200 Subject: [PATCH] [IR] Extract ActualizerSymbolRemapper and ActualizerVisitor from ExpectActualLinker It will provide the possibility to use them not only locally Clarify code of IrActualizer pipeline --- .../common/actualizer/ExpectActualLinker.kt | 199 +++++++++--------- .../FunctionDefaultParametersActualizer.kt | 3 +- .../backend/common/actualizer/IrActualizer.kt | 54 ++--- .../common/actualizer/IrActualizerUtils.kt | 6 +- .../actualizer/MissingFakeOverridesAdder.kt | 2 +- .../common/lower/ExpectDeclarationRemover.kt | 1 - .../kotlin/backend/common/lower/LowerUtils.kt | 75 +++---- 7 files changed, 162 insertions(+), 178 deletions(-) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/ExpectActualLinker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/ExpectActualLinker.kt index 2714ed44ef9..b33c4fb04bc 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/ExpectActualLinker.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/ExpectActualLinker.kt @@ -5,157 +5,148 @@ package org.jetbrains.kotlin.backend.common.actualizer -import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.symbols.* -import org.jetbrains.kotlin.ir.util.DeepCopyIrTreeWithSymbols -import org.jetbrains.kotlin.ir.util.DeepCopyTypeRemapper -import org.jetbrains.kotlin.ir.util.SymbolRemapper -import org.jetbrains.kotlin.ir.util.SymbolRenamer +import org.jetbrains.kotlin.ir.util.* -class ExpectActualLinker(private val expectActualMap: Map) { - private val symbolRemapper = object : SymbolRemapper { - override fun getDeclaredClass(symbol: IrClassSymbol) = symbol +internal class ActualizerSymbolRemapper(private val expectActualMap: Map) : SymbolRemapper { + override fun getDeclaredClass(symbol: IrClassSymbol) = symbol - override fun getDeclaredScript(symbol: IrScriptSymbol) = symbol + override fun getDeclaredScript(symbol: IrScriptSymbol) = symbol - override fun getDeclaredFunction(symbol: IrSimpleFunctionSymbol) = symbol + override fun getDeclaredFunction(symbol: IrSimpleFunctionSymbol) = symbol - override fun getDeclaredProperty(symbol: IrPropertySymbol) = symbol + override fun getDeclaredProperty(symbol: IrPropertySymbol) = symbol - override fun getDeclaredField(symbol: IrFieldSymbol) = symbol + override fun getDeclaredField(symbol: IrFieldSymbol) = symbol - override fun getDeclaredFile(symbol: IrFileSymbol) = symbol + override fun getDeclaredFile(symbol: IrFileSymbol) = symbol - override fun getDeclaredConstructor(symbol: IrConstructorSymbol) = symbol + override fun getDeclaredConstructor(symbol: IrConstructorSymbol) = symbol - override fun getDeclaredEnumEntry(symbol: IrEnumEntrySymbol) = symbol + override fun getDeclaredEnumEntry(symbol: IrEnumEntrySymbol) = symbol - override fun getDeclaredExternalPackageFragment(symbol: IrExternalPackageFragmentSymbol) = symbol + override fun getDeclaredExternalPackageFragment(symbol: IrExternalPackageFragmentSymbol) = symbol - override fun getDeclaredVariable(symbol: IrVariableSymbol) = symbol + override fun getDeclaredVariable(symbol: IrVariableSymbol) = symbol - override fun getDeclaredLocalDelegatedProperty(symbol: IrLocalDelegatedPropertySymbol) = symbol + override fun getDeclaredLocalDelegatedProperty(symbol: IrLocalDelegatedPropertySymbol) = symbol - override fun getDeclaredTypeParameter(symbol: IrTypeParameterSymbol) = symbol + override fun getDeclaredTypeParameter(symbol: IrTypeParameterSymbol) = symbol - override fun getDeclaredValueParameter(symbol: IrValueParameterSymbol) = symbol + override fun getDeclaredValueParameter(symbol: IrValueParameterSymbol) = symbol - override fun getDeclaredTypeAlias(symbol: IrTypeAliasSymbol) = symbol + override fun getDeclaredTypeAlias(symbol: IrTypeAliasSymbol) = symbol - override fun getReferencedClass(symbol: IrClassSymbol) = symbol.actualizeSymbol() + override fun getReferencedClass(symbol: IrClassSymbol) = symbol.actualizeSymbol() - override fun getReferencedScript(symbol: IrScriptSymbol) = symbol.actualizeSymbol() + override fun getReferencedScript(symbol: IrScriptSymbol) = symbol.actualizeSymbol() - override fun getReferencedClassOrNull(symbol: IrClassSymbol?) = symbol?.actualizeSymbol() + override fun getReferencedClassOrNull(symbol: IrClassSymbol?) = symbol?.actualizeSymbol() - override fun getReferencedEnumEntry(symbol: IrEnumEntrySymbol) = symbol.actualizeSymbol() + override fun getReferencedEnumEntry(symbol: IrEnumEntrySymbol) = symbol.actualizeSymbol() - override fun getReferencedVariable(symbol: IrVariableSymbol) = symbol.actualizeSymbol() + override fun getReferencedVariable(symbol: IrVariableSymbol) = symbol.actualizeSymbol() - override fun getReferencedLocalDelegatedProperty(symbol: IrLocalDelegatedPropertySymbol) = symbol.actualizeSymbol() + override fun getReferencedLocalDelegatedProperty(symbol: IrLocalDelegatedPropertySymbol) = symbol.actualizeSymbol() - override fun getReferencedField(symbol: IrFieldSymbol) = symbol.actualizeSymbol() + override fun getReferencedField(symbol: IrFieldSymbol) = symbol.actualizeSymbol() - override fun getReferencedConstructor(symbol: IrConstructorSymbol) = symbol.actualizeSymbol() + override fun getReferencedConstructor(symbol: IrConstructorSymbol) = symbol.actualizeSymbol() - override fun getReferencedValue(symbol: IrValueSymbol) = symbol.actualizeSymbol() + override fun getReferencedValue(symbol: IrValueSymbol) = symbol.actualizeSymbol() - override fun getReferencedFunction(symbol: IrFunctionSymbol) = symbol.actualizeSymbol() + override fun getReferencedFunction(symbol: IrFunctionSymbol) = symbol.actualizeSymbol() - override fun getReferencedProperty(symbol: IrPropertySymbol) = symbol.actualizeSymbol() + override fun getReferencedProperty(symbol: IrPropertySymbol) = symbol.actualizeSymbol() - override fun getReferencedSimpleFunction(symbol: IrSimpleFunctionSymbol) = symbol.actualizeSymbol() + override fun getReferencedSimpleFunction(symbol: IrSimpleFunctionSymbol) = symbol.actualizeSymbol() - override fun getReferencedReturnableBlock(symbol: IrReturnableBlockSymbol) = symbol.actualizeSymbol() + override fun getReferencedReturnableBlock(symbol: IrReturnableBlockSymbol) = symbol.actualizeSymbol() - override fun getReferencedClassifier(symbol: IrClassifierSymbol) = symbol.actualizeSymbol() + override fun getReferencedClassifier(symbol: IrClassifierSymbol) = symbol.actualizeSymbol() - override fun getReferencedTypeAlias(symbol: IrTypeAliasSymbol) = symbol.actualizeSymbol() + override fun getReferencedTypeAlias(symbol: IrTypeAliasSymbol) = symbol.actualizeSymbol() - private inline fun S.actualizeSymbol(): S = (expectActualMap[this] as? S) ?: this - } + private inline fun S.actualizeSymbol(): S = (expectActualMap[this] as? S) ?: this +} - private val typeRemapper = DeepCopyTypeRemapper(symbolRemapper) +internal open class ActualizerVisitor(symbolRemapper: SymbolRemapper, typeRemapper: TypeRemapper) : + DeepCopyIrTreeWithSymbols(symbolRemapper, typeRemapper, SymbolRenamer.DEFAULT) { + override fun visitModuleFragment(declaration: IrModuleFragment) = + declaration.also { it.transformChildren(this, null) } - private val actualizer = object : DeepCopyIrTreeWithSymbols(symbolRemapper, typeRemapper, SymbolRenamer.DEFAULT) { - override fun visitModuleFragment(declaration: IrModuleFragment) = - declaration.also { it.transformChildren(this, null) } + override fun visitExternalPackageFragment(declaration: IrExternalPackageFragment) = + declaration.also { it.transformChildren(this, null) } - override fun visitExternalPackageFragment(declaration: IrExternalPackageFragment) = - declaration.also { it.transformChildren(this, null) } + override fun visitFile(declaration: IrFile) = + declaration.also { it.transformChildren(this, null) } - override fun visitFile(declaration: IrFile) = - declaration.also { it.transformChildren(this, null) } + override fun visitScript(declaration: IrScript) = + declaration.also { + it.baseClass = it.baseClass?.remapType() + it.transformChildren(this, null) + } - override fun visitScript(declaration: IrScript) = - declaration.also { - it.baseClass = it.baseClass?.remapType() - it.transformChildren(this, null) - } + override fun visitClass(declaration: IrClass) = + declaration.also { + it.superTypes = it.superTypes.map { superType -> superType.remapType() } + it.transformChildren(this, null) + } - override fun visitClass(declaration: IrClass) = - declaration.also { - it.superTypes = it.superTypes.map { superType -> superType.remapType() } - it.transformChildren(this, null) - } + override fun visitSimpleFunction(declaration: IrSimpleFunction) = visitFunction(declaration) as IrSimpleFunction - override fun visitSimpleFunction(declaration: IrSimpleFunction) = visitFunction(declaration) as IrSimpleFunction + override fun visitConstructor(declaration: IrConstructor) = visitFunction(declaration) as IrConstructor - override fun visitConstructor(declaration: IrConstructor) = visitFunction(declaration) as IrConstructor + override fun visitFunction(declaration: IrFunction) = + declaration.also { + it.returnType = it.returnType.remapType() + it.transformChildren(this, null) + } - override fun visitFunction(declaration: IrFunction) = - declaration.also { - it.returnType = it.returnType.remapType() - it.transformChildren(this, null) - } + override fun visitProperty(declaration: IrProperty) = + declaration.also { it.transformChildren(this, null) } - override fun visitProperty(declaration: IrProperty) = - declaration.also { it.transformChildren(this, null) } + override fun visitField(declaration: IrField) = + declaration.also { + it.type = it.type.remapType() + it.transformChildren(this, null) + } - override fun visitField(declaration: IrField) = - declaration.also { - it.type = it.type.remapType() - it.transformChildren(this, null) - } + override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty) = + declaration.also { + it.type = it.type.remapType() + it.transformChildren(this, null) + } - override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty) = - declaration.also { - it.type = it.type.remapType() - it.transformChildren(this, null) - } + override fun visitEnumEntry(declaration: IrEnumEntry) = + declaration.also { it.transformChildren(this, null) } - override fun visitEnumEntry(declaration: IrEnumEntry) = - declaration.also { it.transformChildren(this, null) } + override fun visitTypeParameter(declaration: IrTypeParameter) = + declaration.also { + it.superTypes = it.superTypes.map { superType -> superType.remapType() } + it.transformChildren(this, null) + } - override fun visitTypeParameter(declaration: IrTypeParameter) = - declaration.also { - it.superTypes = it.superTypes.map { superType -> superType.remapType() } - it.transformChildren(this, null) - } + override fun visitValueParameter(declaration: IrValueParameter) = + declaration.also { + it.type = it.type.remapType() + it.varargElementType = it.varargElementType?.remapType() + it.transformChildren(this, null) + } - override fun visitValueParameter(declaration: IrValueParameter) = - declaration.also { - it.type = it.type.remapType() - it.varargElementType = it.varargElementType?.remapType() - it.transformChildren(this, null) - } + override fun visitAnonymousInitializer(declaration: IrAnonymousInitializer) = + declaration.also { it.transformChildren(this, null) } - override fun visitAnonymousInitializer(declaration: IrAnonymousInitializer) = - declaration.also { it.transformChildren(this, null) } + override fun visitVariable(declaration: IrVariable) = + declaration.also { + it.type = it.type.remapType() + it.transformChildren(this, null) + } - override fun visitVariable(declaration: IrVariable) = - declaration.also { - it.type = it.type.remapType() - it.transformChildren(this, null) - } - - override fun visitTypeAlias(declaration: IrTypeAlias) = - declaration.also { - it.expandedType = it.expandedType.remapType() - it.transformChildren(this, null) - } - } - - fun actualize(irElement: IrElement) = irElement.transform(actualizer, null) + override fun visitTypeAlias(declaration: IrTypeAlias) = + declaration.also { + it.expandedType = it.expandedType.remapType() + it.transformChildren(this, null) + } } \ No newline at end of file diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/FunctionDefaultParametersActualizer.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/FunctionDefaultParametersActualizer.kt index 1748cd70ee2..8e51ad2c86e 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/FunctionDefaultParametersActualizer.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/FunctionDefaultParametersActualizer.kt @@ -11,7 +11,7 @@ import org.jetbrains.kotlin.ir.symbols.IrClassSymbol import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol import org.jetbrains.kotlin.ir.symbols.IrSymbol -class FunctionDefaultParametersActualizer(private val expectActualMap: Map) { +internal class FunctionDefaultParametersActualizer(private val expectActualMap: Map) { fun actualize() { for ((expect, actual) in expectActualMap) { if (expect is IrFunctionSymbol) { @@ -26,7 +26,6 @@ class FunctionDefaultParametersActualizer(private val expectActualMap: Map) @@ -22,22 +22,41 @@ object IrActualizer { languageVersionSettings: LanguageVersionSettings ): IrActualizationResult { val ktDiagnosticReporter = KtDiagnosticReporterWithImplicitIrBasedContext(diagnosticReporter, languageVersionSettings) - val (expectActualMap, expectActualTypeAliasMap) = ExpectActualCollector(mainFragment, dependentFragments, ktDiagnosticReporter).collect() + + val (expectActualMap, expectActualTypeAliasMap) = ExpectActualCollector( + mainFragment, + dependentFragments, + ktDiagnosticReporter + ).collect() + + val removedExpectDeclarations = removeExpectDeclarations(dependentFragments, expectActualMap) + + val symbolRemapper = ActualizerSymbolRemapper(expectActualMap) + val typeRemapper = DeepCopyTypeRemapper(symbolRemapper) + FunctionDefaultParametersActualizer(expectActualMap).actualize() - val removedExpectDeclarationMetadata = removeExpectDeclarations(dependentFragments, expectActualMap) - addMissingFakeOverrides(expectActualMap, dependentFragments, expectActualTypeAliasMap, ktDiagnosticReporter) - linkExpectToActual(expectActualMap, dependentFragments) + + MissingFakeOverridesAdder( + expectActualMap, + expectActualTypeAliasMap, + ktDiagnosticReporter + ).apply { dependentFragments.forEach { visitModuleFragment(it) } } + + val actualizerVisitor = ActualizerVisitor(symbolRemapper, typeRemapper) + dependentFragments.forEach { it.transform(actualizerVisitor, null) } + mergeIrFragments(mainFragment, dependentFragments) - return IrActualizationResult(removedExpectDeclarationMetadata) + + return IrActualizationResult(removedExpectDeclarations) } private fun removeExpectDeclarations(dependentFragments: List, expectActualMap: Map): List { - val removedDeclarationMetadata = mutableListOf() + val removedExpectDeclarations = mutableListOf() for (fragment in dependentFragments) { for (file in fragment.files) { file.declarations.removeIf { if (shouldRemoveExpectDeclaration(it, expectActualMap)) { - removedDeclarationMetadata.add(it) + removedExpectDeclarations.add(it) true } else { false @@ -45,7 +64,7 @@ object IrActualizer { } } } - return removedDeclarationMetadata + return removedExpectDeclarations } private fun shouldRemoveExpectDeclaration(irDeclaration: IrDeclaration, expectActualMap: Map): Boolean { @@ -57,23 +76,6 @@ object IrActualizer { } } - private fun addMissingFakeOverrides( - expectActualMap: Map, - dependentFragments: List, - expectActualTypeAliasMap: Map, - diagnosticsReporter: KtDiagnosticReporterWithImplicitIrBasedContext - ) { - MissingFakeOverridesAdder( - expectActualMap, - expectActualTypeAliasMap, - diagnosticsReporter - ).apply { dependentFragments.forEach { visitModuleFragment(it) } } - } - - private fun linkExpectToActual(expectActualMap: Map, dependentFragments: List) { - ExpectActualLinker(expectActualMap).apply { dependentFragments.forEach { actualize(it) } } - } - private fun mergeIrFragments(mainFragment: IrModuleFragment, dependentFragments: List) { mainFragment.files.addAll(0, dependentFragments.flatMap { it.files }) } diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizerUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizerUtils.kt index 57f0519faec..bb004ee261d 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizerUtils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizerUtils.kt @@ -108,9 +108,9 @@ private fun IrFunction.match(actualFunction: IrFunction, expectActualTypesMap: M return true } -fun generateActualIrClassOrTypeAliasFullName(declaration: IrElement) = generateIrElementFullNameFromExpect(declaration, emptyMap()) +internal fun generateActualIrClassOrTypeAliasFullName(declaration: IrElement) = generateIrElementFullNameFromExpect(declaration, emptyMap()) -fun generateIrElementFullNameFromExpect( +internal fun generateIrElementFullNameFromExpect( declaration: IrElement, expectActualTypeAliasMap: Map ): String { @@ -157,7 +157,7 @@ private fun appendElementFullName( } @OptIn(ObsoleteDescriptorBasedAPI::class) -fun KtDiagnosticReporterWithImplicitIrBasedContext.reportMissingActual(irDeclaration: IrDeclaration) { +internal fun KtDiagnosticReporterWithImplicitIrBasedContext.reportMissingActual(irDeclaration: IrDeclaration) { at(irDeclaration).report( CommonBackendErrors.NO_ACTUAL_FOR_EXPECT, (irDeclaration as? IrDeclarationWithName)?.name?.asString().orEmpty(), diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/MissingFakeOverridesAdder.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/MissingFakeOverridesAdder.kt index 73c369ec4cc..c14ec8da9bd 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/MissingFakeOverridesAdder.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/MissingFakeOverridesAdder.kt @@ -22,7 +22,7 @@ import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid import org.jetbrains.kotlin.name.FqName -class MissingFakeOverridesAdder( +internal class MissingFakeOverridesAdder( private val expectActualMap: Map, private val typeAliasMap: Map, private val diagnosticsReporter: KtDiagnosticReporterWithImplicitIrBasedContext diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ExpectDeclarationRemover.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ExpectDeclarationRemover.kt index f00c41db1ee..b06927987ec 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ExpectDeclarationRemover.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/ExpectDeclarationRemover.kt @@ -151,7 +151,6 @@ open class ExpectDeclarationRemover(val symbolTable: ReferenceSymbolTable, priva defaultValue.let { originalDefault -> declaration.defaultValue = originalDefault.copyAndActualizeDefaultValue( function, - declaration, typeParameterSubstitutionMap.getValue(expectToActual), classActualizer = { symbolTable.referenceClass(it.descriptor.findActualForExpect() as ClassDescriptor).owner }, functionActualizer = { symbolTable.referenceFunction(it.descriptor.findActualForExpect() as FunctionDescriptor).owner } diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LowerUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LowerUtils.kt index 929c3356459..7802a77af32 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LowerUtils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LowerUtils.kt @@ -19,7 +19,6 @@ import org.jetbrains.kotlin.ir.expressions.impl.* import org.jetbrains.kotlin.ir.linkage.partial.isPartialLinkageRuntimeError import org.jetbrains.kotlin.ir.symbols.IrSymbol import org.jetbrains.kotlin.ir.symbols.IrValueParameterSymbol -import org.jetbrains.kotlin.ir.symbols.IrValueSymbol import org.jetbrains.kotlin.ir.types.IrSimpleType import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.types.classifierOrFail @@ -256,58 +255,52 @@ fun ParameterDescriptor.copyAsValueParameter(newOwner: CallableDescriptor, index fun IrExpressionBody.copyAndActualizeDefaultValue( actualFunction: IrFunction, - actualValueParameter: IrValueParameter, expectActualTypeParametersMap: Map, classActualizer: (IrClass) -> IrClass, functionActualizer: (IrFunction) -> IrFunction -) = actualValueParameter.factory.createExpressionBody(startOffset, endOffset) { - expression = this@copyAndActualizeDefaultValue.expression +): IrExpressionBody { + return this .deepCopyWithSymbols(actualFunction) { symbolRemapper, _ -> DeepCopyIrTreeWithSymbols(symbolRemapper, IrTypeParameterRemapper(expectActualTypeParametersMap)) } .transform(object : IrElementTransformerVoid() { override fun visitGetValue(expression: IrGetValue): IrExpression { expression.transformChildrenVoid() - val newValue = remapExpectValue(expression.symbol) ?: return expression - - return IrGetValueImpl( - expression.startOffset, - expression.endOffset, - newValue.type, - newValue.symbol, - expression.origin + return expression.actualizeForDefaultValue( + classActualizer = { classActualizer(it) }, + functionActualizer = { functionActualizer(it) } ) } - - private fun remapExpectValue(symbol: IrValueSymbol): IrValueParameter? { - if (symbol !is IrValueParameterSymbol) { - return null - } - - val parameter = symbol.owner - - return when (val parent = parameter.parent) { - is IrClass -> { - assert(parameter == parent.thisReceiver) - classActualizer(parent).thisReceiver!! - } - - is IrFunction -> { - val function = functionActualizer(parent) - when (parameter) { - parent.dispatchReceiverParameter -> function.dispatchReceiverParameter!! - parent.extensionReceiverParameter -> function.extensionReceiverParameter!! - else -> { - assert(parent.valueParameters[parameter.index] == parameter) - function.valueParameters[parameter.index] - } - } - } - - else -> error(parent) - } - } }, data = null) } +fun IrGetValue.actualizeForDefaultValue(classActualizer: (IrClass) -> IrClass, functionActualizer: (IrFunction) -> IrFunction): IrGetValue { + val symbol = symbol + if (symbol !is IrValueParameterSymbol) { + return this + } + val parameter = symbol.owner + val newSymbol = when (val parent = parameter.parent) { + is IrClass -> { + assert(parameter == parent.thisReceiver) + classActualizer(parent).thisReceiver!! + } + + is IrFunction -> { + val function = functionActualizer(parent) + when (parameter) { + parent.dispatchReceiverParameter -> function.dispatchReceiverParameter!! + parent.extensionReceiverParameter -> function.extensionReceiverParameter!! + else -> { + assert(parent.valueParameters[parameter.index] == parameter) + function.valueParameters[parameter.index] + } + } + } + + else -> error(parent) + } + + return IrGetValueImpl(startOffset, endOffset, newSymbol.type, newSymbol.symbol, origin) +} \ No newline at end of file