[kotlin compiler][update] adoption [type,value]ArgumentCount

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/EnumSpecialDescriptorsFactory.kt

@@ -88,7 +88,7 @@ internal data class ExternalLoweredEnum(
         override val entriesMap: Map<Name, Int>
 ) : LoweredEnumAccess {
     override fun getValuesField(startOffset: Int, endOffset: Int): IrExpression =
-            IrCallImpl(startOffset, endOffset, valuesGetter.returnType, valuesGetter.symbol)
+            IrCallImpl(startOffset, endOffset, valuesGetter.returnType, valuesGetter.symbol, valuesGetter.typeParameters.size, valuesGetter.valueParameters.size)
 }
 
 internal class EnumSpecialDeclarationsFactory(val context: Context) {

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ToplevelPhases.kt

@@ -368,7 +368,7 @@ internal val useInternalAbiPhase = makeKonanModuleOpPhase(
                             context.internalAbi.reference(it, irClass.module)
                         }
                     }
-                    return IrCallImpl(expression.startOffset, expression.endOffset, expression.type, accessor.symbol)
+                    return IrCallImpl(expression.startOffset, expression.endOffset, expression.type, accessor.symbol, accessor.typeParameters.size, accessor.valueParameters.size)
                 }
             }
             module.transformChildrenVoid(transformer)

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/cgen/CBridgeGen.kt

@@ -553,6 +553,7 @@ internal fun KotlinStubs.generateCFunctionPointer(
             expression.type,
             fakeFunction.symbol,
             typeArgumentsCount = 0,
+            fakeFunction.valueParameters.size,
             reflectionTarget = null
     )
 }

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/KonanSharedVariablesManager.kt

