Update compiler to IR with symbols, part 1

The produced symbols are currently unbound and thus useless.
2017-05-03 14:14:43 +03:00
parent c3074db2d0
commit 0b1e7c9526
26 changed files with 296 additions and 146 deletions
@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.declarations.IrField
 import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.declarations.IrVariable
+import org.jetbrains.kotlin.ir.declarations.getDefault
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
 import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
@@ -28,7 +28,6 @@ import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
 import org.jetbrains.kotlin.ir.descriptors.IrTemporaryVariableDescriptorImpl
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
-import org.jetbrains.kotlin.ir.expressions.impl.IrCallableReferenceImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrReturnImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrTypeOperatorCallImpl
 import org.jetbrains.kotlin.ir.util.DeepCopyIrTree
@@ -383,19 +382,18 @@ internal class DeepCopyIrTreeWithDescriptors(val targetDescriptor: DeclarationDe
        override fun mapLocalPropertyDeclaration    (descriptor: VariableDescriptorWithAccessors) = descriptorSubstituteMap.getOrDefault(descriptor, descriptor) as VariableDescriptorWithAccessors
        override fun mapEnumEntryDeclaration        (descriptor: ClassDescriptor)                 = descriptorSubstituteMap.getOrDefault(descriptor, descriptor) as ClassDescriptor
        override fun mapVariableDeclaration         (descriptor: VariableDescriptor)              = descriptorSubstituteMap.getOrDefault(descriptor, descriptor) as VariableDescriptor
-        override fun mapCatchParameterDeclaration   (descriptor: VariableDescriptor)              = descriptorSubstituteMap.getOrDefault(descriptor, descriptor) as VariableDescriptor
        override fun mapErrorDeclaration            (descriptor: DeclarationDescriptor)           = descriptorSubstituteMap.getOrDefault(descriptor, descriptor)

        override fun mapClassReference              (descriptor: ClassDescriptor)                 = descriptorSubstituteMap.getOrDefault(descriptor, descriptor) as ClassDescriptor
        override fun mapValueReference              (descriptor: ValueDescriptor)                 = descriptorSubstituteMap.getOrDefault(descriptor, descriptor) as ValueDescriptor
        override fun mapVariableReference           (descriptor: VariableDescriptor)              = descriptorSubstituteMap.getOrDefault(descriptor, descriptor) as VariableDescriptor
        override fun mapPropertyReference           (descriptor: PropertyDescriptor)              = descriptorSubstituteMap.getOrDefault(descriptor, descriptor) as PropertyDescriptor
-        override fun mapCallee                      (descriptor: CallableDescriptor)              = descriptorSubstituteMap.getOrDefault(descriptor, descriptor) as CallableDescriptor
+        override fun mapCallee                      (descriptor: FunctionDescriptor)              = descriptorSubstituteMap.getOrDefault(descriptor, descriptor) as FunctionDescriptor
        override fun mapDelegatedConstructorCallee  (descriptor: ClassConstructorDescriptor)      = descriptorSubstituteMap.getOrDefault(descriptor, descriptor) as ClassConstructorDescriptor
        override fun mapEnumConstructorCallee       (descriptor: ClassConstructorDescriptor)      = descriptorSubstituteMap.getOrDefault(descriptor, descriptor) as ClassConstructorDescriptor
-        override fun mapCallableReference           (descriptor: CallableDescriptor)              = descriptorSubstituteMap.getOrDefault(descriptor, descriptor) as CallableDescriptor
+        override fun mapLocalPropertyReference      (descriptor: VariableDescriptorWithAccessors) = descriptorSubstituteMap.getOrDefault(descriptor, descriptor) as VariableDescriptorWithAccessors
        override fun mapClassifierReference         (descriptor: ClassifierDescriptor)            = descriptorSubstituteMap.getOrDefault(descriptor, descriptor) as ClassifierDescriptor
-        override fun mapReturnTarget                (descriptor: CallableDescriptor)              = descriptorSubstituteMap.getOrDefault(descriptor, descriptor) as CallableDescriptor
+        override fun mapReturnTarget                (descriptor: FunctionDescriptor)              = descriptorSubstituteMap.getOrDefault(descriptor, descriptor) as FunctionDescriptor

        //---------------------------------------------------------------------//

@@ -413,10 +411,10 @@ internal class DeepCopyIrTreeWithDescriptors(val targetDescriptor: DeclarationDe
                startOffset    = expression.startOffset,
                endOffset      = expression.endOffset,
                type           = newDescriptor.returnType!!,
-                descriptor     = newDescriptor,
-                typeArguments  = substituteTypeArguments(expression.getTypeArgumentsMap()),
+                calleeDescriptor = newDescriptor,
+                typeArguments  = substituteTypeArguments(expression.transformTypeArguments(newDescriptor)),
                origin         = expression.origin,
-                superQualifier = mapSuperQualifier(expression.superQualifier)
+                superQualifierDescriptor = mapSuperQualifier(expression.superQualifier)
            ).transformValueArguments(expression)
        }

@@ -429,7 +427,7 @@ internal class DeepCopyIrTreeWithDescriptors(val targetDescriptor: DeclarationDe
                origin      = mapDeclarationOrigin(declaration.origin),
                descriptor  = mapFunctionDeclaration(declaration.descriptor),
                body        = declaration.body?.transform(this, null)
-            ).transformDefaults(declaration)
+            ).transformParameters(declaration)

        //---------------------------------------------------------------------//

