Adapt to IR change to allow setting of parameters for default stubs.

(cherry picked from commit 68034d3c816387b4000c1b298dbea5b800643fe7)

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/common/AbstractValueUsageTransformer.kt

@@ -61,6 +61,9 @@ internal abstract class AbstractValueUsageTransformer(
     private fun IrExpression.useForVariable(variable: IrVariable): IrExpression =
             this.useAsValue(variable)
 
+    private fun IrExpression.useForValue(value: IrValueDeclaration) =
+            this.useAsValue(value)
+
     private fun IrExpression.useForField(field: IrField): IrExpression =
             this.useAs(field.type)
 
@@ -144,10 +147,10 @@ internal abstract class AbstractValueUsageTransformer(
         return expression
     }
 
-    override fun visitSetVariable(expression: IrSetVariable): IrExpression {
+    override fun visitSetValue(expression: IrSetValue): IrExpression {
         expression.transformChildrenVoid(this)
 
-        expression.value = expression.value.useForVariable(expression.symbol.owner)
+        expression.value = expression.value.useForValue(expression.symbol.owner)
 
         return expression
     }

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

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.ir.declarations.IrVariable
 import org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl
 import org.jetbrains.kotlin.ir.descriptors.WrappedVariableDescriptor
 import org.jetbrains.kotlin.ir.expressions.IrGetValue
-import org.jetbrains.kotlin.ir.expressions.IrSetVariable
+import org.jetbrains.kotlin.ir.expressions.IrSetValue
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrCompositeImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrConstructorCallImpl
@@ -87,7 +87,7 @@ internal class KonanSharedVariablesManager(val context: KonanBackendContext) : S
                 )
             }
 