@@ -64,7 +64,8 @@ internal class KonanSharedVariablesManager(val context: KonanBackendContext) : S
 
         val sharedVariableInitialization =
                 IrCallImpl(initializer.startOffset, initializer.endOffset,
-                        context.irBuiltIns.unitType, elementProperty.setter!!.symbol)
+                        context.irBuiltIns.unitType, elementProperty.setter!!.symbol,
+                        elementProperty.setter!!.typeParameters.size, elementProperty.setter!!.valueParameters.size)
 
         sharedVariableInitialization.dispatchReceiver =
                 IrGetValueImpl(initializer.startOffset, initializer.endOffset,
@@ -80,7 +81,8 @@ internal class KonanSharedVariablesManager(val context: KonanBackendContext) : S
 
     override fun getSharedValue(sharedVariableSymbol: IrVariableSymbol, originalGet: IrGetValue) =
             IrCallImpl(originalGet.startOffset, originalGet.endOffset,
-                    originalGet.type, elementProperty.getter!!.symbol).apply {
+                    originalGet.type, elementProperty.getter!!.symbol,
+                    elementProperty.getter!!.typeParameters.size, elementProperty.getter!!.valueParameters.size).apply {
                 dispatchReceiver = IrGetValueImpl(
                         originalGet.startOffset, originalGet.endOffset,
                         sharedVariableSymbol.owner.type, sharedVariableSymbol
@@ -89,7 +91,8 @@ internal class KonanSharedVariablesManager(val context: KonanBackendContext) : S
 
     override fun setSharedValue(sharedVariableSymbol: IrVariableSymbol, originalSet: IrSetValue) =
             IrCallImpl(originalSet.startOffset, originalSet.endOffset, context.irBuiltIns.unitType,
-                    elementProperty.setter!!.symbol).apply {
+                    elementProperty.setter!!.symbol, elementProperty.setter!!.typeParameters.size,
+                    elementProperty.setter!!.valueParameters.size).apply {
                 dispatchReceiver = IrGetValueImpl(
                         originalSet.startOffset, originalSet.endOffset,
                         sharedVariableSymbol.owner.type, sharedVariableSymbol

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/NewIrUtils.kt

@@ -7,8 +7,6 @@ package org.jetbrains.kotlin.backend.konan.ir
 
 import org.jetbrains.kotlin.backend.common.atMostOne
 import org.jetbrains.kotlin.backend.konan.DECLARATION_ORIGIN_INLINE_CLASS_SPECIAL_FUNCTION
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.ir.declarations.*

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cenum/CEnumCompanionGenerator.kt

@@ -54,7 +54,9 @@ internal class CEnumCompanionGenerator(
             it.body = irBuilder(irBuiltIns, it.symbol, SYNTHETIC_OFFSET, SYNTHETIC_OFFSET).irBlockBody {
                 +IrDelegatingConstructorCallImpl(
                         startOffset, endOffset, context.irBuiltIns.unitType,
-                        superConstructorSymbol
+                        superConstructorSymbol,
+                        superConstructorSymbol.owner.typeParameters.size,
+                        superConstructorSymbol.owner.valueParameters.size
                 )
                 +irInstanceInitializer(symbolTable.referenceClass(companionObjectDescriptor))
             }

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cenum/CEnumVarClassGenerator.kt

@@ -58,7 +58,9 @@ internal class CEnumVarClassGenerator(
         )
         irConstructor.body = irBuilder(irBuiltIns, irConstructor.symbol, SYNTHETIC_OFFSET, SYNTHETIC_OFFSET).irBlockBody {
             +IrDelegatingConstructorCallImpl(
-                    startOffset, endOffset, context.irBuiltIns.unitType, enumVarConstructorSymbol
+                    startOffset, endOffset, context.irBuiltIns.unitType, enumVarConstructorSymbol,
+                    enumVarConstructorSymbol.owner.typeParameters.size,
+                    enumVarConstructorSymbol.owner.valueParameters.size
             ).also {
                 it.putValueArgument(0, irGet(irConstructor.valueParameters[0]))
             }
@@ -81,7 +83,9 @@ internal class CEnumVarClassGenerator(
             it.body = irBuilder(irBuiltIns, it.symbol, SYNTHETIC_OFFSET, SYNTHETIC_OFFSET).irBlockBody {
                 +IrDelegatingConstructorCallImpl(
                         startOffset, endOffset, context.irBuiltIns.unitType,
-                        superConstructorSymbol
+                        superConstructorSymbol,
+                        superConstructorSymbol.owner.typeParameters.size,
+                        superConstructorSymbol.owner.valueParameters.size
                 ).also {
                     it.putValueArgument(0, irInt(typeSize))
                 }

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cstruct/CStructVarClassGenerator.kt

@@ -64,7 +64,9 @@ internal class CStructVarClassGenerator(
             irConstructor.body = irBuilder(irBuiltIns, irConstructor.symbol, SYNTHETIC_OFFSET, SYNTHETIC_OFFSET).irBlockBody {
                 +IrDelegatingConstructorCallImpl(
                         startOffset, endOffset,
-                        context.irBuiltIns.unitType, enumVarConstructorSymbol
+                        context.irBuiltIns.unitType, enumVarConstructorSymbol,
+                        irConstructor.typeParameters.size,
+                        1
                 ).also {
                     it.putValueArgument(0, irGet(irConstructor.valueParameters[0]))
                 }

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cstruct/CStructVarCompanionGenerator.kt

@@ -48,7 +48,9 @@ internal class CStructVarCompanionGenerator(
             irConstructor.body = irBuilder(irBuiltIns, irConstructor.symbol, SYNTHETIC_OFFSET, SYNTHETIC_OFFSET).irBlockBody {
                 +IrDelegatingConstructorCallImpl(
                         startOffset, endOffset, context.irBuiltIns.unitType,
-                        superConstructorSymbol
+                        superConstructorSymbol,
+                        irConstructor.typeParameters.size,
+                        2
                 ).also {
                     it.putValueArgument(0, irLong(size))
                     it.putValueArgument(1, irInt(align))

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/Autoboxing.kt

@@ -97,7 +97,9 @@ private class AutoboxingTransformer(val context: Context) : AbstractValueUsageTr
                     startOffset,
                     endOffset,
                     symbols.getNativeNullPtr.owner.returnType,
-                    symbols.getNativeNullPtr
+                    symbols.getNativeNullPtr,
+                    symbols.getNativeNullPtr.owner.typeParameters.size,
+                    symbols.getNativeNullPtr.owner.valueParameters.size
             ).uncheckedCast(type)
         }
 
@@ -164,7 +166,8 @@ private class AutoboxingTransformer(val context: Context) : AbstractValueUsageTr
             val parameter = conversion.owner.explicitParameters.single()
             val argument = this.uncheckedCast(parameter.type)
 
-            IrCallImpl(startOffset, endOffset, conversion.owner.returnType, conversion).apply {
+            IrCallImpl(startOffset, endOffset, conversion.owner.returnType, conversion,
+                    conversion.owner.typeParameters.size, conversion.owner.valueParameters.size).apply {
                 addArguments(mapOf(parameter to argument))
             }.uncheckedCast(this.type) // Try not to bring new type incompatibilities.
         }
@@ -273,7 +276,9 @@ private class InlineClassTransformer(private val context: Context) : IrBuildingT
             IrBlockImpl(startOffset, endOffset, irBuiltIns.unitType).apply {
                 statements.addIfNotNull(expression.receiver)
                 statements += expression.value
-                statements += IrCallImpl(startOffset, endOffset, irBuiltIns.nothingType, symbols.throwNullPointerException)
+                statements += IrCallImpl(startOffset, endOffset, irBuiltIns.nothingType, symbols.throwNullPointerException,
+                        symbols.throwNullPointerException.owner.typeParameters.size,
+                        symbols.throwNullPointerException.owner.valueParameters.size)
                 statements += IrGetObjectValueImpl(startOffset, endOffset, irBuiltIns.unitType, irBuiltIns.unitClass)
             }
         } else {

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/BridgesBuilding.kt

@@ -119,6 +119,7 @@ internal class WorkersBridgesBuilding(val context: Context) : DeclarationContain
                         type          = job.type,
                         symbol        = bridge.symbol,
                         typeArgumentsCount = 0,
+                        valueArgumentsCount = bridge.symbol.owner.valueParameters.size,
                         reflectionTarget = null)
                 )
                 return expression
@@ -238,6 +239,8 @@ private fun Context.buildBridge(startOffset: Int, endOffset: Int,
                 endOffset,
                 targetSymbol.owner.returnType,
                 targetSymbol,
+                typeArgumentsCount = targetSymbol.owner.typeParameters.size,
+                valueArgumentsCount = targetSymbol.owner.valueParameters.size,
                 superQualifierSymbol = superQualifierSymbol /* Call non-virtually */
         ).apply {
             bridge.dispatchReceiverParameter?.let {

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/BuiltinOperatorLowering.kt

@@ -58,7 +58,9 @@ internal class BuiltinOperatorLowering(val context: Context) : FileLoweringPass,
 
             irBuiltins.noWhenBranchMatchedExceptionSymbol -> IrCallImpl(expression.startOffset, expression.endOffset,
                     context.ir.symbols.throwNoWhenBranchMatchedException.owner.returnType,
-                    context.ir.symbols.throwNoWhenBranchMatchedException)
+                    context.ir.symbols.throwNoWhenBranchMatchedException,
+                    context.ir.symbols.throwNoWhenBranchMatchedException.owner.typeParameters.size,
+                    context.ir.symbols.throwNoWhenBranchMatchedException.owner.valueParameters.size)
 
             else -> expression
         }

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/EnumClassLowering.kt

@@ -113,9 +113,12 @@ internal class EnumUsageLowering(val context: Context)
         return IrCallImpl(
                 startOffset, endOffset, enumClass.defaultType,
                 loweredEnum.itemGetterSymbol.owner.symbol,
-                typeArgumentsCount = 0
+                typeArgumentsCount = 0,
+                loweredEnum.itemGetterSymbol.owner.valueParameters.size
         ).apply {
-            dispatchReceiver = IrCallImpl(startOffset, endOffset, loweredEnum.valuesGetter.returnType, loweredEnum.valuesGetter.symbol)
+            dispatchReceiver = IrCallImpl(startOffset, endOffset, loweredEnum.valuesGetter.returnType,
+                    loweredEnum.valuesGetter.symbol, loweredEnum.valuesGetter.typeParameters.size,
+                    loweredEnum.valuesGetter.valueParameters.size)
             putValueArgument(0, IrConstImpl.int(startOffset, endOffset, context.irBuiltIns.intType, ordinal))
         }
     }

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/EnumConstructorsLowering.kt

@@ -179,7 +179,9 @@ internal class EnumConstructorsLowering(val context: Context) : ClassLoweringPas
                 val result = IrDelegatingConstructorCallImpl(
                         startOffset, endOffset,
                         context.irBuiltIns.unitType,
-                        enumConstructorCall.symbol)
+                        enumConstructorCall.symbol,
+                        enumConstructorCall.symbol.owner.typeParameters.size,
+                        enumConstructorCall.symbol.owner.valueParameters.size)
 
                 assert(result.symbol.owner.valueParameters.size == 2) {
                     "Enum(String, Int) constructor call expected:\n${result.dump()}"
@@ -214,7 +216,9 @@ internal class EnumConstructorsLowering(val context: Context) : ClassLoweringPas
                 val result = IrDelegatingConstructorCallImpl(
                         startOffset, endOffset,
                         context.irBuiltIns.unitType,
-                        loweredDelegatingConstructor.symbol)
+                        loweredDelegatingConstructor.symbol,
+                        loweredDelegatingConstructor.symbol.owner.typeParameters.size,
+                        loweredDelegatingConstructor.symbol.owner.valueParameters.size)
 
                 val firstParameter = enumClassConstructor.valueParameters[0]
                 result.putValueArgument(0,
@@ -268,7 +272,8 @@ internal class EnumConstructorsLowering(val context: Context) : ClassLoweringPas
 
         private inner class InEnumEntryClassConstructor(enumEntry: IrEnumEntry) : InEnumEntry(enumEntry) {
             override fun createConstructorCall(startOffset: Int, endOffset: Int, loweredConstructor: IrConstructorSymbol) =
-                    IrDelegatingConstructorCallImpl(startOffset, endOffset, context.irBuiltIns.unitType, loweredConstructor)
+                    IrDelegatingConstructorCallImpl(startOffset, endOffset, context.irBuiltIns.unitType, loweredConstructor,
+                    loweredConstructor.owner.typeParameters.size, loweredConstructor.owner.valueParameters.size)
         }
 
         private inner class InEnumEntryInitializer(enumEntry: IrEnumEntry) : InEnumEntry(enumEntry) {

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/InitializersLowering.kt

@@ -188,7 +188,9 @@ internal class InitializersLowering(val context: CommonBackendContext) : ClassLo
                                     val startOffset = it.startOffset
                                     val endOffset = it.endOffset
                                     listOf(IrCallImpl(startOffset, endOffset,
-                                            context.irBuiltIns.unitType, initializeMethodSymbol
+                                            context.irBuiltIns.unitType, initializeMethodSymbol,
+                                            initializeMethodSymbol.owner.typeParameters.size,
+                                            initializeMethodSymbol.owner.valueParameters.size
                                     ).apply {
                                         dispatchReceiver = IrGetValueImpl(
                                                 startOffset, endOffset,

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/InteropLowering.kt

@@ -655,7 +655,8 @@ private class InteropLoweringPart1(val context: Context) : BaseInteropIrTransfor
                         endOffset,
                         context.irBuiltIns.unitType,
                         superConstructor,
-                        0
+                        0,
+                        superConstructor.owner.valueParameters.size
                 )
 
                 +irCall(symbols.interopObjCObjectSuperInitCheck).apply {
@@ -1213,6 +1214,7 @@ private class InteropTransformer(val context: Context, override val irFile: IrFi
                             symbols.executeImpl.owner.valueParameters[3].type,
                             targetSymbol,
                             typeArgumentsCount = 0,
+                            targetSymbol.owner.valueParameters.size,
                             reflectionTarget = null)
 
                     builder.irCall(symbols.executeImpl).apply {

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/RedundantCoercionsCleaner.kt

@@ -41,7 +41,7 @@ internal class RedundantCoercionsCleaner(val context: Context) : FileLoweringPas
                                 typeOperand, expression)
                     }
             with (coercion) {
-                return IrCallImpl(startOffset, endOffset, type, symbol, typeArgumentsCount, origin).apply {
+                return IrCallImpl(startOffset, endOffset, type, symbol, typeArgumentsCount, symbol.owner.valueParameters.size, origin).apply {
                     putValueArgument(0, castedExpression)
                 }
             }

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DFGBuilder.kt

@@ -334,7 +334,9 @@ internal class ModuleDFGBuilder(val context: Context, val irModule: IrModuleFrag
                 // Producer and job of executeImpl are called externally, we need to reflect this somehow.
                 val producerInvocation = IrCallImpl(expression.startOffset, expression.endOffset,
                         executeImplProducerInvoke.returnType,
-                        executeImplProducerInvoke.symbol)
+                        executeImplProducerInvoke.symbol,
+                        executeImplProducerInvoke.symbol.owner.typeParameters.size,
+                        executeImplProducerInvoke.symbol.owner.valueParameters.size)
                 producerInvocation.dispatchReceiver = expression.getValueArgument(2)
 
                 expressions += producerInvocation to currentLoop
@@ -343,7 +345,9 @@ internal class ModuleDFGBuilder(val context: Context, val irModule: IrModuleFrag
                         ?: error("A function reference expected")
                 val jobInvocation = IrCallImpl(expression.startOffset, expression.endOffset,
                         jobFunctionReference.symbol.owner.returnType,
-                        jobFunctionReference.symbol as IrSimpleFunctionSymbol)
+                        jobFunctionReference.symbol as IrSimpleFunctionSymbol,
+                        jobFunctionReference.symbol.owner.typeParameters.size,
+                        jobFunctionReference.symbol.owner.valueParameters.size)
                 jobInvocation.putValueArgument(0, producerInvocation)
 
                 expressions += jobInvocation to currentLoop
@@ -355,7 +359,9 @@ internal class ModuleDFGBuilder(val context: Context, val irModule: IrModuleFrag
                     && expression.typeOperand.isObjCObjectType()) {
                 val objcObjGetter = IrCallImpl(expression.startOffset, expression.endOffset,
                         objCObjectRawValueGetter.owner.returnType,
-                        objCObjectRawValueGetter
+                        objCObjectRawValueGetter,
+                        objCObjectRawValueGetter.owner.typeParameters.size,
+                        objCObjectRawValueGetter.owner.valueParameters.size
                 ).apply {
                     extensionReceiver = expression.argument
                 }

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/serialization/KonanIrlinker.kt

@@ -58,7 +58,7 @@ object KonanFakeOverrideClassFilter : FakeOverrideClassFilter {
     private fun IrClass.hasInteropSuperClass() = this.superTypes
         .mapNotNull { it.classOrNull }
         .filter { it is IrPublicSymbolBase<*> }
-        .any { it.signature.isInteropSignature() }
+        .any { it.signature?.isInteropSignature() ?: false }
 
     override fun needToConstructFakeOverrides(clazz: IrClass): Boolean {
         return !clazz.hasInteropSuperClass()

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/ir/util/IrUtils2.kt

@@ -241,7 +241,7 @@ fun IrBuilderWithScope.irCall(irFunction: IrFunction, typeArguments: List<IrType
 internal fun irCall(startOffset: Int, endOffset: Int, irFunction: IrSimpleFunction, typeArguments: List<IrType>): IrCall =
         IrCallImpl(
                 startOffset, endOffset, irFunction.substitutedReturnType(typeArguments),
-                irFunction.symbol, typeArguments.size
+                irFunction.symbol, typeArguments.size, irFunction.valueParameters.size
         ).apply {
             typeArguments.forEachIndexed { index, irType ->
                 this.putTypeArgument(index, irType)