IR: use IrFactory in IR builders

2020-07-14 18:08:14 +02:00
parent 898dd20a9e
commit d1dc938a5d
58 changed files with 291 additions and 265 deletions
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.builders.Scope
-import org.jetbrains.kotlin.ir.builders.declarations.buildConstructor
+import org.jetbrains.kotlin.ir.builders.declarations.addConstructor
 import org.jetbrains.kotlin.ir.builders.declarations.buildFun
 import org.jetbrains.kotlin.ir.builders.declarations.buildReceiverParameter
 import org.jetbrains.kotlin.ir.builders.declarations.buildTypeParameter
@@ -51,18 +51,14 @@ fun IrClass.addSimpleDelegatingConstructor(
    isPrimary: Boolean = false,
    origin: IrDeclarationOrigin? = null
 ): IrConstructor =
-    buildConstructor {
+    addConstructor {
        val klass = this@addSimpleDelegatingConstructor
        this.startOffset = klass.startOffset
        this.endOffset = klass.endOffset
        this.origin = origin ?: klass.origin
        this.visibility = superConstructor.visibility
-        this.returnType = klass.defaultType
        this.isPrimary = isPrimary
    }.also { constructor ->
-        constructor.parent = this
-        declarations += constructor
-
        constructor.valueParameters = superConstructor.valueParameters.mapIndexed { index, parameter ->
            parameter.copyTo(constructor, index = index)
        }
@@ -477,7 +473,7 @@ fun IrClass.addFakeOverridesViaIncorrectHeuristic(implementedMembers: List<IrSim

    fun createFakeOverride(overriddenFunctions: List<IrSimpleFunction>) =
        overriddenFunctions.first().let { irFunction ->
-            buildFun {
+            irFunction.factory.buildFun {
                origin = IrDeclarationOrigin.FAKE_OVERRIDE
                name = irFunction.name
                visibility = Visibilities.PUBLIC
@@ -271,7 +271,7 @@ abstract class AbstractSuspendFunctionsLowering<C : CommonBackendContext>(val co
        private val unboundFunctionParameters = boundFunctionParameters?.let { functionParameters - it }

        private val coroutineClass: IrClass =
-            buildClass {
+            context.irFactory.buildClass {
                startOffset = irFunction.startOffset
                endOffset = irFunction.endOffset
                origin = DECLARATION_ORIGIN_COROUTINE_IMPL
@@ -366,7 +366,7 @@ abstract class AbstractSuspendFunctionsLowering<C : CommonBackendContext>(val co
        }

        fun buildConstructor(): IrConstructor =
-            buildConstructor {
+            context.irFactory.buildConstructor {
                startOffset = irFunction.startOffset
                endOffset = irFunction.endOffset
                origin = DECLARATION_ORIGIN_COROUTINE_IMPL
@@ -406,7 +406,7 @@ abstract class AbstractSuspendFunctionsLowering<C : CommonBackendContext>(val co
            }

        private fun buildFactoryConstructor(boundParams: List<IrValueParameter>): IrConstructor =
-            buildConstructor {
+            context.irFactory.buildConstructor {
                startOffset = irFunction.startOffset
                endOffset = irFunction.endOffset
                origin = DECLARATION_ORIGIN_COROUTINE_IMPL
@@ -444,7 +444,7 @@ abstract class AbstractSuspendFunctionsLowering<C : CommonBackendContext>(val co
            unboundArgs: List<IrValueParameter>,
            superFunctionSymbol: IrSimpleFunctionSymbol?,
            coroutineConstructor: IrConstructor
-        ): IrSimpleFunction = buildFun {
+        ): IrSimpleFunction = context.irFactory.buildFun {
            startOffset = irFunction.startOffset
            endOffset = irFunction.endOffset
            origin = DECLARATION_ORIGIN_COROUTINE_IMPL
@@ -500,7 +500,7 @@ abstract class AbstractSuspendFunctionsLowering<C : CommonBackendContext>(val co
            functionInvokeFunctionSymbol: IrSimpleFunctionSymbol,
            createFunction: IrFunction,
            stateMachineFunction: IrFunction
-        ): IrSimpleFunction = buildFun {
+        ): IrSimpleFunction = context.irFactory.buildFun {
            startOffset = irFunction.startOffset
            endOffset = irFunction.endOffset
            origin = DECLARATION_ORIGIN_COROUTINE_IMPL
@@ -550,7 +550,7 @@ abstract class AbstractSuspendFunctionsLowering<C : CommonBackendContext>(val co
            stateMachineFunction: IrSimpleFunction,
            coroutineClass: IrClass
        ): IrSimpleFunction {
-            val function = buildFun {
+            val function = context.irFactory.buildFun {
                startOffset = irFunction.startOffset
                endOffset = irFunction.endOffset
                origin = DECLARATION_ORIGIN_COROUTINE_IMPL
@@ -617,7 +617,7 @@ abstract class AbstractSuspendFunctionsLowering<C : CommonBackendContext>(val co

    fun IrClass.addField(name: Name, type: IrType, isMutable: Boolean): IrField {
        val klass = this
-        return buildField {
+        return factory.buildField {
            this.startOffset = klass.startOffset
            this.endOffset = klass.endOffset
            this.origin = DECLARATION_ORIGIN_COROUTINE_IMPL
@@ -527,7 +527,7 @@ private fun IrFunction.generateDefaultsFunctionImpl(
 ): IrFunction {
    val newFunction = when (this) {
        is IrConstructor ->
-            buildConstructor {
+            factory.buildConstructor {
                updateFrom(this@generateDefaultsFunctionImpl)
                origin = newOrigin
                isExternal = false
@@ -536,7 +536,7 @@ private fun IrFunction.generateDefaultsFunctionImpl(
                visibility = newVisibility
            }
        is IrSimpleFunction ->
-            buildFun(descriptor) {
+            factory.buildFun(descriptor) {
                updateFrom(this@generateDefaultsFunctionImpl)
                name = Name.identifier("${this@generateDefaultsFunctionImpl.name}\$default")
                origin = newOrigin
@@ -201,7 +201,7 @@ class LateinitUsageLowering(val backendContext: CommonBackendContext) : BodyLowe
 private fun CommonBackendContext.buildOrGetNullableField(originalField: IrField): IrField {
    if (originalField.type.isMarkedNullable()) return originalField
    return mapping.lateInitFieldToNullableField.getOrPut(originalField) {
-        buildField {
+        irFactory.buildField {
            updateFrom(originalField)
            type = originalField.type.makeNullable()
            name = originalField.name
@@ -213,4 +213,4 @@ private fun CommonBackendContext.buildOrGetNullableField(originalField: IrField)
    }
 }

-private val IrProperty.isRealLateinit get() = isLateinit && !isFakeOverride
+private val IrProperty.isRealLateinit get() = isLateinit && !isFakeOverride
@@ -595,7 +595,7 @@ class LocalDeclarationsLowering(
            // TODO: consider using fields to access the closure of enclosing class.
            val (capturedValues, capturedTypeParameters) = localFunctionContext.closure

-            val newDeclaration = buildFun(oldDeclaration.descriptor) {
+            val newDeclaration = context.irFactory.buildFun(oldDeclaration.descriptor) {
                updateFrom(oldDeclaration)
                name = newName
                visibility = Visibilities.PRIVATE
@@ -694,7 +694,7 @@ class LocalDeclarationsLowering(
            val localClassContext = localClasses[oldDeclaration.parent]!!
            val capturedValues = localClassContext.closure.capturedValues

-            val newDeclaration = buildConstructor(oldDeclaration.descriptor) {
+            val newDeclaration = context.irFactory.buildConstructor(oldDeclaration.descriptor) {
                updateFrom(oldDeclaration)
                visibility = visibilityPolicy.forConstructor(oldDeclaration, constructorContext.inInlineFunctionScope)
                returnType = oldDeclaration.returnType
@@ -730,7 +730,7 @@ class LocalDeclarationsLowering(
            fieldType: IrType,
            isCrossinline: Boolean
        ): IrField =
-            buildField {
+            context.irFactory.buildField {
                this.startOffset = startOffset
                this.endOffset = endOffset
                this.origin =
@@ -21,7 +21,10 @@ import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.builders.*
 import org.jetbrains.kotlin.ir.builders.declarations.*
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.expressions.*
+import org.jetbrains.kotlin.ir.expressions.IrExpression
+import org.jetbrains.kotlin.ir.expressions.IrGetValue
+import org.jetbrains.kotlin.ir.expressions.IrTypeOperator
+import org.jetbrains.kotlin.ir.expressions.IrTypeOperatorCall
 import org.jetbrains.kotlin.ir.expressions.impl.IrInstanceInitializerCallImpl
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.types.IrType
@@ -159,7 +162,7 @@ abstract class SingleAbstractMethodLowering(val context: CommonBackendContext) :
                context.ir.symbols.functionN(superMethod.valueParameters.size + extensionReceiversCount).owner
        val wrappedFunctionType = wrappedFunctionClass.defaultType

-        val subclass = buildClass {
+        val subclass = context.irFactory.buildClass {
            name = wrapperName
            origin = IrDeclarationOrigin.GENERATED_SAM_IMPLEMENTATION
            visibility = wrapperVisibility
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.backend.common.descriptors.synthesizedName
 import org.jetbrains.kotlin.backend.common.ir.copyTo
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.declarations.impl.*
+import org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl
 import org.jetbrains.kotlin.ir.descriptors.*
 import org.jetbrains.kotlin.ir.symbols.impl.*
 import org.jetbrains.kotlin.ir.types.IrType
@@ -20,9 +20,9 @@ import org.jetbrains.kotlin.serialization.deserialization.descriptors.Descriptor
 import org.jetbrains.kotlin.types.Variance

@PublishedApi
-internal fun IrClassBuilder.buildClass(): IrClass {
+internal fun IrFactory.buildClass(builder: IrClassBuilder): IrClass = with(builder) {
    val wrappedDescriptor = WrappedClassDescriptor()
-    return IrClassImpl(
+    createClass(
        startOffset, endOffset, origin,
        IrClassSymbolImpl(wrappedDescriptor),
        name, kind, visibility, modality,
@@ -32,15 +32,16 @@ internal fun IrClassBuilder.buildClass(): IrClass {
    }
 }

-inline fun buildClass(builder: IrClassBuilder.() -> Unit) =
+inline fun IrFactory.buildClass(builder: IrClassBuilder.() -> Unit) =
    IrClassBuilder().run {
        builder()
-        buildClass()
+        buildClass(this)
    }

-fun IrFieldBuilder.buildField(): IrField {
+@PublishedApi
+internal fun IrFactory.buildField(builder: IrFieldBuilder): IrField = with(builder) {
    val wrappedDescriptor = WrappedFieldDescriptor()
-    return IrFieldImpl(
+    createField(
        startOffset, endOffset, origin,
        IrFieldSymbolImpl(wrappedDescriptor),
        name, type, visibility, isFinal, isExternal, isStatic,
@@ -50,14 +51,14 @@ fun IrFieldBuilder.buildField(): IrField {
    }
 }

-inline fun buildField(builder: IrFieldBuilder.() -> Unit) =
+inline fun IrFactory.buildField(builder: IrFieldBuilder.() -> Unit) =
    IrFieldBuilder().run {
        builder()
-        buildField()
+        buildField(this)
    }

-inline fun IrDeclarationContainer.addField(builder: IrFieldBuilder.() -> Unit) =
-    buildField(builder).also { field ->
+inline fun IrClass.addField(builder: IrFieldBuilder.() -> Unit) =
+    factory.buildField(builder).also { field ->
        field.parent = this
        declarations.add(field)
    }
@@ -73,12 +74,15 @@ fun IrClass.addField(fieldName: String, fieldType: IrType, fieldVisibility: Visi
    addField(Name.identifier(fieldName), fieldType, fieldVisibility)

@PublishedApi
-internal fun IrPropertyBuilder.buildProperty(originalDescriptor: PropertyDescriptor? = null): IrProperty {
+internal fun IrFactory.buildProperty(
+    builder: IrPropertyBuilder,
+    originalDescriptor: PropertyDescriptor? = null
+): IrProperty = with(builder) {
    val wrappedDescriptor = when (originalDescriptor) {
        is DescriptorWithContainerSource -> WrappedPropertyDescriptorWithContainerSource(originalDescriptor.containerSource)
        else -> WrappedPropertyDescriptor()
    }
-    return IrPropertyImpl(
+    createProperty(
        startOffset, endOffset, origin,
        IrPropertySymbolImpl(wrappedDescriptor),
        name, visibility, modality,
@@ -88,14 +92,14 @@ internal fun IrPropertyBuilder.buildProperty(originalDescriptor: PropertyDescrip
    }
 }

-inline fun buildProperty(originalDescriptor: PropertyDescriptor? = null, builder: IrPropertyBuilder.() -> Unit) =
+inline fun IrFactory.buildProperty(originalDescriptor: PropertyDescriptor? = null, builder: IrPropertyBuilder.() -> Unit) =
    IrPropertyBuilder().run {
        builder()
-        buildProperty(originalDescriptor)
+        buildProperty(this, originalDescriptor)
    }

-inline fun IrDeclarationContainer.addProperty(originalDescriptor: PropertyDescriptor? = null, builder: IrPropertyBuilder.() -> Unit): IrProperty =
-    buildProperty(originalDescriptor, builder).also { property ->
+inline fun IrClass.addProperty(originalDescriptor: PropertyDescriptor? = null, builder: IrPropertyBuilder.() -> Unit): IrProperty =
+    factory.buildProperty(originalDescriptor, builder).also { property ->
        declarations.add(property)
        property.parent = this@addProperty
    }
@@ -104,25 +108,18 @@ inline fun IrProperty.addGetter(builder: IrFunctionBuilder.() -> Unit = {}): IrS
    IrFunctionBuilder().run {
        name = Name.special("<get-${this@addGetter.name}>")
        builder()
-        buildFunction().also { getter ->
+        factory.buildFunction(this).also { getter ->
            this@addGetter.getter = getter
            getter.correspondingPropertySymbol = this@addGetter.symbol
            getter.parent = this@addGetter.parent
        }
    }

-inline fun IrProperty.addSetter(builder: IrFunctionBuilder.() -> Unit = {}): IrSimpleFunction =
-    IrFunctionBuilder().run {
-        name = Name.special("<set-${this@addSetter.name}>")
-        builder()
-        buildFunction().also { setter ->
-            this@addSetter.setter = setter
-            setter.parent = this@addSetter.parent
-        }
-    }
-
@PublishedApi
-internal fun IrFunctionBuilder.buildFunction(originalDescriptor: FunctionDescriptor? = null): IrSimpleFunction {
+internal fun IrFactory.buildFunction(
+    builder: IrFunctionBuilder,
+    originalDescriptor: FunctionDescriptor? = null
+): IrSimpleFunction = with(builder) {
    // Inlining relies on descriptors for external declarations. When replacing a potentially external function (e.g. in an IrCall),
    // we have to ensure that we keep information from the original descriptor so as not to break inlining.
    val wrappedDescriptor = when (originalDescriptor) {
@@ -132,7 +129,7 @@ internal fun IrFunctionBuilder.buildFunction(originalDescriptor: FunctionDescrip
        null -> WrappedSimpleFunctionDescriptor()
        else -> WrappedSimpleFunctionDescriptor(originalDescriptor)
    }
-    return IrFunctionImpl(
+    createFunction(
        startOffset, endOffset, origin,
        IrSimpleFunctionSymbolImpl(wrappedDescriptor),
        name, visibility, modality, returnType,
@@ -143,11 +140,13 @@ internal fun IrFunctionBuilder.buildFunction(originalDescriptor: FunctionDescrip
 }

@PublishedApi
-internal fun IrFunctionBuilder.buildConstructor(originalDescriptor: ConstructorDescriptor?): IrConstructor {
+internal fun IrFactory.buildConstructor(
+    builder: IrFunctionBuilder, originalDescriptor: ConstructorDescriptor?
+): IrConstructor = with(builder) {
    val wrappedDescriptor =
        if (originalDescriptor != null) WrappedClassConstructorDescriptor(originalDescriptor.annotations, originalDescriptor.source)
        else WrappedClassConstructorDescriptor()
-    return IrConstructorImpl(
+    return createConstructor(
        startOffset, endOffset, origin,
        IrConstructorSymbolImpl(wrappedDescriptor),
        Name.special("<init>"),
@@ -158,19 +157,24 @@ internal fun IrFunctionBuilder.buildConstructor(originalDescriptor: ConstructorD
    }
 }

-inline fun buildFun(originalDescriptor: FunctionDescriptor? = null, builder: IrFunctionBuilder.() -> Unit): IrSimpleFunction =
+inline fun IrFactory.buildFun(
+    originalDescriptor: FunctionDescriptor? = null, builder: IrFunctionBuilder.() -> Unit
+): IrSimpleFunction =
    IrFunctionBuilder().run {
        builder()
-        buildFunction(originalDescriptor)
+        buildFunction(this, originalDescriptor)
    }

-inline fun IrDeclarationContainer.addFunction(builder: IrFunctionBuilder.() -> Unit): IrSimpleFunction =
+inline fun IrFactory.addFunction(klass: IrDeclarationContainer, builder: IrFunctionBuilder.() -> Unit): IrSimpleFunction =
    buildFun(null, builder).also { function ->
-        declarations.add(function)
-        function.parent = this@addFunction
+        klass.declarations.add(function)
+        function.parent = klass
    }

-fun IrDeclarationContainer.addFunction(
+inline fun IrClass.addFunction(builder: IrFunctionBuilder.() -> Unit): IrSimpleFunction =
+    factory.addFunction(this, builder)
+
+fun IrClass.addFunction(
    name: String,
    returnType: IrType,
    modality: Modality = Modality.FINAL,
@@ -194,14 +198,17 @@ fun IrDeclarationContainer.addFunction(
        }
    }

-inline fun buildConstructor(originalDescriptor: ConstructorDescriptor? = null, builder: IrFunctionBuilder.() -> Unit): IrConstructor =
+inline fun IrFactory.buildConstructor(
+    originalDescriptor: ConstructorDescriptor? = null,
+    builder: IrFunctionBuilder.() -> Unit
+): IrConstructor =
    IrFunctionBuilder().run {
        builder()
-        buildConstructor(originalDescriptor)
+        buildConstructor(this, originalDescriptor)
    }

 inline fun IrClass.addConstructor(builder: IrFunctionBuilder.() -> Unit = {}): IrConstructor =
-    buildConstructor {
+    factory.buildConstructor {
        builder()
        returnType = defaultType
    }.also { constructor ->
@@ -211,14 +218,15 @@ inline fun IrClass.addConstructor(builder: IrFunctionBuilder.() -> Unit = {}): I

 private val RECEIVER_PARAMETER_NAME = Name.special("<this>")

-fun buildReceiverParameter(
-    parent: IrDeclarationParent,
+fun <D> buildReceiverParameter(
+    parent: D,
    origin: IrDeclarationOrigin,
    type: IrType,
    startOffset: Int = parent.startOffset,
    endOffset: Int = parent.endOffset
-): IrValueParameter = WrappedReceiverParameterDescriptor().let { wrappedDescriptor ->
-    IrValueParameterImpl(
+): IrValueParameter
+    where D : IrDeclaration, D : IrDeclarationParent = WrappedReceiverParameterDescriptor().let { wrappedDescriptor ->
+    parent.factory.createValueParameter(
        startOffset, endOffset, origin,
        IrValueParameterSymbolImpl(wrappedDescriptor),
        RECEIVER_PARAMETER_NAME, -1, type, null, isCrossinline = false, isNoinline = false
@@ -229,22 +237,25 @@ fun buildReceiverParameter(
 }

@PublishedApi
-internal fun IrValueParameterBuilder.buildValueParameter(parent: IrDeclarationParent): IrValueParameter {
-    val wrappedDescriptor = WrappedValueParameterDescriptor(wrappedDescriptorAnnotations)
-    return IrValueParameterImpl(
-        startOffset, endOffset, origin,
-        IrValueParameterSymbolImpl(wrappedDescriptor),
-        name, index, type, varargElementType, isCrossInline, isNoinline
-    ).also {
-        wrappedDescriptor.bind(it)
-        it.parent = parent
+internal fun IrFactory.buildValueParameter(builder: IrValueParameterBuilder, parent: IrDeclarationParent): IrValueParameter =
+    with(builder) {
+        val wrappedDescriptor = WrappedValueParameterDescriptor(wrappedDescriptorAnnotations)
+        return createValueParameter(
+            startOffset, endOffset, origin,
+            IrValueParameterSymbolImpl(wrappedDescriptor),
+            name, index, type, varargElementType, isCrossInline, isNoinline
+        ).also {
+            wrappedDescriptor.bind(it)
+            it.parent = parent
+        }
    }
-}

-inline fun buildValueParameter(parent: IrDeclarationParent, builder: IrValueParameterBuilder.() -> Unit): IrValueParameter =
+
+inline fun <D> buildValueParameter(declaration: D, builder: IrValueParameterBuilder.() -> Unit): IrValueParameter
+    where D : IrDeclaration, D : IrDeclarationParent =
    IrValueParameterBuilder().run {
        builder()
-        buildValueParameter(parent)
+        declaration.factory.buildValueParameter(this, declaration)
    }

 inline fun IrFunction.addValueParameter(builder: IrValueParameterBuilder.() -> Unit): IrValueParameter =
@@ -253,8 +264,8 @@ inline fun IrFunction.addValueParameter(builder: IrValueParameterBuilder.() -> U
        if (index == UNDEFINED_PARAMETER_INDEX) {
            index = valueParameters.size
        }
-        buildValueParameter(this@addValueParameter).also { valueParameter ->
-            valueParameters += valueParameter
+        factory.buildValueParameter(this, this@addValueParameter).also { valueParameter ->
+            valueParameters = valueParameters + valueParameter
        }
    }

@@ -270,45 +281,41 @@ inline fun IrSimpleFunction.addDispatchReceiver(builder: IrValueParameterBuilder
        builder()
        index = -1
        name = "this".synthesizedName
-        buildValueParameter(this@addDispatchReceiver).also { receiver ->
+        factory.buildValueParameter(this, this@addDispatchReceiver).also { receiver ->
            dispatchReceiverParameter = receiver
        }
    }

-inline fun IrSimpleFunction.addExtensionReceiver(builder: IrValueParameterBuilder.() -> Unit): IrValueParameter =
+fun IrSimpleFunction.addExtensionReceiver(type: IrType, origin: IrDeclarationOrigin = IrDeclarationOrigin.DEFINED): IrValueParameter =
    IrValueParameterBuilder().run {
-        builder()
-        index = -1
-        name = "receiver".synthesizedName
-        buildValueParameter(this@addExtensionReceiver).also { receiver ->
+        this.type = type
+        this.origin = origin
+        this.index = -1
+        this.name = "receiver".synthesizedName
+        factory.buildValueParameter(this, this@addExtensionReceiver).also { receiver ->
            extensionReceiverParameter = receiver
        }
    }

-fun IrSimpleFunction.addExtensionReceiver(type: IrType, origin: IrDeclarationOrigin = IrDeclarationOrigin.DEFINED ): IrValueParameter =
-    addExtensionReceiver {
-        this.type = type
-        this.origin = origin
-    }
-
@PublishedApi
-internal fun IrTypeParameterBuilder.buildTypeParameter(parent: IrDeclarationParent): IrTypeParameter {
-    val wrappedDescriptor = WrappedTypeParameterDescriptor()
-    return IrTypeParameterImpl(
-        startOffset, endOffset, origin,
-        IrTypeParameterSymbolImpl(wrappedDescriptor),
-        name, index, isReified, variance
-    ).also {
-        wrappedDescriptor.bind(it)
-        it.superTypes.addAll(superTypes)
-        it.parent = parent
+internal fun IrFactory.buildTypeParameter(builder: IrTypeParameterBuilder, parent: IrDeclarationParent): IrTypeParameter =
+    with(builder) {
+        val wrappedDescriptor = WrappedTypeParameterDescriptor()
+        createTypeParameter(
+            startOffset, endOffset, origin,
+            IrTypeParameterSymbolImpl(wrappedDescriptor),
+            name, index, isReified, variance
+        ).also {
+            wrappedDescriptor.bind(it)
+            it.superTypes.addAll(superTypes)
+            it.parent = parent
+        }
    }
-}

-inline fun buildTypeParameter(parent: IrDeclarationParent, builder: IrTypeParameterBuilder.() -> Unit): IrTypeParameter =
+inline fun buildTypeParameter(parent: IrTypeParametersContainer, builder: IrTypeParameterBuilder.() -> Unit): IrTypeParameter =
    IrTypeParameterBuilder().run {
        builder()
-        buildTypeParameter(parent)
+        parent.factory.buildTypeParameter(this, parent)
    }

 inline fun IrTypeParametersContainer.addTypeParameter(builder: IrTypeParameterBuilder.() -> Unit): IrTypeParameter =
@@ -317,8 +324,8 @@ inline fun IrTypeParametersContainer.addTypeParameter(builder: IrTypeParameterBu
        if (index == UNDEFINED_PARAMETER_INDEX) {
            index = typeParameters.size
        }
-        buildTypeParameter(this@addTypeParameter).also { typeParameter ->
-            typeParameters += typeParameter
+        factory.buildTypeParameter(this, this@addTypeParameter).also { typeParameter ->
+            typeParameters = typeParameters + typeParameter
        }
    }