@@ -445,20 +443,6 @@ internal class DeepCopyIrTreeWithDescriptors(val targetDescriptor: DeclarationDe

        //---------------------------------------------------------------------//

-        override fun visitCallableReference(expression: IrCallableReference): IrCallableReference {
-            val newDescriptor = mapCallableReference(expression.descriptor)
-            return IrCallableReferenceImpl(
-                startOffset   = expression.startOffset,
-                endOffset     = expression.endOffset,
-                type          = expression.type,
-                descriptor    = newDescriptor,
-                typeArguments = expression.getTypeArgumentsMap(),
-                origin        = mapStatementOrigin(expression.origin)
-            ).transformValueArguments(expression)
-        }
-
-        //---------------------------------------------------------------------//
-
        fun getTypeOperatorReturnType(operator: IrTypeOperator, type: KotlinType) : KotlinType {
            return when (operator) {
                IrTypeOperator.CAST,
@@ -494,7 +478,7 @@ internal class DeepCopyIrTreeWithDescriptors(val targetDescriptor: DeclarationDe
                startOffset  = expression.startOffset,
                endOffset    = expression.endOffset,
                type         = substituteType(expression.type)!!,
-                returnTarget = mapReturnTarget(expression.returnTarget),
+                returnTargetDescriptor = mapReturnTarget(expression.returnTarget),
                value        = expression.value.transform(this, null)
            )

@@ -594,10 +578,10 @@ internal class DeepCopyIrTreeWithDescriptors(val targetDescriptor: DeclarationDe
            startOffset    = oldExpression.startOffset,
            endOffset      = oldExpression.endOffset,
            type           = substituteType(oldExpression.type)!!,
-            descriptor     = newDescriptor,
+            calleeDescriptor = newDescriptor,
            typeArguments  = substituteTypeArguments(oldExpression.typeArguments),
            origin         = oldExpression.origin,
-            superQualifier = newSuperQualifier
+            superQualifierDescriptor = newSuperQualifier
        ).apply {
            oldExpression.descriptor.valueParameters.forEach {
                val valueArgument = oldExpression.getValueArgument(it)
@@ -31,7 +31,7 @@ abstract internal class IrElementTransformerVoidWithContext : IrElementTransform
    private val scopeStack = mutableListOf<ScopeWithIr>()

    override final fun visitFile(declaration: IrFile): IrFile {
-        scopeStack.push(ScopeWithIr(Scope(declaration.packageFragmentDescriptor), declaration))
+        scopeStack.push(ScopeWithIr(Scope(declaration.symbol), declaration))
        val result = visitFileNew(declaration)
        scopeStack.pop()
        return result
@@ -162,12 +162,6 @@ private class Declarations {
        declarations.add(createKey(declaration))
    }

-    fun addParameterOf(aCatch: IrCatch) {
-        val kind = IrDeclarationKind.VARIABLE
-        val key = DeclarationKey(aCatch.parameter, kind)
-        declarations.add(key)
-    }
-
    fun isAlreadyDeclared(declaration: IrDeclaration): Boolean {
        return createKey(declaration) in declarations
    }
@@ -209,7 +203,10 @@ private class IrValidator(val context: BackendContext, performHeavyValidations:

    private fun recordDeclaration(declaration: IrDeclaration) {
        if (foundDeclarations.isAlreadyDeclared(declaration)) {
-            error(declaration, "redeclaration")
+            if (declaration.descriptor !is ReceiverParameterDescriptor && declaration !is IrTypeParameter) {
+                // TODO: remove the check.
+                error(declaration, "redeclaration")
+            }
        } else {
            foundDeclarations.add(declaration)
        }
@@ -224,9 +221,4 @@ private class IrValidator(val context: BackendContext, performHeavyValidations:
        // Do not treat anonymous initializers as declarations, because they are not unique.
        super.visitDeclaration(declaration)
    }
-
-    override fun visitCatch(aCatch: IrCatch) {
-        foundDeclarations.addParameterOf(aCatch)
-        super.visitCatch(aCatch)
-    }
 }
@@ -25,11 +25,10 @@ import org.jetbrains.kotlin.descriptors.impl.*
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.declarations.impl.IrConstructorImpl
-import org.jetbrains.kotlin.ir.declarations.impl.IrFieldImpl
-import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
+import org.jetbrains.kotlin.ir.declarations.impl.*
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
+import org.jetbrains.kotlin.ir.util.createParameterDeclarations
 import org.jetbrains.kotlin.ir.util.transformFlat
 import org.jetbrains.kotlin.ir.visitors.*
 import org.jetbrains.kotlin.name.Name
@@ -136,8 +135,8 @@ class LocalDeclarationsLowering(val context: BackendContext) : DeclarationContai

        val transformedDescriptors = mutableMapOf<DeclarationDescriptor, DeclarationDescriptor>()

-        val CallableDescriptor.transformed: CallableDescriptor?
-            get() = transformedDescriptors[this] as CallableDescriptor?
+        val FunctionDescriptor.transformed: FunctionDescriptor?
+            get() = transformedDescriptors[this] as FunctionDescriptor?

        val oldParameterToNew: MutableMap<ParameterDescriptor, ParameterDescriptor> = HashMap()
        val newParameterToOld: MutableMap<ParameterDescriptor, ParameterDescriptor> = HashMap()
@@ -168,6 +167,8 @@ class LocalDeclarationsLowering(val context: BackendContext) : DeclarationContai
                                it.transformedDescriptor,
                                original.body
                        ).apply {
+                            createParameterDeclarations()
+
                            original.descriptor.valueParameters.filter { it.declaresDefaultValue() }.forEach { argument ->
                                val body = original.getDefault(argument)!!
                                this.putDefault(oldParameterToNew[argument] as ValueParameterDescriptor, body)
@@ -207,6 +208,9 @@ class LocalDeclarationsLowering(val context: BackendContext) : DeclarationContai
                if (transformedDescriptor != null) {
                    return IrConstructorImpl(declaration.startOffset, declaration.endOffset, declaration.origin,
                            transformedDescriptor, declaration.body!!).apply {
+
+                        createParameterDeclarations()
+
                        declaration.descriptor.valueParameters.filter { it.declaresDefaultValue() }.forEach { argument ->
                            val body = declaration.getDefault(argument)!!
                            this.putDefault(oldParameterToNew[argument] as ValueParameterDescriptor, body)
@@ -287,13 +291,13 @@ class LocalDeclarationsLowering(val context: BackendContext) : DeclarationContai
                return this
            }

-            override fun visitCallableReference(expression: IrCallableReference): IrExpression {
+            override fun visitFunctionReference(expression: IrFunctionReference): IrExpression {
                expression.transformChildrenVoid(this)

                val oldCallee = expression.descriptor.original
                val newCallee = oldCallee.transformed ?: return expression

-                val newCallableReference = IrCallableReferenceImpl(
+                val newCallableReference = IrFunctionReferenceImpl(
                        expression.startOffset, expression.endOffset,
                        expression.type, // TODO functional type for transformed descriptor
                        newCallee,
@@ -386,7 +390,7 @@ class LocalDeclarationsLowering(val context: BackendContext) : DeclarationContai
            rewriteFunctionBody(memberDeclaration, null)
        }

-        private fun createNewCall(oldCall: IrCall, newCallee: CallableDescriptor) =
+        private fun createNewCall(oldCall: IrCall, newCallee: FunctionDescriptor) =
                if (oldCall is IrCallWithShallowCopy)
                    oldCall.shallowCopy(oldCall.origin, newCallee, oldCall.superQualifier)
                else
@@ -25,11 +25,13 @@ import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.builders.*
 import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl
 import org.jetbrains.kotlin.ir.expressions.IrDelegatingConstructorCall
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
 import org.jetbrains.kotlin.ir.expressions.IrTypeOperator
 import org.jetbrains.kotlin.ir.expressions.impl.*
+import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
 import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid
@@ -44,22 +46,45 @@ import org.jetbrains.kotlin.utils.Printer

 class IrLoweringContext(backendContext: BackendContext) : IrGeneratorContext(backendContext.irBuiltIns)

-class DeclarationIrBuilder(backendContext: BackendContext,
-                           declarationDescriptor: DeclarationDescriptor,
-                           startOffset : Int = UNDEFINED_OFFSET,
-                           endOffset : Int = UNDEFINED_OFFSET) :
-        IrBuilderWithScope(
-                IrLoweringContext(backendContext),
-                Scope(declarationDescriptor),
-                startOffset,
-                endOffset
-        )
+class DeclarationIrBuilder : IrBuilderWithScope {

+    constructor(
+            backendContext: BackendContext,
+            symbol: IrSymbol,
+            startOffset: Int = UNDEFINED_OFFSET,
+            endOffset: Int = UNDEFINED_OFFSET
+    ) : super(
+            IrLoweringContext(backendContext),
+            Scope(symbol),
+            startOffset,
+            endOffset
+    )
+
+    @Deprecated("Creates unbound symbol")
+    constructor(
+            backendContext: BackendContext,
+            declarationDescriptor: DeclarationDescriptor,
+            startOffset: Int = UNDEFINED_OFFSET,
+            endOffset: Int = UNDEFINED_OFFSET
+    ) : super(
+            IrLoweringContext(backendContext),
+            Scope(declarationDescriptor),
+            startOffset,
+            endOffset
+    )
+}
+
+@Deprecated("Creates unbound symbol")
 fun BackendContext.createIrBuilder(declarationDescriptor: DeclarationDescriptor,
                                   startOffset : Int = UNDEFINED_OFFSET,
                                   endOffset : Int = UNDEFINED_OFFSET) =
        DeclarationIrBuilder(this, declarationDescriptor, startOffset, endOffset)

+fun BackendContext.createIrBuilder(symbol: IrSymbol,
+                                   startOffset : Int = UNDEFINED_OFFSET,
+                                   endOffset : Int = UNDEFINED_OFFSET) =
+        DeclarationIrBuilder(this, symbol, startOffset, endOffset)
+

 fun <T : IrBuilder> T.at(element: IrElement) = this.at(element.startOffset, element.endOffset)

@@ -75,26 +100,36 @@ inline fun IrGeneratorWithScope.irBlockBody(irElement: IrElement, body: IrBlockB
        this.irBlockBody(irElement.startOffset, irElement.endOffset, body)


+@Deprecated("Creates unbound symbol")
 fun IrBuilderWithScope.irUnit() =
        IrGetObjectValueImpl(startOffset, endOffset, context.builtIns.unitType, context.builtIns.unit)

 fun IrBuilderWithScope.irIfThen(condition: IrExpression, thenPart: IrExpression) =
        IrIfThenElseImpl(startOffset, endOffset, context.builtIns.unitType, condition, thenPart, null)

+@Deprecated("Creates unbound symbol")
 fun IrBuilderWithScope.irGet(descriptor: PropertyDescriptor) =
-        IrGetterCallImpl(startOffset, endOffset, descriptor.getter!!, null)
+        IrCallImpl(startOffset, endOffset, descriptor.getter!!)

+@Deprecated("Creates unbound symbol")
 fun IrBuilderWithScope.irSet(receiver: IrExpression, descriptor: PropertyDescriptor, arg: IrExpression) =
-        IrSetterCallImpl(startOffset, endOffset, descriptor.setter!!, null, receiver, null, arg)
+        IrCallImpl(startOffset, endOffset, descriptor.setter!!).apply {
+            dispatchReceiver = receiver
+            putValueArgument(0, arg)
+        }

 fun IrBuilderWithScope.irNot(arg: IrExpression) =
-        primitiveOp1(startOffset, endOffset, context.irBuiltIns.booleanNot, IrStatementOrigin.EXCL, arg)
+        primitiveOp1(startOffset, endOffset, context.irBuiltIns.booleanNotSymbol, IrStatementOrigin.EXCL, arg)

 fun IrBuilderWithScope.irThrow(arg: IrExpression) =
        IrThrowImpl(startOffset, endOffset, context.builtIns.nothingType, arg)

 fun IrBuilderWithScope.irCatch(parameter: VariableDescriptor, result: IrExpression) =
-        IrCatchImpl(startOffset, endOffset, parameter, result)
+        IrCatchImpl(
+                startOffset, endOffset,
+                IrVariableImpl(startOffset, endOffset, IrDeclarationOrigin.CATCH_PARAMETER, parameter),
+                result
+        )

 fun IrBuilderWithScope.irCast(arg: IrExpression, type: KotlinType, typeOperand: KotlinType) =
        IrTypeOperatorCallImpl(startOffset, endOffset, type, IrTypeOperator.CAST, typeOperand, arg)
@@ -103,12 +138,15 @@ fun IrBuilderWithScope.irImplicitCoercionToUnit(arg: IrExpression) =
        IrTypeOperatorCallImpl(startOffset, endOffset, context.builtIns.unitType,
                IrTypeOperator.IMPLICIT_COERCION_TO_UNIT, context.builtIns.unitType, arg)

+@Deprecated("Creates unbound symbol")
 fun IrBuilderWithScope.irGetField(receiver: IrExpression, descriptor: PropertyDescriptor) =
        IrGetFieldImpl(startOffset, endOffset, descriptor, receiver)

+@Deprecated("Creates unbound symbol")
 fun IrBuilderWithScope.irSetField(receiver: IrExpression, descriptor: PropertyDescriptor, value: IrExpression) =
        IrSetFieldImpl(startOffset, endOffset, descriptor, receiver, value)

+@Deprecated("Creates unbound symbol")
 open class IrBuildingTransformer(private val context: BackendContext) : IrElementTransformerVoid() {
    private var currentBuilder: IrBuilderWithScope? = null

@@ -28,7 +28,9 @@ import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
 import org.jetbrains.kotlin.ir.builders.*
 import org.jetbrains.kotlin.ir.declarations.IrFunction
+import org.jetbrains.kotlin.ir.declarations.getDefault
 import org.jetbrains.kotlin.ir.expressions.*
+import org.jetbrains.kotlin.ir.symbols.IrVariableSymbol
 import org.jetbrains.kotlin.ir.util.getArguments
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
 import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
@@ -60,7 +62,7 @@ private fun lowerTailRecursionCalls(context: BackendContext, irFunction: IrFunct
    irFunction.body = builder.irBlockBody {
        // Define variables containing current values of parameters:
        val parameterToVariable = parameters.associate {
-            it to defineTemporaryVar(irGet(it), nameHint = it.suggestVariableName())
+            it to irTemporaryVar(irGet(it), nameHint = it.suggestVariableName()).symbol
        }
        // (these variables are to be updated on any tail call).

@@ -93,7 +95,7 @@ private class BodyTransformer(
        val irFunction: IrFunction,
        val loop: IrLoop,
        val parameterToNew: Map<ParameterDescriptor, ValueDescriptor>,
-        val parameterToVariable: Map<ParameterDescriptor, VariableDescriptor>,
+        val parameterToVariable: Map<ParameterDescriptor, IrVariableSymbol>,
        val tailRecursionCalls: Set<IrCall>
 ) : IrElementTransformerVoid() {

@@ -139,7 +141,7 @@ private class BodyTransformer(
            // Copy default value, mapping parameters to variables containing freshly computed arguments:
            val defaultValue = originalDefaultValue.transform(object : DeepCopyIrTreeWithDeclarations() {
                override fun mapValueReference(descriptor: ValueDescriptor): ValueDescriptor {
-                    return parameterToVariable[descriptor] ?: super.mapValueReference(descriptor)
+                    return parameterToVariable[descriptor]?.descriptor ?: super.mapValueReference(descriptor)
                }
            }, data = null)

@@ -264,7 +264,7 @@ class DumpIrTreeWithDescriptorsVisitor(out: Appendable): IrElementVisitor<Unit,

    override fun visitEnumEntry(declaration: IrEnumEntry, data: String) {
        declaration.dumpLabeledElementWith(data) {
-            declaration.initializerExpression.accept(this, "init")
+            declaration.initializerExpression?.accept(this, "init")
            declaration.correspondingClass?.accept(this, "class")
        }
    }
@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.ir.declarations.impl.IrConstructorImpl
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.util.DumpIrTreeVisitor
+import org.jetbrains.kotlin.ir.util.createParameterDeclarations
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.KotlinType
@@ -104,7 +105,9 @@ internal fun ClassDescriptor.createSimpleDelegatingConstructor(superConstructorD
                    IrInstanceInitializerCallImpl(startOffset, endOffset, this)
            )
    )
-    return IrConstructorImpl(startOffset, endOffset, origin, constructorDescriptor, body)
+    return IrConstructorImpl(startOffset, endOffset, origin, constructorDescriptor, body).apply {
+        createParameterDeclarations()
+    }
 }

 internal fun Context.createArrayOfExpression(arrayElementType: KotlinType,
@@ -586,7 +586,9 @@ internal class CodeGeneratorVisitor(val context: Context) : IrElementVisitorVoid
        }
        using(ClassScope(declaration)) {
            debugClassDeclaration(declaration) {
-                declaration.acceptChildrenVoid(this)
+                declaration.declarations.forEach {
+                    it.acceptVoid(this)
+                }
            }
        }
    }
@@ -33,6 +33,7 @@ import org.jetbrains.kotlin.ir.expressions.impl.IrBlockBodyImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrReturnImpl
+import org.jetbrains.kotlin.ir.util.createParameterDeclarations
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
 import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
 import org.jetbrains.kotlin.types.KotlinType
@@ -54,7 +55,8 @@ internal class DirectBridgesCallsLowering(val context: Context) : BodyLoweringPa

                return IrCallImpl(expression.startOffset, expression.endOffset,
                        target, remapTypeArguments(expression, target), expression.origin,
-                        superQualifier = target.containingDeclaration as ClassDescriptor /* Call non-virtually */).apply {
+                        superQualifierDescriptor = target.containingDeclaration as ClassDescriptor /* Call non-virtually */
+                ).apply {
                    dispatchReceiver = expression.dispatchReceiver
                    extensionReceiver = expression.extensionReceiver
                    mapValueParameters { expression.getValueArgument(it)!! }
@@ -114,7 +116,8 @@ internal class BridgesBuilding(val context: Context) : ClassLoweringPass {
        val target = descriptor.descriptor.target

        val delegatingCall = IrCallImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, target,
-                superQualifier = target.containingDeclaration as ClassDescriptor /* Call non-virtually */).apply {
+                superQualifierDescriptor = target.containingDeclaration as ClassDescriptor /* Call non-virtually */
+        ).apply {
            val dispatchReceiverParameter = bridgeDescriptor.dispatchReceiverParameter
            if (dispatchReceiverParameter != null)
                dispatchReceiver = IrGetValueImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, dispatchReceiverParameter)
@@ -130,7 +133,10 @@ internal class BridgesBuilding(val context: Context) : ClassLoweringPass {
            IrReturnImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, bridgeDescriptor, delegatingCall)
        else
            delegatingCall
-        irClass.declarations.add(IrFunctionImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, DECLARATION_ORIGIN_BRIDGE_METHOD,
-                bridgeDescriptor, IrBlockBodyImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, listOf(bridgeBody))))
+        irClass.declarations.add(
+                IrFunctionImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, DECLARATION_ORIGIN_BRIDGE_METHOD,
+                        bridgeDescriptor, IrBlockBodyImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, listOf(bridgeBody))
+                ).apply { createParameterDeclarations() }
+        )
    }
 }
@@ -33,10 +33,12 @@ import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
 import org.jetbrains.kotlin.ir.expressions.IrCallableReference
 import org.jetbrains.kotlin.ir.expressions.IrExpression
+import org.jetbrains.kotlin.ir.expressions.IrFunctionReference
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
-import org.jetbrains.kotlin.ir.expressions.impl.IrCallableReferenceImpl
+import org.jetbrains.kotlin.ir.expressions.impl.IrFunctionReferenceImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrVarargImpl
 import org.jetbrains.kotlin.ir.util.addArguments
+import org.jetbrains.kotlin.ir.util.createParameterDeclarations
 import org.jetbrains.kotlin.ir.util.getArguments
 import org.jetbrains.kotlin.ir.util.transformFlat
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
@@ -115,7 +117,7 @@ private class CallableReferencesUnbinder(val lower: CallableReferenceLowering,
        return declaration
    }

-    override fun visitCallableReference(expression: IrCallableReference): IrExpression {
+    override fun visitFunctionReference(expression: IrFunctionReference): IrExpression {
        expression.transformChildrenVoid(this)
        if (!expression.type.isFunctionOrKFunctionType) {
            // Not a subject of this lowering.
@@ -142,7 +144,7 @@ private class CallableReferencesUnbinder(val lower: CallableReferenceLowering,

        // Create the call to constructor and its arguments:

-        val unboundRef = IrCallableReferenceImpl(startOffset, endOffset,
+        val unboundRef = IrFunctionReferenceImpl(startOffset, endOffset,
                unboundCallableReferenceType, newFunction.descriptor, null)
        val simpleFunctionImplClassConstructor = simpleFunctionImplClass.unsubstitutedPrimaryConstructor!!

@@ -164,7 +166,7 @@ private class CallableReferencesUnbinder(val lower: CallableReferenceLowering,
     * For given function [descriptor] creates the function which calls [descriptor] but
     * takes all [boundParams] packed into `SimpleFunctionImpl` (and all [unboundParams] as is).
     */
-    private fun createSimpleFunctionImplTarget(descriptor: CallableDescriptor,
+    private fun createSimpleFunctionImplTarget(descriptor: FunctionDescriptor,
                                               unboundParams: List<ParameterDescriptor>,
                                               boundParams: List<ParameterDescriptor>,
                                               startOffset: Int, endOffset: Int): IrFunctionImpl {
@@ -212,6 +214,8 @@ private class CallableReferencesUnbinder(val lower: CallableReferenceLowering,
                blockBody
        )

+        newFunction.createParameterDeclarations()
+
        return newFunction
    }

@@ -35,16 +35,14 @@ import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.builders.*
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationContainer
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOriginImpl
-import org.jetbrains.kotlin.ir.declarations.IrFunction
+import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrConstructorImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl
 import org.jetbrains.kotlin.ir.descriptors.IrTemporaryVariableDescriptorImpl
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
+import org.jetbrains.kotlin.ir.util.createParameterDeclarations
 import org.jetbrains.kotlin.ir.util.transformFlat
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
 import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
@@ -141,7 +139,7 @@ class DefaultArgumentStubGenerator internal constructor(val context: Context): D
                    + IrDelegatingConstructorCallImpl(
                            startOffset = irFunction.startOffset,
                            endOffset   = irFunction.endOffset,
-                            descriptor  = functionDescriptor
+                            constructorDescriptor = functionDescriptor
                    ).apply {
                        params.forEachIndexed { i, variable ->
                            putValueArgument(i, irGet(variable))
@@ -164,12 +162,9 @@ class DefaultArgumentStubGenerator internal constructor(val context: Context): D
                    })
                }
            }
-            // Replace default argument initializers with empty composites.
-            functionDescriptor.valueParameters.forEach {
-                if (it.declaresDefaultValue()) {
-                    irFunction.putDefault(it, IrExpressionBodyImpl(irFunction.startOffset, irFunction.endOffset,
-                            IrCompositeImpl(irFunction.startOffset, irFunction.startOffset, it.type)))
-                }
+            // Remove default argument initializers.
+            irFunction.valueParameters.forEach {
+                it.defaultValue = null
            }
            return if (functionDescriptor is ClassConstructorDescriptor)
                      listOf(irFunction, IrConstructorImpl(
@@ -177,14 +172,14 @@ class DefaultArgumentStubGenerator internal constructor(val context: Context): D
                              endOffset   = irFunction.endOffset,
                              descriptor  = descriptor as ClassConstructorDescriptor,
                              origin      = DECLARATION_ORIGIN_FUNCTION_FOR_DEFAULT_PARAMETER,
-                              body        = body))
+                              body        = body).apply { createParameterDeclarations() })
                   else
                      listOf(irFunction, IrFunctionImpl(
                              startOffset = irFunction.startOffset,
                              endOffset   = irFunction.endOffset,
                              descriptor  = descriptor,
                              origin      = DECLARATION_ORIGIN_FUNCTION_FOR_DEFAULT_PARAMETER,
-                              body        = body))
+                              body        = body).apply { createParameterDeclarations() })
        }
        return listOf(irFunction)
    }
@@ -246,7 +241,7 @@ class DefaultParameterInjector internal constructor(val context: Context): BodyL
                return IrDelegatingConstructorCallImpl(
                        startOffset = expression.startOffset,
                        endOffset   = expression.endOffset,
-                        descriptor  = descriptorForCall as ClassConstructorDescriptor)
+                        constructorDescriptor = descriptorForCall as ClassConstructorDescriptor)
                            .apply {
                                params.forEach {
                                    log("call::params@${it.first.index}/${it.first.name.asString()}: ${ir2string(it.second)}")
@@ -273,7 +268,7 @@ class DefaultParameterInjector internal constructor(val context: Context): BodyL
                return IrCallImpl(
                        startOffset   = expression.startOffset,
                        endOffset     = expression.endOffset,
-                        descriptor    = descriptor,
+                        calleeDescriptor = descriptor,
                        typeArguments = expression.descriptor.typeParameters.map{it to (expression.getTypeArgument(it) ?: it.defaultType) }.toMap())
                        .apply {
                            params.forEach {
@@ -178,7 +178,7 @@ internal class PropertyDelegationLowering(val context: Context) : FileLoweringPa
                        receiverType = receiverTypes.firstOrNull(),
                        parameterTypes = if (receiverTypes.size < 2) listOf() else listOf(receiverTypes[1]),
                        returnType = returnType)
-                IrCallableReferenceImpl(startOffset, endOffset, getterKFunctionType, getter, null).apply {
+                IrFunctionReferenceImpl(startOffset, endOffset, getterKFunctionType, getter, null).apply {
                    dispatchReceiver = expression.dispatchReceiver
                    extensionReceiver = expression.extensionReceiver
                }
@@ -193,7 +193,7 @@ internal class PropertyDelegationLowering(val context: Context) : FileLoweringPa
                        receiverType = receiverTypes.firstOrNull(),
                        parameterTypes = if (receiverTypes.size < 2) listOf(returnType) else listOf(receiverTypes[1], returnType),
                        returnType = context.builtIns.unitType)
-                IrCallableReferenceImpl(startOffset, endOffset, setterKFunctionType, it, null).apply {
+                IrFunctionReferenceImpl(startOffset, endOffset, setterKFunctionType, it, null).apply {
                    dispatchReceiver = expression.dispatchReceiver
                    extensionReceiver = expression.extensionReceiver
                }
@@ -32,11 +32,13 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.impl.ClassConstructorDescriptorImpl
 import org.jetbrains.kotlin.descriptors.impl.ClassDescriptorImpl
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
+import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.*
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
+import org.jetbrains.kotlin.ir.util.createParameterDeclarations
 import org.jetbrains.kotlin.ir.util.dump
 import org.jetbrains.kotlin.ir.util.transform
 import org.jetbrains.kotlin.ir.util.transformFlat
@@ -247,6 +249,8 @@ internal class EnumClassLowering(val context: Context) : ClassLoweringPass {
                    ClassKind.CLASS, listOf(descriptor.defaultType), SourceElement.NO_SOURCE, false)
            val defaultClass = IrClassImpl(startOffset, endOffset, IrDeclarationOrigin.DEFINED, defaultClassDescriptor)

+            defaultClass.createParameterDeclarations()
+
            val constructors = mutableSetOf<ClassConstructorDescriptor>()

            descriptor.constructors.forEach {
@@ -286,6 +290,8 @@ internal class EnumClassLowering(val context: Context) : ClassLoweringPass {
            val implObjectDescriptor = loweredEnum.implObjectDescriptor
            val implObject = IrClassImpl(startOffset, endOffset, IrDeclarationOrigin.DEFINED, implObjectDescriptor)

+            implObject.createParameterDeclarations()
+
            val enumEntries = mutableListOf<IrEnumEntry>()
            var i = 0
            while (i < irClass.declarations.size) {
@@ -329,7 +335,7 @@ internal class EnumClassLowering(val context: Context) : ClassLoweringPass {
            val startOffset = irClass.startOffset
            val endOffset = irClass.endOffset
            val irValuesInitializer = context.createArrayOfExpression(irClass.descriptor.defaultType,
-                    enumEntries.sortedBy { it.descriptor.name }.map { it.initializerExpression }, startOffset, endOffset)
+                    enumEntries.sortedBy { it.descriptor.name }.map { it.initializerExpression!! }, startOffset, endOffset)

            val irField = IrFieldImpl(startOffset, endOffset, DECLARATION_ORIGIN_ENUM,
                    loweredEnum.valuesProperty,
@@ -337,6 +343,8 @@ internal class EnumClassLowering(val context: Context) : ClassLoweringPass {

            val getter = IrFunctionImpl(startOffset, endOffset, DECLARATION_ORIGIN_ENUM, loweredEnum.valuesGetter)

+            getter.createParameterDeclarations()
+
            val receiver = IrGetObjectValueImpl(startOffset, endOffset,
                    loweredEnum.implObjectDescriptor.defaultType, loweredEnum.implObjectDescriptor)
            val value = IrGetFieldImpl(startOffset, endOffset, loweredEnum.valuesProperty, receiver)
@@ -374,11 +382,9 @@ internal class EnumClassLowering(val context: Context) : ClassLoweringPass {
        }

        private fun lowerEnumConstructors(irClass: IrClass) {
-            irClass.declarations.transform { declaration ->
+            irClass.declarations.forEachIndexed { index, declaration ->
                if (declaration is IrConstructor)
-                    transformEnumConstructor(declaration)
-                else
-                    declaration
+                    irClass.declarations[index] = transformEnumConstructor(declaration)
            }
        }

@@ -390,6 +396,9 @@ internal class EnumClassLowering(val context: Context) : ClassLoweringPass {
                    loweredConstructorDescriptor,
                    enumConstructor.body!! // will be transformed later
            )
+
+            loweredEnumConstructor.createParameterDeclarations()
+
            enumConstructor.descriptor.valueParameters.filter { it.declaresDefaultValue() }.forEach {
                val body = enumConstructor.getDefault(it)!!
                body.transformChildrenVoid(ParameterMapper(constructorDescriptor))
@@ -31,9 +31,9 @@ internal class FinallyBlocksLowering(val context: Context): FunctionLoweringPass
        fun toIr(context: Context, startOffset: Int, endOffset: Int, value: IrExpression): IrExpression
    }

-    private data class Return(val callableDescriptor: CallableDescriptor): HighLevelJump {
+    private data class Return(val functionDescriptor: FunctionDescriptor): HighLevelJump {
        override fun toIr(context: Context, startOffset: Int, endOffset: Int, value: IrExpression)
-                = IrReturnImpl(startOffset, endOffset, callableDescriptor, value)
+                = IrReturnImpl(startOffset, endOffset, functionDescriptor, value)
    }

    private data class Break(val loop: IrLoop): HighLevelJump {
@@ -178,7 +178,7 @@ internal class FinallyBlocksLowering(val context: Context): FunctionLoweringPass
                        return IrReturnImpl(
                                startOffset  = startOffset,
                                endOffset    = endOffset,
-                                returnTarget = it,
+                                returnTargetDescriptor = it,
                                value        = value)
                    }
                }
@@ -282,7 +282,7 @@ internal class FinallyBlocksLowering(val context: Context): FunctionLoweringPass
    private fun IrBuilderWithScope.irVar(descriptor: VariableDescriptor, initializer: IrExpression?) =
            IrVariableImpl(startOffset, endOffset, DECLARATION_ORIGIN_FINALLY_BLOCK, descriptor, initializer)

-    fun IrBuilderWithScope.irReturn(target: CallableDescriptor, value: IrExpression) =
+    fun IrBuilderWithScope.irReturn(target: FunctionDescriptor, value: IrExpression) =
            IrReturnImpl(startOffset, endOffset, target, value)

    inline fun IrBuilderWithScope.irReturnableBlock(descriptor: FunctionDescriptor, body: IrBlockBuilder.() -> Unit) =
@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
+import org.jetbrains.kotlin.ir.declarations.getDefault
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
@@ -30,6 +30,7 @@ import org.jetbrains.kotlin.ir.expressions.IrDelegatingConstructorCall
 import org.jetbrains.kotlin.ir.expressions.IrInstanceInitializerCall
 import org.jetbrains.kotlin.ir.expressions.IrStatementOriginImpl
 import org.jetbrains.kotlin.ir.expressions.impl.*
+import org.jetbrains.kotlin.ir.util.createParameterDeclarations
 import org.jetbrains.kotlin.ir.util.transformFlat
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
 import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
@@ -112,6 +113,9 @@ internal class InitializersLowering(val context: Context) : ClassLoweringPass {
            val endOffset = irClass.endOffset
            val initializer = IrFunctionImpl(startOffset, endOffset, DECLARATION_ORIGIN_ANONYMOUS_INITIALIZER,
                    initializerMethodDescriptor, IrBlockBodyImpl(startOffset, endOffset, initializers))
+
+            initializer.createParameterDeclarations()
+
            irClass.declarations.add(initializer)

            return initializerMethodDescriptor
@@ -34,8 +34,8 @@ import org.jetbrains.kotlin.ir.builders.irGet
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
-import org.jetbrains.kotlin.ir.expressions.impl.IrCallableReferenceImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrConstImpl
+import org.jetbrains.kotlin.ir.expressions.impl.IrFunctionReferenceImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrGetObjectValueImpl
 import org.jetbrains.kotlin.ir.util.getArguments
 import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
@@ -309,7 +309,7 @@ private class InteropTransformer(val context: Context, val irFile: IrFile) : IrB
                    }
                }

-                IrCallableReferenceImpl(
+                IrFunctionReferenceImpl(
                        builder.startOffset, builder.endOffset,
                        expression.type,
                        target,
@@ -387,8 +387,8 @@ private class InteropTransformer(val context: Context, val irFile: IrFile) : IrB
        reportError("Type $this is not supported in callback signature")
    }

-    private fun unwrapStaticFunctionArgument(argument: IrExpression): IrCallableReference? {
-        if (argument is IrCallableReference) {
+    private fun unwrapStaticFunctionArgument(argument: IrExpression): IrFunctionReference? {
+        if (argument is IrFunctionReference) {
            return argument
        }

@@ -413,7 +413,7 @@ private class InteropTransformer(val context: Context, val irFile: IrFile) : IrB

        // 3. Second statement is IrCallableReference:

-        return argument.statements.last() as? IrCallableReference
+        return argument.statements.last() as? IrFunctionReference
    }

    private fun IrCall.getSingleTypeArgument(): KotlinType {
@@ -22,13 +22,14 @@ import org.jetbrains.kotlin.backend.konan.Context
 import org.jetbrains.kotlin.backend.konan.descriptors.signature2Descriptor
 import org.jetbrains.kotlin.ir.builders.irLetSequence
 import org.jetbrains.kotlin.builtins.PrimitiveType
-import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.builders.*
 import org.jetbrains.kotlin.ir.declarations.IrDeclaration
 import org.jetbrains.kotlin.ir.declarations.IrFile
+import org.jetbrains.kotlin.ir.declarations.IrSymbolDeclaration
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrStringConcatenation
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
@@ -74,12 +75,12 @@ private class StringConcatenationTransformer(val lower: StringConcatenationLower
    private val defaultAppendFunction =
            classStringBuilder.signature2Descriptor(nameAppend, arrayOf(builtIns.nullableAnyType))!!

-    private val appendFunctions: Map<KotlinType, CallableDescriptor?> =
+    private val appendFunctions: Map<KotlinType, FunctionDescriptor?> =
            typesWithSpecialAppendFunction.map {
                it to classStringBuilder.signature2Descriptor(nameAppend, arrayOf(it))
            }.toMap()

-    private fun typeToAppendFunction(type : KotlinType) : CallableDescriptor {
+    private fun typeToAppendFunction(type : KotlinType) : FunctionDescriptor {
        return appendFunctions[type]?:defaultAppendFunction
    }

@@ -107,9 +108,13 @@ private class StringConcatenationTransformer(val lower: StringConcatenationLower
    }

    override fun visitDeclaration(declaration: IrDeclaration): IrStatement {
+        if (declaration !is IrSymbolDeclaration<*>) {
+            return super.visitDeclaration(declaration)
+        }
+
        with(declaration) {
            buildersStack.add(
-                    context.createIrBuilder(declaration.descriptor, startOffset, endOffset)
+                    context.createIrBuilder(declaration.symbol, startOffset, endOffset)
            )
            transformChildrenVoid(this@StringConcatenationTransformer)
            buildersStack.removeAt(buildersStack.lastIndex)
@@ -40,6 +40,7 @@ import org.jetbrains.kotlin.ir.declarations.impl.*
 import org.jetbrains.kotlin.ir.descriptors.IrTemporaryVariableDescriptorImpl
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
+import org.jetbrains.kotlin.ir.util.createParameterDeclarations
 import org.jetbrains.kotlin.ir.util.getArguments
 import org.jetbrains.kotlin.ir.util.transformFlat
 import org.jetbrains.kotlin.ir.visitors.*
@@ -131,7 +132,7 @@ internal class SuspendFunctionsLowering(val context: Context): DeclarationContai
                    return IrCallImpl(
                            startOffset = expression.startOffset,
                            endOffset = expression.endOffset,
-                            descriptor = invokeFunctionDescriptor
+                            calleeDescriptor = invokeFunctionDescriptor
                    ).apply {
                        dispatchReceiver = expression.dispatchReceiver
                        putValueArgument(0, expression.extensionReceiver)
@@ -164,7 +165,7 @@ internal class SuspendFunctionsLowering(val context: Context): DeclarationContai
            }

            SuspendFunctionKind.NEEDS_STATE_MACHINE -> {
-                val coroutine = buildCoroutine(irFunction, callableReference)   // Coroutine implementation.
+                val coroutine: IrDeclaration = buildCoroutine(irFunction, callableReference)   // Coroutine implementation.
                if (suspendLambdas.contains(irFunction.descriptor))             // Suspend lambdas are called through factory method <create>,
                    listOf(coroutine)                                           // thus we can eliminate original body.
                else
@@ -450,6 +451,9 @@ internal class SuspendFunctionsLowering(val context: Context): DeclarationContai
                    descriptor  = coroutineClassDescriptor,
                    members     = coroutineMembers
            )
+
+            coroutineClass.createParameterDeclarations()
+
            return BuiltCoroutine(
                    coroutineClass                 = coroutineClass,
                    coroutineConstructorDescriptor = coroutineFactoryConstructorBuilder?.descriptor
@@ -496,6 +500,9 @@ internal class SuspendFunctionsLowering(val context: Context): DeclarationContai
                        endOffset   = endOffset,
                        origin      = DECLARATION_ORIGIN_COROUTINE_IMPL,
                        descriptor  = descriptor).apply {
+
+                    createParameterDeclarations()
+
                    body = irBuilder.irBlockBody {
                        val completionParameter = descriptor.valueParameters.last()
                        +IrDelegatingConstructorCallImpl(startOffset, endOffset, coroutineImplConstructorDescriptor).apply {
@@ -561,6 +568,9 @@ internal class SuspendFunctionsLowering(val context: Context): DeclarationContai
                        endOffset   = endOffset,
                        origin      = DECLARATION_ORIGIN_COROUTINE_IMPL,
                        descriptor  = descriptor).apply {
+
+                    createParameterDeclarations()
+
                    body = irBuilder.irBlockBody {
                        +IrDelegatingConstructorCallImpl(startOffset, endOffset, coroutineImplConstructorDescriptor).apply {
                            putValueArgument(0, irNull()) // Completion.
@@ -619,6 +629,9 @@ internal class SuspendFunctionsLowering(val context: Context): DeclarationContai
                        endOffset   = endOffset,
                        origin      = DECLARATION_ORIGIN_COROUTINE_IMPL,
                        descriptor  = descriptor).apply {
+
+                    createParameterDeclarations()
+
                    body = irBuilder.irBlockBody(startOffset, endOffset) {
                        +irReturn(
                                irCall(coroutineConstructorDescriptor).apply {
@@ -684,6 +697,9 @@ internal class SuspendFunctionsLowering(val context: Context): DeclarationContai
                        endOffset   = endOffset,
                        origin      = DECLARATION_ORIGIN_COROUTINE_IMPL,
                        descriptor  = this.descriptor).apply {
+
+                    createParameterDeclarations()
+
                    body = irBuilder.irBlockBody(startOffset, endOffset) {
                        +irReturn(
                                irCall(doResumeFunctionDescriptor).apply {
@@ -731,6 +747,9 @@ internal class SuspendFunctionsLowering(val context: Context): DeclarationContai
                    endOffset   = irFunction.endOffset,
                    origin      = DECLARATION_ORIGIN_COROUTINE_IMPL,
                    descriptor  = descriptor).apply {
+
+                createParameterDeclarations()
+
                body = context.createIrBuilder(descriptor, startOffset, endOffset).irBlockBody {
                    +irReturn(irGetField(irThis(), propertyDescriptor))
                }
@@ -780,6 +799,9 @@ internal class SuspendFunctionsLowering(val context: Context): DeclarationContai
                    endOffset   = irFunction.endOffset,
                    origin      = DECLARATION_ORIGIN_COROUTINE_IMPL,
                    descriptor  = descriptor).apply {
+
+                createParameterDeclarations()
+
                body = context.createIrBuilder(descriptor, startOffset, endOffset).irBlockBody {
                    +irSetField(irThis(), propertyDescriptor, irGet(valueParameterDescriptor))
                }
@@ -872,6 +894,8 @@ internal class SuspendFunctionsLowering(val context: Context): DeclarationContai
                        origin      = DECLARATION_ORIGIN_COROUTINE_IMPL,
                        descriptor  = descriptor).apply {

+                    createParameterDeclarations()
+
                    body = irBuilder.irBlockBody(startOffset, endOffset) {

                        // Extract all suspend calls to temporaries in order to make correct jumps to them.
@@ -1021,20 +1045,6 @@ internal class SuspendFunctionsLowering(val context: Context): DeclarationContai
                            descriptor  = newVariable,
                            initializer = declaration.initializer)
                }
-
-                override fun visitCatch(aCatch: IrCatch): IrCatch {
-                    aCatch.transformChildrenVoid(this)
-
-                    val newVariable = variablesMap[aCatch.parameter]
-                            ?: return aCatch
-
-                    return IrCatchImpl(
-                            startOffset = aCatch.startOffset,
-                            endOffset   = aCatch.endOffset,
-                            parameter   = newVariable,
-                            result      = aCatch.result
-                    )
-                }
            })
        }

@@ -278,6 +278,6 @@ class VarargInjectionLowering internal constructor(val context: Context): Declar

 private fun IrBuilderWithScope.irConstInt(value: Int): IrConst<Int> = IrConstImpl.int(startOffset, endOffset, context.builtIns.intType, value)
 private fun IrBuilderWithScope.irBlock(type: KotlinType): IrBlock = IrBlockImpl(startOffset, endOffset, type)
-private fun IrBuilderWithScope.irCall(descriptor: CallableDescriptor, typeArguments: Map<TypeParameterDescriptor, KotlinType>?): IrCall = IrCallImpl(startOffset, endOffset, descriptor, typeArguments)
+private fun IrBuilderWithScope.irCall(descriptor: FunctionDescriptor, typeArguments: Map<TypeParameterDescriptor, KotlinType>?): IrCall = IrCallImpl(startOffset, endOffset, descriptor, typeArguments)
 private val IrBuilderWithScope.kIntZero get() = irConstInt(0)
 private val IrBuilderWithScope.kIntOne get() = irConstInt(1)
@@ -38,6 +38,8 @@ import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
+import org.jetbrains.kotlin.ir.symbols.impl.createFunctionSymbol
+import org.jetbrains.kotlin.ir.util.createParameterDeclarations
 import org.jetbrains.kotlin.serialization.KonanIr
 import org.jetbrains.kotlin.serialization.KonanIr.IrConst.ValueCase.*
 import org.jetbrains.kotlin.serialization.KonanIr.IrOperation.OperationCase.*
@@ -496,14 +498,17 @@ internal class IrSerializer(val context: Context,
        val proto = KonanIr.IrClass.newBuilder()
        val declarations = clazz.declarations
        declarations.forEach {
-            proto.addMember(serializeDeclaration(it))
+            val descriptor = it.descriptor
+            if (descriptor !is CallableMemberDescriptor || descriptor.kind.isReal) {
+                proto.addMember(serializeDeclaration(it))
+            }
        }
        return proto.build()
    }

    fun serializeIrEnumEntry(enumEntry: IrEnumEntry): KonanIr.IrEnumEntry {
        val proto = KonanIr.IrEnumEntry.newBuilder()
-        val initializer = enumEntry.initializerExpression
+        val initializer = enumEntry.initializerExpression!!
        proto.setInitializer(serializeExpression(initializer))
        val correspondingClass = enumEntry.correspondingClass
        if (correspondingClass != null) {
@@ -626,9 +631,10 @@ internal class IrDeserializer(val context: Context,

    fun deserializeCatch(proto: KonanIr.IrCatch, start: Int, end: Int): IrCatch {
        val parameter = deserializeDescriptor(proto.getParameter()) as VariableDescriptor
+        val catchParameter = IrVariableImpl(start, end, IrDeclarationOrigin.CATCH_PARAMETER, parameter)
        val result = deserializeExpression(proto.getResult())

-        return IrCatchImpl(start, end, parameter, result)
+        return IrCatchImpl(start, end, catchParameter, result)
    }

    fun deserializeStatement(proto: KonanIr.IrStatement): IrElement {
@@ -685,7 +691,7 @@ internal class IrDeserializer(val context: Context,
    }

    fun deserializeCall(proto: KonanIr.IrCall, start: Int, end: Int, type: KotlinType): IrCall {
-        val descriptor = deserializeDescriptor(proto.getDescriptor()) as CallableDescriptor
+        val descriptor = deserializeDescriptor(proto.getDescriptor()) as FunctionDescriptor

        val superDescriptor = if (proto.hasSuper()) {
            deserializeDescriptor(proto.getSuper()) as ClassDescriptor
@@ -697,7 +703,7 @@ internal class IrDeserializer(val context: Context,
                // TODO: implement the last three args here.
                IrCallImpl(start, end, type, descriptor, typeArgs , null, superDescriptor)
            KonanIr.IrCall.Primitive.NULLARY ->
-                IrNullaryPrimitiveImpl(start, end, null, descriptor)
+                IrNullaryPrimitiveImpl(start, end, null, createFunctionSymbol(descriptor))
            KonanIr.IrCall.Primitive.UNARY ->
                IrUnaryPrimitiveImpl(start, end, null, descriptor)
            KonanIr.IrCall.Primitive.BINARY ->
@@ -713,7 +719,10 @@ internal class IrDeserializer(val context: Context,

        val descriptor = deserializeDescriptor(proto.getDescriptor()) as CallableDescriptor
        val typeMap = deserializeTypeMap(descriptor, proto.typeMap)
-        val callable = IrCallableReferenceImpl(start, end, type, descriptor, typeMap, null)
+        val callable = when (descriptor) {
+            is FunctionDescriptor -> IrFunctionReferenceImpl(start, end, type, descriptor, typeMap, null)
+            else -> TODO()
+        }
        return callable
    }

@@ -761,7 +770,7 @@ internal class IrDeserializer(val context: Context,

    fun deserializeReturn(proto: KonanIr.IrReturn, start: Int, end: Int, type: KotlinType): IrReturn {
        val descriptor = 
-            deserializeDescriptor(proto.getReturnTarget()) as CallableDescriptor
+            deserializeDescriptor(proto.getReturnTarget()) as FunctionDescriptor
        val value = deserializeExpression(proto.getValue())
        return IrReturnImpl(start, end, type, descriptor, value)
    }
@@ -769,9 +778,7 @@ internal class IrDeserializer(val context: Context,
    fun deserializeSetVariable(proto: KonanIr.IrSetVariable, start: Int, end: Int, type: KotlinType): IrSetVariable {
        val descriptor = deserializeDescriptor(proto.getDescriptor()) as VariableDescriptor
        val value = deserializeExpression(proto.getValue())
-        val setVar = IrSetVariableImpl(start, end, descriptor, null)
-        setVar.value = value
-        return setVar
+        return IrSetVariableImpl(start, end, descriptor, value, null)
    }

    fun deserializeStringConcat(proto: KonanIr.IrStringConcat, start: Int, end: Int, type: KotlinType): IrStringConcatenation {
@@ -972,6 +979,9 @@ internal class IrDeserializer(val context: Context,
        }

        val clazz = IrClassImpl(start, end, origin, descriptor, members)
+
+        clazz.createParameterDeclarations()
+
        return clazz

    }
@@ -983,6 +993,8 @@ internal class IrDeserializer(val context: Context,
        val function = IrFunctionImpl(start, end, origin, 
            descriptor, body as IrBody)

+        function.createParameterDeclarations()
+
        proto.defaultArgumentList.forEach {
            val expr = deserializeExpression(it.value)

@@ -1024,7 +1036,7 @@ internal class IrDeserializer(val context: Context,
        val origin = DEFINED // TODO: retore the real origins
        val declarator = proto.getDeclarator()

-        val declaration = when {
+        val declaration: IrDeclaration = when {
            declarator.hasIrClass()
                -> deserializeIrClass(declarator.irClass,
                    descriptor as ClassDescriptor, start, end, origin)
@@ -16,10 +16,8 @@

 package org.jetbrains.kotlin.ir.builders

-import org.jetbrains.kotlin.descriptors.CallableDescriptor
-import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
-import org.jetbrains.kotlin.descriptors.ValueDescriptor
-import org.jetbrains.kotlin.descriptors.VariableDescriptor
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.ir.expressions.IrCall
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrLoop
 import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
@@ -52,11 +50,34 @@ fun IrBuilderWithScope.irContinue(loop: IrLoop) =

 fun IrBuilderWithScope.irTrue() = IrConstImpl.boolean(startOffset, endOffset, context.builtIns.booleanType, true)

+@Deprecated("Creates unbound symbol")
 fun IrBuilderWithScope.irGet(value: ValueDescriptor) =
        IrGetValueImpl(startOffset, endOffset, value)

+@Deprecated("Creates unbound symbol")
+fun IrBuilderWithScope.irGet(receiver: IrExpression?, property: PropertyDescriptor): IrCall =
+        IrCallImpl(startOffset, endOffset, property.getter!!).apply {
+            dispatchReceiver = receiver
+        }
+
+@Deprecated("Creates unbound symbol")
+fun IrBuilderWithScope.irThis() =
+        scope.classOwner().let { classOwner ->
+            IrGetValueImpl(startOffset, endOffset, classOwner.thisAsReceiverParameter)
+        }
+
+@Deprecated("Creates unbound symbol")
+fun IrBuilderWithScope.irSetVar(variable: VariableDescriptor, value: IrExpression) =
+        IrSetVariableImpl(startOffset, endOffset, variable, value, IrStatementOrigin.EQ)
+
+@Deprecated("Creates unbound symbol")
+fun IrBuilderWithScope.irCall(descriptor: FunctionDescriptor): IrCallImpl {
+    return IrCallImpl(this.startOffset, this.endOffset, descriptor)
+}
+
+@Deprecated("Creates unbound symbol")
 fun IrBuilderWithScope.irCall(
-        callee: CallableDescriptor,
+        callee: FunctionDescriptor,
        typeArguments: Map<TypeParameterDescriptor, KotlinType>
 ): IrCallImpl {
    val substitutionContext = typeArguments.map { (typeParameter, typeArgument) ->
@@ -17,10 +17,19 @@
 package org.jetbrains.kotlin.ir.util

 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithSource
 import org.jetbrains.kotlin.descriptors.ParameterDescriptor
 import org.jetbrains.kotlin.ir.IrElement
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
 import org.jetbrains.kotlin.ir.declarations.IrFile
+import org.jetbrains.kotlin.ir.declarations.IrFunction
+import org.jetbrains.kotlin.ir.declarations.impl.IrTypeParameterImpl
+import org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl
 import org.jetbrains.kotlin.ir.expressions.*
+import org.jetbrains.kotlin.psi.psiUtil.endOffset
+import org.jetbrains.kotlin.psi.psiUtil.startOffset
+import org.jetbrains.kotlin.resolve.source.PsiSourceElement

 /**
 * Binds the arguments explicitly represented in the IR to the parameters of the accessed function.
@@ -93,3 +102,51 @@ fun IrElement.getCompilerMessageLocation(containingFile: IrFile): CompilerMessag
            lineContent = null // TODO: retrieve the line content.
    )
 }
+
+fun IrFunction.createParameterDeclarations() {
+    fun ParameterDescriptor.irValueParameter() = IrValueParameterImpl(
+            innerStartOffset(this), innerEndOffset(this),
+            IrDeclarationOrigin.DEFINED,
+            this
+    )
+
+    dispatchReceiverParameter = descriptor.dispatchReceiverParameter?.irValueParameter()
+    extensionReceiverParameter = descriptor.extensionReceiverParameter?.irValueParameter()
+
+    assert(valueParameters.isEmpty())
+    descriptor.valueParameters.mapTo(valueParameters) { it.irValueParameter() }
+
+    assert(typeParameters.isEmpty())
+    descriptor.typeParameters.mapTo(typeParameters) {
+        IrTypeParameterImpl(
+                innerStartOffset(it), innerEndOffset(it),
+                IrDeclarationOrigin.DEFINED,
+                it
+        )
+    }
+}
+
+fun IrClass.createParameterDeclarations() {
+    descriptor.thisAsReceiverParameter.let {
+        thisReceiver = IrValueParameterImpl(
+                innerStartOffset(it), innerEndOffset(it),
+                IrDeclarationOrigin.INSTANCE_RECEIVER,
+                it
+        )
+    }
+
+    assert(typeParameters.isEmpty())
+    descriptor.declaredTypeParameters.mapTo(typeParameters) {
+        IrTypeParameterImpl(
+                innerStartOffset(it), innerEndOffset(it),
+                IrDeclarationOrigin.DEFINED,
+                it
+        )
+    }
+}
+
+private fun IrElement.innerStartOffset(descriptor: DeclarationDescriptorWithSource): Int =
+        (descriptor.source as? PsiSourceElement)?.psi?.startOffset ?: this.startOffset
+
+private fun IrElement.innerEndOffset(descriptor: DeclarationDescriptorWithSource): Int =
+        (descriptor.source as? PsiSourceElement)?.psi?.endOffset ?: this.endOffset
@@ -21,8 +21,8 @@ remoteRoot=konan_tests
 #kotlinCompilerModule=org.jetbrains.kotlin:kotlin-compiler:1.1-SNAPSHOT
 # Download artifacts of https://teamcity.jetbrains.com/viewType.html?buildTypeId=bt345
 testDataVersion=1053418:id
-#kotlinCompilerRepo=http://dl.bintray.com/jetbrains/kotlin-native-dependencies
+kotlinCompilerRepo=http://dl.bintray.com/jetbrains/kotlin-native-dependencies
 #kotlinCompilerRepo=http://oss.sonatype.org/content/repositories/snapshots
-kotlinCompilerRepo=http://dl.bintray.com/kotlin/kotlin-dev
-kotlinCompilerModule=org.jetbrains.kotlin:kotlin-compiler:1.1.3-dev-1810
+#kotlinCompilerRepo=http://dl.bintray.com/kotlin/kotlin-dev
+kotlinCompilerModule=org.jetbrains.kotlin:kotlin-compiler:1.1-20170505.123347-536
 konanVersion=0.2