From b5607e4b3d3aca2f164cbcbabc68e67149e539d7 Mon Sep 17 00:00:00 2001 From: Dmitry Petrov Date: Mon, 26 Mar 2018 12:43:02 +0300 Subject: [PATCH] Store type arguments by indices instead of TypeParameterDescriptor keys --- .../backend/jvm/intrinsics/IsArrayOf.kt | 2 +- .../expressions/IrMemberAccessExpression.kt | 33 ++++++- .../kotlin/ir/expressions/impl/IrCallImpl.kt | 74 +++++++++++++-- .../impl/IrCallWithIndexedArgumentsBase.kt | 37 ++++++-- .../impl/IrDelegatingConstructorCallImpl.kt | 47 ++++++++-- .../impl/IrEnumConstructorCallImpl.kt | 34 +++++-- .../impl/IrFunctionReferenceImpl.kt | 45 +++++++-- .../IrLocalDelegatedPropertyReferenceImpl.kt | 5 +- .../impl/IrMemberAccessExpressionBase.kt | 21 +++-- .../IrNoArgumentsCallableReferenceBase.kt | 9 +- .../ir/expressions/impl/IrPrimitiveCall.kt | 10 +- .../impl/IrPropertyAccessorCall.kt | 92 ++++++++++++++----- .../impl/IrPropertyReferenceImpl.kt | 23 ++++- .../kotlin/ir/util/DeepCopyIrTree.kt | 61 +++++++----- .../ir/util/DeepCopyIrTreeWithSymbols.kt | 50 ++++++---- .../kotlin/ir/util/remapTypeArguments.kt | 49 ---------- 16 files changed, 415 insertions(+), 177 deletions(-) delete mode 100644 compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/remapTypeArguments.kt diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IsArrayOf.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IsArrayOf.kt index 050826fdbf7..396f068d33f 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IsArrayOf.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IsArrayOf.kt @@ -32,7 +32,7 @@ class IsArrayOf : IntrinsicMethod() { "Expected only one type parameter for Any?.isArrayOf(), got: ${descriptor.typeParameters}" } /*TODO original?*/ - val elementType = expression.getTypeArgument(descriptor.original.typeParameters.first())!! + val elementType = expression.getTypeArgument(descriptor.original.typeParameters.first().index)!! val arrayKtType = builtIns.getArrayType(Variance.INVARIANT, elementType) val arrayType = typeMapper.mapType(arrayKtType) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrMemberAccessExpression.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrMemberAccessExpression.kt index f4be818d966..38e626a45f4 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrMemberAccessExpression.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrMemberAccessExpression.kt @@ -30,8 +30,9 @@ interface IrMemberAccessExpression : IrExpression { val descriptor: CallableDescriptor val origin: IrStatementOrigin? - // NB `typeParameterDescriptor` should be taken from `descriptor.original` - fun getTypeArgument(typeParameterDescriptor: TypeParameterDescriptor): KotlinType? + val typeArgumentsCount: Int + fun getTypeArgument(index: Int): KotlinType? + fun putTypeArgument(index: Int, type: KotlinType?) val valueArgumentsCount: Int fun getValueArgument(index: Int): IrExpression? @@ -39,6 +40,34 @@ interface IrMemberAccessExpression : IrExpression { fun removeValueArgument(index: Int) } +fun IrMemberAccessExpression.getTypeArgument(typeParameterDescriptor: TypeParameterDescriptor): KotlinType? = + getTypeArgument(typeParameterDescriptor.index) + +fun IrMemberAccessExpression.copyTypeArgumentsFrom(other: IrMemberAccessExpression) { + assert(typeArgumentsCount == other.typeArgumentsCount) { + "Mismatching type arguments: $typeArgumentsCount vs ${other.typeArgumentsCount} " + } + for (i in 0 until typeArgumentsCount) { + putTypeArgument(i, other.getTypeArgument(i)) + } +} + +fun IrMemberAccessExpression.copyTypeArgumentsFrom(source: Map?) { + if (source == null) return + for ((typeParameter, typeArgument) in source) { + val index = typeParameter.index + assert(index < typeArgumentsCount) { + "Index out of range for type parameter $typeParameter; " + + "containingDeclaration: ${typeParameter.containingDeclaration}; " + + "callee: $descriptor" + } + putTypeArgument(index, typeArgument) + } +} + +val Map?.typeArgumentsCount: Int + get() = this?.size ?: 0 + fun IrMemberAccessExpression.getTypeArgumentOrDefault(typeParameterDescriptor: TypeParameterDescriptor) = getTypeArgument(typeParameterDescriptor) ?: typeParameterDescriptor.defaultType diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCallImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCallImpl.kt index 82508df63ab..7f836fb0e62 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCallImpl.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCallImpl.kt @@ -21,6 +21,8 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.ir.expressions.IrCall import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin +import org.jetbrains.kotlin.ir.expressions.copyTypeArgumentsFrom +import org.jetbrains.kotlin.ir.expressions.typeArgumentsCount import org.jetbrains.kotlin.ir.symbols.IrClassSymbol import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol import org.jetbrains.kotlin.ir.symbols.impl.createClassSymbolOrNull @@ -34,11 +36,50 @@ class IrCallImpl( type: KotlinType, override val symbol: IrFunctionSymbol, override val descriptor: FunctionDescriptor, - typeArguments: Map?, - override val origin: IrStatementOrigin? = null, + typeArgumentsCount: Int, + origin: IrStatementOrigin? = null, override val superQualifierSymbol: IrClassSymbol? = null -) : IrCall, - IrCallWithIndexedArgumentsBase(startOffset, endOffset, type, symbol.descriptor.valueParameters.size, typeArguments) { +) : + IrCallWithIndexedArgumentsBase( + startOffset, endOffset, type, + typeArgumentsCount, + symbol.descriptor.valueParameters.size, + origin + ), + IrCall { + + constructor( + startOffset: Int, + endOffset: Int, + type: KotlinType, + symbol: IrFunctionSymbol, + descriptor: FunctionDescriptor, + typeArguments: Map?, + origin: IrStatementOrigin? = null, + superQualifierSymbol: IrClassSymbol? = null + ) : this(startOffset, endOffset, type, symbol, descriptor, typeArguments.typeArgumentsCount, origin, superQualifierSymbol) { + copyTypeArgumentsFrom(typeArguments) + } + + @Deprecated("Creates unbound symbols") + constructor( + startOffset: Int, + endOffset: Int, + type: KotlinType, + calleeDescriptor: FunctionDescriptor, + typeArgumentsCount: Int, + origin: IrStatementOrigin? = null, + superQualifierDescriptor: ClassDescriptor? = null + ) : this( + startOffset, endOffset, + type, + createFunctionSymbol(calleeDescriptor), + calleeDescriptor, + typeArgumentsCount, + origin, + createClassSymbolOrNull(superQualifierDescriptor) + ) + @Deprecated("Creates unbound symbols") constructor( startOffset: Int, @@ -53,9 +94,11 @@ class IrCallImpl( type, createFunctionSymbol(calleeDescriptor), calleeDescriptor, - typeArguments, origin, + typeArguments.typeArgumentsCount, origin, createClassSymbolOrNull(superQualifierDescriptor) - ) + ) { + copyTypeArgumentsFrom(typeArguments) + } @Deprecated("Creates unbound symbols") constructor( @@ -70,9 +113,11 @@ class IrCallImpl( calleeDescriptor.returnType!!, createFunctionSymbol(calleeDescriptor), calleeDescriptor, - typeArguments, origin, + typeArguments.typeArgumentsCount, origin, createClassSymbolOrNull(superQualifierDescriptor) - ) + ) { + copyTypeArgumentsFrom(typeArguments) + } constructor( startOffset: Int, endOffset: Int, @@ -81,7 +126,18 @@ class IrCallImpl( typeArguments: Map? = null, origin: IrStatementOrigin? = null, superQualifierSymbol: IrClassSymbol? = null - ) : this(startOffset, endOffset, descriptor.returnType!!, symbol, descriptor, typeArguments, origin, superQualifierSymbol) + ) : this( + startOffset, + endOffset, + descriptor.returnType!!, + symbol, + descriptor, + typeArguments.typeArgumentsCount, + origin, + superQualifierSymbol + ) { + copyTypeArgumentsFrom(typeArguments) + } constructor(startOffset: Int, endOffset: Int, symbol: IrFunctionSymbol) : this(startOffset, endOffset, symbol, symbol.descriptor) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCallWithIndexedArgumentsBase.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCallWithIndexedArgumentsBase.kt index d537dc69417..8a5998e1ec9 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCallWithIndexedArgumentsBase.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCallWithIndexedArgumentsBase.kt @@ -19,27 +19,46 @@ package org.jetbrains.kotlin.ir.expressions.impl import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.ir.expressions.IrExpression import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin +import org.jetbrains.kotlin.ir.expressions.copyTypeArgumentsFrom +import org.jetbrains.kotlin.ir.expressions.typeArgumentsCount +import org.jetbrains.kotlin.ir.util.render import org.jetbrains.kotlin.ir.visitors.IrElementTransformer import org.jetbrains.kotlin.ir.visitors.IrElementVisitor import org.jetbrains.kotlin.types.KotlinType import java.lang.AssertionError abstract class IrCallWithIndexedArgumentsBase( - startOffset: Int, endOffset: Int, type: KotlinType, + startOffset: Int, + endOffset: Int, + type: KotlinType, + typeArgumentsCount: Int, valueArgumentsCount: Int, - typeArguments: Map?, - override val origin: IrStatementOrigin? = null -) : IrMemberAccessExpressionBase(startOffset, endOffset, type, typeArguments, valueArgumentsCount) { + origin: IrStatementOrigin? = null +) : IrMemberAccessExpressionBase(startOffset, endOffset, type, typeArgumentsCount, valueArgumentsCount, origin) { - private val argumentsByParameterIndex = - arrayOfNulls(valueArgumentsCount) + constructor( + startOffset: Int, + endOffset: Int, + type: KotlinType, + valueArgumentsCount: Int, + typeArguments: Map?, + origin: IrStatementOrigin? = null + ) : this(startOffset, endOffset, type, typeArguments.typeArgumentsCount, valueArgumentsCount, origin) { + copyTypeArgumentsFrom(typeArguments) + } - override fun getValueArgument(index: Int): IrExpression? = - argumentsByParameterIndex[index] + private val argumentsByParameterIndex: Array = arrayOfNulls(valueArgumentsCount) + + override fun getValueArgument(index: Int): IrExpression? { + if (index >= argumentsByParameterIndex.size) { + throw AssertionError("$this: No such argument slot: $index in ${render()}") + } + return argumentsByParameterIndex[index] + } override fun putValueArgument(index: Int, valueArgument: IrExpression?) { if (index >= argumentsByParameterIndex.size) { - throw AssertionError("$this: No such argument slot: $index") + throw AssertionError("$this: No such argument slot: $index in ${render()}") } argumentsByParameterIndex[index] = valueArgument } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDelegatingConstructorCallImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDelegatingConstructorCallImpl.kt index 1433691ca69..676f87fc0b3 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDelegatingConstructorCallImpl.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDelegatingConstructorCallImpl.kt @@ -19,6 +19,8 @@ package org.jetbrains.kotlin.ir.expressions.impl import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.ir.expressions.IrDelegatingConstructorCall +import org.jetbrains.kotlin.ir.expressions.copyTypeArgumentsFrom +import org.jetbrains.kotlin.ir.expressions.typeArgumentsCount import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol import org.jetbrains.kotlin.ir.symbols.impl.IrConstructorSymbolImpl import org.jetbrains.kotlin.ir.visitors.IrElementVisitor @@ -30,24 +32,51 @@ class IrDelegatingConstructorCallImpl( endOffset: Int, override val symbol: IrConstructorSymbol, override val descriptor: ClassConstructorDescriptor, - typeArguments: Map? = null -) : IrDelegatingConstructorCall, + typeArgumentsCount: Int +) : IrCallWithIndexedArgumentsBase( - startOffset, endOffset, + startOffset, + endOffset, symbol.descriptor.builtIns.unitType, - symbol.descriptor.valueParameters.size, - typeArguments - ) { + typeArgumentsCount = typeArgumentsCount, + valueArgumentsCount = symbol.descriptor.valueParameters.size + ), + IrDelegatingConstructorCall { + + @Deprecated("Use constructor with typeArgumentsCount and fill type arguments explicitly or with copyTypeArgumentsFrom") + constructor( + startOffset: Int, + endOffset: Int, + symbol: IrConstructorSymbol, + descriptor: ClassConstructorDescriptor, + typeArguments: Map? = null + ) : this(startOffset, endOffset, symbol, descriptor, typeArguments.typeArgumentsCount) { + copyTypeArgumentsFrom(typeArguments) + } + @Deprecated("Creates unbound symbol") constructor( startOffset: Int, endOffset: Int, - constructorDescriptor: ClassConstructorDescriptor, + descriptor: ClassConstructorDescriptor, + typeArgumentsCount: Int + ) : this( + startOffset, endOffset, + IrConstructorSymbolImpl(descriptor.original), + descriptor, + typeArgumentsCount + ) + + @Deprecated("Creates unbound symbol") + constructor( + startOffset: Int, + endOffset: Int, + descriptor: ClassConstructorDescriptor, typeArguments: Map? = null ) : this( startOffset, endOffset, - IrConstructorSymbolImpl(constructorDescriptor.original), - constructorDescriptor, + IrConstructorSymbolImpl(descriptor.original), + descriptor, typeArguments ) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrEnumConstructorCallImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrEnumConstructorCallImpl.kt index 675f2228d53..252a636124b 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrEnumConstructorCallImpl.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrEnumConstructorCallImpl.kt @@ -19,6 +19,8 @@ package org.jetbrains.kotlin.ir.expressions.impl import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.ir.expressions.IrEnumConstructorCall +import org.jetbrains.kotlin.ir.expressions.copyTypeArgumentsFrom +import org.jetbrains.kotlin.ir.expressions.typeArgumentsCount import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol import org.jetbrains.kotlin.ir.symbols.impl.IrConstructorSymbolImpl import org.jetbrains.kotlin.ir.visitors.IrElementVisitor @@ -29,14 +31,34 @@ class IrEnumConstructorCallImpl( startOffset: Int, endOffset: Int, override val symbol: IrConstructorSymbol, - typeArguments: Map? -) : IrEnumConstructorCall, + typeArgumentsCount: Int +) : IrCallWithIndexedArgumentsBase( - startOffset, endOffset, + startOffset, + endOffset, symbol.descriptor.builtIns.unitType, - symbol.descriptor.valueParameters.size, - typeArguments - ) { + typeArgumentsCount = typeArgumentsCount, + valueArgumentsCount = symbol.descriptor.valueParameters.size + ), + IrEnumConstructorCall { + + @Deprecated("Use constructor with typeArgumentsCount and fill type arguments explicitly or with copyTypeArgumentsFrom") + constructor( + startOffset: Int, + endOffset: Int, + symbol: IrConstructorSymbol, + typeArguments: Map? = null + ) : this(startOffset, endOffset, symbol, typeArguments.typeArgumentsCount) { + copyTypeArgumentsFrom(typeArguments) + } + + @Deprecated("Creates unbound symbols") + constructor( + startOffset: Int, + endOffset: Int, + descriptor: ClassConstructorDescriptor, + typeArgumentsCount: Int + ) : this(startOffset, endOffset, IrConstructorSymbolImpl(descriptor), typeArgumentsCount) @Deprecated("Creates unbound symbols") constructor( diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrFunctionReferenceImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrFunctionReferenceImpl.kt index 4d10b6050e5..9e209eb84ee 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrFunctionReferenceImpl.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrFunctionReferenceImpl.kt @@ -20,6 +20,8 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.ir.expressions.IrFunctionReference import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin +import org.jetbrains.kotlin.ir.expressions.copyTypeArgumentsFrom +import org.jetbrains.kotlin.ir.expressions.typeArgumentsCount import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol import org.jetbrains.kotlin.ir.symbols.impl.createFunctionSymbol import org.jetbrains.kotlin.ir.visitors.IrElementVisitor @@ -31,15 +33,30 @@ class IrFunctionReferenceImpl( type: KotlinType, override val symbol: IrFunctionSymbol, override val descriptor: FunctionDescriptor, - typeArguments: Map?, + typeArgumentsCount: Int, origin: IrStatementOrigin? = null -) : IrFunctionReference, +) : IrCallWithIndexedArgumentsBase( - startOffset, endOffset, type, + startOffset, + endOffset, + type, + typeArgumentsCount, symbol.descriptor.valueParameters.size, - typeArguments, origin - ) { + ), + IrFunctionReference { + + constructor( + startOffset: Int, + endOffset: Int, + type: KotlinType, + symbol: IrFunctionSymbol, + descriptor: FunctionDescriptor, + typeArguments: Map? = null, + origin: IrStatementOrigin? = null + ) : this(startOffset, endOffset, type, symbol, descriptor, typeArguments.typeArgumentsCount, origin) { + copyTypeArgumentsFrom(typeArguments) + } @Deprecated("Creates unbound symbol") constructor( @@ -47,9 +64,23 @@ class IrFunctionReferenceImpl( endOffset: Int, type: KotlinType, descriptor: FunctionDescriptor, - typeArguments: Map?, + typeArgumentsCount: Int, origin: IrStatementOrigin? = null - ) : this(startOffset, endOffset, type, createFunctionSymbol(descriptor.original), descriptor, typeArguments, origin) + ) : this(startOffset, endOffset, type, createFunctionSymbol(descriptor.original), descriptor, typeArgumentsCount, origin) + + @Deprecated("Creates unbound symbol") + constructor( + startOffset: Int, + endOffset: Int, + type: KotlinType, + descriptor: FunctionDescriptor, + typeArguments: Map? = null, + origin: IrStatementOrigin? = null + ) : this( + startOffset, endOffset, type, createFunctionSymbol(descriptor.original), descriptor, typeArguments.typeArgumentsCount, origin + ) { + copyTypeArgumentsFrom(typeArguments) + } override fun accept(visitor: IrElementVisitor, data: D): R = visitor.visitFunctionReference(this, data) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrLocalDelegatedPropertyReferenceImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrLocalDelegatedPropertyReferenceImpl.kt index ec7ea452ced..f01128abf29 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrLocalDelegatedPropertyReferenceImpl.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrLocalDelegatedPropertyReferenceImpl.kt @@ -33,8 +33,9 @@ class IrLocalDelegatedPropertyReferenceImpl( override val getter: IrFunctionSymbol, override val setter: IrFunctionSymbol?, origin: IrStatementOrigin? = null -) : IrLocalDelegatedPropertyReference, - IrNoArgumentsCallableReferenceBase(startOffset, endOffset, type, null, origin) { +) : IrNoArgumentsCallableReferenceBase(startOffset, endOffset, type, 0, origin), + IrLocalDelegatedPropertyReference { + override fun accept(visitor: IrElementVisitor, data: D): R = visitor.visitLocalDelegatedPropertyReference(this, data) } \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrMemberAccessExpressionBase.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrMemberAccessExpressionBase.kt index edd0b59d068..7605bd8ecae 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrMemberAccessExpressionBase.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrMemberAccessExpressionBase.kt @@ -16,9 +16,9 @@ package org.jetbrains.kotlin.ir.expressions.impl -import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.ir.expressions.IrExpression import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression +import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin import org.jetbrains.kotlin.ir.visitors.IrElementTransformer import org.jetbrains.kotlin.ir.visitors.IrElementVisitor import org.jetbrains.kotlin.types.KotlinType @@ -27,14 +27,23 @@ abstract class IrMemberAccessExpressionBase( startOffset: Int, endOffset: Int, type: KotlinType, - val typeArguments: Map?, - override val valueArgumentsCount: Int -) : IrExpressionBase(startOffset, endOffset, type), IrMemberAccessExpression { + final override val typeArgumentsCount: Int, + final override val valueArgumentsCount: Int, + final override val origin: IrStatementOrigin? = null +) : IrExpressionBase(startOffset, endOffset, type), + IrMemberAccessExpression { + override var dispatchReceiver: IrExpression? = null override var extensionReceiver: IrExpression? = null - override fun getTypeArgument(typeParameterDescriptor: TypeParameterDescriptor): KotlinType? = - typeArguments?.get(typeParameterDescriptor) + private val typeArgumentsByIndex = arrayOfNulls(typeArgumentsCount) + + override fun getTypeArgument(index: Int): KotlinType? = + typeArgumentsByIndex[index] + + override fun putTypeArgument(index: Int, type: KotlinType?) { + typeArgumentsByIndex[index] = type + } override fun acceptChildren(visitor: IrElementVisitor, data: D) { dispatchReceiver?.accept(visitor, data) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrNoArgumentsCallableReferenceBase.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrNoArgumentsCallableReferenceBase.kt index 9c24a004e76..34b5381f08a 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrNoArgumentsCallableReferenceBase.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrNoArgumentsCallableReferenceBase.kt @@ -16,7 +16,6 @@ package org.jetbrains.kotlin.ir.expressions.impl -import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.ir.expressions.IrCallableReference import org.jetbrains.kotlin.ir.expressions.IrExpression import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin @@ -26,10 +25,10 @@ abstract class IrNoArgumentsCallableReferenceBase( startOffset: Int, endOffset: Int, type: KotlinType, - typeArguments: Map?, - override val origin: IrStatementOrigin? = null -) : IrCallableReference, - IrMemberAccessExpressionBase(startOffset, endOffset, type, typeArguments, 0) { + typeArgumentsCount: Int, + origin: IrStatementOrigin? = null +) : IrMemberAccessExpressionBase(startOffset, endOffset, type, typeArgumentsCount, 0, origin), + IrCallableReference { private fun throwNoValueArguments(): Nothing { throw UnsupportedOperationException("Property reference $descriptor has no value arguments") diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrPrimitiveCall.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrPrimitiveCall.kt index c0c33e1b656..3ccd6e90b10 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrPrimitiveCall.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrPrimitiveCall.kt @@ -18,7 +18,6 @@ package org.jetbrains.kotlin.ir.expressions.impl import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.FunctionDescriptor -import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.ir.expressions.IrCall import org.jetbrains.kotlin.ir.expressions.IrCallWithShallowCopy import org.jetbrains.kotlin.ir.expressions.IrExpression @@ -44,6 +43,12 @@ abstract class IrPrimitiveCallBase( override val superQualifier: ClassDescriptor? get() = null override val superQualifierSymbol: IrClassSymbol? get() = null + override val typeArgumentsCount: Int = 0 + + override fun getTypeArgument(index: Int): KotlinType? = null + + override fun putTypeArgument(index: Int, type: KotlinType?) {} + override var dispatchReceiver: IrExpression? get() = null set(value) { @@ -58,9 +63,6 @@ abstract class IrPrimitiveCallBase( throw UnsupportedOperationException("Operator call expression can't have a receiver") } - override fun getTypeArgument(typeParameterDescriptor: TypeParameterDescriptor): KotlinType? = - null // IR primitives have no type parameters - override fun removeValueArgument(index: Int) { throw AssertionError("Operator call expression can't have a default argument") } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrPropertyAccessorCall.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrPropertyAccessorCall.kt index 6596ddbac8e..339cc7afa28 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrPropertyAccessorCall.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrPropertyAccessorCall.kt @@ -19,10 +19,7 @@ package org.jetbrains.kotlin.ir.expressions.impl import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor -import org.jetbrains.kotlin.ir.expressions.IrCall -import org.jetbrains.kotlin.ir.expressions.IrCallWithShallowCopy -import org.jetbrains.kotlin.ir.expressions.IrExpression -import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin +import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.symbols.IrClassSymbol import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol import org.jetbrains.kotlin.ir.symbols.impl.createClassSymbolOrNull @@ -37,11 +34,11 @@ abstract class IrPropertyAccessorCallBase( startOffset: Int, endOffset: Int, override val symbol: IrFunctionSymbol, override val descriptor: FunctionDescriptor, - typeArguments: Map?, + typeArgumentsCount: Int, valueArgumentsCount: Int, - override val origin: IrStatementOrigin? = null, + origin: IrStatementOrigin? = null, override val superQualifierSymbol: IrClassSymbol? = null -) : IrMemberAccessExpressionBase(startOffset, endOffset, descriptor.returnType!!, typeArguments, valueArgumentsCount), +) : IrMemberAccessExpressionBase(startOffset, endOffset, descriptor.returnType!!, typeArgumentsCount, valueArgumentsCount, origin), IrCall { override val superQualifier: ClassDescriptor? get() = superQualifierSymbol?.descriptor @@ -56,17 +53,34 @@ abstract class IrPropertyAccessorCallBase( } class IrGetterCallImpl( - startOffset: Int, endOffset: Int, + startOffset: Int, + endOffset: Int, symbol: IrFunctionSymbol, descriptor: FunctionDescriptor, - typeArguments: Map?, + typeArgumentsCount: Int, origin: IrStatementOrigin? = null, superQualifierSymbol: IrClassSymbol? = null -) : IrPropertyAccessorCallBase(startOffset, endOffset, symbol, descriptor, typeArguments, 0, origin, superQualifierSymbol), +) : IrPropertyAccessorCallBase(startOffset, endOffset, symbol, descriptor, typeArgumentsCount, 0, origin, superQualifierSymbol), IrCallWithShallowCopy { constructor( - startOffset: Int, endOffset: Int, + startOffset: Int, + endOffset: Int, + symbol: IrFunctionSymbol, + descriptor: FunctionDescriptor, + typeArgumentsCount: Int, + dispatchReceiver: IrExpression?, + extensionReceiver: IrExpression?, + origin: IrStatementOrigin? = null, + superQualifierSymbol: IrClassSymbol? = null + ) : this(startOffset, endOffset, symbol, descriptor, typeArgumentsCount, origin, superQualifierSymbol) { + this.dispatchReceiver = dispatchReceiver + this.extensionReceiver = extensionReceiver + } + + constructor( + startOffset: Int, + endOffset: Int, symbol: IrFunctionSymbol, descriptor: FunctionDescriptor, typeArguments: Map?, @@ -74,9 +88,12 @@ class IrGetterCallImpl( extensionReceiver: IrExpression?, origin: IrStatementOrigin? = null, superQualifierSymbol: IrClassSymbol? = null - ) : this(startOffset, endOffset, symbol, descriptor, typeArguments, origin, superQualifierSymbol) { - this.dispatchReceiver = dispatchReceiver - this.extensionReceiver = extensionReceiver + ) : this( + startOffset, endOffset, symbol, descriptor, + typeArguments.typeArgumentsCount, + dispatchReceiver, extensionReceiver, origin, superQualifierSymbol + ) { + copyTypeArgumentsFrom(typeArguments) } override fun getValueArgument(index: Int): IrExpression? = null @@ -93,30 +110,50 @@ class IrGetterCallImpl( IrGetterCallImpl( startOffset, endOffset, newCallee, descriptor, // TODO substitute descriptor for new callee? - typeArguments, dispatchReceiver, extensionReceiver, newOrigin, newSuperQualifier - ) + typeArgumentsCount, newOrigin, newSuperQualifier + ).also { newCall -> + newCall.copyTypeArgumentsFrom(this) + } override fun shallowCopy(newOrigin: IrStatementOrigin?, newCallee: FunctionDescriptor, newSuperQualifier: ClassDescriptor?): IrCall = IrGetterCallImpl( startOffset, endOffset, createFunctionSymbol(newCallee), newCallee, - typeArguments, dispatchReceiver, extensionReceiver, + typeArgumentsCount, newOrigin, createClassSymbolOrNull(newSuperQualifier) - ) + ).also { newCall -> + newCall.copyTypeArgumentsFrom(this) + } } class IrSetterCallImpl( startOffset: Int, endOffset: Int, symbol: IrFunctionSymbol, descriptor: FunctionDescriptor, - typeArguments: Map?, + typeArgumentsCount: Int, origin: IrStatementOrigin? = null, superQualifierSymbol: IrClassSymbol? = null -) : IrPropertyAccessorCallBase(startOffset, endOffset, symbol, descriptor, typeArguments, 1, origin, superQualifierSymbol), +) : IrPropertyAccessorCallBase(startOffset, endOffset, symbol, descriptor, typeArgumentsCount, 1, origin, superQualifierSymbol), IrCallWithShallowCopy { + constructor( + startOffset: Int, endOffset: Int, + symbol: IrFunctionSymbol, + descriptor: FunctionDescriptor, + typeArgumentsCount: Int, + dispatchReceiver: IrExpression?, + extensionReceiver: IrExpression?, + argument: IrExpression, + origin: IrStatementOrigin? = null, + superQualifierSymbol: IrClassSymbol? = null + ) : this(startOffset, endOffset, symbol, descriptor, typeArgumentsCount, origin, superQualifierSymbol) { + this.dispatchReceiver = dispatchReceiver + this.extensionReceiver = extensionReceiver + putValueArgument(SETTER_ARGUMENT_INDEX, argument) + } + constructor( startOffset: Int, endOffset: Int, symbol: IrFunctionSymbol, @@ -127,7 +164,8 @@ class IrSetterCallImpl( argument: IrExpression, origin: IrStatementOrigin? = null, superQualifierSymbol: IrClassSymbol? = null - ) : this(startOffset, endOffset, symbol, descriptor, typeArguments, origin, superQualifierSymbol) { + ) : this(startOffset, endOffset, symbol, descriptor, typeArguments.typeArgumentsCount, origin, superQualifierSymbol) { + copyTypeArgumentsFrom(typeArguments) this.dispatchReceiver = dispatchReceiver this.extensionReceiver = extensionReceiver putValueArgument(SETTER_ARGUMENT_INDEX, argument) @@ -152,18 +190,22 @@ class IrSetterCallImpl( IrSetterCallImpl( startOffset, endOffset, newCallee, descriptor, // TODO substitute newCallee.descriptor? - typeArguments, newOrigin, newSuperQualifier - ) + typeArgumentsCount, newOrigin, newSuperQualifier + ).also { newCall -> + newCall.copyTypeArgumentsFrom(this) + } override fun shallowCopy(newOrigin: IrStatementOrigin?, newCallee: FunctionDescriptor, newSuperQualifier: ClassDescriptor?): IrCall = IrSetterCallImpl( startOffset, endOffset, createFunctionSymbol(newCallee), newCallee, - typeArguments, + typeArgumentsCount, newOrigin, createClassSymbolOrNull(newSuperQualifier) - ) + ).also { newCall -> + newCall.copyTypeArgumentsFrom(this) + } override fun transformChildren(transformer: IrElementTransformer, data: D) { super.transformChildren(transformer, data) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrPropertyReferenceImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrPropertyReferenceImpl.kt index 629c7e0b74e..c78d9c73694 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrPropertyReferenceImpl.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrPropertyReferenceImpl.kt @@ -20,6 +20,8 @@ import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.ir.expressions.IrPropertyReference import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin +import org.jetbrains.kotlin.ir.expressions.copyTypeArgumentsFrom +import org.jetbrains.kotlin.ir.expressions.typeArgumentsCount import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol import org.jetbrains.kotlin.ir.visitors.IrElementVisitor @@ -30,13 +32,28 @@ class IrPropertyReferenceImpl( endOffset: Int, type: KotlinType, override val descriptor: PropertyDescriptor, + typeArgumentsCount: Int, override val field: IrFieldSymbol?, override val getter: IrFunctionSymbol?, override val setter: IrFunctionSymbol?, - typeArguments: Map?, origin: IrStatementOrigin? = null -) : IrPropertyReference, - IrNoArgumentsCallableReferenceBase(startOffset, endOffset, type, typeArguments, origin) { +) : IrNoArgumentsCallableReferenceBase(startOffset, endOffset, type, typeArgumentsCount, origin), + IrPropertyReference { + + constructor( + startOffset: Int, + endOffset: Int, + type: KotlinType, + descriptor: PropertyDescriptor, + field: IrFieldSymbol?, + getter: IrFunctionSymbol?, + setter: IrFunctionSymbol?, + typeArguments: Map?, + origin: IrStatementOrigin? = null + ) : this(startOffset, endOffset, type, descriptor, typeArguments.typeArgumentsCount, field, getter, setter, origin) { + copyTypeArgumentsFrom(typeArguments) + } + override fun accept(visitor: IrElementVisitor, data: D): R = visitor.visitPropertyReference(this, data) } \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTree.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTree.kt index 36bcedd51e3..d0ef1f4b2c0 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTree.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTree.kt @@ -34,6 +34,7 @@ inline fun T.deepCopyOld(): T = @Deprecated("Creates unbound symbols") open class DeepCopyIrTree : IrElementTransformerVoid() { + protected open fun mapDeclarationOrigin(declarationOrigin: IrDeclarationOrigin) = declarationOrigin protected open fun mapStatementOrigin(statementOrigin: IrStatementOrigin?) = statementOrigin protected open fun mapFileEntry(fileEntry: SourceManager.FileEntry) = fileEntry @@ -154,8 +155,9 @@ open class DeepCopyIrTree : IrElementTransformerVoid() { } @Deprecated("Replace with remapTypeArguments") - protected fun IrMemberAccessExpression.transformTypeArguments(newCallee: CallableDescriptor) = - remapTypeArguments(this, newCallee) + protected fun IrMemberAccessExpression.transformTypeArguments(newCallee: CallableDescriptor) { + // Do nothing: assume that type parameters of the newCallee directly correspond to the original type parameters + } private fun FunctionDescriptor.getTypeParametersToTransform() = when { @@ -389,7 +391,9 @@ open class DeepCopyIrTree : IrElementTransformerVoid() { ) override fun visitCall(expression: IrCall): IrCall = - shallowCopyCall(expression).transformValueArguments(expression) + shallowCopyCall(expression).apply { + transformValueArguments(expression) + } protected fun shallowCopyCall(expression: IrCall) = when (expression) { @@ -405,30 +409,33 @@ open class DeepCopyIrTree : IrElementTransformerVoid() { expression.startOffset, expression.endOffset, expression.type, newCallee, - remapTypeArguments(expression, newCallee), + expression.typeArgumentsCount, mapStatementOrigin(expression.origin), mapSuperQualifier(expression.superQualifier) - ) + ).apply { + copyTypeArgumentsFrom(expression) + } } } - protected fun T.transformValueArguments(original: IrMemberAccessExpression): T = - apply { - dispatchReceiver = original.dispatchReceiver?.transform() - extensionReceiver = original.extensionReceiver?.transform() - mapValueParameters { valueParameter -> - original.getValueArgument(valueParameter)?.transform() - } - Unit + protected fun T.transformValueArguments(original: IrMemberAccessExpression) { + dispatchReceiver = original.dispatchReceiver?.transform() + extensionReceiver = original.extensionReceiver?.transform() + mapValueParameters { valueParameter -> + original.getValueArgument(valueParameter)?.transform() } + } override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall): IrDelegatingConstructorCall { val newCallee = mapDelegatedConstructorCallee(expression.descriptor) return IrDelegatingConstructorCallImpl( expression.startOffset, expression.endOffset, newCallee, - remapTypeArguments(expression, newCallee) - ).transformValueArguments(expression) + expression.typeArgumentsCount + ).apply { + copyTypeArgumentsFrom(expression) + transformValueArguments(expression) + } } override fun visitEnumConstructorCall(expression: IrEnumConstructorCall): IrEnumConstructorCall { @@ -437,8 +444,11 @@ open class DeepCopyIrTree : IrElementTransformerVoid() { return IrEnumConstructorCallImpl( expression.startOffset, expression.endOffset, newConstructor, - remapTypeArguments(expression, newConstructor) - ).transformValueArguments(expression) + expression.typeArgumentsCount + ).apply { + copyTypeArgumentsFrom(expression) + transformValueArguments(expression) + } } override fun visitGetClass(expression: IrGetClass): IrGetClass = @@ -454,9 +464,12 @@ open class DeepCopyIrTree : IrElementTransformerVoid() { expression.startOffset, expression.endOffset, expression.type, newCallee.original, - remapTypeArguments(expression, newCallee), + expression.typeArgumentsCount, mapStatementOrigin(expression.origin) - ).transformValueArguments(expression) + ).apply { + copyTypeArgumentsFrom(expression) + transformValueArguments(expression) + } } override fun visitPropertyReference(expression: IrPropertyReference): IrExpression { @@ -466,10 +479,13 @@ open class DeepCopyIrTree : IrElementTransformerVoid() { val newSetterSymbol = newProperty.setter?.let { IrSimpleFunctionSymbolImpl(it.original) } return IrPropertyReferenceImpl( expression.startOffset, expression.endOffset, expression.type, - newProperty, newFieldSymbol, newGetterSymbol, newSetterSymbol, - remapTypeArguments(expression, newProperty), + newProperty, + expression.typeArgumentsCount, newFieldSymbol, newGetterSymbol, newSetterSymbol, mapStatementOrigin(expression.origin) - ).transformValueArguments(expression) + ).apply { + copyTypeArgumentsFrom(expression) + transformValueArguments(expression) + } } override fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference): IrExpression { @@ -633,5 +649,4 @@ open class DeepCopyIrTree : IrElementTransformerVoid() { expression.arguments.mapTo(arguments) { it.transform() } } - } \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt index d739cfe64ab..9aae353af6b 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt @@ -315,7 +315,10 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper) ) override fun visitCall(expression: IrCall): IrCall = - shallowCopyCall(expression).transformValueArguments(expression) + shallowCopyCall(expression).apply { + copyTypeArgumentsFrom(expression) + transformValueArguments(expression) + } private fun shallowCopyCall(expression: IrCall) = when (expression) { @@ -332,10 +335,12 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper) expression.type, newCallee, expression.descriptor, // TODO substitute referenced descriptor - remapTypeArguments(expression, newCallee.descriptor), + expression.typeArgumentsCount, mapStatementOrigin(expression.origin), symbolRemapper.getReferencedClassOrNull(expression.superQualifierSymbol) - ) + ).apply { + copyTypeArgumentsFrom(expression) + } } } @@ -345,13 +350,12 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper) extensionReceiver = original.extensionReceiver?.transform() } - private fun T.transformValueArguments(original: T): T = - apply { - transformReceiverArguments(original) - mapValueParameters { valueParameter -> - original.getValueArgument(valueParameter)?.transform() - } + private fun T.transformValueArguments(original: T) { + transformReceiverArguments(original) + mapValueParameters { valueParameter -> + original.getValueArgument(valueParameter)?.transform() } + } override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall): IrDelegatingConstructorCall { val newConstructor = symbolRemapper.getReferencedConstructor(expression.symbol) @@ -359,8 +363,11 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper) expression.startOffset, expression.endOffset, newConstructor, expression.descriptor, - remapTypeArguments(expression, newConstructor.descriptor) - ).transformValueArguments(expression) + expression.typeArgumentsCount + ).apply { + copyTypeArgumentsFrom(expression) + transformValueArguments(expression) + } } override fun visitEnumConstructorCall(expression: IrEnumConstructorCall): IrEnumConstructorCall { @@ -368,8 +375,11 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper) return IrEnumConstructorCallImpl( expression.startOffset, expression.endOffset, newConstructor, - remapTypeArguments(expression, newConstructor.descriptor) - ).transformValueArguments(expression) + expression.typeArgumentsCount + ).apply { + copyTypeArgumentsFrom(expression) + transformValueArguments(expression) + } } override fun visitGetClass(expression: IrGetClass): IrGetClass = @@ -385,21 +395,27 @@ open class DeepCopyIrTreeWithSymbols(private val symbolRemapper: SymbolRemapper) expression.type, symbolRemapper.getReferencedFunction(expression.symbol), expression.descriptor, // TODO substitute referenced descriptor - expression.getTypeArgumentsMap(), + expression.typeArgumentsCount, mapStatementOrigin(expression.origin) - ).transformValueArguments(expression) + ).apply { + copyTypeArgumentsFrom(expression) + transformValueArguments(expression) + } override fun visitPropertyReference(expression: IrPropertyReference): IrPropertyReference = IrPropertyReferenceImpl( expression.startOffset, expression.endOffset, expression.type, expression.descriptor, + expression.typeArgumentsCount, expression.field?.let { symbolRemapper.getReferencedField(it) }, expression.getter?.let { symbolRemapper.getReferencedFunction(it) }, expression.setter?.let { symbolRemapper.getReferencedFunction(it) }, - expression.getTypeArgumentsMap(), mapStatementOrigin(expression.origin) - ).transformReceiverArguments(expression) + ).apply { + copyTypeArgumentsFrom(expression) + transformReceiverArguments(expression) + } override fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference): IrLocalDelegatedPropertyReference = IrLocalDelegatedPropertyReferenceImpl( diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/remapTypeArguments.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/remapTypeArguments.kt deleted file mode 100644 index 9d2510d6547..00000000000 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/remapTypeArguments.kt +++ /dev/null @@ -1,49 +0,0 @@ -/* - * Copyright 2010-2018 JetBrains s.r.o. 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.util - -import org.jetbrains.kotlin.descriptors.CallableDescriptor -import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor -import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression -import org.jetbrains.kotlin.ir.expressions.impl.IrMemberAccessExpressionBase -import org.jetbrains.kotlin.types.KotlinType - -fun remapTypeArguments( - expression: IrMemberAccessExpression, - newDescriptor: CallableDescriptor -): Map? { - val oldDescriptor = expression.descriptor - val oldTypeArguments = expression.getTypeArgumentsMap() - val oldTypeParameters = oldDescriptor.original.typeParameters - val newTypeParameters = newDescriptor.original.typeParameters - - assert(oldTypeParameters.size == newTypeParameters.size) { - "Mismatching type parameters: oldDescriptor: $oldDescriptor; newDescriptor: $newDescriptor" - } - - return when { - oldDescriptor.original == newDescriptor.original -> oldTypeArguments - - oldTypeArguments == null || oldTypeArguments.isEmpty() -> null - - else -> newTypeParameters.associate { newTypeParameter -> - val oldTypeParameter = oldTypeParameters[newTypeParameter.index] - val newTypeArgument = expression.getTypeArgument(oldTypeParameter) - ?: throw AssertionError("No type argument for $newTypeParameter <= $oldTypeParameter") - newTypeParameter to newTypeArgument - } - } -} - -fun IrMemberAccessExpression.getTypeArgumentsMap(): Map? { - if (this is IrMemberAccessExpressionBase) return typeArguments - - val typeParameters = descriptor.original.typeParameters - return if (typeParameters.isEmpty()) - null - else - typeParameters.associateBy({ it }, { getTypeArgument(it)!! }) -} \ No newline at end of file