IrTypes: use proper scope for type parameters in stub generation

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/transformations/InsertImplicitCasts.kt

@@ -50,13 +50,6 @@ class InsertImplicitCasts(context: GeneratorContext) : IrElementTransformerVoid(
     private val typeTranslator = TypeTranslator(context.moduleDescriptor, symbolTable)
     private fun KotlinType.toIrType() = typeTranslator.translateType(this)
 
-    private inline fun <T> runInTypeParameterScope(typeParametersContainer: IrTypeParametersContainer, fn: () -> T): T {
-        typeTranslator.enterScope(typeParametersContainer)
-        val result = fn()
-        typeTranslator.leaveScope()
-        return result
-    }
-
     override fun visitCallableReference(expression: IrCallableReference): IrExpression =
         expression.transformPostfix {
             transformReceiverArguments()
@@ -128,7 +121,7 @@ class InsertImplicitCasts(context: GeneratorContext) : IrElementTransformerVoid(
         }
 
     override fun visitFunction(declaration: IrFunction): IrStatement =
-        runInTypeParameterScope(declaration) {
+        typeTranslator.buildWithScope(declaration) {
             declaration.transformPostfix {
                 valueParameters.forEach {
                     it.defaultValue?.coerceInnerExpression(it.descriptor.type)
@@ -137,7 +130,7 @@ class InsertImplicitCasts(context: GeneratorContext) : IrElementTransformerVoid(
         }
 
     override fun visitClass(declaration: IrClass): IrStatement =
-        runInTypeParameterScope(declaration) {
+        typeTranslator.buildWithScope(declaration) {
             super.visitClass(declaration)
         }
 

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

@@ -86,10 +86,10 @@ class DeclarationStubGenerator(
         ).also { irFunction ->
             generateTypeParameterStubs(descriptor.propertyIfAccessor.typeParameters, irFunction)
 
-            // TODO make sure that type parameters have proper scopes
+            typeTranslator.buildWithScope(irFunction) {
-            irFunction.returnType = descriptor.returnType!!.toIrType()
+                irFunction.returnType = descriptor.returnType!!.toIrType()
-
+                generateValueParametersStubs(irFunction)
-            generateValueParametersStubs(irFunction)
+            }
         }
 
     private fun generateConstructorStub(descriptor: ClassConstructorDescriptor): IrConstructor =
@@ -98,7 +98,6 @@ class DeclarationStubGenerator(
         ).also { irConstructor ->
             // So far, constructors in Kotlin can't have type parameters of their own.
             irConstructor.returnType = descriptor.returnType.toIrType()
-
             generateValueParametersStubs(irConstructor)
         }
 
@@ -137,15 +136,17 @@ class DeclarationStubGenerator(
         symbolTable.declareClass(UNDEFINED_OFFSET, UNDEFINED_OFFSET, origin, descriptor).also { irClass ->
             generateTypeParameterStubs(descriptor.declaredTypeParameters, irClass)
 
-            // TODO get rid of code duplication, see ClassGenerator#generateClass
+            typeTranslator.buildWithScope(irClass) {
-            descriptor.typeConstructor.supertypes.mapNotNullTo(irClass.superTypes) {
+                // TODO get rid of code duplication, see ClassGenerator#generateClass
-                it.toIrType()
+                descriptor.typeConstructor.supertypes.mapNotNullTo(irClass.superTypes) {
-            }
+                    it.toIrType()
+                }
 
-            irClass.thisReceiver = descriptor.thisAsReceiverParameter.generateReceiverParameterStub()
+                irClass.thisReceiver = descriptor.thisAsReceiverParameter.generateReceiverParameterStub()
-            generateChildStubs(descriptor.constructors, irClass)
+                generateChildStubs(descriptor.constructors, irClass)
-            generateMemberStubs(descriptor.defaultType.memberScope, irClass)
+                generateMemberStubs(descriptor.defaultType.memberScope, irClass)
-            generateMemberStubs(descriptor.staticScope, irClass)
+                generateMemberStubs(descriptor.staticScope, irClass)
+            }
         }
 
     private fun generateEnumEntryStub(descriptor: ClassDescriptor): IrEnumEntry =
@@ -154,12 +155,12 @@ class DeclarationStubGenerator(
     private fun generateTypeParameterStubs(typeParameters: List<TypeParameterDescriptor>, container: IrTypeParametersContainer) {
         typeParameters.mapTo(container.typeParameters) { generateTypeParameterStub(it) }
 
-        typeTranslator.enterScope(container)
+        typeTranslator.buildWithScope(container) {
-        for (typeParameter in container.typeParameters) {
+            for (typeParameter in container.typeParameters) {
-            val descriptor = typeParameter.descriptor
+                val descriptor = typeParameter.descriptor
-            descriptor.upperBounds.mapTo(typeParameter.superTypes) { it.toIrType() }
+                descriptor.upperBounds.mapTo(typeParameter.superTypes) { it.toIrType() }
+            }
         }
-        typeTranslator.leaveScope()
     }
 
     private fun generateTypeParameterStub(descriptor: TypeParameterDescriptor): IrTypeParameter =

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

@@ -36,6 +36,13 @@ class TypeTranslator(
         typeParametersResolver.leaveTypeParameterScope()
     }
 
+    inline fun <T> buildWithScope(container: IrTypeParametersContainer, builder: () -> T): T {
+        enterScope(container)
+        val result = builder()
+        leaveScope()
+        return result
+    }
+
     private fun resolveTypeParameter(typeParameterDescriptor: TypeParameterDescriptor) =
         typeParametersResolver.resolveScopedTypeParameter(typeParameterDescriptor)
                 ?: symbolTable.referenceTypeParameter(typeParameterDescriptor)
@@ -101,4 +108,3 @@ class TypeTranslator(
                 translateType(it.type, it.projectionKind)
         }
 }
-