diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt index d91723da33b..1f8749da06f 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt @@ -318,7 +318,7 @@ class CallAndReferenceGenerator( internal fun IrExpression.applyCallArguments(call: FirCall?): IrExpression { if (call == null) return this return when (this) { - is IrMemberAccessExpression -> { + is IrMemberAccessExpression<*> -> { val argumentsCount = call.arguments.size if (argumentsCount <= valueArgumentsCount) { apply { @@ -363,7 +363,7 @@ class CallAndReferenceGenerator( } } - private fun IrMemberAccessExpression.applyArgumentsWithReorderingIfNeeded( + private fun IrMemberAccessExpression<*>.applyArgumentsWithReorderingIfNeeded( call: FirCall, argumentMapping: Map, valueParameters: List, @@ -437,7 +437,7 @@ class CallAndReferenceGenerator( private fun IrExpression.applyTypeArguments(access: FirQualifiedAccess): IrExpression { return when (this) { - is IrMemberAccessExpression -> { + is IrMemberAccessExpression<*> -> { val argumentsCount = access.typeArguments.size if (argumentsCount <= typeArgumentsCount) { apply { @@ -495,7 +495,7 @@ class CallAndReferenceGenerator( private fun IrExpression.applyReceivers(qualifiedAccess: FirQualifiedAccess, explicitReceiverExpression: IrExpression?): IrExpression { return when (this) { - is IrMemberAccessExpression -> { + is IrMemberAccessExpression<*> -> { val ownerFunction = symbol.owner as? IrFunction ?: (symbol.owner as? IrProperty)?.getter diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DataClassMembersGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DataClassMembersGenerator.kt index bbc57d69829..f36a882e655 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DataClassMembersGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DataClassMembersGenerator.kt @@ -95,7 +95,7 @@ class DataClassMembersGenerator(val components: Fir2IrComponents) { return components.irBuiltIns.anyType } - override fun commitSubstituted(irMemberAccessExpression: IrMemberAccessExpression, descriptor: CallableDescriptor) { + override fun commitSubstituted(irMemberAccessExpression: IrMemberAccessExpression<*>, descriptor: CallableDescriptor) { // TODO } } diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/IfNullExpressionsFusionLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/IfNullExpressionsFusionLowering.kt index 891768fb3e1..045e35d732b 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/IfNullExpressionsFusionLowering.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/IfNullExpressionsFusionLowering.kt @@ -131,7 +131,7 @@ class IfNullExpressionsFusionLowering(val context: CommonBackendContext) : FileL is IrConstructorCall, is IrGetSingletonValue, is IrFunctionExpression, - is IrCallableReference, + is IrCallableReference<*>, is IrClassReference, is IrGetClass -> return false diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/KCallableNamePropertyLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/KCallableNamePropertyLowering.kt index 22a301fbd66..1e8a3834d02 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/KCallableNamePropertyLowering.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/KCallableNamePropertyLowering.kt @@ -45,8 +45,7 @@ private class KCallableNamePropertyLowering(val context: BackendContext) : FileL } private class KCallableNamePropertyTransformer(val lower: KCallableNamePropertyLowering) : IrElementTransformerVoid() { - - private fun nameForCallableMember(reference: IrCallableReference): Name { + private fun nameForCallableMember(reference: IrCallableReference<*>): Name { return when (reference) { is IrFunctionReference -> reference.symbol.owner.name is IrPropertyReference -> reference.symbol.owner.name @@ -56,8 +55,7 @@ private class KCallableNamePropertyTransformer(val lower: KCallableNamePropertyL } override fun visitCall(expression: IrCall): IrExpression { - - val callableReference = expression.dispatchReceiver as? IrCallableReference ?: return expression + val callableReference = expression.dispatchReceiver as? IrCallableReference<*> ?: return expression //TODO rewrite checking val directMember = expression.symbol.owner.let { diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt index 6d9aafde882..506d4093760 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt @@ -367,7 +367,7 @@ class LocalDeclarationsLowering( } } - inline fun T.mapValueParameters( + inline fun > T.mapValueParameters( newTarget: IrFunction, transform: (IrValueParameter) -> IrExpression? ): T = @@ -377,8 +377,10 @@ class LocalDeclarationsLowering( } } - private fun T.fillArguments2(oldExpression: IrMemberAccessExpression, newTarget: IrFunction): T { - + private fun > T.fillArguments2( + oldExpression: IrMemberAccessExpression<*>, + newTarget: IrFunction + ): T { mapValueParameters(newTarget) { newValueParameterDeclaration -> val oldParameter = newParameterToOld[newValueParameterDeclaration] @@ -542,7 +544,7 @@ class LocalDeclarationsLowering( it.copyTypeArgumentsFrom(oldCall) } - private fun IrMemberAccessExpression.setLocalTypeArguments(callee: IrFunction) { + private fun IrMemberAccessExpression<*>.setLocalTypeArguments(callee: IrFunction) { val context = localFunctions[callee] ?: return for ((outerTypeParameter, innerTypeParameter) in context.capturedTypeParameterToTypeParameter) { putTypeArgument(innerTypeParameter.index, outerTypeParameter.defaultType) // TODO: remap default type! diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BlockDecomposerLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BlockDecomposerLowering.kt index eb4b01c9a82..b9068a987b2 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BlockDecomposerLowering.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/BlockDecomposerLowering.kt @@ -566,7 +566,7 @@ class BlockDecomposerTransformer( // var p4_tmp = p4 // var p5_tmp = block {} // d_tmp.foo(p1_tmp, p2_tmp, p3_tmp, p4_tmp, p5_tmp, p6, p7) - override fun visitMemberAccess(expression: IrMemberAccessExpression): IrExpression { + override fun visitMemberAccess(expression: IrMemberAccessExpression<*>): IrExpression { expression.transformChildrenVoid(expressionTransformer) val oldArguments = mutableListOf(expression.dispatchReceiver, expression.extensionReceiver) diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/PrivateMembersLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/PrivateMembersLowering.kt index f4ea1c45ae1..ff8b6d1a341 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/PrivateMembersLowering.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/PrivateMembersLowering.kt @@ -218,9 +218,9 @@ class PrivateMemberBodiesLowering(val context: JsIrBackendContext) : BodyLowerin } private fun transformPrivateToStaticReference( - expression: IrCallableReference, - builder: () -> IrCallableReference - ): IrCallableReference { + expression: IrCallableReference<*>, + builder: () -> IrCallableReference<*> + ): IrCallableReference<*> { val newExpression = builder() diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/StateMachineBuilder.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/StateMachineBuilder.kt index 099eac3d7d9..3b7dbf758c7 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/StateMachineBuilder.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/StateMachineBuilder.kt @@ -503,7 +503,7 @@ class StateMachineBuilder( return newArguments } - override fun visitMemberAccess(expression: IrMemberAccessExpression) { + override fun visitMemberAccess(expression: IrMemberAccessExpression<*>) { if (expression !in suspendableNodes) { addExceptionEdge() diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/jsAstUtils.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/jsAstUtils.kt index 6375db575e7..a4ccb283416 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/jsAstUtils.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/jsAstUtils.kt @@ -201,7 +201,7 @@ fun translateCall( } } -fun translateCallArguments(expression: IrMemberAccessExpression, context: JsGenerationContext, transformer: IrElementToJsExpressionTransformer): List { +fun translateCallArguments(expression: IrMemberAccessExpression<*>, context: JsGenerationContext, transformer: IrElementToJsExpressionTransformer): List { val size = expression.valueArgumentsCount val arguments = (0 until size).mapTo(ArrayList(size)) { index -> diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCodegen.kt index c0db33bee5b..e3970f76d28 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCodegen.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCodegen.kt @@ -273,7 +273,7 @@ class IrDefaultLambda( fun isInlineIrExpression(argumentExpression: IrExpression) = when (argumentExpression) { is IrBlock -> argumentExpression.isInlineIrBlock() - is IrCallableReference -> true.also { + is IrCallableReference<*> -> true.also { assert((0 until argumentExpression.valueArgumentsCount).count { argumentExpression.getValueArgument(it) != null } == 0) { "Expecting 0 value arguments for bounded callable reference: ${argumentExpression.dump()}" } @@ -284,4 +284,4 @@ fun isInlineIrExpression(argumentExpression: IrExpression) = fun IrBlock.isInlineIrBlock(): Boolean = origin.isLambda fun IrFunction.isInlineFunctionCall(context: JvmBackendContext) = - (!context.state.isInlineDisabled || typeParameters.any { it.isReified }) && isInline \ No newline at end of file + (!context.state.isInlineDisabled || typeParameters.any { it.isReified }) && isInline diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/irCodegenUtils.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/irCodegenUtils.kt index b4afa56ba95..5c4bcef0340 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/irCodegenUtils.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/irCodegenUtils.kt @@ -427,5 +427,5 @@ val IrFunction.deprecationFlags: Int val IrDeclaration.psiElement: PsiElement? get() = (descriptor as? DeclarationDescriptorWithSource)?.psiElement -val IrMemberAccessExpression.psiElement: PsiElement? +val IrMemberAccessExpression<*>.psiElement: PsiElement? get() = (symbol.descriptor.original as? DeclarationDescriptorWithSource)?.psiElement diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt index 542e7b3b5f7..53af142f651 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt @@ -31,7 +31,7 @@ abstract class IntrinsicMethod { companion object { - fun calcReceiverType(call: IrMemberAccessExpression, context: JvmBackendContext): Type { + fun calcReceiverType(call: IrMemberAccessExpression<*>, context: JvmBackendContext): Type { return context.typeMapper.mapType(call.dispatchReceiver?.type ?: call.extensionReceiver!!.type) } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrInlineReferenceLocator.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrInlineReferenceLocator.kt index c8b2a697cc6..a94f6c1ce75 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrInlineReferenceLocator.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrInlineReferenceLocator.kt @@ -13,7 +13,10 @@ import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.declarations.IrDeclaration import org.jetbrains.kotlin.ir.declarations.IrFunction import org.jetbrains.kotlin.ir.declarations.IrValueParameter -import org.jetbrains.kotlin.ir.expressions.* +import org.jetbrains.kotlin.ir.expressions.IrBlock +import org.jetbrains.kotlin.ir.expressions.IrCallableReference +import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression +import org.jetbrains.kotlin.ir.expressions.IrFunctionReference import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid internal open class IrInlineReferenceLocator(private val context: JvmBackendContext) : IrElementVisitorVoidWithContext() { @@ -33,7 +36,7 @@ internal open class IrInlineReferenceLocator(private val context: JvmBackendCont if (valueArgument is IrBlock && valueArgument.origin.isLambda) { val reference = valueArgument.statements.last() as IrFunctionReference visitInlineLambda(reference, function, parameter, currentScope!!.irElement as IrDeclaration) - } else if (valueArgument is IrCallableReference) { + } else if (valueArgument is IrCallableReference<*>) { visitInlineReference(valueArgument) } } @@ -41,19 +44,19 @@ internal open class IrInlineReferenceLocator(private val context: JvmBackendCont return super.visitFunctionAccess(expression) } - open fun visitInlineReference(argument: IrCallableReference) {} + open fun visitInlineReference(argument: IrCallableReference<*>) {} open fun visitInlineLambda(argument: IrFunctionReference, callee: IrFunction, parameter: IrValueParameter, scope: IrDeclaration) = visitInlineReference(argument) companion object { - fun scan(context: JvmBackendContext, element: IrElement): Set = - mutableSetOf().apply { + fun scan(context: JvmBackendContext, element: IrElement): Set> = + mutableSetOf>().apply { element.accept(object : IrInlineReferenceLocator(context) { - override fun visitInlineReference(argument: IrCallableReference) { + override fun visitInlineReference(argument: IrCallableReference<*>) { add(argument) } }, null) } } -} \ No newline at end of file +} diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AddContinuationLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AddContinuationLowering.kt index bd71f63323c..1a519db5c88 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AddContinuationLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AddContinuationLowering.kt @@ -87,10 +87,10 @@ private class AddContinuationLowering(private val context: JvmBackendContext) : } private fun transformSuspendLambdasIntoContinuations(irFile: IrFile) { - val inlineReferences = mutableSetOf() + val inlineReferences = mutableSetOf>() val suspendLambdas = mutableMapOf() irFile.acceptChildrenVoid(object : IrInlineReferenceLocator(context) { - override fun visitInlineReference(argument: IrCallableReference) { + override fun visitInlineReference(argument: IrCallableReference<*>) { inlineReferences.add(argument) } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionReferenceLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionReferenceLowering.kt index 0ad0c3dfcb0..80b2818af04 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionReferenceLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionReferenceLowering.kt @@ -39,7 +39,7 @@ internal val functionReferencePhase = makeIrFilePhase( internal class FunctionReferenceLowering(private val context: JvmBackendContext) : FileLoweringPass, IrElementTransformerVoidWithContext() { // This pass ignores suspend function references and function references used in inline arguments to inline functions. - private val ignoredFunctionReferences = mutableSetOf() + private val ignoredFunctionReferences = mutableSetOf>() private val IrFunctionReference.isIgnored: Boolean get() = (!type.isFunctionOrKFunction() || ignoredFunctionReferences.contains(this)) && !isSuspendFunctionReference() diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InlineCallableReferenceToLambda.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InlineCallableReferenceToLambda.kt index 408d5153eb9..96fc3cf71a9 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InlineCallableReferenceToLambda.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InlineCallableReferenceToLambda.kt @@ -46,7 +46,7 @@ internal val inlineCallableReferenceToLambdaPhase = makeIrFilePhase( internal class InlineCallableReferenceToLambdaPhase(val context: JvmBackendContext) : FileLoweringPass, IrElementTransformerVoidWithContext() { - private var inlinableReferences = mutableSetOf() + private var inlinableReferences = mutableSetOf>() override fun lower(irFile: IrFile) { inlinableReferences.addAll(IrInlineReferenceLocator.scan(context, irFile)) @@ -113,7 +113,7 @@ internal class InlineCallableReferenceToLambdaPhase(val context: JvmBackendConte } } - private fun expandInlineFunctionReferenceToLambda(expression: IrCallableReference, referencedFunction: IrFunction): IrExpression { + private fun expandInlineFunctionReferenceToLambda(expression: IrCallableReference<*>, referencedFunction: IrFunction): IrExpression { val irBuilder = context.createJvmIrBuilder(currentScope!!.scope.scopeOwnerSymbol, expression.startOffset, expression.endOffset) return irBuilder.irBlock(expression, IrStatementOrigin.LAMBDA) { diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmArgumentNullabilityAssertionsLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmArgumentNullabilityAssertionsLowering.kt index dbefe089274..f8f71e9709a 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmArgumentNullabilityAssertionsLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmArgumentNullabilityAssertionsLowering.kt @@ -52,7 +52,7 @@ private class JvmArgumentNullabilityAssertionsLowering(context: JvmBackendContex else super.visitTypeOperator(expression, data) - override fun visitMemberAccess(expression: IrMemberAccessExpression, data: AssertionScope): IrElement { + override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: AssertionScope): IrElement { // Always drop nullability assertions on dispatch receivers, assuming that it will throw NPE. // // NB there are some members in Kotlin built-in classes which are NOT implemented as platform method calls, @@ -89,7 +89,7 @@ private class JvmArgumentNullabilityAssertionsLowering(context: JvmBackendContex return expression } - private fun isCallToMethodWithTypeCheckBarrier(expression: IrMemberAccessExpression): Boolean = + private fun isCallToMethodWithTypeCheckBarrier(expression: IrMemberAccessExpression<*>): Boolean = expression.symbol.owner.safeAs()?.let { specialBridgeMethods.findSpecialWithOverride(it) != null } == true private val IrStatementOrigin?.isOperatorWithNoNullabilityAssertionsOnExtensionReceiver diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineClassLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineClassLowering.kt index 8cf0cf39a50..b095142d65a 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineClassLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineClassLowering.kt @@ -256,15 +256,15 @@ private class JvmInlineClassLowering(private val context: JvmBackendContext) : F return listOf(replacement) } - private fun typedArgumentList(function: IrFunction, expression: IrMemberAccessExpression) = + private fun typedArgumentList(function: IrFunction, expression: IrMemberAccessExpression<*>) = listOfNotNull( function.dispatchReceiverParameter?.let { it to expression.dispatchReceiver }, function.extensionReceiverParameter?.let { it to expression.extensionReceiver } ) + function.valueParameters.map { it to expression.getValueArgument(it.index) } - private fun IrMemberAccessExpression.buildReplacement( + private fun IrMemberAccessExpression<*>.buildReplacement( originalFunction: IrFunction, - original: IrMemberAccessExpression, + original: IrMemberAccessExpression<*>, replacement: IrSimpleFunction ) { copyTypeArgumentsFrom(original) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt index 15f9e1a34a0..1f145cc4897 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt @@ -56,13 +56,13 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : Class private val localPropertyIndices = mutableMapOf() // TODO: join IrLocalDelegatedPropertyReference and IrPropertyReference via the class hierarchy? - private val IrMemberAccessExpression.getter: IrSimpleFunctionSymbol? + private val IrMemberAccessExpression<*>.getter: IrSimpleFunctionSymbol? get() = (this as? IrPropertyReference)?.getter ?: (this as? IrLocalDelegatedPropertyReference)?.getter - private val IrMemberAccessExpression.setter: IrSimpleFunctionSymbol? + private val IrMemberAccessExpression<*>.setter: IrSimpleFunctionSymbol? get() = (this as? IrPropertyReference)?.setter ?: (this as? IrLocalDelegatedPropertyReference)?.setter - private val IrMemberAccessExpression.field: IrFieldSymbol? + private val IrMemberAccessExpression<*>.field: IrFieldSymbol? get() = (this as? IrPropertyReference)?.field private val IrSimpleFunction.signature: String @@ -91,7 +91,7 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : Class private val useOptimizedSuperClass = context.state.generateOptimizedCallableReferenceSuperClasses - private val IrMemberAccessExpression.propertyContainer: IrDeclarationParent + private val IrMemberAccessExpression<*>.propertyContainer: IrDeclarationParent get() { var current: IrDeclaration = getter?.owner ?: field?.owner ?: error("Property without getter or field: ${dump()}") while (current.parent is IrFunction) @@ -99,13 +99,13 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : Class return current.parent } - private fun IrBuilderWithScope.buildReflectedContainerReference(expression: IrMemberAccessExpression): IrExpression = + private fun IrBuilderWithScope.buildReflectedContainerReference(expression: IrMemberAccessExpression<*>): IrExpression = calculateOwner(expression.propertyContainer, this@PropertyReferenceLowering.context) - private fun JvmIrBuilder.buildReflectedContainerReferenceKClass(expression: IrMemberAccessExpression): IrExpression = + private fun JvmIrBuilder.buildReflectedContainerReferenceKClass(expression: IrMemberAccessExpression<*>): IrExpression = calculateOwnerKClass(expression.propertyContainer, backendContext) - private fun IrBuilderWithScope.computeSignatureString(expression: IrCallableReference): IrExpression { + private fun IrBuilderWithScope.computeSignatureString(expression: IrMemberAccessExpression<*>): IrExpression { return expression.getter?.let { getter -> localPropertyIndices[getter]?.let { irString("") } ?: irCall(signatureStringIntrinsic).apply { @@ -174,7 +174,7 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : Class context.ir.symbols.reflection.owner.functions.single { it.name.asString() == (if (mutable) "mutableProperty$i" else "property$i") } ) - private fun propertyReferenceKindFor(expression: IrMemberAccessExpression): PropertyReferenceKind = + private fun propertyReferenceKindFor(expression: IrMemberAccessExpression<*>): PropertyReferenceKind = expression.getter?.owner?.let { val boundReceivers = listOfNotNull(expression.dispatchReceiver, expression.extensionReceiver).size val needReceivers = listOfNotNull(it.dispatchReceiverParameter, it.extensionReceiverParameter).size @@ -213,7 +213,7 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : Class override fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference): IrExpression = cachedKProperty(expression) - private fun cachedKProperty(expression: IrCallableReference): IrExpression { + private fun cachedKProperty(expression: IrCallableReference<*>): IrExpression { if (expression.origin != IrStatementOrigin.PROPERTY_REFERENCE_FOR_DELEGATE) return createSpecializedKProperty(expression) @@ -233,7 +233,7 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : Class // Create an instance of KProperty that uses Java reflection to locate the getter and the setter. This kind of reference // does not support local variables or bound receivers (e.g. `Class()::field`) and is slower, but takes up less space. // Example: `C::property` -> `Reflection.property1(PropertyReference1Impl(C::class, "property", "getProperty()LType;"))`. - private fun createReflectedKProperty(expression: IrCallableReference): IrExpression { + private fun createReflectedKProperty(expression: IrCallableReference<*>): IrExpression { val referenceKind = propertyReferenceKindFor(expression) return context.createIrBuilder(currentScope!!.scope.scopeOwnerSymbol, expression.startOffset, expression.endOffset).run { irCall(referenceKind.wrapper).apply { @@ -258,7 +258,7 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : Class // // and then `C()::property` -> `C$property$0(C())`. // - private fun createSpecializedKProperty(expression: IrCallableReference): IrExpression { + private fun createSpecializedKProperty(expression: IrCallableReference<*>): IrExpression { val referenceClass = createKPropertySubclass(expression) return context.createIrBuilder( currentScope?.scope?.scopeOwnerSymbol ?: irClass.symbol, expression.startOffset, expression.endOffset @@ -274,7 +274,7 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : Class } } - private fun createKPropertySubclass(expression: IrCallableReference): IrClass { + private fun createKPropertySubclass(expression: IrCallableReference<*>): IrClass { val kind = propertyReferenceKindFor(expression) val superClass = if (useOptimizedSuperClass) kind.implSymbol.owner else kind.interfaceSymbol.owner val referenceClass = buildClass { @@ -362,7 +362,7 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : Class return referenceClass } - private fun addConstructor(expression: IrCallableReference, referenceClass: IrClass, superClass: IrClass) { + private fun addConstructor(expression: IrCallableReference<*>, referenceClass: IrClass, superClass: IrClass) { // See propertyReferenceKindFor -- only one of them could ever be present. val hasBoundReceiver = expression.dispatchReceiver != null || expression.extensionReceiver != null val numOfSuperArgs = diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/StaticLambdaLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/StaticLambdaLowering.kt index 1f4366f25c9..d5d23aeb142 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/StaticLambdaLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/StaticLambdaLowering.kt @@ -100,7 +100,7 @@ class StaticLambdaLowering(val backendContext: JvmBackendContext) : FileLowering element.acceptChildrenVoid(this) } - override fun visitMemberAccess(expression: IrMemberAccessExpression) { + override fun visitMemberAccess(expression: IrMemberAccessExpression<*>) { for (i in 0 until expression.typeArgumentsCount) { if (expression.getTypeArgument(i)?.isReified == true) { containsReified = true diff --git a/compiler/ir/ir.ir2cfg/src/org/jetbrains/kotlin/ir2cfg/generators/FunctionGenerator.kt b/compiler/ir/ir.ir2cfg/src/org/jetbrains/kotlin/ir2cfg/generators/FunctionGenerator.kt index 536a78df120..03c72883a9b 100644 --- a/compiler/ir/ir.ir2cfg/src/org/jetbrains/kotlin/ir2cfg/generators/FunctionGenerator.kt +++ b/compiler/ir/ir.ir2cfg/src/org/jetbrains/kotlin/ir2cfg/generators/FunctionGenerator.kt @@ -173,7 +173,7 @@ class FunctionGenerator(val function: IrFunction) { return jump } - override fun visitMemberAccess(expression: IrMemberAccessExpression, data: Boolean): IrStatement? { + override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: Boolean): IrStatement? { expression.dispatchReceiver?.process() expression.extensionReceiver?.process() val callee = expression.symbol.owner as IrFunction diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt index 255ac18a3f7..b644e351b5d 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt @@ -410,7 +410,7 @@ class CallGenerator(statementGenerator: StatementGenerator) : StatementGenerator fun IrExpression.hasNoSideEffects() = this is IrFunctionExpression || - (this is IrCallableReference && dispatchReceiver == null && extensionReceiver == null) || + (this is IrCallableReference<*> && dispatchReceiver == null && extensionReceiver == null) || this is IrClassReference || this is IrConst<*> || this is IrGetValue diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DataClassMembersGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DataClassMembersGenerator.kt index 46b687cbaf5..6e154830d14 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DataClassMembersGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DataClassMembersGenerator.kt @@ -48,7 +48,7 @@ class DataClassMembersGenerator( MyDataClassMethodGenerator(ktClassOrObject, irClass, IrDeclarationOrigin.GENERATED_DATA_CLASS_MEMBER).generate() } - fun IrMemberAccessExpression.commitSubstituted(descriptor: CallableDescriptor) = context.run { commitSubstituted(descriptor) } + fun IrMemberAccessExpression<*>.commitSubstituted(descriptor: CallableDescriptor) = context.run { commitSubstituted(descriptor) } private fun declareSimpleFunction(startOffset: Int, endOffset: Int, origin: IrDeclarationOrigin, function: FunctionDescriptor) = context.symbolTable.declareSimpleFunctionWithOverrides( @@ -81,7 +81,7 @@ class DataClassMembersGenerator( override fun transform(typeParameterDescriptor: TypeParameterDescriptor): IrType = typeParameterDescriptor.defaultType.toIrType() - override fun commitSubstituted(irMemberAccessExpression: IrMemberAccessExpression, descriptor: CallableDescriptor) { + override fun commitSubstituted(irMemberAccessExpression: IrMemberAccessExpression<*>, descriptor: CallableDescriptor) { irMemberAccessExpression.commitSubstituted(descriptor) } } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DelegatedPropertyGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DelegatedPropertyGenerator.kt index b4dc0608b50..fd624f854d9 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DelegatedPropertyGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DelegatedPropertyGenerator.kt @@ -204,7 +204,7 @@ class DelegatedPropertyGenerator(declarationGenerator: DeclarationGenerator) : D type: KotlinType, referencedDescriptor: CallableDescriptor, statementGenerator: StatementGenerator - ): IrCallableReference = + ): IrCallableReference<*> = ReflectionReferencesGenerator(statementGenerator).generateCallableReference( ktElement, type, referencedDescriptor, @@ -216,7 +216,7 @@ class DelegatedPropertyGenerator(declarationGenerator: DeclarationGenerator) : D type: KotlinType, referencedDescriptor: VariableDescriptorWithAccessors, scopeOwner: IrSymbol - ): IrCallableReference = + ): IrCallableReference<*> = createCallableReference( ktElement, type, referencedDescriptor, createBodyGenerator(scopeOwner).createStatementGenerator() @@ -388,7 +388,7 @@ class DelegatedPropertyGenerator(declarationGenerator: DeclarationGenerator) : D ktDelegate: KtPropertyDelegate, getterDescriptor: VariableAccessorDescriptor, delegateReceiverValue: IntermediateValue, - irPropertyReference: IrCallableReference + irPropertyReference: IrCallableReference<*> ): IrBody = with(createBodyGenerator(irGetter.symbol)) { val startOffset = ktDelegate.startOffsetSkippingComments @@ -414,7 +414,7 @@ class DelegatedPropertyGenerator(declarationGenerator: DeclarationGenerator) : D ktDelegate: KtPropertyDelegate, setterDescriptor: VariableAccessorDescriptor, delegateReceiverValue: IntermediateValue, - irPropertyReference: IrCallableReference + irPropertyReference: IrCallableReference<*> ): IrBody = with(createBodyGenerator(irSetter.symbol)) { val startOffset = ktDelegate.startOffsetSkippingComments val endOffset = ktDelegate.endOffset @@ -429,4 +429,4 @@ class DelegatedPropertyGenerator(declarationGenerator: DeclarationGenerator) : D +irReturn(CallGenerator(statementGenerator).generateCall(startOffset, endOffset, conventionMethodCall)) } } -} \ No newline at end of file +} diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ReflectionReferencesGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ReflectionReferencesGenerator.kt index b3fb1486c3f..5fc71ddb08e 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ReflectionReferencesGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ReflectionReferencesGenerator.kt @@ -416,7 +416,7 @@ class ReflectionReferencesGenerator(statementGenerator: StatementGenerator) : St callableDescriptor: CallableDescriptor, typeArguments: Map?, origin: IrStatementOrigin? = null - ): IrCallableReference { + ): IrCallableReference<*> { val startOffset = ktElement.startOffsetSkippingComments val endOffset = ktElement.endOffset return when (callableDescriptor) { diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/PropertyLValue.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/PropertyLValue.kt index cea0bd7441a..818e1d34791 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/PropertyLValue.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/PropertyLValue.kt @@ -137,7 +137,7 @@ class AccessorPropertyLValue( private val typeArgumentsCount = typeArguments?.size ?: 0 - private fun IrMemberAccessExpression.putTypeArguments() { + private fun IrMemberAccessExpression<*>.putTypeArguments() { typeArguments?.forEachIndexed { index, irType -> putTypeArgument(index, irType) } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/transformations/InsertImplicitCasts.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/transformations/InsertImplicitCasts.kt index 423976b052f..e31cc7a31e2 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/transformations/InsertImplicitCasts.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/transformations/InsertImplicitCasts.kt @@ -113,14 +113,14 @@ internal class InsertImplicitCasts( private val IrDeclarationReference.substitutedDescriptor get() = callToSubstitutedDescriptorMap[this] ?: symbol.descriptor as CallableDescriptor - override fun visitCallableReference(expression: IrCallableReference): IrExpression { + override fun visitCallableReference(expression: IrCallableReference<*>): IrExpression { val substitutedDescriptor = expression.substitutedDescriptor return expression.transformPostfix { transformReceiverArguments(substitutedDescriptor) } } - private fun IrMemberAccessExpression.transformReceiverArguments(substitutedDescriptor: CallableDescriptor) { + private fun IrMemberAccessExpression<*>.transformReceiverArguments(substitutedDescriptor: CallableDescriptor) { dispatchReceiver = dispatchReceiver?.cast(getEffectiveDispatchReceiverType(substitutedDescriptor)) val extensionReceiverType = substitutedDescriptor.extensionReceiverParameter?.type val originalExtensionReceiverType = substitutedDescriptor.original.extensionReceiverParameter?.type @@ -144,7 +144,7 @@ internal class InsertImplicitCasts( descriptor.dispatchReceiverParameter?.type } - override fun visitMemberAccess(expression: IrMemberAccessExpression): IrExpression { + override fun visitMemberAccess(expression: IrMemberAccessExpression<*>): IrExpression { val substitutedDescriptor = expression.substitutedDescriptor return expression.transformPostfix { transformReceiverArguments(substitutedDescriptor) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt index e28953227e3..73e26c537d6 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt @@ -209,7 +209,7 @@ fun IrBuilderWithScope.irCall( callee: IrFunctionSymbol, type: IrType, typeArguments: List -): IrMemberAccessExpression = +): IrMemberAccessExpression<*> = irCall(callee, type).apply { typeArguments.forEachIndexed { index, irType -> this.putTypeArgument(index, irType) @@ -299,7 +299,7 @@ fun IrBuilderWithScope.irCallOp( type: IrType, dispatchReceiver: IrExpression, argument: IrExpression? = null -): IrMemberAccessExpression = +): IrMemberAccessExpression<*> = irCall(callee, type, valueArgumentsCount = if (argument != null) 1 else 0, typeArgumentsCount = 0).apply { this.dispatchReceiver = dispatchReceiver if (argument != null) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrCallableReference.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrCallableReference.kt index f713271e002..612cca571be 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrCallableReference.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrCallableReference.kt @@ -19,11 +19,11 @@ package org.jetbrains.kotlin.ir.expressions import org.jetbrains.kotlin.ir.symbols.* import org.jetbrains.kotlin.name.Name -interface IrCallableReference : IrMemberAccessExpression { +interface IrCallableReference : IrMemberAccessExpression { val referencedName: Name } -interface IrFunctionReference : IrCallableReference, IrFunctionAccessExpression { +interface IrFunctionReference : IrCallableReference, IrFunctionAccessExpression { val reflectionTarget: IrFunctionSymbol? } @@ -33,15 +33,13 @@ val IrFunctionReference.isWithReflection: Boolean val IrFunctionReference.isAdapterWithReflection: Boolean get() = reflectionTarget != null && reflectionTarget != symbol -interface IrPropertyReference : IrCallableReference { - override val symbol: IrPropertySymbol +interface IrPropertyReference : IrCallableReference { val field: IrFieldSymbol? val getter: IrSimpleFunctionSymbol? val setter: IrSimpleFunctionSymbol? } -interface IrLocalDelegatedPropertyReference : IrCallableReference { - override val symbol: IrLocalDelegatedPropertySymbol +interface IrLocalDelegatedPropertyReference : IrCallableReference { val delegate: IrVariableSymbol val getter: IrSimpleFunctionSymbol val setter: IrSimpleFunctionSymbol? 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 98de1a1667f..9dae538be80 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 @@ -16,11 +16,11 @@ import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.types.defaultType import org.jetbrains.kotlin.types.KotlinType -interface IrMemberAccessExpression : IrExpression, IrDeclarationReference { +interface IrMemberAccessExpression : IrDeclarationReference { var dispatchReceiver: IrExpression? var extensionReceiver: IrExpression? - override val symbol: IrSymbol + override val symbol: S val origin: IrStatementOrigin? @@ -34,10 +34,10 @@ interface IrMemberAccessExpression : IrExpression, IrDeclarationReference { fun removeValueArgument(index: Int) } -fun IrMemberAccessExpression.getTypeArgument(typeParameterDescriptor: TypeParameterDescriptor): IrType? = +fun IrMemberAccessExpression<*>.getTypeArgument(typeParameterDescriptor: TypeParameterDescriptor): IrType? = getTypeArgument(typeParameterDescriptor.index) -fun IrMemberAccessExpression.copyTypeArgumentsFrom(other: IrMemberAccessExpression, shift: Int = 0) { +fun IrMemberAccessExpression<*>.copyTypeArgumentsFrom(other: IrMemberAccessExpression<*>, shift: Int = 0) { assert(typeArgumentsCount == other.typeArgumentsCount + shift) { "Mismatching type arguments: $typeArgumentsCount vs ${other.typeArgumentsCount} + $shift" } @@ -46,7 +46,7 @@ fun IrMemberAccessExpression.copyTypeArgumentsFrom(other: IrMemberAccessExpressi } } -inline fun IrMemberAccessExpression.putTypeArguments( +inline fun IrMemberAccessExpression<*>.putTypeArguments( typeArguments: Map?, toIrType: (KotlinType) -> IrType ) { @@ -63,26 +63,24 @@ val CallableDescriptor.typeParametersCount: Int else -> typeParameters.size } -fun IrMemberAccessExpression.getTypeArgumentOrDefault(irTypeParameter: IrTypeParameter) = +fun IrMemberAccessExpression<*>.getTypeArgumentOrDefault(irTypeParameter: IrTypeParameter) = getTypeArgument(irTypeParameter.index) ?: irTypeParameter.defaultType -interface IrFunctionAccessExpression : IrMemberAccessExpression { - override val symbol: IrFunctionSymbol -} +interface IrFunctionAccessExpression : IrMemberAccessExpression -fun IrMemberAccessExpression.getValueArgument(valueParameterDescriptor: ValueParameterDescriptor) = +fun IrMemberAccessExpression<*>.getValueArgument(valueParameterDescriptor: ValueParameterDescriptor) = getValueArgument(valueParameterDescriptor.index) -fun IrMemberAccessExpression.putValueArgument(valueParameterDescriptor: ValueParameterDescriptor, valueArgument: IrExpression?) { +fun IrMemberAccessExpression<*>.putValueArgument(valueParameterDescriptor: ValueParameterDescriptor, valueArgument: IrExpression?) { putValueArgument(valueParameterDescriptor.index, valueArgument) } -fun IrMemberAccessExpression.removeValueArgument(valueParameterDescriptor: ValueParameterDescriptor) { +fun IrMemberAccessExpression<*>.removeValueArgument(valueParameterDescriptor: ValueParameterDescriptor) { removeValueArgument(valueParameterDescriptor.index) } @ObsoleteDescriptorBasedAPI -inline fun T.mapTypeParameters(transform: (TypeParameterDescriptor) -> IrType) : T = +inline fun > T.mapTypeParameters(transform: (TypeParameterDescriptor) -> IrType) : T = apply { val descriptor = symbol.descriptor as CallableDescriptor descriptor.typeParameters.forEach { @@ -91,7 +89,7 @@ inline fun T.mapTypeParameters(transform: (TypePa } @ObsoleteDescriptorBasedAPI -inline fun T.mapValueParameters(transform: (ValueParameterDescriptor) -> IrExpression?): T = +inline fun > T.mapValueParameters(transform: (ValueParameterDescriptor) -> IrExpression?): T = apply { val descriptor = symbol.descriptor as CallableDescriptor descriptor.valueParameters.forEach { @@ -100,7 +98,7 @@ inline fun T.mapValueParameters(transform: (Value } @ObsoleteDescriptorBasedAPI -inline fun T.mapValueParametersIndexed(transform: (Int, ValueParameterDescriptor) -> IrExpression?): T = +inline fun > T.mapValueParametersIndexed(transform: (Int, ValueParameterDescriptor) -> IrExpression?): T = apply { val descriptor = symbol.descriptor as CallableDescriptor descriptor.valueParameters.forEach { @@ -108,7 +106,7 @@ inline fun T.mapValueParametersIndexed(transform: } } -fun IrMemberAccessExpression.putArgument(callee: IrFunction, parameter: IrValueParameter, argument: IrExpression) = +fun IrMemberAccessExpression<*>.putArgument(callee: IrFunction, parameter: IrValueParameter, argument: IrExpression) = when (parameter) { callee.dispatchReceiverParameter -> dispatchReceiver = argument callee.extensionReceiverParameter -> extensionReceiver = argument 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 eb0bb6e7f8d..e238e8d3fd1 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 @@ -18,6 +18,7 @@ package org.jetbrains.kotlin.ir.expressions.impl import org.jetbrains.kotlin.ir.expressions.IrExpression import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin +import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.visitors.IrElementTransformer import org.jetbrains.kotlin.ir.visitors.IrElementVisitor @@ -30,7 +31,7 @@ abstract class IrCallWithIndexedArgumentsBase( valueArgumentsCount: Int, origin: IrStatementOrigin? = null ) : - IrMemberAccessExpressionBase( + IrMemberAccessExpressionBase( startOffset, endOffset, type, @@ -70,4 +71,4 @@ abstract class IrCallWithIndexedArgumentsBase( argumentsByParameterIndex[i] = irExpression?.transform(transformer, data) } } -} \ No newline at end of file +} 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 c139890a6df..b7eacea0d83 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 @@ -16,7 +16,6 @@ package org.jetbrains.kotlin.ir.expressions.impl -import org.jetbrains.kotlin.descriptors.VariableDescriptorWithAccessors import org.jetbrains.kotlin.ir.expressions.IrLocalDelegatedPropertyReference import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin import org.jetbrains.kotlin.ir.symbols.IrLocalDelegatedPropertySymbol @@ -36,7 +35,7 @@ class IrLocalDelegatedPropertyReferenceImpl( override val setter: IrSimpleFunctionSymbol?, origin: IrStatementOrigin? = null ) : - IrNoArgumentsCallableReferenceBase(startOffset, endOffset, type, 0, origin), + IrNoArgumentsCallableReferenceBase(startOffset, endOffset, type, 0, origin), IrLocalDelegatedPropertyReference { override val referencedName: Name @@ -44,4 +43,4 @@ class IrLocalDelegatedPropertyReferenceImpl( 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 6e6172f25da..2a8e5047572 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 @@ -19,11 +19,12 @@ package org.jetbrains.kotlin.ir.expressions.impl 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.symbols.IrSymbol import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.visitors.IrElementTransformer import org.jetbrains.kotlin.ir.visitors.IrElementVisitor -abstract class IrMemberAccessExpressionBase( +abstract class IrMemberAccessExpressionBase( startOffset: Int, endOffset: Int, type: IrType, @@ -32,7 +33,7 @@ abstract class IrMemberAccessExpressionBase( final override val origin: IrStatementOrigin? = null ) : IrExpressionBase(startOffset, endOffset, type), - IrMemberAccessExpression { + IrMemberAccessExpression { override var dispatchReceiver: IrExpression? = null override var extensionReceiver: IrExpression? = null @@ -62,4 +63,4 @@ abstract class IrMemberAccessExpressionBase( dispatchReceiver = dispatchReceiver?.transform(transformer, data) extensionReceiver = extensionReceiver?.transform(transformer, data) } -} \ No newline at end of file +} 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 1086bedbef7..bd7c808c703 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 @@ -19,17 +19,18 @@ package org.jetbrains.kotlin.ir.expressions.impl import org.jetbrains.kotlin.ir.expressions.IrCallableReference import org.jetbrains.kotlin.ir.expressions.IrExpression import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin +import org.jetbrains.kotlin.ir.symbols.IrSymbol import org.jetbrains.kotlin.ir.types.IrType -abstract class IrNoArgumentsCallableReferenceBase( +abstract class IrNoArgumentsCallableReferenceBase( startOffset: Int, endOffset: Int, type: IrType, typeArgumentsCount: Int, origin: IrStatementOrigin? = null ) : - IrMemberAccessExpressionBase(startOffset, endOffset, type, typeArgumentsCount, 0, origin), - IrCallableReference { + IrMemberAccessExpressionBase(startOffset, endOffset, type, typeArgumentsCount, 0, origin), + IrCallableReference { private fun throwNoValueArguments(): Nothing { throw UnsupportedOperationException("Property reference $symbol has no value arguments") @@ -41,4 +42,3 @@ abstract class IrNoArgumentsCallableReferenceBase( override fun removeValueArgument(index: Int) = throwNoValueArguments() } - 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 994677fa4a7..cdd30164cf5 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 @@ -38,7 +38,7 @@ class IrPropertyReferenceImpl( override val setter: IrSimpleFunctionSymbol?, origin: IrStatementOrigin? = null ) : - IrNoArgumentsCallableReferenceBase(startOffset, endOffset, type, typeArgumentsCount, origin), + IrNoArgumentsCallableReferenceBase(startOffset, endOffset, type, typeArgumentsCount, origin), IrPropertyReference { @Deprecated(message = "Don't use descriptor-based API for IrPropertyReference", level = DeprecationLevel.WARNING) @@ -63,4 +63,4 @@ class IrPropertyReferenceImpl( 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/DataClassMembersGenerator.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DataClassMembersGenerator.kt index d863e9e5b81..758a887cb77 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DataClassMembersGenerator.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DataClassMembersGenerator.kt @@ -340,7 +340,7 @@ abstract class DataClassMembersGenerator( ): IrSimpleFunctionSymbol = getHashCodeFunction(property.type, symbolResolve) - abstract fun commitSubstituted(irMemberAccessExpression: IrMemberAccessExpression, descriptor: CallableDescriptor) + abstract fun commitSubstituted(irMemberAccessExpression: IrMemberAccessExpression<*>, descriptor: CallableDescriptor) // Entry for psi2ir fun generateHashCodeMethod(function: FunctionDescriptor, properties: List) { 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 450d4c33e74..88163b492f4 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 @@ -505,7 +505,7 @@ open class DeepCopyIrTreeWithSymbols( }.copyAttributes(expression) } - private fun IrMemberAccessExpression.copyRemappedTypeArgumentsFrom(other: IrMemberAccessExpression) { + private fun IrMemberAccessExpression<*>.copyRemappedTypeArgumentsFrom(other: IrMemberAccessExpression<*>) { assert(typeArgumentsCount == other.typeArgumentsCount) { "Mismatching type arguments: $typeArgumentsCount vs ${other.typeArgumentsCount} " } @@ -529,13 +529,13 @@ open class DeepCopyIrTreeWithSymbols( }.copyAttributes(expression) } - private fun T.transformReceiverArguments(original: T): T = + private fun > T.transformReceiverArguments(original: T): T = apply { dispatchReceiver = original.dispatchReceiver?.transform() extensionReceiver = original.extensionReceiver?.transform() } - private fun T.transformValueArguments(original: T) { + private fun > T.transformValueArguments(original: T) { transformReceiverArguments(original) for (i in 0 until original.valueArgumentsCount) { putValueArgument(i, original.getValueArgument(i)?.transform()) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DumpIrTree.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DumpIrTree.kt index 8b44f1edc61..b26cb78b63c 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DumpIrTree.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DumpIrTree.kt @@ -168,7 +168,7 @@ class DumpIrTreeVisitor( } } - override fun visitMemberAccess(expression: IrMemberAccessExpression, data: String) { + override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: String) { expression.dumpLabeledElementWith(data) { dumpTypeArguments(expression) expression.dispatchReceiver?.accept(this, "\$this") @@ -195,7 +195,7 @@ class DumpIrTreeVisitor( } } - private fun dumpTypeArguments(expression: IrMemberAccessExpression) { + private fun dumpTypeArguments(expression: IrMemberAccessExpression<*>) { val typeParameterNames = expression.getTypeParameterNames(expression.typeArgumentsCount) for (index in 0 until expression.typeArgumentsCount) { printer.println("<${typeParameterNames[index]}>: ${expression.renderTypeArgument(index)}") @@ -215,7 +215,7 @@ class DumpIrTreeVisitor( } } - private fun IrMemberAccessExpression.getTypeParameterNames(expectedCount: Int): List = + private fun IrMemberAccessExpression<*>.getTypeParameterNames(expectedCount: Int): List = if (this is IrDeclarationReference && symbol.isBound) symbol.owner.getTypeParameterNames(expectedCount) else @@ -243,7 +243,7 @@ class DumpIrTreeVisitor( return parentClass.typeParameters + typeParameters } - private fun IrMemberAccessExpression.renderTypeArgument(index: Int): String = + private fun IrMemberAccessExpression<*>.renderTypeArgument(index: Int): String = getTypeArgument(index)?.render() ?: "" override fun visitGetField(expression: IrGetField, data: String) { @@ -372,7 +372,7 @@ class DumpTreeFromSourceLineVisitor( } } -internal fun IrMemberAccessExpression.getValueParameterNamesForDebug(): List { +internal fun IrMemberAccessExpression<*>.getValueParameterNamesForDebug(): List { val expectedCount = valueArgumentsCount if (symbol.isBound) { val owner = symbol.owner diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt index 0fed840390e..98a06248251 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt @@ -36,7 +36,7 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs * The arguments are to be evaluated in the same order as they appear in the resulting list. */ @ObsoleteDescriptorBasedAPI -fun IrMemberAccessExpression.getArguments(): List> { +fun IrMemberAccessExpression<*>.getArguments(): List> { val res = mutableListOf>() val descriptor = symbol.descriptor as CallableDescriptor @@ -91,7 +91,7 @@ fun IrFunctionAccessExpression.getArgumentsWithSymbols(): List> { +fun IrMemberAccessExpression<*>.getArgumentsWithIr(): List> { val res = mutableListOf>() val irFunction = when (this) { is IrFunctionAccessExpression -> this.symbol.owner @@ -125,7 +125,7 @@ fun IrMemberAccessExpression.getArgumentsWithIr(): List) { +fun IrMemberAccessExpression<*>.addArguments(args: Map) { val descriptor = symbol.descriptor as CallableDescriptor descriptor.dispatchReceiverParameter?.let { val arg = args[it] @@ -150,7 +150,7 @@ fun IrMemberAccessExpression.addArguments(args: Map>) = +fun IrMemberAccessExpression<*>.addArguments(args: List>) = this.addArguments(args.toMap()) fun IrExpression.isNullConst() = this is IrConst<*> && this.kind == IrConstKind.Null @@ -199,7 +199,7 @@ fun IrExpression.coerceToUnitIfNeeded(valueType: IrType, irBuiltIns: IrBuiltIns) } @ObsoleteDescriptorBasedAPI -fun IrMemberAccessExpression.usesDefaultArguments(): Boolean = +fun IrMemberAccessExpression<*>.usesDefaultArguments(): Boolean = (symbol.descriptor as CallableDescriptor).valueParameters.any { this.getValueArgument(it) == null } val DeclarationDescriptorWithSource.startOffset: Int? get() = (this.source as? PsiSourceElement)?.psi?.startOffset @@ -508,8 +508,8 @@ fun IrFunctionAccessExpression.copyTypeAndValueArgumentsFrom( copyValueArgumentsFrom(src, src.symbol.owner, symbol.owner, receiversAsArguments, argumentsAsReceivers) } -fun IrMemberAccessExpression.copyValueArgumentsFrom( - src: IrMemberAccessExpression, +fun IrMemberAccessExpression<*>.copyValueArgumentsFrom( + src: IrMemberAccessExpression<*>, srcFunction: IrFunction, destFunction: IrFunction, receiversAsArguments: Boolean = false, @@ -573,7 +573,7 @@ val IrFunction.allTypeParameters: List else typeParameters -fun IrMemberAccessExpression.getTypeSubstitutionMap(irFunction: IrFunction): Map = +fun IrMemberAccessExpression<*>.getTypeSubstitutionMap(irFunction: IrFunction): Map = irFunction.allTypeParameters.withIndex().associate { it.value.symbol to getTypeArgument(it.index)!! } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementTransformer.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementTransformer.kt index 0e2d81b2d72..ad1ebcc0899 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementTransformer.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementTransformer.kt @@ -86,7 +86,7 @@ interface IrElementTransformer : IrElementVisitor { override fun visitFieldAccess(expression: IrFieldAccessExpression, data: D) = visitDeclarationReference(expression, data) override fun visitGetField(expression: IrGetField, data: D) = visitFieldAccess(expression, data) override fun visitSetField(expression: IrSetField, data: D) = visitFieldAccess(expression, data) - override fun visitMemberAccess(expression: IrMemberAccessExpression, data: D): IrElement = visitExpression(expression, data) + override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D): IrElement = visitExpression(expression, data) override fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: D): IrElement = visitMemberAccess(expression, data) override fun visitCall(expression: IrCall, data: D) = visitFunctionAccess(expression, data) override fun visitConstructorCall(expression: IrConstructorCall, data: D): IrElement = visitFunctionAccess(expression, data) @@ -94,7 +94,7 @@ interface IrElementTransformer : IrElementVisitor { override fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: D) = visitFunctionAccess(expression, data) override fun visitGetClass(expression: IrGetClass, data: D) = visitExpression(expression, data) - override fun visitCallableReference(expression: IrCallableReference, data: D) = visitMemberAccess(expression, data) + override fun visitCallableReference(expression: IrCallableReference<*>, data: D) = visitMemberAccess(expression, data) override fun visitFunctionReference(expression: IrFunctionReference, data: D) = visitCallableReference(expression, data) override fun visitPropertyReference(expression: IrPropertyReference, data: D) = visitCallableReference(expression, data) override fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference, data: D) = diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementTransformerVoid.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementTransformerVoid.kt index d1c6610e10e..669314a4afe 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementTransformerVoid.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementTransformerVoid.kt @@ -163,8 +163,8 @@ abstract class IrElementTransformerVoid : IrElementTransformer { open fun visitSetField(expression: IrSetField) = visitFieldAccess(expression) final override fun visitSetField(expression: IrSetField, data: Nothing?) = visitSetField(expression) - open fun visitMemberAccess(expression: IrMemberAccessExpression) = visitExpression(expression) - final override fun visitMemberAccess(expression: IrMemberAccessExpression, data: Nothing?) = visitMemberAccess(expression) + open fun visitMemberAccess(expression: IrMemberAccessExpression<*>) = visitExpression(expression) + final override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: Nothing?) = visitMemberAccess(expression) open fun visitFunctionAccess(expression: IrFunctionAccessExpression) = visitMemberAccess(expression) final override fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: Nothing?) = visitFunctionAccess(expression) @@ -185,8 +185,8 @@ abstract class IrElementTransformerVoid : IrElementTransformer { open fun visitGetClass(expression: IrGetClass) = visitExpression(expression) final override fun visitGetClass(expression: IrGetClass, data: Nothing?) = visitGetClass(expression) - open fun visitCallableReference(expression: IrCallableReference) = visitMemberAccess(expression) - final override fun visitCallableReference(expression: IrCallableReference, data: Nothing?) = visitCallableReference(expression) + open fun visitCallableReference(expression: IrCallableReference<*>) = visitMemberAccess(expression) + final override fun visitCallableReference(expression: IrCallableReference<*>, data: Nothing?) = visitCallableReference(expression) open fun visitFunctionReference(expression: IrFunctionReference) = visitCallableReference(expression) final override fun visitFunctionReference(expression: IrFunctionReference, data: Nothing?): IrElement = diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt index 33b912ff14d..c8a029eeffe 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt @@ -72,7 +72,7 @@ interface IrElementVisitor { fun visitGetField(expression: IrGetField, data: D) = visitFieldAccess(expression, data) fun visitSetField(expression: IrSetField, data: D) = visitFieldAccess(expression, data) - fun visitMemberAccess(expression: IrMemberAccessExpression, data: D) = visitExpression(expression, data) + fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D) = visitExpression(expression, data) fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: D) = visitMemberAccess(expression, data) fun visitCall(expression: IrCall, data: D) = visitFunctionAccess(expression, data) fun visitConstructorCall(expression: IrConstructorCall, data: D) = visitFunctionAccess(expression, data) @@ -80,7 +80,7 @@ interface IrElementVisitor { fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: D) = visitFunctionAccess(expression, data) fun visitGetClass(expression: IrGetClass, data: D) = visitExpression(expression, data) - fun visitCallableReference(expression: IrCallableReference, data: D) = visitMemberAccess(expression, data) + fun visitCallableReference(expression: IrCallableReference<*>, data: D) = visitMemberAccess(expression, data) fun visitFunctionReference(expression: IrFunctionReference, data: D) = visitCallableReference(expression, data) fun visitPropertyReference(expression: IrPropertyReference, data: D) = visitCallableReference(expression, data) fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference, data: D) = diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitorVoid.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitorVoid.kt index 25bd05053d9..f8aa7e9b998 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitorVoid.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitorVoid.kt @@ -155,8 +155,8 @@ interface IrElementVisitorVoid : IrElementVisitor { fun visitSetField(expression: IrSetField) = visitFieldAccess(expression) override fun visitSetField(expression: IrSetField, data: Nothing?) = visitSetField(expression) - fun visitMemberAccess(expression: IrMemberAccessExpression) = visitExpression(expression) - override fun visitMemberAccess(expression: IrMemberAccessExpression, data: Nothing?) = visitMemberAccess(expression) + fun visitMemberAccess(expression: IrMemberAccessExpression<*>) = visitExpression(expression) + override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: Nothing?) = visitMemberAccess(expression) fun visitFunctionAccess(expression: IrFunctionAccessExpression) = visitMemberAccess(expression) override fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: Nothing?) = visitFunctionAccess(expression) @@ -177,8 +177,8 @@ interface IrElementVisitorVoid : IrElementVisitor { fun visitGetClass(expression: IrGetClass) = visitExpression(expression) override fun visitGetClass(expression: IrGetClass, data: Nothing?) = visitGetClass(expression) - fun visitCallableReference(expression: IrCallableReference) = visitMemberAccess(expression) - override fun visitCallableReference(expression: IrCallableReference, data: Nothing?) = visitCallableReference(expression) + fun visitCallableReference(expression: IrCallableReference<*>) = visitMemberAccess(expression) + override fun visitCallableReference(expression: IrCallableReference<*>, data: Nothing?) = visitCallableReference(expression) fun visitFunctionReference(expression: IrFunctionReference) = visitCallableReference(expression) override fun visitFunctionReference(expression: IrFunctionReference, data: Nothing?) = visitFunctionReference(expression) diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileDeserializer.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileDeserializer.kt index b16ed75ba17..bf1830971b9 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileDeserializer.kt +++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileDeserializer.kt @@ -331,7 +331,7 @@ abstract class IrFileDeserializer( return IrBlockImpl(start, end, type, origin, statements) } - private fun deserializeMemberAccessCommon(access: IrMemberAccessExpression, proto: ProtoMemberAccessCommon) { + private fun deserializeMemberAccessCommon(access: IrMemberAccessExpression<*>, proto: ProtoMemberAccessCommon) { proto.valueArgumentList.mapIndexed { i, arg -> if (arg.hasExpression()) { diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt index fe38e14d758..2afe9021467 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt +++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt @@ -472,7 +472,7 @@ open class IrFileSerializer( return proto.build() } - private fun serializeMemberAccessCommon(call: IrMemberAccessExpression): ProtoMemberAccessCommon { + private fun serializeMemberAccessCommon(call: IrMemberAccessExpression<*>): ProtoMemberAccessCommon { val proto = ProtoMemberAccessCommon.newBuilder() if (call.extensionReceiver != null) { proto.extensionReceiver = serializeExpression(call.extensionReceiver!!) diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt index 79512a16468..9a1177ec682 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt @@ -71,7 +71,7 @@ interface IrBuilderExtension { callee: IrFunctionSymbol, vararg args: IrExpression, typeHint: IrType? = null - ): IrMemberAccessExpression { + ): IrMemberAccessExpression<*> { assert(callee.isBound) { "Symbol $callee expected to be bound" } val returnType = typeHint ?: callee.run { owner.returnType } val call = irCall(callee, type = returnType) @@ -86,7 +86,7 @@ interface IrBuilderExtension { typeArguments: List, valueArguments: List, returnTypeHint: IrType? = null - ): IrMemberAccessExpression = + ): IrMemberAccessExpression<*> = irInvoke( dispatchReceiver, callee,