[K/N] New parameter API: misc 2 ^KT-73361

Aleksei.Glushko · Space Team · commit a5a62a78efd6 · 2025-02-20T22:41:23.000Z
diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/CachesAbiLowering.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/CachesAbiLowering.kt
@@ -136,7 +136,7 @@ internal class ExportCachesAbiVisitor(val context: Context) : IrVisitor<Unit, Mu
             context.createIrBuilder(function.symbol).apply {
                 function.body = irBlockBody {
                     +irReturn(irGetField(
-                            irGet(function.valueParameters[0]),
+                            irGet(function.parameters[0]),
                             this@ExportCachesAbiVisitor.context.innerClassesSupport.getOuterThisField(declaration))
                     )
                 }
@@ -157,7 +157,7 @@ internal class ExportCachesAbiVisitor(val context: Context) : IrVisitor<Unit, Mu
         val function = cachesAbiSupport.getLateinitPropertyAccessor(declaration)
         context.createIrBuilder(function.symbol).apply {
             function.body = irBlockBody {
-                +irReturn(irGetField(ownerClass?.let { irGet(function.valueParameters[0]) }, backingField))
+                +irReturn(irGetField(ownerClass?.let { irGet(function.parameters[0]) }, backingField))
             }
         }
         data.add(function)
@@ -210,7 +210,7 @@ internal class ImportCachesAbiTransformer(val generationState: NativeGenerationS
                 dependenciesTracker.add(irClass)
                 createIrBuilder().run {
                     irCall(accessor).apply {
-                        putValueArgument(0, expression.receiver)
+                        arguments[0] = expression.receiver
                     }
                 }
             }
@@ -221,7 +221,7 @@ internal class ImportCachesAbiTransformer(val generationState: NativeGenerationS
                 createIrBuilder().run {
                     irCall(accessor).apply {
                         if (irClass != null)
-                            putValueArgument(0, expression.receiver)
+                            arguments[0] = expression.receiver
                     }
                 }
             }
diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/ExpectToActualDefaultValueCopier.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/ExpectToActualDefaultValueCopier.kt
@@ -57,15 +57,15 @@ internal class ExpectToActualDefaultValueCopier(private val irModule: IrModuleFr
                 val defaultValue = declaration.defaultValue ?: return
                 val function = declaration.parent as IrFunction
 
-                val index = declaration.indexInOldValueParameters
-                assert(function.valueParameters[index] == declaration)
+                val index = declaration.indexInParameters
+                assert(function.parameters[index] == declaration)
 
                 if (function is IrConstructor && OptionalAnnotationUtil.isOptionalAnnotationClass(function.descriptor.constructedClass)) {
                     return
                 }
 
                 val actualForExpected = function.findActualForExpected()
-                actualForExpected.valueParameters[index].defaultValue =
+                actualForExpected.parameters[index].defaultValue =
                         irBuiltIns.irFactory.createExpressionBody(
                                 defaultValue.startOffset, defaultValue.endOffset,
                                 defaultValue.expression.remapExpectValueSymbols().patchDeclarationParents(actualForExpected)
@@ -188,13 +188,9 @@ internal class ExpectToActualDefaultValueCopier(private val irModule: IrModuleFr
             is IrFunction ->
                 if (!parent.descriptor.isExpect)
                     null
-                else when (parameter) {
-                    parent.dispatchReceiverParameter -> parent.findActualForExpected().dispatchReceiverParameter!!
-                    parent.extensionReceiverParameter -> parent.findActualForExpected().extensionReceiverParameter!!
-                    else -> {
-                        assert(parent.valueParameters[parameter.indexInOldValueParameters] == parameter)
-                        parent.findActualForExpected().valueParameters[parameter.indexInOldValueParameters]
-                    }
+                else {
+                    assert(parent.parameters[parameter.indexInParameters] == parameter)
+                    parent.findActualForExpected().parameters[parameter.indexInParameters]
                 }
 
             else -> error(parent)
diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/NativeDefaultParameterInjector.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/NativeDefaultParameterInjector.kt
@@ -49,7 +49,7 @@ internal class NativeDefaultParameterInjector(context: KonanBackendContext) : De
 
         return with(createIrBuilder()) {
             irCallWithSubstitutedType(symbols.reinterpret, listOf(nullConstOfEquivalentType.type, type)).apply {
-                extensionReceiver = nullConstOfEquivalentType
+                arguments[0] = nullConstOfEquivalentType
             }
         }
     }
diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/NativeReflectionIrBuilder.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/NativeReflectionIrBuilder.kt
@@ -60,16 +60,16 @@ internal class NativeRuntimeReflectionIrBuilder(
             typeArguments: List<IrType>
     ): IrExpression {
         val constructor = clazz.primaryConstructor!!.symbol.owner
-        val arguments = constructor.valueParameters.also {
+        val arguments = constructor.parameters.also {
             require(it.size == elements.size) {
                 "Wrong number of values provided for ${clazz.name} construction: ${elements.size} instead of ${it.size}"
             }
         }.map {
             elements[it.name.asString()] ?: error("No value for field named ${it.name} provided")
         }
         return irCallConstructor(constructor.symbol, typeArguments).apply {
-            for ((index, i) in arguments.withIndex()) {
-                putValueArgument(index, i)
+            for ((index, arg) in arguments.withIndex()) {
+                this.arguments[index] = arg
             }
         }
     }
diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/RedundantCoercionsCleaner.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/RedundantCoercionsCleaner.kt
@@ -78,15 +78,15 @@ internal class RedundantCoercionsCleaner(val context: Context) : FileLoweringPas
                 IrCallImpl(
                         startOffset, endOffset, type, symbol, typeArguments.size, origin
                 ).apply {
-                    putValueArgument(0, result)
+                    arguments[0] = result
                 }
             }
         }
     }
 
     private fun IrFunction.getCoercedClass(): IrClass {
         if (name.asString().endsWith("-box>"))
-            return valueParameters[0].type.classifierOrFail.owner as IrClass
+            return parameters[0].type.classifierOrFail.owner as IrClass
         if (name.asString().endsWith("-unbox>"))
             return returnType.classifierOrFail.owner as IrClass
         error("Unexpected coercion: ${this.render()}")
@@ -109,7 +109,7 @@ internal class RedundantCoercionsCleaner(val context: Context) : FileLoweringPas
             if (!expression.isBoxOrUnboxCall())
                 return super.visitCall(expression, null)
 
-            val argument = expression.getValueArgument(0)!!
+            val argument = expression.arguments[0]!!
             return if (expression.symbol.owner.getCoercedClass() == data?.coercion?.symbol?.owner?.getCoercedClass()) {
                 data.folded = true
                 argument.transform(this, null)
@@ -119,7 +119,7 @@ internal class RedundantCoercionsCleaner(val context: Context) : FileLoweringPas
                 if (state.folded)
                     result
                 else
-                    expression.also { it.putValueArgument(0, result) }
+                    expression.also { it.arguments[0] = result }
             }
         }
 
diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/StaticCallableReferenceOptimization.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/StaticCallableReferenceOptimization.kt
@@ -62,7 +62,7 @@ internal class StaticCallableReferenceOptimization(val context: Context) : FileL
                 val constructor = expression.symbol.owner
                 val constructedClass = constructor.constructedClass
 
-                return if ((isLoweredFunctionReference(constructedClass) && constructor.valueParameters.isEmpty()) || expression.symbol in allPropertyReferenceSymbols) {
+                return if ((isLoweredFunctionReference(constructedClass) && constructor.parameters.isEmpty()) || expression.symbol in allPropertyReferenceSymbols) {
                     context.createIrBuilder(
                             currentScope!!.scope.scopeOwnerSymbol,
                             expression.startOffset,

Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ internal class ExportCachesAbiVisitor(val context: Context) : IrVisitor<Unit, Mu`
`136`	`136`	`context.createIrBuilder(function.symbol).apply {`
`137`	`137`	`function.body = irBlockBody {`
`138`	`138`	`+irReturn(irGetField(`
`139`		`- irGet(function.valueParameters[0]),`
	`139`	`+ irGet(function.parameters[0]),`
`140`	`140`	`this@ExportCachesAbiVisitor.context.innerClassesSupport.getOuterThisField(declaration))`
`141`	`141`	`)`
`142`	`142`	`}`
`@@ -157,7 +157,7 @@ internal class ExportCachesAbiVisitor(val context: Context) : IrVisitor<Unit, Mu`
`157`	`157`	`val function = cachesAbiSupport.getLateinitPropertyAccessor(declaration)`
`158`	`158`	`context.createIrBuilder(function.symbol).apply {`
`159`	`159`	`function.body = irBlockBody {`
`160`		`- +irReturn(irGetField(ownerClass?.let { irGet(function.valueParameters[0]) }, backingField))`
	`160`	`+ +irReturn(irGetField(ownerClass?.let { irGet(function.parameters[0]) }, backingField))`
`161`	`161`	`}`
`162`	`162`	`}`
`163`	`163`	`data.add(function)`
`@@ -210,7 +210,7 @@ internal class ImportCachesAbiTransformer(val generationState: NativeGenerationS`
`210`	`210`	`dependenciesTracker.add(irClass)`
`211`	`211`	`createIrBuilder().run {`
`212`	`212`	`irCall(accessor).apply {`
`213`		`- putValueArgument(0, expression.receiver)`
	`213`	`+ arguments[0] = expression.receiver`
`214`	`214`	`}`
`215`	`215`	`}`
`216`	`216`	`}`
`@@ -221,7 +221,7 @@ internal class ImportCachesAbiTransformer(val generationState: NativeGenerationS`
`221`	`221`	`createIrBuilder().run {`
`222`	`222`	`irCall(accessor).apply {`
`223`	`223`	`if (irClass != null)`
`224`		`- putValueArgument(0, expression.receiver)`
	`224`	`+ arguments[0] = expression.receiver`
`225`	`225`	`}`
`226`	`226`	`}`
`227`	`227`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ internal class NativeDefaultParameterInjector(context: KonanBackendContext) : De`
`49`	`49`
`50`	`50`	`return with(createIrBuilder()) {`
`51`	`51`	`irCallWithSubstitutedType(symbols.reinterpret, listOf(nullConstOfEquivalentType.type, type)).apply {`
`52`		`- extensionReceiver = nullConstOfEquivalentType`
	`52`	`+ arguments[0] = nullConstOfEquivalentType`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,16 +60,16 @@ internal class NativeRuntimeReflectionIrBuilder(`
`60`	`60`	`typeArguments: List<IrType>`
`61`	`61`	`): IrExpression {`
`62`	`62`	`val constructor = clazz.primaryConstructor!!.symbol.owner`
`63`		`- val arguments = constructor.valueParameters.also {`
	`63`	`+ val arguments = constructor.parameters.also {`
`64`	`64`	`require(it.size == elements.size) {`
`65`	`65`	`"Wrong number of values provided for ${clazz.name} construction: ${elements.size} instead of ${it.size}"`
`66`	`66`	`}`
`67`	`67`	`}.map {`
`68`	`68`	`elements[it.name.asString()] ?: error("No value for field named ${it.name} provided")`
`69`	`69`	`}`
`70`	`70`	`return irCallConstructor(constructor.symbol, typeArguments).apply {`
`71`		`- for ((index, i) in arguments.withIndex()) {`
`72`		`- putValueArgument(index, i)`
	`71`	`+ for ((index, arg) in arguments.withIndex()) {`
	`72`	`+ this.arguments[index] = arg`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -78,15 +78,15 @@ internal class RedundantCoercionsCleaner(val context: Context) : FileLoweringPas`
`78`	`78`	`IrCallImpl(`
`79`	`79`	`startOffset, endOffset, type, symbol, typeArguments.size, origin`
`80`	`80`	`).apply {`
`81`		`- putValueArgument(0, result)`
	`81`	`+ arguments[0] = result`
`82`	`82`	`}`
`83`	`83`	`}`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`private fun IrFunction.getCoercedClass(): IrClass {`
`88`	`88`	`if (name.asString().endsWith("-box>"))`
`89`		`- return valueParameters[0].type.classifierOrFail.owner as IrClass`
	`89`	`+ return parameters[0].type.classifierOrFail.owner as IrClass`
`90`	`90`	`if (name.asString().endsWith("-unbox>"))`
`91`	`91`	`return returnType.classifierOrFail.owner as IrClass`
`92`	`92`	`error("Unexpected coercion: ${this.render()}")`
`@@ -109,7 +109,7 @@ internal class RedundantCoercionsCleaner(val context: Context) : FileLoweringPas`
`109`	`109`	`if (!expression.isBoxOrUnboxCall())`
`110`	`110`	`return super.visitCall(expression, null)`
`111`	`111`
`112`		`- val argument = expression.getValueArgument(0)!!`
	`112`	`+ val argument = expression.arguments[0]!!`
`113`	`113`	`return if (expression.symbol.owner.getCoercedClass() == data?.coercion?.symbol?.owner?.getCoercedClass()) {`
`114`	`114`	`data.folded = true`
`115`	`115`	`argument.transform(this, null)`
`@@ -119,7 +119,7 @@ internal class RedundantCoercionsCleaner(val context: Context) : FileLoweringPas`
`119`	`119`	`if (state.folded)`
`120`	`120`	`result`
`121`	`121`	`else`
`122`		`- expression.also { it.putValueArgument(0, result) }`
	`122`	`+ expression.also { it.arguments[0] = result }`
`123`	`123`	`}`
`124`	`124`	`}`
`125`	`125`