IrTypes required to declare symbol

2018-05-17 17:12:26 +03:00
parent 609a6ca9bb
commit 6649ef2740
14 changed files with 121 additions and 79 deletions
@@ -241,7 +241,7 @@ class CallGenerator(statementGenerator: StatementGenerator) : StatementGenerator
        for (valueArgument in valueArgumentsInEvaluationOrder) {
            val valueParameter = valueArgumentsToValueParameters[valueArgument]!!
            val irArgument = call.getValueArgument(valueParameter) ?: continue
-            val irArgumentValue = scope.createTemporaryVariableInBlock(irArgument, irBlock, valueParameter.name.asString())
+            val irArgumentValue = scope.createTemporaryVariableInBlock(context, irArgument, irBlock, valueParameter.name.asString())
            irArgumentValues[valueParameter] = irArgumentValue
        }

@@ -62,7 +62,8 @@ class ClassGenerator(
            irClass.thisReceiver = context.symbolTable.declareValueParameter(
                startOffset, endOffset,
                IrDeclarationOrigin.INSTANCE_RECEIVER,
-                irClass.descriptor.thisAsReceiverParameter
+                irClass.descriptor.thisAsReceiverParameter,
+                irClass.descriptor.thisAsReceiverParameter.type.toIrType()
            )

            declarationGenerator.generateGlobalTypeParametersDeclarations(irClass, descriptor.declaredTypeParameters)
@@ -132,7 +133,7 @@ class ClassGenerator(
        val irDelegateField = context.symbolTable.declareField(
            ktDelegateExpression.startOffset, ktDelegateExpression.endOffset,
            IrDeclarationOrigin.DELEGATE,
-            delegateDescriptor,
+            delegateDescriptor, delegateDescriptor.type.toIrType(),
            createBodyGenerator(irClass.symbol).generateExpressionBody(ktDelegateExpression)
        )
        irClass.addMember(irDelegateField)
@@ -207,7 +208,8 @@ class ClassGenerator(
        context.symbolTable.declareSimpleFunctionWithOverrides(
            irDelegate.startOffset, irDelegate.endOffset,
            IrDeclarationOrigin.DELEGATED_MEMBER,
-            delegated
+            delegated,
+            delegated.returnType!!.toIrType()
        ).buildWithScope { irFunction ->
            FunctionGenerator(declarationGenerator).generateSyntheticFunctionParameterDeclarations(irFunction)
            irFunction.body = generateDelegateFunctionBody(irDelegate, delegated, overridden, irFunction)
@@ -53,7 +53,10 @@ class DataClassMembersGenerator(
    }

    private fun declareSimpleFunction(startOffset: Int, endOffset: Int, origin: IrDeclarationOrigin, function: FunctionDescriptor) =
-        context.symbolTable.declareSimpleFunctionWithOverrides(startOffset, endOffset, origin, function)
+        context.symbolTable.declareSimpleFunctionWithOverrides(
+            startOffset, endOffset, origin,
+            function, function.returnType!!.toIrType()
+        )

    private inner class MemberFunctionBuilder(
        val irClass: IrClass,
@@ -91,7 +91,8 @@ class DeclarationGenerator(override val context: GeneratorContext) : Generator {
                startOffset,
                endOffset,
                IrDeclarationOrigin.DEFINED,
-                typeParameterDescriptor
+                typeParameterDescriptor,
+                typeParameterDescriptor.upperBounds.map { it.toIrType() }
            )
        }
    }
@@ -105,7 +106,8 @@ class DeclarationGenerator(override val context: GeneratorContext) : Generator {
                startOffset,
                endOffset,
                IrDeclarationOrigin.DEFINED,
-                typeParameterDescriptor
+                typeParameterDescriptor,
+                typeParameterDescriptor.upperBounds.map { it.toIrType() }
            )
        }
    }
@@ -162,17 +164,20 @@ class DeclarationGenerator(override val context: GeneratorContext) : Generator {
    }

    private fun generateFakeOverrideProperty(propertyDescriptor: PropertyDescriptor, ktElement: KtElement): IrProperty {
+        val startOffset = ktElement.startOffset
+        val endOffset = ktElement.endOffset
+
        val backingField =
            if (propertyDescriptor.getter == null)
                context.symbolTable.declareField(
-                    ktElement.startOffsetOrUndefined, ktElement.endOffsetOrUndefined, IrDeclarationOrigin.FAKE_OVERRIDE,
-                    propertyDescriptor
+                    startOffset, endOffset, IrDeclarationOrigin.FAKE_OVERRIDE,
+                    propertyDescriptor, propertyDescriptor.type.toIrType()
                )
            else
                null

        return IrPropertyImpl(
-            ktElement.startOffsetOrUndefined, ktElement.endOffsetOrUndefined,
+            startOffset, endOffset,
            IrDeclarationOrigin.FAKE_OVERRIDE,
            false,
            propertyDescriptor,
@@ -100,7 +100,7 @@ class DelegatedPropertyGenerator(declarationGenerator: DeclarationGenerator) : D
        context.symbolTable.declareSimpleFunctionWithOverrides(
            ktDelegate.startOffset, ktDelegate.endOffset,
            IrDeclarationOrigin.DELEGATED_PROPERTY_ACCESSOR,
-            accessorDescriptor
+            accessorDescriptor, accessorDescriptor.returnType!!.toIrType()
        ).buildWithScope { irAccessor ->
            FunctionGenerator(declarationGenerator).generateFunctionParameterDeclarations(irAccessor, ktProperty, null)
            irAccessor.body = generateBody(irAccessor)
@@ -127,7 +127,7 @@ class DelegatedPropertyGenerator(declarationGenerator: DeclarationGenerator) : D

        return context.symbolTable.declareField(
            ktDelegate.startOffset, ktDelegate.endOffset, IrDeclarationOrigin.DELEGATE,
-            delegateDescriptor
+            delegateDescriptor, delegateDescriptor.type.toIrType()
        ).also { irDelegate ->
            irDelegate.initializer = generateInitializerBodyForPropertyDelegate(
                propertyDescriptor, kPropertyType, ktDelegate,
@@ -282,7 +282,7 @@ class DelegatedPropertyGenerator(declarationGenerator: DeclarationGenerator) : D

        return context.symbolTable.declareVariable(
            ktDelegate.startOffset, ktDelegate.endOffset, IrDeclarationOrigin.DELEGATE,
-            delegateDescriptor
+            delegateDescriptor, delegateDescriptor.type.toIrType()
        ).also { irVariable ->
            irVariable.initializer = generateInitializerForLocalDelegatedPropertyDelegate(
                variableDescriptor, kPropertyType, ktDelegate,
@@ -338,7 +338,7 @@ class DelegatedPropertyGenerator(declarationGenerator: DeclarationGenerator) : D
        context.symbolTable.declareSimpleFunctionWithOverrides(
            ktDelegate.startOffset, ktDelegate.endOffset,
            IrDeclarationOrigin.DELEGATED_PROPERTY_ACCESSOR,
-            getterDescriptor
+            getterDescriptor, getterDescriptor.returnType!!.toIrType()
        ).buildWithScope { irAccessor ->
            FunctionGenerator(declarationGenerator).generateFunctionParameterDeclarations(irAccessor, ktDelegate, null)
            irAccessor.body = generateBody(irAccessor)
@@ -42,7 +42,7 @@ class EnumClassMembersGenerator(declarationGenerator: DeclarationGenerator) : De
            context.symbolTable.declareSimpleFunctionWithOverrides(
                irClass.startOffset, irClass.endOffset,
                IrDeclarationOrigin.ENUM_CLASS_SPECIAL_MEMBER,
-                valuesFunction
+                valuesFunction, valuesFunction.returnType!!.toIrType()
            ).also { irFunction ->
                FunctionGenerator(declarationGenerator).generateFunctionParameterDeclarations(irFunction, null, null)
                irFunction.body = IrSyntheticBodyImpl(irClass.startOffset, irClass.endOffset, IrSyntheticBodyKind.ENUM_VALUES)
@@ -61,7 +61,7 @@ class EnumClassMembersGenerator(declarationGenerator: DeclarationGenerator) : De
            context.symbolTable.declareSimpleFunctionWithOverrides(
                UNDEFINED_OFFSET, UNDEFINED_OFFSET,
                IrDeclarationOrigin.ENUM_CLASS_SPECIAL_MEMBER,
-                valueOfFunction
+                valueOfFunction, valueOfFunction.returnType!!.toIrType()
            ).also { irFunction ->
                FunctionGenerator(declarationGenerator).generateFunctionParameterDeclarations(irFunction, null, null)
                irFunction.body = IrSyntheticBodyImpl(irClass.startOffset, irClass.endOffset, IrSyntheticBodyKind.ENUM_VALUEOF)
@@ -58,11 +58,7 @@ class FunctionGenerator(declarationGenerator: DeclarationGenerator) : Declaratio
        }

    fun generateFakeOverrideFunction(functionDescriptor: FunctionDescriptor, ktElement: KtElement): IrSimpleFunction =
-        context.symbolTable.declareSimpleFunctionWithOverrides(
-            ktElement.startOffsetOrUndefined, ktElement.endOffsetOrUndefined,
-            IrDeclarationOrigin.FAKE_OVERRIDE,
-            functionDescriptor
-        ).buildWithScope { irFunction ->
+        declareSimpleFunctionInner(functionDescriptor, ktElement, IrDeclarationOrigin.FAKE_OVERRIDE).buildWithScope { irFunction ->
            generateFunctionParameterDeclarations(irFunction, ktElement, null)
        }

@@ -73,13 +69,21 @@ class FunctionGenerator(declarationGenerator: DeclarationGenerator) : Declaratio
        descriptor: FunctionDescriptor,
        generateBody: BodyGenerator.() -> IrBody?
    ): IrSimpleFunction =
-        context.symbolTable.declareSimpleFunctionWithOverrides(
-            ktFunction.startOffset, ktFunction.endOffset, origin, descriptor
-        ).buildWithScope { irFunction ->
+        declareSimpleFunctionInner(descriptor, ktFunction, origin).buildWithScope { irFunction ->
            generateFunctionParameterDeclarations(irFunction, ktFunction, ktReceiver)
            irFunction.body = createBodyGenerator(irFunction.symbol).generateBody()
        }

+    private fun declareSimpleFunctionInner(
+        descriptor: FunctionDescriptor,
+        ktElement: KtElement,
+        origin: IrDeclarationOrigin
+    ): IrSimpleFunction =
+        context.symbolTable.declareSimpleFunctionWithOverrides(
+            ktElement.startOffset, ktElement.endOffset, origin,
+            descriptor, descriptor.returnType!!.toIrType()
+        )
+
    fun generateFunctionParameterDeclarations(
        irFunction: IrFunction,
        ktParameterOwner: KtElement?,
@@ -94,11 +98,10 @@ class FunctionGenerator(declarationGenerator: DeclarationGenerator) : Declaratio
        ktProperty: KtProperty,
        ktAccessor: KtPropertyAccessor?
    ): IrSimpleFunction =
-        context.symbolTable.declareSimpleFunctionWithOverrides(
-            ktAccessor?.startOffset ?: ktProperty.startOffset,
-            ktAccessor?.endOffset ?: ktProperty.endOffset,
-            if (ktAccessor != null) IrDeclarationOrigin.DEFINED else IrDeclarationOrigin.DEFAULT_PROPERTY_ACCESSOR,
-            descriptor
+        declareSimpleFunctionInner(
+            descriptor,
+            ktAccessor ?: ktProperty,
+            if (ktAccessor != null) IrDeclarationOrigin.DEFINED else IrDeclarationOrigin.DEFAULT_PROPERTY_ACCESSOR
        ).buildWithScope { irAccessor ->
            declarationGenerator.generateScopedTypeParameterDeclarations(irAccessor, descriptor.correspondingProperty.typeParameters)
            generateFunctionParameterDeclarations(irAccessor, ktAccessor ?: ktProperty, ktProperty.receiverTypeReference)
@@ -114,12 +117,7 @@ class FunctionGenerator(declarationGenerator: DeclarationGenerator) : Declaratio
        descriptor: PropertyAccessorDescriptor,
        ktParameter: KtParameter
    ): IrSimpleFunction =
-        context.symbolTable.declareSimpleFunctionWithOverrides(
-            ktParameter.startOffsetOrUndefined,
-            ktParameter.endOffsetOrUndefined,
-            IrDeclarationOrigin.DEFAULT_PROPERTY_ACCESSOR,
-            descriptor
-        ).buildWithScope { irAccessor ->
+        declareSimpleFunctionInner(descriptor, ktParameter, IrDeclarationOrigin.DEFAULT_PROPERTY_ACCESSOR).buildWithScope { irAccessor ->
            declarationGenerator.generateScopedTypeParameterDeclarations(irAccessor, descriptor.typeParameters)
            FunctionGenerator(declarationGenerator).generateSyntheticFunctionParameterDeclarations(irAccessor)
            irAccessor.body = generateDefaultAccessorBody(ktParameter, descriptor, irAccessor)
@@ -237,7 +235,8 @@ class FunctionGenerator(declarationGenerator: DeclarationGenerator) : Declaratio
        generateBody: BodyGenerator.() -> IrBody?
    ): IrConstructor =
        context.symbolTable.declareConstructor(
-            ktConstructorElement.startOffset, ktConstructorElement.endOffset, IrDeclarationOrigin.DEFINED, constructorDescriptor
+            ktConstructorElement.startOffset, ktConstructorElement.endOffset, IrDeclarationOrigin.DEFINED,
+            constructorDescriptor, constructorDescriptor.returnType.toIrType()
        ).buildWithScope { irConstructor ->
            generateValueParameterDeclarations(irConstructor, ktParametersElement, null)
            irConstructor.body = createBodyGenerator(irConstructor.symbol).generateBody()
@@ -277,12 +276,7 @@ class FunctionGenerator(declarationGenerator: DeclarationGenerator) : Declaratio
        bodyGenerator: BodyGenerator,
        withDefaultValues: Boolean
    ): IrValueParameter =
-        context.symbolTable.declareValueParameter(
-            ktParameter.startOffsetOrUndefined,
-            ktParameter.endOffsetOrUndefined,
-            IrDeclarationOrigin.DEFINED,
-            valueParameterDescriptor
-        ).also {
+        declareParameter(valueParameterDescriptor, ktParameter).also {
            if (withDefaultValues) {
                it.defaultValue = ktParameter?.defaultValue?.let {
                    bodyGenerator.generateExpressionBody(it)
@@ -294,11 +288,12 @@ class FunctionGenerator(declarationGenerator: DeclarationGenerator) : Declaratio
        receiverParameterDescriptor: ReceiverParameterDescriptor,
        ktElement: KtElement?
    ): IrValueParameter =
-        context.symbolTable.declareValueParameter(
-            ktElement.startOffsetOrUndefined,
-            ktElement.endOffsetOrUndefined,
-            IrDeclarationOrigin.DEFINED,
-            receiverParameterDescriptor
-        )
+        declareParameter(receiverParameterDescriptor, ktElement)

+    private fun declareParameter(descriptor: ParameterDescriptor, ktElement: KtElement?) =
+        context.symbolTable.declareValueParameter(
+            ktElement.startOffsetOrUndefined, ktElement.endOffsetOrUndefined,
+            IrDeclarationOrigin.DEFINED,
+            descriptor, descriptor.type.toIrType()
+        )
 }
@@ -182,14 +182,16 @@ class LoopExpressionGenerator(statementGenerator: StatementGenerator) : Statemen
        nextCall.setExplicitReceiverValue(iteratorValue)
        val irNextCall = callGenerator.generateCall(ktLoopRange, nextCall, IrStatementOrigin.FOR_LOOP_NEXT)
        val irLoopParameter =
-            if (ktLoopParameter != null && ktLoopDestructuringDeclaration == null)
+            if (ktLoopParameter != null && ktLoopDestructuringDeclaration == null) {
+                val loopParameter = getOrFail(BindingContext.VALUE_PARAMETER, ktLoopParameter)
                context.symbolTable.declareVariable(
                    ktLoopParameter.startOffset, ktLoopParameter.endOffset, IrDeclarationOrigin.FOR_LOOP_VARIABLE,
-                    getOrFail(BindingContext.VALUE_PARAMETER, ktLoopParameter),
+                    loopParameter, loopParameter.type.toIrType(),
                    irNextCall
                )
-            else
+            } else {
                scope.createTemporaryVariable(irNextCall, "loop_parameter", origin = IrDeclarationOrigin.FOR_LOOP_IMPLICIT_VARIABLE)
+            }
        irInnerBody.statements.add(irLoopParameter)

        if (ktLoopDestructuringDeclaration != null) {
@@ -85,7 +85,7 @@ class PropertyGenerator(declarationGenerator: DeclarationGenerator) : Declaratio
        context.symbolTable.declareField(
            ktPropertyElement.startOffset, ktPropertyElement.endOffset,
            IrDeclarationOrigin.PROPERTY_BACKING_FIELD,
-            propertyDescriptor
+            propertyDescriptor, propertyDescriptor.type.toIrType()
        ).also {
            it.initializer = generateInitializer(it)
        }
@@ -99,7 +99,9 @@ class StatementGenerator(

        return context.symbolTable.declareVariable(
            property.startOffset, property.endOffset, IrDeclarationOrigin.DEFINED,
-            variableDescriptor, property.initializer?.genExpr()
+            variableDescriptor,
+            variableDescriptor.type.toIrType(),
+            property.initializer?.genExpr()
        )
    }

@@ -118,7 +120,7 @@ class StatementGenerator(
            context.irBuiltIns.unitType, IrStatementOrigin.DESTRUCTURING_DECLARATION
        )
        val ktInitializer = multiDeclaration.initializer!!
-        val containerValue = scope.createTemporaryVariableInBlock(ktInitializer.genExpr(), irBlock, "container")
+        val containerValue = scope.createTemporaryVariableInBlock(context, ktInitializer.genExpr(), irBlock, "container")

        declareComponentVariablesInBlock(multiDeclaration, irBlock, containerValue)

@@ -148,7 +150,7 @@ class StatementGenerator(
            )
            val irComponentVar = context.symbolTable.declareVariable(
                ktEntry.startOffset, ktEntry.endOffset, IrDeclarationOrigin.DEFINED,
-                componentVariable, irComponentCall
+                componentVariable, componentVariable.type.toIrType(), irComponentCall
            )
            irBlock.statements.add(irComponentVar)
        }
@@ -42,7 +42,7 @@ class TryCatchExpressionGenerator(statementGenerator: StatementGenerator) : Stat
                context.symbolTable.declareVariable(
                    ktCatchParameter.startOffset, ktCatchParameter.endOffset,
                    IrDeclarationOrigin.CATCH_PARAMETER,
-                    catchParameterDescriptor
+                    catchParameterDescriptor, catchParameterDescriptor.type.toIrType()
                )
            ).apply {
                result = ktCatchBody.genExpr()
@@ -70,7 +70,7 @@ class DeclarationStubGenerator(
            val getterDescriptor = descriptor.getter
            if (getterDescriptor == null) {
                irProperty.backingField =
-                        symbolTable.declareField(UNDEFINED_OFFSET, UNDEFINED_OFFSET, origin, descriptor)
+                        symbolTable.declareField(UNDEFINED_OFFSET, UNDEFINED_OFFSET, origin, descriptor, descriptor.type.toIrType())
            } else {
                irProperty.getter = generateFunctionStub(getterDescriptor)
            }
@@ -86,14 +86,17 @@ class DeclarationStubGenerator(
            } else {
                origin
            },
-            descriptor.original
+            descriptor.original,
+            descriptor.returnType!!.toIrType()
        ).also { irFunction ->
            generateTypeParameterStubs(descriptor.propertyIfAccessor.typeParameters, irFunction)
            generateValueParametersStubs(irFunction)
        }

    private fun generateConstructorStub(descriptor: ClassConstructorDescriptor): IrConstructor =
-        symbolTable.declareConstructor(UNDEFINED_OFFSET, UNDEFINED_OFFSET, origin, descriptor.original).also { irConstructor ->
+        symbolTable.declareConstructor(
+            UNDEFINED_OFFSET, UNDEFINED_OFFSET, origin, descriptor.original, descriptor.returnType.toIrType()
+        ).also { irConstructor ->
            generateValueParametersStubs(irConstructor)
        }

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 import org.jetbrains.kotlin.ir.symbols.*
 import org.jetbrains.kotlin.ir.symbols.impl.*
+import org.jetbrains.kotlin.ir.types.IrType

 class SymbolTable {
    private abstract class SymbolTableBase<D : DeclarationDescriptor, B : IrSymbolOwner, S : IrBindableSymbol<D, B>> {
@@ -189,12 +190,13 @@ class SymbolTable {
        startOffset: Int,
        endOffset: Int,
        origin: IrDeclarationOrigin,
-        descriptor: ClassConstructorDescriptor
+        descriptor: ClassConstructorDescriptor,
+        returnType: IrType
    ): IrConstructor =
        constructorSymbolTable.declare(
            descriptor,
            { IrConstructorSymbolImpl(descriptor) },
-            { IrConstructorImpl(startOffset, endOffset, origin, it) }
+            { IrConstructorImpl(startOffset, endOffset, origin, it, returnType) }
        )

    fun referenceConstructor(descriptor: ClassConstructorDescriptor) =
@@ -214,18 +216,30 @@ class SymbolTable {

    val unboundEnumEntries: Set<IrEnumEntrySymbol> get() = enumEntrySymbolTable.unboundSymbols

-    fun declareField(startOffset: Int, endOffset: Int, origin: IrDeclarationOrigin, descriptor: PropertyDescriptor): IrField =
+    fun declareField(
+        startOffset: Int,
+        endOffset: Int,
+        origin: IrDeclarationOrigin,
+        descriptor: PropertyDescriptor,
+        type: IrType
+    ): IrField =
        fieldSymbolTable.declare(
            descriptor,
            { IrFieldSymbolImpl(descriptor) },
-            { IrFieldImpl(startOffset, endOffset, origin, it) }
+            { IrFieldImpl(startOffset, endOffset, origin, it, type) }
        )

    fun declareField(
-        startOffset: Int, endOffset: Int, origin: IrDeclarationOrigin, descriptor: PropertyDescriptor,
+        startOffset: Int,
+        endOffset: Int,
+        origin: IrDeclarationOrigin,
+        descriptor: PropertyDescriptor,
+        type: IrType,
        irInitializer: IrExpressionBody?
    ): IrField =
-        declareField(startOffset, endOffset, origin, descriptor).apply { initializer = irInitializer }
+        declareField(startOffset, endOffset, origin, descriptor, type).apply {
+            initializer = irInitializer
+        }

    fun referenceField(descriptor: PropertyDescriptor) =
        fieldSymbolTable.referenced(descriptor) { IrFieldSymbolImpl(descriptor) }
@@ -236,12 +250,13 @@ class SymbolTable {
        startOffset: Int,
        endOffset: Int,
        origin: IrDeclarationOrigin,
-        descriptor: FunctionDescriptor
+        descriptor: FunctionDescriptor,
+        returnType: IrType
    ): IrSimpleFunction =
        simpleFunctionSymbolTable.declare(
            descriptor,
            { IrSimpleFunctionSymbolImpl(descriptor) },
-            { IrFunctionImpl(startOffset, endOffset, origin, it) }
+            { IrFunctionImpl(startOffset, endOffset, origin, it, returnType) }
        )

    fun referenceSimpleFunction(descriptor: FunctionDescriptor) =
@@ -256,24 +271,26 @@ class SymbolTable {
        startOffset: Int,
        endOffset: Int,
        origin: IrDeclarationOrigin,
-        descriptor: TypeParameterDescriptor
+        descriptor: TypeParameterDescriptor,
+        upperBounds: List<IrType>
    ): IrTypeParameter =
        globalTypeParameterSymbolTable.declare(
            descriptor,
            { IrTypeParameterSymbolImpl(descriptor) },
-            { IrTypeParameterImpl(startOffset, endOffset, origin, it) }
+            { IrTypeParameterImpl(startOffset, endOffset, origin, it, upperBounds) }
        )

    fun declareScopedTypeParameter(
        startOffset: Int,
        endOffset: Int,
        origin: IrDeclarationOrigin,
-        descriptor: TypeParameterDescriptor
+        descriptor: TypeParameterDescriptor,
+        upperBounds: List<IrType>
    ): IrTypeParameter =
        scopedTypeParameterSymbolTable.declare(
            descriptor,
            { IrTypeParameterSymbolImpl(descriptor) },
-            { IrTypeParameterImpl(startOffset, endOffset, origin, it) }
+            { IrTypeParameterImpl(startOffset, endOffset, origin, it, upperBounds) }
        )

    val unboundTypeParameters: Set<IrTypeParameterSymbol> get() = globalTypeParameterSymbolTable.unboundSymbols
@@ -282,12 +299,14 @@ class SymbolTable {
        startOffset: Int,
        endOffset: Int,
        origin: IrDeclarationOrigin,
-        descriptor: ParameterDescriptor
+        descriptor: ParameterDescriptor,
+        type: IrType,
+        varargElementType: IrType? = null
    ): IrValueParameter =
        valueParameterSymbolTable.declareLocal(
            descriptor,
            { IrValueParameterSymbolImpl(descriptor) },
-            { IrValueParameterImpl(startOffset, endOffset, origin, it) }
+            { IrValueParameterImpl(startOffset, endOffset, origin, it, type, varargElementType) }
        )

    fun introduceValueParameter(irValueParameter: IrValueParameter) {
@@ -307,19 +326,28 @@ class SymbolTable {

    val unboundValueParameters: Set<IrValueParameterSymbol> get() = valueParameterSymbolTable.unboundSymbols

-    fun declareVariable(startOffset: Int, endOffset: Int, origin: IrDeclarationOrigin, descriptor: VariableDescriptor): IrVariable =
+    fun declareVariable(
+        startOffset: Int,
+        endOffset: Int,
+        origin: IrDeclarationOrigin,
+        descriptor: VariableDescriptor,
+        type: IrType
+    ): IrVariable =
        variableSymbolTable.declareLocal(
            descriptor,
            { IrVariableSymbolImpl(descriptor) },
-            { IrVariableImpl(startOffset, endOffset, origin, it) }
+            { IrVariableImpl(startOffset, endOffset, origin, it, type) }
        )

    fun declareVariable(
-        startOffset: Int, endOffset: Int, origin: IrDeclarationOrigin,
+        startOffset: Int,
+        endOffset: Int,
+        origin: IrDeclarationOrigin,
        descriptor: VariableDescriptor,
+        type: IrType,
        irInitializerExpression: IrExpression?
    ): IrVariable =
-        declareVariable(startOffset, endOffset, origin, descriptor).apply {
+        declareVariable(startOffset, endOffset, origin, descriptor, type).apply {
            initializer = irInitializerExpression
        }

@@ -8,14 +8,16 @@ package org.jetbrains.kotlin.ir.util
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
 import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
+import org.jetbrains.kotlin.ir.types.IrType

 fun SymbolTable.declareSimpleFunctionWithOverrides(
    startOffset: Int,
    endOffset: Int,
    origin: IrDeclarationOrigin,
-    descriptor: FunctionDescriptor
+    descriptor: FunctionDescriptor,
+    returnType: IrType
 ) =
-    declareSimpleFunction(startOffset, endOffset, origin, descriptor).also { declaration ->
+    declareSimpleFunction(startOffset, endOffset, origin, descriptor, returnType).also { declaration ->
        generateOverriddenSymbols(declaration, this)
    }