IrTypes required to declare symbol

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt

@@ -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
         }
 

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt

@@ -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)

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DataClassMembersGenerator.kt

@@ -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,

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DeclarationGenerator.kt

@@ -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,
+                    startOffset, endOffset, IrDeclarationOrigin.FAKE_OVERRIDE,
-                    propertyDescriptor
+                    propertyDescriptor, propertyDescriptor.type.toIrType()
                 )
             else
                 null
 
         return IrPropertyImpl(
-            ktElement.startOffsetOrUndefined, ktElement.endOffsetOrUndefined,
+            startOffset, endOffset,
             IrDeclarationOrigin.FAKE_OVERRIDE,
             false,
             propertyDescriptor,

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DelegatedPropertyGenerator.kt

@@ -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)

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/EnumClassMembersGenerator.kt

@@ -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)

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/FunctionGenerator.kt

@@ -58,11 +58,7 @@ class FunctionGenerator(declarationGenerator: DeclarationGenerator) : Declaratio
         }
 
     fun generateFakeOverrideFunction(functionDescriptor: FunctionDescriptor, ktElement: KtElement): IrSimpleFunction =
-        context.symbolTable.declareSimpleFunctionWithOverrides(
+        declareSimpleFunctionInner(functionDescriptor, ktElement, IrDeclarationOrigin.FAKE_OVERRIDE).buildWithScope { irFunction ->
-            ktElement.startOffsetOrUndefined, ktElement.endOffsetOrUndefined,
-            IrDeclarationOrigin.FAKE_OVERRIDE,
-            functionDescriptor
-        ).buildWithScope { irFunction ->
             generateFunctionParameterDeclarations(irFunction, ktElement, null)
         }
 
@@ -73,13 +69,21 @@ class FunctionGenerator(declarationGenerator: DeclarationGenerator) : Declaratio
         descriptor: FunctionDescriptor,
         generateBody: BodyGenerator.() -> IrBody?
     ): IrSimpleFunction =
-        context.symbolTable.declareSimpleFunctionWithOverrides(
+        declareSimpleFunctionInner(descriptor, ktFunction, origin).buildWithScope { irFunction ->
-            ktFunction.startOffset, ktFunction.endOffset, origin, descriptor
-        ).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(
+        declareSimpleFunctionInner(
-            ktAccessor?.startOffset ?: ktProperty.startOffset,
+            descriptor,
-            ktAccessor?.endOffset ?: ktProperty.endOffset,
+            ktAccessor ?: ktProperty,
-            if (ktAccessor != null) IrDeclarationOrigin.DEFINED else IrDeclarationOrigin.DEFAULT_PROPERTY_ACCESSOR,
+            if (ktAccessor != null) IrDeclarationOrigin.DEFINED else IrDeclarationOrigin.DEFAULT_PROPERTY_ACCESSOR
-            descriptor
         ).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(
+        declareSimpleFunctionInner(descriptor, ktParameter, IrDeclarationOrigin.DEFAULT_PROPERTY_ACCESSOR).buildWithScope { irAccessor ->
-            ktParameter.startOffsetOrUndefined,
-            ktParameter.endOffsetOrUndefined,
-            IrDeclarationOrigin.DEFAULT_PROPERTY_ACCESSOR,
-            descriptor
-        ).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(
+        declareParameter(valueParameterDescriptor, ktParameter).also {
-            ktParameter.startOffsetOrUndefined,
-            ktParameter.endOffsetOrUndefined,
-            IrDeclarationOrigin.DEFINED,
-            valueParameterDescriptor
-        ).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(
+        declareParameter(receiverParameterDescriptor, ktElement)
-            ktElement.startOffsetOrUndefined,
-            ktElement.endOffsetOrUndefined,
-            IrDeclarationOrigin.DEFINED,
-            receiverParameterDescriptor
-        )
 
+    private fun declareParameter(descriptor: ParameterDescriptor, ktElement: KtElement?) =
+        context.symbolTable.declareValueParameter(
+            ktElement.startOffsetOrUndefined, ktElement.endOffsetOrUndefined,
+            IrDeclarationOrigin.DEFINED,
+            descriptor, descriptor.type.toIrType()
+        )
 }

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LoopExpressionGenerator.kt

@@ -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) {

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/PropertyGenerator.kt

@@ -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)
         }

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StatementGenerator.kt

@@ -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)
         }

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/TryCatchExpressionGenerator.kt

@@ -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()

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt

@@ -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)
         }
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTable.kt

@@ -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
         }
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/overrides.kt

@@ -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)
     }