From 6aa09f61d45b9857a60ad31abf5bd740bb15f43f Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Wed, 8 Jul 2020 15:03:16 +0200 Subject: [PATCH] IR: use buildFun where possible --- .../kotlin/backend/common/ir/IrUtils.kt | 32 +-- .../lower/AbstractSuspendFunctionsLowering.kt | 249 ++++++++---------- .../lower/DefaultArgumentStubGenerator.kt | 4 +- .../common/lower/LocalDeclarationsLowering.kt | 39 +-- .../declarations/declarationBuilders.kt | 31 +-- .../kotlin/ir/backend/js/ir/IrBuilder.kt | 41 ++- .../js/lower/CreateScriptFunctionsPhase.kt | 29 +- .../js/lower/PrivateMembersLowering.kt | 26 +- .../AbstractSuspendFunctionsLowering.kt | 201 +++++++------- .../jvm/descriptors/JvmDeclarationFactory.kt | 48 ++-- .../jvm/lower/AddContinuationLowering.kt | 4 +- .../lower/JvmOverloadsAnnotationLowering.kt | 33 +-- .../jvm/lower/JvmStaticAnnotationLowering.kt | 5 +- .../MemoizedInlineClassReplacements.kt | 3 +- 14 files changed, 308 insertions(+), 437 deletions(-) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt index 51ab23071b7..8aa37e534c5 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt @@ -16,6 +16,7 @@ import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET import org.jetbrains.kotlin.ir.builders.Scope +import org.jetbrains.kotlin.ir.builders.declarations.buildFun import org.jetbrains.kotlin.ir.builders.declarations.buildReceiverParameter import org.jetbrains.kotlin.ir.builders.declarations.buildTypeParameter import org.jetbrains.kotlin.ir.declarations.* @@ -486,25 +487,20 @@ fun IrClass.addFakeOverridesViaIncorrectHeuristic(implementedMembers: List) = overriddenFunctions.first().let { irFunction -> - val descriptor = WrappedSimpleFunctionDescriptor() - IrFunctionImpl( - UNDEFINED_OFFSET, - UNDEFINED_OFFSET, - IrDeclarationOrigin.FAKE_OVERRIDE, - IrSimpleFunctionSymbolImpl(descriptor), - irFunction.name, - Visibilities.PUBLIC, - irFunction.modality, - irFunction.returnType, - isInline = irFunction.isInline, - isExternal = irFunction.isExternal, - isTailrec = irFunction.isTailrec, - isSuspend = irFunction.isSuspend, - isExpect = irFunction.isExpect, - isFakeOverride = true, + buildFun { + origin = IrDeclarationOrigin.FAKE_OVERRIDE + name = irFunction.name + visibility = Visibilities.PUBLIC + modality = irFunction.modality + returnType = irFunction.returnType + isInline = irFunction.isInline + isExternal = irFunction.isExternal + isTailrec = irFunction.isTailrec + isSuspend = irFunction.isSuspend isOperator = irFunction.isOperator - ).apply { - descriptor.bind(this) + isExpect = irFunction.isExpect + isFakeOverride = true + }.apply { parent = this@addFakeOverridesViaIncorrectHeuristic overriddenSymbols = overriddenFunctions.map { it.symbol } copyParameterDeclarationsFrom(irFunction) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/AbstractSuspendFunctionsLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/AbstractSuspendFunctionsLowering.kt index 00eb5887cd5..de6f902ad7d 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/AbstractSuspendFunctionsLowering.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/AbstractSuspendFunctionsLowering.kt @@ -10,18 +10,17 @@ import org.jetbrains.kotlin.backend.common.ir.* import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibilities -import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI import org.jetbrains.kotlin.ir.IrElement +import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI import org.jetbrains.kotlin.ir.builders.* +import org.jetbrains.kotlin.ir.builders.declarations.buildFun import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.impl.IrClassImpl 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.descriptors.WrappedClassConstructorDescriptor import org.jetbrains.kotlin.ir.descriptors.WrappedClassDescriptor import org.jetbrains.kotlin.ir.descriptors.WrappedFieldDescriptor -import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.expressions.impl.IrInstanceInitializerCallImpl import org.jetbrains.kotlin.ir.symbols.IrClassSymbol @@ -29,7 +28,6 @@ import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol import org.jetbrains.kotlin.ir.symbols.impl.IrClassSymbolImpl import org.jetbrains.kotlin.ir.symbols.impl.IrConstructorSymbolImpl import org.jetbrains.kotlin.ir.symbols.impl.IrFieldSymbolImpl -import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.types.classifierOrFail import org.jetbrains.kotlin.ir.types.defaultType @@ -472,65 +470,54 @@ abstract class AbstractSuspendFunctionsLowering(val co unboundArgs: List, superFunctionSymbol: IrSimpleFunctionSymbol?, coroutineConstructor: IrConstructor - ) = WrappedSimpleFunctionDescriptor().let { d -> - IrFunctionImpl( - startOffset, endOffset, - DECLARATION_ORIGIN_COROUTINE_IMPL, - IrSimpleFunctionSymbolImpl(d), - Name.identifier("create"), - Visibilities.PROTECTED, - Modality.FINAL, - coroutineClass.defaultType, - isInline = false, - isExternal = false, - isTailrec = false, - isSuspend = false, - isExpect = false, - isFakeOverride = false, - isOperator = false - ).apply { - d.bind(this) - parent = coroutineClass - coroutineClass.declarations += this + ): IrSimpleFunction = buildFun { + startOffset = irFunction.startOffset + endOffset = irFunction.endOffset + origin = DECLARATION_ORIGIN_COROUTINE_IMPL + name = Name.identifier("create") + visibility = Visibilities.PROTECTED + returnType = coroutineClass.defaultType + }.apply { + parent = coroutineClass + coroutineClass.declarations += this - typeParameters = irFunction.typeParameters.map { parameter -> - parameter.copyToWithoutSuperTypes(this, origin = DECLARATION_ORIGIN_COROUTINE_IMPL) - .apply { superTypes += parameter.superTypes } - } + typeParameters = irFunction.typeParameters.map { parameter -> + parameter.copyToWithoutSuperTypes(this, origin = DECLARATION_ORIGIN_COROUTINE_IMPL) + .apply { superTypes += parameter.superTypes } + } - valueParameters = (unboundArgs + create1CompletionParameter).mapIndexed { index, parameter -> - parameter.copyTo(this, DECLARATION_ORIGIN_COROUTINE_IMPL, index) - } + valueParameters = (unboundArgs + create1CompletionParameter).mapIndexed { index, parameter -> + parameter.copyTo(this, DECLARATION_ORIGIN_COROUTINE_IMPL, index) + } - this.createDispatchReceiverParameter() + this.createDispatchReceiverParameter() - superFunctionSymbol?.let { - overriddenSymbols += it.owner.overriddenSymbols - overriddenSymbols += it - } + superFunctionSymbol?.let { + overriddenSymbols += it.owner.overriddenSymbols + overriddenSymbols += it + } - val thisReceiver = this.dispatchReceiverParameter!! + val thisReceiver = this.dispatchReceiverParameter!! - val irBuilder = context.createIrBuilder(symbol, startOffset, endOffset) - body = irBuilder.irBlockBody(startOffset, endOffset) { - +irReturn( - irCall(coroutineConstructor).apply { - var unboundIndex = 0 - val unboundArgsSet = unboundArgs.toSet() - functionParameters.map { - if (unboundArgsSet.contains(it)) - irGet(valueParameters[unboundIndex++]) - else - irGetField(irGet(thisReceiver), argumentToPropertiesMap.getValue(it)) - }.forEachIndexed { index, argument -> - putValueArgument(index, argument) - } - putValueArgument(functionParameters.size, irGet(valueParameters[unboundIndex])) - assert(unboundIndex == valueParameters.size - 1) { - "Not all arguments of are used" - } - }) - } + val irBuilder = context.createIrBuilder(symbol, startOffset, endOffset) + body = irBuilder.irBlockBody(startOffset, endOffset) { + +irReturn( + irCall(coroutineConstructor).apply { + var unboundIndex = 0 + val unboundArgsSet = unboundArgs.toSet() + functionParameters.map { + if (unboundArgsSet.contains(it)) + irGet(valueParameters[unboundIndex++]) + else + irGetField(irGet(thisReceiver), argumentToPropertiesMap.getValue(it)) + }.forEachIndexed { index, argument -> + putValueArgument(index, argument) + } + putValueArgument(functionParameters.size, irGet(valueParameters[unboundIndex])) + assert(unboundIndex == valueParameters.size - 1) { + "Not all arguments of are used" + } + }) } } @@ -539,59 +526,49 @@ abstract class AbstractSuspendFunctionsLowering(val co functionInvokeFunctionSymbol: IrSimpleFunctionSymbol, createFunction: IrFunction, stateMachineFunction: IrFunction - ) = WrappedSimpleFunctionDescriptor().let { d -> - IrFunctionImpl( - startOffset, endOffset, - DECLARATION_ORIGIN_COROUTINE_IMPL, - IrSimpleFunctionSymbolImpl(d), - Name.identifier("invoke"), - Visibilities.PROTECTED, - Modality.FINAL, - context.irBuiltIns.anyNType, - isInline = false, - isExternal = false, - isTailrec = false, - isSuspend = true, - isExpect = false, - isFakeOverride = false, - isOperator = false - ).apply { - d.bind(this) - parent = coroutineClass - coroutineClass.declarations += this + ): IrSimpleFunction = buildFun { + startOffset = irFunction.startOffset + endOffset = irFunction.endOffset + origin = DECLARATION_ORIGIN_COROUTINE_IMPL + name = Name.identifier("invoke") + visibility = Visibilities.PROTECTED + returnType = context.irBuiltIns.anyNType + isSuspend = true + }.apply { + parent = coroutineClass + coroutineClass.declarations += this - typeParameters = irFunction.typeParameters.map { parameter -> - parameter.copyToWithoutSuperTypes(this, origin = DECLARATION_ORIGIN_COROUTINE_IMPL) - .apply { superTypes += parameter.superTypes } + typeParameters = irFunction.typeParameters.map { parameter -> + parameter.copyToWithoutSuperTypes(this, origin = DECLARATION_ORIGIN_COROUTINE_IMPL) + .apply { superTypes += parameter.superTypes } + } + + valueParameters = createFunction.valueParameters + // Skip completion - invoke() already has it implicitly as a suspend function. + .take(createFunction.valueParameters.size - 1) + .mapIndexed { index, parameter -> + parameter.copyTo(this, DECLARATION_ORIGIN_COROUTINE_IMPL, index) } - valueParameters = createFunction.valueParameters - // Skip completion - invoke() already has it implicitly as a suspend function. - .take(createFunction.valueParameters.size - 1) - .mapIndexed { index, parameter -> - parameter.copyTo(this, DECLARATION_ORIGIN_COROUTINE_IMPL, index) + this.createDispatchReceiverParameter() + + overriddenSymbols += functionInvokeFunctionSymbol + overriddenSymbols += suspendFunctionInvokeFunctionSymbol + + val thisReceiver = dispatchReceiverParameter!! + + val irBuilder = context.createIrBuilder(symbol, startOffset, endOffset) + body = irBuilder.irBlockBody(startOffset, endOffset) { + generateCoroutineStart(stateMachineFunction, irCall(createFunction).apply { + dispatchReceiver = irGet(thisReceiver) + valueParameters.forEachIndexed { index, parameter -> + putValueArgument(index, irGet(parameter)) } - - this.createDispatchReceiverParameter() - - overriddenSymbols += functionInvokeFunctionSymbol - overriddenSymbols += suspendFunctionInvokeFunctionSymbol - - val thisReceiver = dispatchReceiverParameter!! - - val irBuilder = context.createIrBuilder(symbol, startOffset, endOffset) - body = irBuilder.irBlockBody(startOffset, endOffset) { - generateCoroutineStart(stateMachineFunction, irCall(createFunction).apply { - dispatchReceiver = irGet(thisReceiver) - valueParameters.forEachIndexed { index, parameter -> - putValueArgument(index, irGet(parameter)) - } - putValueArgument( - valueParameters.size, - irCall(getContinuationSymbol, getContinuationSymbol.owner.returnType, listOf(returnType)) - ) - }) - } + putValueArgument( + valueParameters.size, + irCall(getContinuationSymbol, getContinuationSymbol.owner.returnType, listOf(returnType)) + ) + }) } } @@ -599,40 +576,36 @@ abstract class AbstractSuspendFunctionsLowering(val co stateMachineFunction: IrSimpleFunction, coroutineClass: IrClass ): IrSimpleFunction { - val function = WrappedSimpleFunctionDescriptor().let { d -> - IrFunctionImpl( - startOffset, endOffset, - DECLARATION_ORIGIN_COROUTINE_IMPL, - IrSimpleFunctionSymbolImpl(d), - stateMachineFunction.name, - stateMachineFunction.visibility, - Modality.FINAL, - context.irBuiltIns.anyNType, - isInline = stateMachineFunction.isInline, - isExternal = stateMachineFunction.isExternal, - isTailrec = stateMachineFunction.isTailrec, - isSuspend = stateMachineFunction.isSuspend, - isExpect = stateMachineFunction.isExpect, - isFakeOverride = false, - isOperator = false - ).apply { - d.bind(this) - parent = coroutineClass - coroutineClass.declarations += this + val function = buildFun { + startOffset = irFunction.startOffset + endOffset = irFunction.endOffset + origin = DECLARATION_ORIGIN_COROUTINE_IMPL + name = stateMachineFunction.name + visibility = stateMachineFunction.visibility + returnType = context.irBuiltIns.anyNType + isInline = stateMachineFunction.isInline + isExternal = stateMachineFunction.isExternal + isTailrec = stateMachineFunction.isTailrec + isSuspend = stateMachineFunction.isSuspend + isOperator = false + isExpect = stateMachineFunction.isExpect + isFakeOverride = false + }.apply { + parent = coroutineClass + coroutineClass.declarations += this - typeParameters = stateMachineFunction.typeParameters.map { parameter -> - parameter.copyToWithoutSuperTypes(this, origin = DECLARATION_ORIGIN_COROUTINE_IMPL) - .apply { superTypes += parameter.superTypes } - } - - valueParameters = stateMachineFunction.valueParameters.mapIndexed { index, parameter -> - parameter.copyTo(this, DECLARATION_ORIGIN_COROUTINE_IMPL, index) - } - - this.createDispatchReceiverParameter() - - overriddenSymbols += stateMachineFunction.symbol + typeParameters = stateMachineFunction.typeParameters.map { parameter -> + parameter.copyToWithoutSuperTypes(this, origin = DECLARATION_ORIGIN_COROUTINE_IMPL) + .apply { superTypes += parameter.superTypes } } + + valueParameters = stateMachineFunction.valueParameters.mapIndexed { index, parameter -> + parameter.copyTo(this, DECLARATION_ORIGIN_COROUTINE_IMPL, index) + } + + this.createDispatchReceiverParameter() + + overriddenSymbols += stateMachineFunction.symbol } buildStateMachine(function, irFunction, argumentToPropertiesMap) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt index db1931e21a2..32ec4f157b5 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt @@ -16,7 +16,7 @@ import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET import org.jetbrains.kotlin.ir.builders.* import org.jetbrains.kotlin.ir.builders.declarations.addValueParameter import org.jetbrains.kotlin.ir.builders.declarations.buildConstructor -import org.jetbrains.kotlin.ir.builders.declarations.buildFunWithDescriptorForInlining +import org.jetbrains.kotlin.ir.builders.declarations.buildFun import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.expressions.impl.* @@ -514,7 +514,7 @@ private fun IrFunction.generateDefaultsFunctionImpl( visibility = newVisibility } is IrSimpleFunction -> - buildFunWithDescriptorForInlining(descriptor) { + buildFun(descriptor) { updateFrom(this@generateDefaultsFunctionImpl) name = Name.identifier("${this@generateDefaultsFunctionImpl.name}\$default") origin = newOrigin diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt index 4623855442b..e9c5c144163 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt @@ -17,14 +17,13 @@ import org.jetbrains.kotlin.ir.IrStatement import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET import org.jetbrains.kotlin.ir.builders.Scope +import org.jetbrains.kotlin.ir.builders.declarations.buildFun import org.jetbrains.kotlin.ir.builders.declarations.buildValueParameter 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.descriptors.WrappedClassConstructorDescriptor import org.jetbrains.kotlin.ir.descriptors.WrappedFieldDescriptor -import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.expressions.impl.* import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol @@ -32,11 +31,9 @@ import org.jetbrains.kotlin.ir.symbols.IrValueParameterSymbol import org.jetbrains.kotlin.ir.symbols.IrValueSymbol import org.jetbrains.kotlin.ir.symbols.impl.IrConstructorSymbolImpl import org.jetbrains.kotlin.ir.symbols.impl.IrFieldSymbolImpl -import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl import org.jetbrains.kotlin.ir.types.* import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl import org.jetbrains.kotlin.ir.types.impl.IrTypeAbbreviationImpl -import org.jetbrains.kotlin.ir.types.impl.IrUninitializedType import org.jetbrains.kotlin.ir.types.impl.makeTypeProjection import org.jetbrains.kotlin.ir.util.constructedClass import org.jetbrains.kotlin.ir.util.file @@ -587,38 +584,22 @@ class LocalDeclarationsLowering( private fun createLiftedDeclaration(localFunctionContext: LocalFunctionContext) { val oldDeclaration = localFunctionContext.declaration - assert(oldDeclaration.dispatchReceiverParameter == null) - - val memberOwner = localFunctionContext.ownerForLoweredDeclaration - val newDescriptor = WrappedSimpleFunctionDescriptor(oldDeclaration.descriptor) - val newSymbol = IrSimpleFunctionSymbolImpl(newDescriptor) - val newName = generateNameForLiftedDeclaration(oldDeclaration, memberOwner) - if (oldDeclaration.dispatchReceiverParameter != null) { throw AssertionError("local functions must not have dispatch receiver") } + val memberOwner = localFunctionContext.ownerForLoweredDeclaration + val newName = generateNameForLiftedDeclaration(oldDeclaration, memberOwner) + // TODO: consider using fields to access the closure of enclosing class. val (capturedValues, capturedTypeParameters) = localFunctionContext.closure - val newDeclaration = IrFunctionImpl( - oldDeclaration.startOffset, - oldDeclaration.endOffset, - oldDeclaration.origin, - newSymbol, - newName, - Visibilities.PRIVATE, - Modality.FINAL, - returnType = IrUninitializedType, - isInline = oldDeclaration.isInline, - isExternal = oldDeclaration.isExternal, - isTailrec = oldDeclaration.isTailrec, - isSuspend = oldDeclaration.isSuspend, - isExpect = oldDeclaration.isExpect, - isFakeOverride = oldDeclaration.isFakeOverride, - isOperator = oldDeclaration.isOperator - ) - newDescriptor.bind(newDeclaration) + val newDeclaration = buildFun(oldDeclaration.descriptor) { + updateFrom(oldDeclaration) + name = newName + visibility = Visibilities.PRIVATE + modality = Modality.FINAL + } localFunctionContext.transformedDeclaration = newDeclaration diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/builders/declarations/declarationBuilders.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/builders/declarations/declarationBuilders.kt index 531bde65f89..cbf51920a63 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/builders/declarations/declarationBuilders.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/builders/declarations/declarationBuilders.kt @@ -105,7 +105,7 @@ inline fun IrProperty.addGetter(builder: IrFunctionBuilder.() -> Unit = {}): IrS IrFunctionBuilder().run { name = Name.special("") builder() - buildFun().also { getter -> + buildFunction().also { getter -> this@addGetter.getter = getter getter.correspondingPropertySymbol = this@addGetter.symbol getter.parent = this@addGetter.parent @@ -116,13 +116,16 @@ inline fun IrProperty.addSetter(builder: IrFunctionBuilder.() -> Unit = {}): IrS IrFunctionBuilder().run { name = Name.special("") builder() - buildFun().also { setter -> + buildFunction().also { setter -> this@addSetter.setter = setter setter.parent = this@addSetter.parent } } -fun IrFunctionBuilder.buildFun(originalDescriptor: FunctionDescriptor? = null): IrSimpleFunction { +@PublishedApi +internal fun IrFunctionBuilder.buildFunction(originalDescriptor: FunctionDescriptor? = null): IrSimpleFunction { + // 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) { is DescriptorWithContainerSource -> WrappedFunctionDescriptorWithContainerSource(originalDescriptor.containerSource) is PropertyGetterDescriptor -> WrappedPropertyGetterDescriptor(originalDescriptor.annotations, originalDescriptor.source) @@ -134,8 +137,7 @@ fun IrFunctionBuilder.buildFun(originalDescriptor: FunctionDescriptor? = null): startOffset, endOffset, origin, IrSimpleFunctionSymbolImpl(wrappedDescriptor), name, visibility, modality, returnType, - isInline = isInline, isExternal = isExternal, isTailrec = isTailrec, isSuspend = isSuspend, isExpect = isExpect, - isFakeOverride = isFakeOverride, isOperator = isOperator + isInline, isExternal, isTailrec, isSuspend, isOperator, isExpect, isFakeOverride ).also { wrappedDescriptor.bind(it) } @@ -154,27 +156,14 @@ fun IrFunctionBuilder.buildConstructor(): IrConstructor { } } -/** - * 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. - */ -inline fun buildFunWithDescriptorForInlining( - originalDescriptor: FunctionDescriptor, builder: IrFunctionBuilder.() -> Unit -): IrSimpleFunction = +inline fun buildFun(originalDescriptor: FunctionDescriptor? = null, builder: IrFunctionBuilder.() -> Unit): IrSimpleFunction = IrFunctionBuilder().run { builder() - buildFun(originalDescriptor) - } - -inline fun buildFun(builder: IrFunctionBuilder.() -> Unit): IrSimpleFunction = - IrFunctionBuilder().run { - builder() - buildFun() + buildFunction(originalDescriptor) } inline fun IrDeclarationContainer.addFunction(builder: IrFunctionBuilder.() -> Unit): IrSimpleFunction = - buildFun(builder).also { function -> + buildFun(null, builder).also { function -> declarations.add(function) function.parent = this@addFunction } diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ir/IrBuilder.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ir/IrBuilder.kt index ac830c9a7ae..cfa19189afb 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ir/IrBuilder.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ir/IrBuilder.kt @@ -10,18 +10,16 @@ import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.ir.IrStatement import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET +import org.jetbrains.kotlin.ir.builders.declarations.buildFun import org.jetbrains.kotlin.ir.builders.declarations.buildValueParameter import org.jetbrains.kotlin.ir.builders.declarations.buildVariable import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.impl.IrAnonymousInitializerImpl -import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl import org.jetbrains.kotlin.ir.descriptors.WrappedClassDescriptor -import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.expressions.impl.* import org.jetbrains.kotlin.ir.symbols.* import org.jetbrains.kotlin.ir.symbols.impl.IrAnonymousInitializerSymbolImpl -import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.name.Name @@ -103,28 +101,21 @@ object JsIrBuilder { isOperator: Boolean = false, isFakeOverride: Boolean = false, origin: IrDeclarationOrigin = SYNTHESIZED_DECLARATION - ): IrSimpleFunction { - val descriptor = WrappedSimpleFunctionDescriptor() - return IrFunctionImpl( - UNDEFINED_OFFSET, - UNDEFINED_OFFSET, - origin, - IrSimpleFunctionSymbolImpl(descriptor), - name, - visibility, - modality, - returnType, - isInline = isInline, - isExternal = isExternal, - isTailrec = isTailrec, - isSuspend = isSuspend, - isExpect = isExpect, - isFakeOverride = isFakeOverride, - isOperator = isOperator - ).also { - descriptor.bind(it) - it.parent = parent - } + ): IrSimpleFunction = buildFun { + this.origin = origin + this.name = name + this.visibility = visibility + this.modality = modality + this.returnType = returnType + this.isInline = isInline + this.isExternal = isExternal + this.isTailrec = isTailrec + this.isSuspend = isSuspend + this.isOperator = isOperator + this.isExpect = isExpect + this.isFakeOverride = isFakeOverride + }.also { + it.parent = parent } fun buildAnonymousInitializer() = diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/CreateScriptFunctionsPhase.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/CreateScriptFunctionsPhase.kt index 8ebe0c3233c..3950972da7d 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/CreateScriptFunctionsPhase.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/CreateScriptFunctionsPhase.kt @@ -7,13 +7,11 @@ package org.jetbrains.kotlin.ir.backend.js.lower import org.jetbrains.kotlin.backend.common.CommonBackendContext import org.jetbrains.kotlin.backend.common.FileLoweringPass -import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.ir.IrStatement import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET +import org.jetbrains.kotlin.ir.builders.declarations.buildFun import org.jetbrains.kotlin.ir.declarations.* -import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl -import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor import org.jetbrains.kotlin.ir.expressions.IrCall import org.jetbrains.kotlin.ir.expressions.IrExpression import org.jetbrains.kotlin.ir.expressions.IrSetField @@ -21,7 +19,6 @@ import org.jetbrains.kotlin.ir.expressions.impl.IrBlockBodyImpl import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl import org.jetbrains.kotlin.ir.expressions.impl.IrReturnImpl import org.jetbrains.kotlin.ir.expressions.impl.IrSetFieldImpl -import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.util.transformFlat import org.jetbrains.kotlin.name.Name @@ -88,22 +85,18 @@ class CreateScriptFunctionsPhase(val context: CommonBackendContext) : FileLoweri return (irScript.statements.lastOrNull() as? IrExpression)?.type ?: context.irBuiltIns.unitType } - private fun createFunction(irScript: IrScript, name: String, returnType: IrType): IrSimpleFunction { - val (startOffset, endOffset) = getFunctionBodyOffsets(irScript) - val descriptor = WrappedSimpleFunctionDescriptor() - - return IrFunctionImpl( - startOffset, endOffset, SCRIPT_FUNCTION, - IrSimpleFunctionSymbolImpl(descriptor), - Name.identifier(name), - Visibilities.PRIVATE, Modality.FINAL, returnType, - isInline = false, isExternal = false, isTailrec = false, isSuspend = false, isExpect = false, isFakeOverride = false, - isOperator = false - ).also { - descriptor.bind(it) + private fun createFunction(irScript: IrScript, name: String, returnType: IrType): IrSimpleFunction = + buildFun { + val (startOffset, endOffset) = getFunctionBodyOffsets(irScript) + this.startOffset = startOffset + this.endOffset = endOffset + this.origin = SCRIPT_FUNCTION + this.name = Name.identifier(name) + this.visibility = Visibilities.PRIVATE + this.returnType = returnType + }.also { it.parent = irScript } - } private fun List.prepareForEvaluateScriptFunction(evaluateScriptFunction: IrFunction): List { return if (isNotEmpty()) { diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/PrivateMembersLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/PrivateMembersLowering.kt index 64720306446..9da168f17ac 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/PrivateMembersLowering.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/PrivateMembersLowering.kt @@ -10,13 +10,11 @@ import org.jetbrains.kotlin.backend.common.DeclarationTransformer import org.jetbrains.kotlin.backend.common.ir.copyTo import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext +import org.jetbrains.kotlin.ir.builders.declarations.buildFun import org.jetbrains.kotlin.ir.builders.declarations.buildValueParameter import org.jetbrains.kotlin.ir.declarations.* -import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl -import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.expressions.impl.* -import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl import org.jetbrains.kotlin.ir.util.deepCopyWithSymbols import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid import org.jetbrains.kotlin.name.Name @@ -48,21 +46,13 @@ class PrivateMembersLowering(val context: JsIrBackendContext) : DeclarationTrans if (function.visibility != Visibilities.PRIVATE || function.dispatchReceiverParameter == null) return null - val descriptor = WrappedSimpleFunctionDescriptor() - val symbol = IrSimpleFunctionSymbolImpl(descriptor) - val staticFunction = function.run { - IrFunctionImpl( - startOffset, endOffset, origin, - symbol, name, visibility, modality, - returnType, - isInline = isInline, isExternal = isExternal, isTailrec = isTailrec, isSuspend = isSuspend, isExpect = isExpect, - isFakeOverride = isFakeOverride, - isOperator = isOperator - ).also { - descriptor.bind(it) - it.parent = parent - it.correspondingPropertySymbol = correspondingPropertySymbol - } + val staticFunction = buildFun { + updateFrom(function) + name = function.name + returnType = function.returnType + }.also { + it.parent = function.parent + it.correspondingPropertySymbol = function.correspondingPropertySymbol } staticFunction.typeParameters += function.typeParameters.map { it.deepCopyWithSymbols(staticFunction) } diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/AbstractSuspendFunctionsLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/AbstractSuspendFunctionsLowering.kt index e277b865153..6104dadfddb 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/AbstractSuspendFunctionsLowering.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/AbstractSuspendFunctionsLowering.kt @@ -14,15 +14,14 @@ import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.backend.js.lower.CallableReferenceLowering import org.jetbrains.kotlin.ir.builders.* +import org.jetbrains.kotlin.ir.builders.declarations.buildFun import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.impl.IrClassImpl 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.descriptors.WrappedClassConstructorDescriptor import org.jetbrains.kotlin.ir.descriptors.WrappedClassDescriptor import org.jetbrains.kotlin.ir.descriptors.WrappedFieldDescriptor -import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.expressions.impl.IrInstanceInitializerCallImpl import org.jetbrains.kotlin.ir.symbols.IrClassSymbol @@ -30,14 +29,15 @@ import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol import org.jetbrains.kotlin.ir.symbols.impl.IrClassSymbolImpl import org.jetbrains.kotlin.ir.symbols.impl.IrConstructorSymbolImpl import org.jetbrains.kotlin.ir.symbols.impl.IrFieldSymbolImpl -import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.types.classifierOrFail import org.jetbrains.kotlin.ir.types.defaultType import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl import org.jetbrains.kotlin.ir.types.typeWith import org.jetbrains.kotlin.ir.util.* -import org.jetbrains.kotlin.ir.visitors.* +import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid +import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid +import org.jetbrains.kotlin.ir.visitors.acceptVoid import org.jetbrains.kotlin.name.Name abstract class AbstractSuspendFunctionsLowering(val context: C) : BodyLoweringPass { @@ -302,128 +302,111 @@ abstract class AbstractSuspendFunctionsLowering(val co } private fun buildInvokeSuspendMethod(stateMachineFunction: IrSimpleFunction): IrSimpleFunction { - val smFunction = WrappedSimpleFunctionDescriptor().let { d -> - IrFunctionImpl( - startOffset, endOffset, - DECLARATION_ORIGIN_COROUTINE_IMPL, - IrSimpleFunctionSymbolImpl(d), - stateMachineFunction.name, - stateMachineFunction.visibility, - Modality.FINAL, - context.irBuiltIns.anyNType, - isInline = stateMachineFunction.isInline, - isExternal = stateMachineFunction.isExternal, - isTailrec = stateMachineFunction.isTailrec, - isSuspend = stateMachineFunction.isSuspend, - isExpect = stateMachineFunction.isExpect, - isFakeOverride = false, - isOperator = false - ).apply { - d.bind(this) - parent = coroutineClass - coroutineClass.addChild(this) + val smFunction = buildFun { + startOffset = function.startOffset + endOffset = function.endOffset + origin = DECLARATION_ORIGIN_COROUTINE_IMPL + name = stateMachineFunction.name + visibility = stateMachineFunction.visibility + modality = Modality.FINAL + returnType = context.irBuiltIns.anyNType + isInline = stateMachineFunction.isInline + isExternal = stateMachineFunction.isExternal + isTailrec = stateMachineFunction.isTailrec + isSuspend = stateMachineFunction.isSuspend + isOperator = false + isExpect = stateMachineFunction.isExpect + isFakeOverride = false + }.apply { + parent = coroutineClass + coroutineClass.addChild(this) - typeParameters = stateMachineFunction.typeParameters.map { parameter -> - parameter.copyToWithoutSuperTypes(this, origin = DECLARATION_ORIGIN_COROUTINE_IMPL) - .apply { superTypes += parameter.superTypes } - } - - valueParameters = stateMachineFunction.valueParameters.mapIndexed { index, parameter -> - parameter.copyTo(this, DECLARATION_ORIGIN_COROUTINE_IMPL, index) - } - - this.createDispatchReceiverParameter() - - overriddenSymbols = listOf(stateMachineFunction.symbol) + typeParameters = stateMachineFunction.typeParameters.map { parameter -> + parameter.copyToWithoutSuperTypes(this, origin = DECLARATION_ORIGIN_COROUTINE_IMPL) + .apply { superTypes += parameter.superTypes } } + + valueParameters = stateMachineFunction.valueParameters.mapIndexed { index, parameter -> + parameter.copyTo(this, DECLARATION_ORIGIN_COROUTINE_IMPL, index) + } + + this.createDispatchReceiverParameter() + + overriddenSymbols = listOf(stateMachineFunction.symbol) } buildStateMachine(smFunction, function, argumentToPropertiesMap) return smFunction } - private fun buildCreateMethod(superCreateFunction: IrSimpleFunction?, constructor: IrConstructor): IrSimpleFunction { - // val i = $lambdaN(this.f1, this.f2, ..., this.fn, continuation) // bound - // i.s1 = p1 // unbound - // ... - // i.sn = pn - // return i - val createFunction = WrappedSimpleFunctionDescriptor().let { d -> - IrFunctionImpl( - startOffset, endOffset, - DECLARATION_ORIGIN_COROUTINE_IMPL, - IrSimpleFunctionSymbolImpl(d), - Name.identifier("create"), - Visibilities.PROTECTED, - Modality.FINAL, - coroutineClass.defaultType, - isInline = false, - isExternal = false, - isTailrec = false, - isSuspend = false, - isExpect = false, - isFakeOverride = false, - isOperator = false - ).apply { - d.bind(this) - parent = coroutineClass - coroutineClass.addChild(this) + // val i = $lambdaN(this.f1, this.f2, ..., this.fn, continuation) // bound + // i.s1 = p1 // unbound + // ... + // i.sn = pn + // return i + private fun buildCreateMethod(superCreateFunction: IrSimpleFunction?, constructor: IrConstructor): IrSimpleFunction = + buildFun { + startOffset = function.startOffset + endOffset = function.endOffset + origin = DECLARATION_ORIGIN_COROUTINE_IMPL + name = Name.identifier("create") + visibility = Visibilities.PROTECTED + returnType = coroutineClass.defaultType + }.apply { + parent = coroutineClass + coroutineClass.addChild(this) - typeParameters = function.typeParameters.map { parameter -> - parameter.copyToWithoutSuperTypes(this, origin = DECLARATION_ORIGIN_COROUTINE_IMPL) - .apply { superTypes += parameter.superTypes } - } + typeParameters = function.typeParameters.map { parameter -> + parameter.copyToWithoutSuperTypes(this, origin = DECLARATION_ORIGIN_COROUTINE_IMPL) + .apply { superTypes += parameter.superTypes } + } - val unboundArgs = function.valueParameters + val unboundArgs = function.valueParameters - val createValueParameters = (unboundArgs + create1CompletionParameter).mapIndexed { index, parameter -> - parameter.copyTo(this, DECLARATION_ORIGIN_COROUTINE_IMPL, index) - } + val createValueParameters = (unboundArgs + create1CompletionParameter).mapIndexed { index, parameter -> + parameter.copyTo(this, DECLARATION_ORIGIN_COROUTINE_IMPL, index) + } - valueParameters = createValueParameters + valueParameters = createValueParameters - this.createDispatchReceiverParameter() + this.createDispatchReceiverParameter() - superCreateFunction?.let { - overriddenSymbols = ArrayList(it.overriddenSymbols.size + 1).apply { - addAll(it.overriddenSymbols) - add(it.symbol) - } - } - - val thisReceiver = this.dispatchReceiverParameter!! - - val boundFields = - context.mapping.capturedFields[coroutineClass] ?: error("No captured values for class ${coroutineClass.render()}") - - val irBuilder = context.createIrBuilder(symbol, startOffset, endOffset) - body = irBuilder.irBlockBody(startOffset, endOffset) { - val instanceCreate = irCall(constructor).apply { - var unboundIndex = 0 - for (f in boundFields) { - putValueArgument(unboundIndex++, irGetField(irGet(thisReceiver), f)) - } - putValueArgument(unboundIndex++, irGet(createValueParameters.last())) - assert(unboundIndex == constructor.valueParameters.size) { - "Not all arguments of are used" - } - } - val instanceVal = scope.createTmpVariable(instanceCreate, "i") - +instanceVal - - assert(createValueParameters.size - 1 == argumentToPropertiesMap.size) - - for ((p, f) in createValueParameters.zip(argumentToPropertiesMap.values)) { - +irSetField(irGet(instanceVal), f, irGet(p)) - } - - +irReturn(irGet(instanceVal)) + superCreateFunction?.let { + overriddenSymbols = ArrayList(it.overriddenSymbols.size + 1).apply { + addAll(it.overriddenSymbols) + add(it.symbol) } } - } - return createFunction - } + val thisReceiver = this.dispatchReceiverParameter!! + + val boundFields = + context.mapping.capturedFields[coroutineClass] ?: error("No captured values for class ${coroutineClass.render()}") + + val irBuilder = context.createIrBuilder(symbol, startOffset, endOffset) + body = irBuilder.irBlockBody(startOffset, endOffset) { + val instanceCreate = irCall(constructor).apply { + var unboundIndex = 0 + for (f in boundFields) { + putValueArgument(unboundIndex++, irGetField(irGet(thisReceiver), f)) + } + putValueArgument(unboundIndex++, irGet(createValueParameters.last())) + assert(unboundIndex == constructor.valueParameters.size) { + "Not all arguments of are used" + } + } + val instanceVal = scope.createTmpVariable(instanceCreate, "i") + +instanceVal + + assert(createValueParameters.size - 1 == argumentToPropertiesMap.size) + + for ((p, f) in createValueParameters.zip(argumentToPropertiesMap.values)) { + +irSetField(irGet(instanceVal), f, irGet(p)) + } + + +irReturn(irGet(instanceVal)) + } + } private fun transformInvokeMethod(createFunction: IrSimpleFunction, stateMachineFunction: IrSimpleFunction) { val irBuilder = context.createIrBuilder(function.symbol, startOffset, endOffset) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/JvmDeclarationFactory.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/JvmDeclarationFactory.kt index e1e2179ee42..00f2c4c7c61 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/JvmDeclarationFactory.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/JvmDeclarationFactory.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.backend.jvm.descriptors -import org.jetbrains.kotlin.backend.common.DescriptorsToIrRemapper import org.jetbrains.kotlin.backend.common.ir.* import org.jetbrains.kotlin.backend.common.lower.createIrBuilder import org.jetbrains.kotlin.backend.jvm.JvmBackendContext @@ -21,21 +20,19 @@ import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibilities -import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET import org.jetbrains.kotlin.ir.builders.declarations.buildField +import org.jetbrains.kotlin.ir.builders.declarations.buildFun import org.jetbrains.kotlin.ir.builders.declarations.buildValueParameter import org.jetbrains.kotlin.ir.builders.irCall import org.jetbrains.kotlin.ir.builders.setSourceRange import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.impl.IrClassImpl import org.jetbrains.kotlin.ir.declarations.impl.IrConstructorImpl -import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl import org.jetbrains.kotlin.ir.descriptors.WrappedClassConstructorDescriptor import org.jetbrains.kotlin.ir.descriptors.WrappedClassDescriptor import org.jetbrains.kotlin.ir.expressions.IrExpressionBody import org.jetbrains.kotlin.ir.symbols.impl.IrClassSymbolImpl import org.jetbrains.kotlin.ir.symbols.impl.IrConstructorSymbolImpl -import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl import org.jetbrains.kotlin.ir.util.* import org.jetbrains.kotlin.load.java.JavaVisibilities import org.jetbrains.kotlin.load.java.JvmAbi @@ -282,30 +279,25 @@ class JvmDeclarationFactory( defaultImplsRedirections.getOrPut(fakeOverride) { assert(fakeOverride.isFakeOverride) val irClass = fakeOverride.parentAsClass - val descriptor = DescriptorsToIrRemapper.remapDeclaredSimpleFunction(fakeOverride.descriptor) - with(fakeOverride) { - IrFunctionImpl( - UNDEFINED_OFFSET, UNDEFINED_OFFSET, JvmLoweredDeclarationOrigin.DEFAULT_IMPLS_BRIDGE, - IrSimpleFunctionSymbolImpl(descriptor), - name, visibility, modality, returnType, - isInline = isInline, - isExternal = false, - isTailrec = false, - isSuspend = isSuspend, - isExpect = false, - isFakeOverride = false, - isOperator = isOperator - ).apply { - descriptor.bind(this) - parent = irClass - overriddenSymbols = fakeOverride.overriddenSymbols - copyParameterDeclarationsFrom(fakeOverride) - annotations = fakeOverride.annotations - copyCorrespondingPropertyFrom(fakeOverride) - } + buildFun(fakeOverride.descriptor) { + origin = JvmLoweredDeclarationOrigin.DEFAULT_IMPLS_BRIDGE + name = fakeOverride.name + visibility = fakeOverride.visibility + modality = fakeOverride.modality + returnType = fakeOverride.returnType + isInline = fakeOverride.isInline + isExternal = false + isTailrec = false + isSuspend = fakeOverride.isSuspend + isOperator = fakeOverride.isOperator + isExpect = false + isFakeOverride = false + }.apply { + parent = irClass + overriddenSymbols = fakeOverride.overriddenSymbols + copyParameterDeclarationsFrom(fakeOverride) + annotations = fakeOverride.annotations + copyCorrespondingPropertyFrom(fakeOverride) } - - } - } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AddContinuationLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AddContinuationLowering.kt index 8471b03c312..829b1c5334f 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AddContinuationLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AddContinuationLowering.kt @@ -583,7 +583,7 @@ private class AddContinuationLowering(private val context: JvmBackendContext) : if (function.body == null || !function.hasContinuation()) return result if (flag.capturesCrossinline || function.isInline) { - result += buildFunWithDescriptorForInlining(view.descriptor) { + result += buildFun(view.descriptor) { name = Name.identifier(view.name.asString() + FOR_INLINE_SUFFIX) returnType = view.returnType modality = view.modality @@ -651,7 +651,7 @@ internal fun IrFunction.suspendFunctionOriginal(): IrFunction = private fun IrFunction.createSuspendFunctionStub(context: JvmBackendContext): IrFunction { require(this.isSuspend && this is IrSimpleFunction) - return buildFunWithDescriptorForInlining(descriptor) { + return buildFun(descriptor) { updateFrom(this@createSuspendFunctionStub) name = this@createSuspendFunctionStub.name origin = this@createSuspendFunctionStub.origin diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOverloadsAnnotationLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOverloadsAnnotationLowering.kt index 68cef413d62..e3d72a181e0 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOverloadsAnnotationLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOverloadsAnnotationLowering.kt @@ -14,14 +14,12 @@ import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET +import org.jetbrains.kotlin.ir.builders.declarations.buildFun 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.descriptors.WrappedClassConstructorDescriptor -import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor import org.jetbrains.kotlin.ir.expressions.impl.* import org.jetbrains.kotlin.ir.symbols.impl.IrConstructorSymbolImpl -import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl import org.jetbrains.kotlin.ir.types.defaultType import org.jetbrains.kotlin.ir.util.allTypeParameters import org.jetbrains.kotlin.ir.util.deepCopyWithSymbols @@ -137,29 +135,16 @@ private class JvmOverloadsAnnotationLowering(val context: JvmBackendContext) : C descriptor.bind(this) } } - is IrSimpleFunction -> { - val descriptor = WrappedSimpleFunctionDescriptor(oldFunction.descriptor.annotations) - val modality = + is IrSimpleFunction -> buildFun(oldFunction.descriptor) { + origin = JvmLoweredDeclarationOrigin.JVM_OVERLOADS_WRAPPER + name = oldFunction.name + visibility = oldFunction.visibility + modality = if (context.state.languageVersionSettings.supportsFeature(LanguageFeature.GenerateJvmOverloadsAsFinal)) Modality.FINAL else oldFunction.modality - IrFunctionImpl( - UNDEFINED_OFFSET, UNDEFINED_OFFSET, - JvmLoweredDeclarationOrigin.JVM_OVERLOADS_WRAPPER, - IrSimpleFunctionSymbolImpl(descriptor), - oldFunction.name, - oldFunction.visibility, - modality, - returnType = oldFunction.returnType, - isInline = oldFunction.isInline, - isExternal = false, - isTailrec = false, - isSuspend = oldFunction.isSuspend, - isExpect = false, - isFakeOverride = false, - isOperator = false, - ).apply { - descriptor.bind(this) - } + returnType = oldFunction.returnType + isInline = oldFunction.isInline + isSuspend = oldFunction.isSuspend } else -> error("Unknown kind of IrFunction: $oldFunction") } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStaticAnnotationLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStaticAnnotationLowering.kt index 410ee9ce590..ac34bda3f6f 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStaticAnnotationLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStaticAnnotationLowering.kt @@ -23,7 +23,7 @@ import org.jetbrains.kotlin.backend.jvm.ir.replaceThisByStaticReference import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.ir.builders.declarations.addFunction -import org.jetbrains.kotlin.ir.builders.declarations.buildFunWithDescriptorForInlining +import org.jetbrains.kotlin.ir.builders.declarations.buildFun import org.jetbrains.kotlin.ir.builders.irCall import org.jetbrains.kotlin.ir.builders.irExprBody import org.jetbrains.kotlin.ir.builders.irGet @@ -192,7 +192,7 @@ private class MakeCallsStatic( } private fun IrSimpleFunction.copyRemovingDispatchReceiver(): IrSimpleFunction = - buildFunWithDescriptorForInlining(descriptor) { + buildFun(descriptor) { updateFrom(this@copyRemovingDispatchReceiver) name = this@copyRemovingDispatchReceiver.name returnType = this@copyRemovingDispatchReceiver.returnType @@ -210,4 +210,3 @@ private fun isJvmStaticFunction(declaration: IrDeclaration): Boolean = (declaration.hasAnnotation(JVM_STATIC_ANNOTATION_FQ_NAME) || declaration.correspondingPropertySymbol?.owner?.hasAnnotation(JVM_STATIC_ANNOTATION_FQ_NAME) == true) && declaration.origin != JvmLoweredDeclarationOrigin.SYNTHETIC_METHOD_FOR_PROPERTY_ANNOTATIONS - diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/MemoizedInlineClassReplacements.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/MemoizedInlineClassReplacements.kt index cdda34fdad0..45010959b5a 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/MemoizedInlineClassReplacements.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/MemoizedInlineClassReplacements.kt @@ -17,7 +17,6 @@ import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.ir.builders.declarations.addValueParameter import org.jetbrains.kotlin.ir.builders.declarations.buildFun -import org.jetbrains.kotlin.ir.builders.declarations.buildFunWithDescriptorForInlining import org.jetbrains.kotlin.ir.builders.declarations.buildProperty import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns @@ -185,7 +184,7 @@ class MemoizedInlineClassReplacements(private val mangleReturnTypes: Boolean) { replacementOrigin: IrDeclarationOrigin, noFakeOverride: Boolean = false, body: IrFunction.() -> Unit - ) = buildFunWithDescriptorForInlining(function.descriptor) { + ): IrSimpleFunction = buildFun(function.descriptor) { updateFrom(function) if (function is IrConstructor) { // The [updateFrom] call will set the modality to FINAL for constructors, while the JVM backend would use OPEN here.