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

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]
+        callGenerator.genValueAndPut(
-        val valueArgument = argument.valueArgument!!
+            valueParameters[i],
-        val argumentExpression = valueArgument.getArgumentExpression() ?: error(valueArgument.asElement().text)
+            argument.valueArgument!!.getArgumentExpression()!!,
-        callGenerator.genValueAndPut(parameter, argumentExpression, if (isVarargInvoke) OBJECT_TYPE else valueParameterTypes[i], i)
+            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
 }

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 container = valueParameterDescriptor?.containingDeclaration
-            val isVarargInvoke = JvmCodegenUtil.isDeclarationOfBigArityFunctionInvoke(container)
+            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
     )
 

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(
+            putValueIfNeeded(parameterType, value, ValueKind.GENERAL, parameterIndex)
-                JvmKotlinType(parameterType, valueParameterDescriptor.original.type),
-                value,
-                ValueKind.GENERAL,
-                valueParameterDescriptor.index
-            )
         }
     }
 

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")