backend: do not rely on parameter.original in autoboxing

`function.parameter.original` sometimes turns out to be
not the same as `function.original.parameter`.

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

@@ -37,6 +37,15 @@ abstract class AbstractValueUsageTransformer(val builtIns: KotlinBuiltIns): IrEl
     protected open fun IrExpression.useAsArgument(parameter: ParameterDescriptor): IrExpression =
             this.useAsValue(parameter)
 
+    protected open fun IrExpression.useAsDispatchReceiver(function: CallableDescriptor): IrExpression =
+            this.useAsArgument(function.dispatchReceiverParameter!!)
+
+    protected open fun IrExpression.useAsExtensionReceiver(function: CallableDescriptor): IrExpression =
+            this.useAsArgument(function.extensionReceiverParameter!!)
+
+    protected open fun IrExpression.useAsValueArgument(parameter: ValueParameterDescriptor): IrExpression =
+            this.useAsArgument(parameter)
+
     protected open fun IrExpression.useForVariable(variable: VariableDescriptor): IrExpression =
             this.useAsValue(variable)
 
@@ -55,12 +64,12 @@ abstract class AbstractValueUsageTransformer(val builtIns: KotlinBuiltIns): IrEl
         expression.transformChildrenVoid(this)
 
         with(expression) {
-            dispatchReceiver = dispatchReceiver?.useAsArgument(descriptor.dispatchReceiverParameter!!)
-            extensionReceiver = extensionReceiver?.useAsArgument(descriptor.extensionReceiverParameter!!)
+            dispatchReceiver = dispatchReceiver?.useAsDispatchReceiver(descriptor)
+            extensionReceiver = extensionReceiver?.useAsExtensionReceiver(descriptor)
             for (index in descriptor.valueParameters.indices) {
                 val argument = getValueArgument(index) ?: continue
                 val parameter = descriptor.valueParameters[index]
-                putValueArgument(index, argument.useAsArgument(parameter))
+                putValueArgument(index, argument.useAsValueArgument(parameter))
             }
         }
 
@@ -214,7 +223,7 @@ abstract class AbstractValueUsageTransformer(val builtIns: KotlinBuiltIns): IrEl
         declaration.descriptor.valueParameters.forEach { parameter ->
             val defaultValue = declaration.getDefault(parameter)
             if (defaultValue is IrExpressionBody) {
-                defaultValue.expression = defaultValue.expression.useAsArgument(parameter)
+                defaultValue.expression = defaultValue.expression.useAsValueArgument(parameter)
             }
         }
 

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

@@ -6,8 +6,9 @@ import org.jetbrains.kotlin.backend.konan.Context
 import org.jetbrains.kotlin.backend.konan.descriptors.getKonanInternalClass
 import org.jetbrains.kotlin.backend.konan.descriptors.getKonanInternalFunctions
 import org.jetbrains.kotlin.backend.konan.descriptors.unboundCallableReferenceTypeOrNull
-import org.jetbrains.kotlin.descriptors.ParameterDescriptor
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
@@ -128,8 +129,17 @@ private class AutoboxingTransformer(val context: Context) : AbstractValueUsageTr
         return this.adaptIfNecessary(actualType, type)
     }
 
-    override fun IrExpression.useAsArgument(parameter: ParameterDescriptor): IrExpression {
-        return this.useAsValue(parameter.original)
+    override fun IrExpression.useAsDispatchReceiver(function: CallableDescriptor): IrExpression {
+        return this.useAsArgument(function.original.dispatchReceiverParameter!!)
+    }
+
+    override fun IrExpression.useAsExtensionReceiver(function: CallableDescriptor): IrExpression {
+        return this.useAsArgument(function.original.extensionReceiverParameter!!)
+    }
+
+    override fun IrExpression.useAsValueArgument(parameter: ValueParameterDescriptor): IrExpression {
+        val function = parameter.containingDeclaration
+        return this.useAsArgument(function.original.valueParameters[parameter.index])
     }
 
     override fun IrExpression.useForField(field: PropertyDescriptor): IrExpression {