-    override fun setSharedValue(sharedVariableSymbol: IrVariableSymbol, originalSet: IrSetVariable) =
+    override fun setSharedValue(sharedVariableSymbol: IrVariableSymbol, originalSet: IrSetValue) =
             IrCallImpl(originalSet.startOffset, originalSet.endOffset, context.irBuiltIns.unitType,
                     elementProperty.setter!!.symbol).apply {
                 dispatchReceiver = IrGetValueImpl(

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

@@ -130,9 +130,9 @@ internal interface CodeContext {
     fun genDeclareVariable(variable: IrVariable, value: LLVMValueRef?, variableLocation: VariableDebugLocation?): Int
 
     /**
-     * @return index of variable declared before, or -1 if no such variable has been declared yet.
+     * @return index of value declared before, or -1 if no such variable has been declared yet.
      */
-    fun getDeclaredVariable(variable: IrVariable): Int
+    fun getDeclaredValue(value: IrValueDeclaration): Int
 
     /**
      * Generates the code to obtain a value available in this context.
@@ -244,7 +244,7 @@ internal class CodeGeneratorVisitor(val context: Context, val lifetimes: Map<IrE
 
         override fun genDeclareVariable(variable: IrVariable, value: LLVMValueRef?, variableLocation: VariableDebugLocation?) = unsupported(variable)
 
-        override fun getDeclaredVariable(variable: IrVariable) = -1
+        override fun getDeclaredValue(value: IrValueDeclaration) = -1
 
         override fun genGetValue(value: IrValueDeclaration) = unsupported(value)
 
@@ -576,9 +576,9 @@ internal class CodeGeneratorVisitor(val context: Context, val lifetimes: Map<IrE
             return functionGenerationContext.vars.createVariable(variable, value, variableLocation)
         }
 
-        override fun getDeclaredVariable(variable: IrVariable): Int {
+        override fun getDeclaredValue(value: IrValueDeclaration): Int {
-            val index = functionGenerationContext.vars.indexOf(variable)
+            val index = functionGenerationContext.vars.indexOf(value)
-            return if (index < 0) super.getDeclaredVariable(variable) else return index
+            return if (index < 0) super.getDeclaredValue(value) else index
         }
 
         override fun genGetValue(value: IrValueDeclaration): LLVMValueRef {
@@ -862,7 +862,7 @@ internal class CodeGeneratorVisitor(val context: Context, val lifetimes: Map<IrE
             is IrInstanceInitializerCall ->
                                         return evaluateInstanceInitializerCall(value)
             is IrGetValue            -> return evaluateGetValue               (value)
-            is IrSetVariable         -> return evaluateSetVariable            (value)
+            is IrSetValue            -> return evaluateSetValue               (value)
             is IrGetField            -> return evaluateGetField               (value)
             is IrSetField            -> return evaluateSetField               (value)
             is IrConst<*>            -> return evaluateConst                  (value)
@@ -1267,10 +1267,10 @@ internal class CodeGeneratorVisitor(val context: Context, val lifetimes: Map<IrE
 
     //-------------------------------------------------------------------------//
 
-    private fun evaluateSetVariable(value: IrSetVariable): LLVMValueRef {
+    private fun evaluateSetValue(value: IrSetValue): LLVMValueRef {
-        context.log{"evaluateSetVariable            : ${ir2string(value)}"}
+        context.log{"evaluateSetValue               : ${ir2string(value)}"}
         val result = evaluateExpression(value.value)
-        val variable = currentCodeContext.getDeclaredVariable(value.symbol.owner)
+        val variable = currentCodeContext.getDeclaredValue(value.symbol.owner)
         functionGenerationContext.vars.store(result, variable)
         assert(value.type.isUnit())
         return functionGenerationContext.theUnitInstanceRef.llvm

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

@@ -33,7 +33,7 @@ internal class VariableManager(val functionGenerationContext: FunctionGeneration
 
     inner class ParameterRecord(val address: LLVMValueRef, val refSlot: Boolean) : Record {
         override fun load() : LLVMValueRef = functionGenerationContext.loadSlot(address, false)
-        override fun store(value: LLVMValueRef) = throw Error("writing to parameter")
+        override fun store(value: LLVMValueRef) = functionGenerationContext.store(value, address)
         override fun address() : LLVMValueRef = this.address
         override fun toString() = (if (refSlot) "refslot" else "slot") + " for ${address}"
     }

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

@@ -121,7 +121,6 @@ private class AutoboxingTransformer(val context: Context) : AbstractValueUsageTr
 
             else -> this.type
         }
-
         return this.adaptIfNecessary(actualType, type)
     }
 
@@ -469,6 +468,12 @@ private class InlineClassTransformer(private val context: Context) : IrBuildingT
                         return expression
                     }
 
+                    override fun visitSetValue(expression: IrSetValue): IrExpression {
+                        expression.transformChildrenVoid()
+                        parameterMapping[expression.symbol]?.let { return irSet(it.symbol, expression.value) }
+                        return expression
+                    }
+
                     override fun visitReturn(expression: IrReturn): IrExpression {
                         expression.transformChildrenVoid()
                         if (expression.returnTargetSymbol == irConstructor.symbol) {

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

@@ -98,7 +98,8 @@ internal class WorkersBridgesBuilding(val context: Context) : DeclarationContain
                                 type = context.irBuiltIns.anyNType,
                                 varargElementType = null,
                                 isCrossinline = arg.isCrossinline,
-                                isNoinline = arg.isNoinline
+                                isNoinline = arg.isNoinline,
+                                isAssignable = arg.isAssignable
                         ).apply { it.bind(this) }
                     }
                 }

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

@@ -351,6 +351,14 @@ internal class EnumConstructorsLowering(val context: Context) : ClassLoweringPas
                             loweredParameter.symbol, expression.origin)
                 }
             }
+
+            override fun visitSetValue(expression: IrSetValue): IrExpression {
+                expression.transformChildrenVoid()
+                return loweredEnumConstructorParameters[expression.symbol.owner]?.let {
+                    IrSetValueImpl(expression.startOffset, expression.endOffset, it.type,
+                            it.symbol, expression.value, expression.origin)
+                } ?: expression
+            }
         }
     }
 }
@@ -375,4 +383,20 @@ private class ParameterMapper(superConstructor: IrConstructor,
         }
         return expression
     }
+
+    override fun visitSetValue(expression: IrSetValue): IrExpression {
+        expression.transformChildrenVoid()
+        val superParameter = expression.symbol.owner as? IrValueParameter ?: return expression
+        if (valueParameters.contains(superParameter)) {
+            val index = if (useLoweredIndex) superParameter.loweredIndex else superParameter.index
+            val parameter = constructor.valueParameters[index]
+            return IrSetValueImpl(
+                    expression.startOffset, expression.endOffset,
+                    parameter.type,
+                    parameter.symbol,
+                    expression.value,
+                    expression.origin)
+        }
+        return expression
+    }
 }

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

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor
 import org.jetbrains.kotlin.ir.descriptors.WrappedVariableDescriptor
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl
-import org.jetbrains.kotlin.ir.expressions.impl.IrSetVariableImpl
+import org.jetbrains.kotlin.ir.expressions.impl.IrSetValueImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrSuspendableExpressionImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrSuspensionPointImpl
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
@@ -123,6 +123,13 @@ internal class NativeSuspendFunctionsLowering(ctx: Context): AbstractSuspendFunc
                     return irGetField(irGet(thisReceiver), capturedValue)
                 }
 
+                override fun visitSetValue(expression: IrSetValue): IrExpression {
+                    expression.transformChildrenVoid(this)
+                    val capturedValue = argumentToPropertiesMap[expression.symbol.owner]
+                            ?: return expression
+                    return irSetField(irGet(thisReceiver), capturedValue, expression.value)
+                }
+
                 // Save/restore state at suspension points.
                 override fun visitExpression(expression: IrExpression): IrExpression {
                     expression.transformChildrenVoid(this)
@@ -202,13 +209,13 @@ internal class NativeSuspendFunctionsLowering(ctx: Context): AbstractSuspendFunc
                         origin      = expression.origin)
             }
 
-            override fun visitSetVariable(expression: IrSetVariable): IrExpression {
+            override fun visitSetValue(expression: IrSetValue): IrExpression {
                 expression.transformChildrenVoid(this)
 
                 val newVariable = variablesMap[expression.symbol.owner]
                         ?: return expression
 
-                return IrSetVariableImpl(
+                return IrSetValueImpl(
                         startOffset = expression.startOffset,
                         endOffset   = expression.endOffset,
                         type        = context.irBuiltIns.unitType,
@@ -384,7 +391,7 @@ internal class NativeSuspendFunctionsLowering(ctx: Context): AbstractSuspendFunc
                         result                     = irBlock(startOffset, endOffset) {
                             if (!calledSaveState)
                                 +irCall(saveState)
-                            +irSetVar(suspendResult.symbol, suspendCall)
+                            +irSet(suspendResult.symbol, suspendCall)
                             +irReturnIfSuspended(suspendResult)
                             +irGet(suspendResult)
                         },

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

@@ -165,7 +165,7 @@ internal class VarargInjectionLowering constructor(val context: KonanBackendCont
     }
 
     private fun IrBuilderWithScope.incrementVariable(variable: IrVariable, value: IrExpression): IrExpression {
-        return irSetVar(variable.symbol, intPlus().apply {
+        return irSet(variable.symbol, intPlus().apply {
             dispatchReceiver = irGet(variable)
             putValueArgument(0, value)
         })

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

@@ -56,16 +56,16 @@ private fun IrTypeOperator.callsInstanceOf() =
 private class VariableValues {
     data class Variable(val loop: IrLoop?, val values: MutableSet<IrExpression>)
 
-    val elementData = HashMap<IrVariable, Variable>()
+    val elementData = HashMap<IrValueDeclaration, Variable>()
 
-    fun addEmpty(variable: IrVariable, loop: IrLoop?) {
+    fun addEmpty(variable: IrValueDeclaration, loop: IrLoop?) {
         elementData[variable] = Variable(loop, mutableSetOf())
     }
 
-    fun add(variable: IrVariable, element: IrExpression) =
+    fun add(variable: IrValueDeclaration, element: IrExpression) =
             elementData[variable]?.values?.add(element)
 
-    private fun add(variable: IrVariable, elements: Set<IrExpression>) =
+    private fun add(variable: IrValueDeclaration, elements: Set<IrExpression>) =
             elementData[variable]?.values?.addAll(elements)
 
     fun computeClosure() {
@@ -75,14 +75,14 @@ private class VariableValues {
     }
 
     // Computes closure of all possible values for given variable.
-    private fun computeValueClosure(value: IrVariable): Set<IrExpression> {
+    private fun computeValueClosure(value: IrValueDeclaration): Set<IrExpression> {
         val result = mutableSetOf<IrExpression>()
-        val seen = mutableSetOf<IrVariable>()
+        val seen = mutableSetOf<IrValueDeclaration>()
         dfs(value, seen, result)
         return result
     }
 
-    private fun dfs(value: IrVariable, seen: MutableSet<IrVariable>, result: MutableSet<IrExpression>) {
+    private fun dfs(value: IrValueDeclaration, seen: MutableSet<IrValueDeclaration>, result: MutableSet<IrExpression>) {
         seen += value
         val elements = elementData[value]?.values ?: return
         for (element in elements) {
@@ -313,7 +313,7 @@ internal class ModuleDFGBuilder(val context: Context, val irModule: IrModuleFrag
             element.acceptChildrenVoid(this)
         }
 
-        private fun assignVariable(variable: IrVariable, value: IrExpression) {
+        private fun assignValue(variable: IrValueDeclaration, value: IrExpression) {
             expressionValuesExtractor.forEachValue(value) {
                 variableValues.add(variable, it)
             }
@@ -410,15 +410,15 @@ internal class ModuleDFGBuilder(val context: Context, val irModule: IrModuleFrag
             super.visitCatch(aCatch)
         }
 
-        override fun visitSetVariable(expression: IrSetVariable) {
+        override fun visitSetValue(expression: IrSetValue) {
-            super.visitSetVariable(expression)
+            super.visitSetValue(expression)
-            assignVariable(expression.symbol.owner, expression.value)
+            assignValue(expression.symbol.owner, expression.value)
         }
 
         override fun visitVariable(declaration: IrVariable) {
             variableValues.addEmpty(declaration, currentLoop)
             super.visitVariable(declaration)
-            declaration.initializer?.let { assignVariable(declaration, it) }
+            declaration.initializer?.let { assignValue(declaration, it) }
         }
     }
 
@@ -473,7 +473,7 @@ internal class ModuleDFGBuilder(val context: Context, val irModule: IrModuleFrag
                 ?: error("Function ${declaration.descriptor} has no continuation parameter")
 
         private val nodes = mutableMapOf<IrExpression, Scoped<DataFlowIR.Node>>()
-        private val variables = mutableMapOf<IrVariable, Scoped<DataFlowIR.Node.Variable>>()
+        private val variables = mutableMapOf<IrValueDeclaration, Scoped<DataFlowIR.Node.Variable>>()
         private val expressionsScopes = mutableMapOf<IrExpression, DataFlowIR.Node.Scope>()
 
         fun build(): DataFlowIR.Function {

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

@@ -259,7 +259,7 @@ fun IrBuilderWithScope.irCallOp(
         }
 
 fun IrBuilderWithScope.irSetVar(variable: IrVariable, value: IrExpression) =
-        irSetVar(variable.symbol, value)
+        irSet(variable.symbol, value)
 
 fun IrBuilderWithScope.irCatch(type: IrType) =
         IrCatchImpl(