PSI2IR: suspend conversion on arbitrary arguments

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ArgumentsGenerationUtils.kt

@@ -23,11 +23,22 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptor
 import org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptor
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
+import org.jetbrains.kotlin.ir.builders.*
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
+import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
+import org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl
+import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor
+import org.jetbrains.kotlin.ir.descriptors.WrappedValueParameterDescriptor
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
+import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
 import org.jetbrains.kotlin.ir.types.IrType
+import org.jetbrains.kotlin.ir.util.isImmutable
+import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.ValueArgument
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.startOffsetSkippingComments
 import org.jetbrains.kotlin.psi2ir.intermediate.*
@@ -45,6 +56,8 @@ import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.TypeProjectionImpl
 import org.jetbrains.kotlin.types.TypeSubstitutor
 import org.jetbrains.kotlin.types.Variance
+import org.jetbrains.kotlin.types.typeUtil.isUnit
+import org.jetbrains.kotlin.util.OperatorNameConventions
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import kotlin.math.max
 import kotlin.math.min
@@ -235,9 +248,10 @@ private fun StatementGenerator.generateReceiverForCalleeImportedFromObject(
     }
 }
 
-fun StatementGenerator.generateVarargExpressionUsing(
+private fun StatementGenerator.generateVarargExpressionUsing(
     varargArgument: VarargValueArgument,
     valueParameter: ValueParameterDescriptor,
+    resolvedCall: ResolvedCall<*>, // TODO resolvedCall is required for suspend conversions, see KT-38604
     generateArgumentExpression: (KtExpression) -> IrExpression?
 ): IrExpression? {
     if (varargArgument.arguments.isEmpty()) {
@@ -282,12 +296,14 @@ fun StatementGenerator.generateVarargExpressionUsing(
 
 fun StatementGenerator.generateValueArgument(
     valueArgument: ResolvedValueArgument,
-    valueParameter: ValueParameterDescriptor
-) = generateValueArgumentUsing(valueArgument, valueParameter) { generateExpression(it) }
+    valueParameter: ValueParameterDescriptor,
+    resolvedCall: ResolvedCall<*>
+) = generateValueArgumentUsing(valueArgument, valueParameter, resolvedCall) { generateExpression(it) }
 
-fun StatementGenerator.generateValueArgumentUsing(
+private fun StatementGenerator.generateValueArgumentUsing(
     valueArgument: ResolvedValueArgument,
     valueParameter: ValueParameterDescriptor,
+    resolvedCall: ResolvedCall<*>,
     generateArgumentExpression: (KtExpression) -> IrExpression?
 ): IrExpression? =
     when (valueArgument) {
@@ -298,14 +314,157 @@ fun StatementGenerator.generateValueArgumentUsing(
                 ?: throw AssertionError("No value argument: $valueArgument")
             val argumentExpression = valueArgument1.getArgumentExpression()
                 ?: throw AssertionError("No argument expression: $valueArgument1")
-            generateArgumentExpression(argumentExpression)
+            generateArgumentExpression(argumentExpression)?.let { expression ->
+                applySuspendConversionForValueArgumentIfRequired(expression, valueArgument1, valueParameter, resolvedCall)
+            }
         }
         is VarargValueArgument ->
-            generateVarargExpressionUsing(valueArgument, valueParameter, generateArgumentExpression)
+            generateVarargExpressionUsing(valueArgument, valueParameter, resolvedCall, generateArgumentExpression)
         else ->
             TODO("Unexpected valueArgument: ${valueArgument::class.java.simpleName}")
     }
 
+private fun StatementGenerator.applySuspendConversionForValueArgumentIfRequired(
+    expression: IrExpression,
+    valueArgument: ValueArgument,
+    valueParameter: ValueParameterDescriptor,
+    resolvedCall: ResolvedCall<*>
+): IrExpression {
+    if (!context.languageVersionSettings.supportsFeature(LanguageFeature.SuspendConversion))
+        return expression
+
+    if (expression is IrBlock && expression.origin == IrStatementOrigin.ADAPTED_FUNCTION_REFERENCE)
+        return expression
+
+    val newResolvedCall = resolvedCall as? NewResolvedCallImpl<*>
+        ?: return expression
+
+    val suspendConversionType = newResolvedCall.getExpectedTypeForSuspendConvertedArgument(valueArgument)
+        ?: return expression
+
+    val valueParameterType = if (valueParameter.isVararg) valueParameter.varargElementType!! else valueParameter.type
+
+    return wrapInSuspendConversion(expression, suspendConversionType, valueParameterType)
+}
+
+private fun StatementGenerator.wrapInSuspendConversion(
+    expression: IrExpression,
+    funType: KotlinType,
+    suspendFunType: KotlinType
+): IrExpression {
+    val irFunType = funType.toIrType()
+    val irSuspendFunType = suspendFunType.toIrType()
+
+    return irBlock(
+        expression.startOffset, expression.endOffset,
+        IrStatementOrigin.SUSPEND_CONVERSION,
+        irSuspendFunType
+    ) {
+        val irArgumentValue =
+            if (expression is IrGetValue && expression.symbol.owner.isImmutable)
+                expression.symbol.owner
+            else
+                irTemporary(expression, typeHint = funType, irType = irFunType)
+        +IrFunctionExpressionImpl(
+            startOffset, endOffset, irSuspendFunType,
+            createFunctionForSuspendConversion(startOffset, endOffset, irArgumentValue.symbol, funType, suspendFunType),
+            IrStatementOrigin.SUSPEND_CONVERSION
+        )
+    }
+}
+
+private fun StatementGenerator.createFunctionForSuspendConversion(
+    startOffset: Int,
+    endOffset: Int,
+    irCapturedValueSymbol: IrValueSymbol,
+    funType: KotlinType,
+    suspendFunType: KotlinType
+): IrSimpleFunction {
+    val irFunReturnType = funType.arguments.last().type.toIrType()
+    val suspendFunReturnType = suspendFunType.arguments.last().type
+    val irSuspendFunReturnType = suspendFunReturnType.toIrType()
+
+    val adapterFunctionDescriptor = WrappedSimpleFunctionDescriptor()
+
+    val irAdapterFun = context.symbolTable.declareSimpleFunction(
+        startOffset, endOffset,
+        IrDeclarationOrigin.ADAPTER_FOR_SUSPEND_CONVERSION,
+        adapterFunctionDescriptor
+    ) { irAdapterSymbol ->
+        IrFunctionImpl(
+            startOffset, endOffset,
+            IrDeclarationOrigin.ADAPTER_FOR_SUSPEND_CONVERSION,
+            irAdapterSymbol,
+            Name.identifier(scope.inventNameForTemporary("suspendConversion")),
+            Visibilities.LOCAL, Modality.FINAL,
+            irSuspendFunReturnType,
+            isInline = false, isExternal = false, isTailrec = false,
+            isSuspend = true,
+            isOperator = false, isExpect = false, isFakeOverride = false
+        )
+    }
+    adapterFunctionDescriptor.bind(irAdapterFun)
+
+    context.symbolTable.enterScope(adapterFunctionDescriptor)
+
+    irAdapterFun.valueParameters = suspendFunType.arguments
+        .take(suspendFunType.arguments.size - 1)
+        .mapIndexed { index, typeProjection ->
+            val adaptedParameterDescriptor = WrappedValueParameterDescriptor()
+            val irParameterType = typeProjection.type.toIrType()
+            context.symbolTable.declareValueParameter(
+                startOffset, endOffset, IrDeclarationOrigin.ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION,
+                adaptedParameterDescriptor,
+                irParameterType,
+            ) { irValueParameterSymbol ->
+                IrValueParameterImpl(
+                    startOffset, endOffset, IrDeclarationOrigin.ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION,
+                    irValueParameterSymbol,
+                    Name.identifier("p$index"),
+                    index,
+                    irParameterType,
+                    varargElementType = null, isCrossinline = false, isNoinline = false
+                )
+            }.also {
+                adaptedParameterDescriptor.bind(it)
+            }
+        }
+
+    val valueArgumentsCount = irAdapterFun.valueParameters.size
+    val invokeDescriptor = funType.memberScope
+        .getContributedFunctions(OperatorNameConventions.INVOKE, NoLookupLocation.FROM_BACKEND)
+        .find { it.valueParameters.size == valueArgumentsCount }
+        ?: error("No matching operator fun 'invoke' for suspend conversion: funType=$funType, suspendFunType=$suspendFunType")
+    val invokeSymbol = context.symbolTable.referenceSimpleFunction(invokeDescriptor.original)
+
+    irAdapterFun.body = irBlockBody(startOffset, endOffset) {
+        val irAdapteeCall = IrCallImpl(
+            startOffset, endOffset, irFunReturnType,
+            invokeSymbol,
+            typeArgumentsCount = 0,
+            valueArgumentsCount = valueArgumentsCount
+        )
+
+        irAdapteeCall.dispatchReceiver = irGet(irCapturedValueSymbol.owner)
+
+        this@createFunctionForSuspendConversion.context
+            .callToSubstitutedDescriptorMap[irAdapteeCall] = invokeDescriptor
+
+        for (irAdapterParameter in irAdapterFun.valueParameters) {
+            irAdapteeCall.putValueArgument(irAdapterParameter.index, irGet(irAdapterParameter))
+        }
+        if (suspendFunReturnType.isUnit()) {
+            +irAdapteeCall
+        } else {
+            +irReturn(irAdapteeCall)
+        }
+    }
+
+    context.symbolTable.leaveScope(adapterFunctionDescriptor)
+
+    return irAdapterFun
+}
+
 fun StatementGenerator.castArgumentToFunctionalInterfaceForSamType(irExpression: IrExpression, samType: KotlinType): IrExpression {
     val kotlinFunctionType = samType.getSubstitutedFunctionTypeForSamType()
     val irFunctionType = context.typeTranslator.translateType(kotlinFunctionType)
@@ -392,7 +551,7 @@ fun StatementGenerator.pregenerateExtensionInvokeCall(resolvedCall: ResolvedCall
     call.irValueArgumentsByIndex[0] = null
     resolvedCall.valueArgumentsByIndex!!.forEachIndexed { index, valueArgument ->
         val valueParameter = call.descriptor.valueParameters[index]
-        call.irValueArgumentsByIndex[index + 1] = generateValueArgument(valueArgument, valueParameter)
+        call.irValueArgumentsByIndex[index + 1] = generateValueArgument(valueArgument, valueParameter, resolvedCall)
     }
 
     return call
@@ -530,12 +689,13 @@ fun StatementGenerator.pregenerateValueArgumentsUsing(
 ) {
     resolvedCall.valueArgumentsByIndex!!.forEachIndexed { index, valueArgument ->
         val valueParameter = call.descriptor.valueParameters[index]
-        call.irValueArgumentsByIndex[index] = generateValueArgumentUsing(valueArgument, valueParameter, generateArgumentExpression)
+        call.irValueArgumentsByIndex[index] =
+            generateValueArgumentUsing(valueArgument, valueParameter, resolvedCall, generateArgumentExpression)
     }
 }
 
 fun StatementGenerator.pregenerateCallReceivers(resolvedCall: ResolvedCall<*>): CallBuilder {
-    val call = unwrapCallableDescriptorAndTypeArguments(resolvedCall, context.extensions.samConversion)
+    val call = unwrapCallableDescriptorAndTypeArguments(resolvedCall)
 
     call.callReceiver = generateCallReceiver(
         resolvedCall.call.callElement,
@@ -560,7 +720,7 @@ private fun unwrapSpecialDescriptor(descriptor: CallableDescriptor): CallableDes
             descriptor.getOriginalForFunctionInterfaceAdapter()?.let { unwrapSpecialDescriptor(it) } ?: descriptor
     }
 
-fun unwrapCallableDescriptorAndTypeArguments(resolvedCall: ResolvedCall<*>, samConversion: GeneratorExtensions.SamConversion): CallBuilder {
+fun unwrapCallableDescriptorAndTypeArguments(resolvedCall: ResolvedCall<*>): CallBuilder {
     val originalDescriptor = resolvedCall.resultingDescriptor
     val candidateDescriptor = resolvedCall.candidateDescriptor
 

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ReflectionReferencesGenerator.kt

@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
 import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
 import org.jetbrains.kotlin.ir.symbols.IrVariableSymbol
+import org.jetbrains.kotlin.ir.util.isImmutable
 import org.jetbrains.kotlin.ir.util.referenceClassifier
 import org.jetbrains.kotlin.ir.util.referenceFunction
 import org.jetbrains.kotlin.ir.util.withScope
@@ -75,7 +76,7 @@ class ReflectionReferencesGenerator(statementGenerator: StatementGenerator) : St
         val resolvedCall = getResolvedCall(ktCallableReference.callableReference)!!
         val resolvedDescriptor = resolvedCall.resultingDescriptor
 
-        val callBuilder = unwrapCallableDescriptorAndTypeArguments(resolvedCall, context.extensions.samConversion)
+        val callBuilder = unwrapCallableDescriptorAndTypeArguments(resolvedCall)
 
         val callableReferenceType = getTypeInferredByFrontendOrFail(ktCallableReference)
         if (resolvedCall.valueArguments.isNotEmpty() ||
@@ -237,10 +238,7 @@ class ReflectionReferencesGenerator(statementGenerator: StatementGenerator) : St
         this is IrGetObjectValue ||
                 this is IrGetEnumValue ||
                 this is IrConst<*> ||
-                this is IrGetValue && symbol.isBound && symbol.owner.isImmutable()
-
-    private fun IrValueDeclaration.isImmutable() =
-        this is IrValueParameter || this is IrVariable && !this.isVar
+                this is IrGetValue && symbol.isBound && symbol.owner.isImmutable
 
     private fun putAdaptedValueArguments(
         startOffset: Int,

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/Scope.kt

@@ -53,6 +53,11 @@ class Scope(val scopeOwnerSymbol: IrSymbol) {
     private var lastTemporaryIndex: Int = 0
     private fun nextTemporaryIndex(): Int = lastTemporaryIndex++
 
+    fun inventNameForTemporary(prefix: String = "tmp", nameHint: String? = null): String {
+        val index = nextTemporaryIndex()
+        return if (nameHint != null) "$prefix${index}_$nameHint" else "$prefix$index"
+    }
+
     private fun createDescriptorForTemporaryVariable(
         type: KotlinType,
         nameHint: String? = null,
@@ -60,10 +65,8 @@ class Scope(val scopeOwnerSymbol: IrSymbol) {
     ): IrTemporaryVariableDescriptor =
         IrTemporaryVariableDescriptorImpl(scopeOwner, Name.identifier(getNameForTemporary(nameHint)), type, isMutable)
 
-    private fun getNameForTemporary(nameHint: String?): String {
-        val index = nextTemporaryIndex()
-        return if (nameHint != null) "tmp${index}_$nameHint" else "tmp$index"
-    }
+    private fun getNameForTemporary(nameHint: String?): String =
+        inventNameForTemporary("tmp", nameHint)
 
     fun createTemporaryVariableDeclaration(
         irType: IrType,

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt

@@ -57,6 +57,8 @@ interface IrDeclarationOrigin {
 
     object ADAPTER_FOR_CALLABLE_REFERENCE : IrDeclarationOriginImpl("ADAPTER_FOR_CALLABLE_REFERENCE")
     object ADAPTER_PARAMETER_FOR_CALLABLE_REFERENCE : IrDeclarationOriginImpl("ADAPTER_PARAMETER_FOR_CALLABLE_REFERENCE")
+    object ADAPTER_FOR_SUSPEND_CONVERSION : IrDeclarationOriginImpl("ADAPTER_FOR_SUSPEND_CONVERSION")
+    object ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION : IrDeclarationOriginImpl("ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION")
 
     object GENERATED_SAM_IMPLEMENTATION : IrDeclarationOriginImpl("GENERATED_SAM_IMPLEMENTATION", isSynthetic = true)
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrStatementOrigin.kt

@@ -90,6 +90,7 @@ interface IrStatementOrigin {
     object ANONYMOUS_FUNCTION : IrStatementOriginImpl("ANONYMOUS_FUNCTION")
     object OBJECT_LITERAL : IrStatementOriginImpl("OBJECT_LITERAL")
     object ADAPTED_FUNCTION_REFERENCE : IrStatementOriginImpl("ADAPTED_FUNCTION_REFERENCE")
+    object SUSPEND_CONVERSION: IrStatementOriginImpl("SUSPEND_CONVERSION")
 
     object INITIALIZE_PROPERTY_FROM_PARAMETER : IrStatementOriginImpl("INITIALIZE_PROPERTY_FROM_PARAMETER")
     object INITIALIZE_FIELD : IrStatementOriginImpl("INITIALIZE_FIELD")

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/ExternalDependenciesGenerator.kt

@@ -31,7 +31,9 @@ class ExternalDependenciesGenerator(
 ) {
     fun generateUnboundSymbolsAsDependencies() {
         if (languageVersionSettings.supportsFeature(LanguageFeature.NewInference)) {
-            require(symbolTable.unboundTypeParameters.isEmpty()) { "Unbound type parameters are forbidden" }
+            require(symbolTable.unboundTypeParameters.isEmpty()) {
+                "Unbound type parameters are forbidden: ${symbolTable.unboundTypeParameters.map { it.descriptor }}"
+            }
         }
         // There should be at most one DeclarationStubGenerator (none in closed world?)
         irProviders.singleOrNull { it is DeclarationStubGenerator }?.let {

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt

@@ -680,3 +680,6 @@ fun SymbolTable.findOrDeclareExternalPackageFragment(descriptor: PackageFragment
 
 val IrDeclaration.isFileClass: Boolean
     get() = origin == IrDeclarationOrigin.FILE_CLASS || origin == IrDeclarationOrigin.SYNTHETIC_FILE_CLASS
+
+val IrValueDeclaration.isImmutable: Boolean
+    get() = this is IrValueParameter || this is IrVariable && !isVar