From 0331f84ccd0c8c2bc7efd32e85e6f5eda3a5735a Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Mon, 12 Nov 2018 18:25:58 +0100 Subject: [PATCH] Make parameter descriptor in CallGenerator.genValueAndPut optional The main implementation in DefaultCallGenerator did not use anything from that parameter anyway in 99% cases, except the type, which is passed separately now as JvmKotlinType. This will be useful to implement call generation for functions which do not have descriptors for their value parameters (such as signature-polymorphic) #KT-14416 In Progress --- .../codegen/CallBasedArgumentGenerator.kt | 15 ++++++++++----- .../jetbrains/kotlin/codegen/CallGenerator.kt | 19 ++++++++----------- .../kotlin/codegen/inline/InlineCodegen.kt | 18 +++++++++--------- .../inline/InlineCodegenForDefaultBody.kt | 4 ++-- 4 files changed, 29 insertions(+), 27 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/CallBasedArgumentGenerator.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/CallBasedArgumentGenerator.kt index 8c527555786..83fd3549832 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/CallBasedArgumentGenerator.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/CallBasedArgumentGenerator.kt @@ -31,10 +31,12 @@ class CallBasedArgumentGenerator( } override fun generateExpression(i: Int, argument: ExpressionValueArgument) { - val parameter = valueParameters[i] - val valueArgument = argument.valueArgument!! - val argumentExpression = valueArgument.getArgumentExpression() ?: error(valueArgument.asElement().text) - callGenerator.genValueAndPut(parameter, argumentExpression, if (isVarargInvoke) OBJECT_TYPE else valueParameterTypes[i], i) + callGenerator.genValueAndPut( + valueParameters[i], + argument.valueArgument!!.getArgumentExpression()!!, + if (isVarargInvoke) JvmKotlinType(OBJECT_TYPE) else getJvmKotlinType(i), + i + ) } override fun generateDefault(i: Int, argument: DefaultValueArgument) { @@ -64,5 +66,8 @@ class CallBasedArgumentGenerator( } private fun getJvmKotlinType(i: Int): JvmKotlinType = - JvmKotlinType(valueParameterTypes[i], valueParameters[i].original.type) + JvmKotlinType(valueParameterTypes[i], valueParameters[i].unsubstitutedType) + + private val ValueParameterDescriptor.unsubstitutedType + get() = containingDeclaration.original.valueParameters[index].type } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/CallGenerator.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/CallGenerator.kt index 58c4b8bfc87..a28166cad5d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/CallGenerator.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/CallGenerator.kt @@ -47,18 +47,18 @@ interface CallGenerator { } override fun genValueAndPut( - valueParameterDescriptor: ValueParameterDescriptor, + valueParameterDescriptor: ValueParameterDescriptor?, argumentExpression: KtExpression, - parameterType: Type, + parameterType: JvmKotlinType, parameterIndex: Int ) { - val container = valueParameterDescriptor.containingDeclaration - val isVarargInvoke = JvmCodegenUtil.isDeclarationOfBigArityFunctionInvoke(container) + val container = valueParameterDescriptor?.containingDeclaration + val isVarargInvoke = container != null && JvmCodegenUtil.isDeclarationOfBigArityFunctionInvoke(container) val v = codegen.v if (isVarargInvoke) { if (parameterIndex == 0) { - v.iconst(container.valueParameters.size) + v.iconst(container!!.valueParameters.size) v.newarray(OBJECT_TYPE) } v.dup() @@ -66,16 +66,13 @@ interface CallGenerator { } val value = codegen.gen(argumentExpression) - value.put(parameterType, valueParameterDescriptor.unsubstitutedType, v) + value.put(parameterType.type, parameterType.kotlinType, v) if (isVarargInvoke) { v.astore(OBJECT_TYPE) } } - private val ValueParameterDescriptor.unsubstitutedType - get() = containingDeclaration.original.valueParameters[index].type - override fun putCapturedValueOnStack(stackValue: StackValue, valueType: Type, paramIndex: Int) { stackValue.put(stackValue.type, stackValue.kotlinType, codegen.v) } @@ -119,9 +116,9 @@ interface CallGenerator { fun genCallInner(callableMethod: Callable, resolvedCall: ResolvedCall<*>?, callDefault: Boolean, codegen: ExpressionCodegen) fun genValueAndPut( - valueParameterDescriptor: ValueParameterDescriptor, + valueParameterDescriptor: ValueParameterDescriptor?, argumentExpression: KtExpression, - parameterType: Type, + parameterType: JvmKotlinType, parameterIndex: Int ) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt index d80cc6f78e3..cb26f0f8fa4 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt @@ -737,13 +737,18 @@ class PsiInlineCodegen( } override fun genValueAndPut( - valueParameterDescriptor: ValueParameterDescriptor, + valueParameterDescriptor: ValueParameterDescriptor?, argumentExpression: KtExpression, - parameterType: Type, + parameterType: JvmKotlinType, parameterIndex: Int ) { + requireNotNull(valueParameterDescriptor) { + "Parameter descriptor can only be null in case a @PolymorphicSignature function is called, " + + "which cannot be declared in Kotlin and thus be inline: $codegen" + } + if (isInliningParameter(argumentExpression, valueParameterDescriptor)) { - val lambdaInfo = rememberClosure(argumentExpression, parameterType, valueParameterDescriptor) + val lambdaInfo = rememberClosure(argumentExpression, parameterType.type, valueParameterDescriptor) val receiverValue = getBoundCallableReferenceReceiver(argumentExpression) if (receiverValue != null) { @@ -762,12 +767,7 @@ class PsiInlineCodegen( } } else { val value = codegen.gen(argumentExpression) - putValueIfNeeded( - JvmKotlinType(parameterType, valueParameterDescriptor.original.type), - value, - ValueKind.GENERAL, - valueParameterDescriptor.index - ) + putValueIfNeeded(parameterType, value, ValueKind.GENERAL, parameterIndex) } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenForDefaultBody.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenForDefaultBody.kt index 5146af98fb6..be30fb3930b 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenForDefaultBody.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenForDefaultBody.kt @@ -81,9 +81,9 @@ class InlineCodegenForDefaultBody( } override fun genValueAndPut( - valueParameterDescriptor: ValueParameterDescriptor, + valueParameterDescriptor: ValueParameterDescriptor?, argumentExpression: KtExpression, - parameterType: Type, + parameterType: JvmKotlinType, parameterIndex: Int ) { throw UnsupportedOperationException("Shouldn't be called")