IR: move containerSource from descriptor to IrFunction, IrProperty

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt

@@ -508,7 +508,7 @@ fun IrFactory.createStaticFunctionWithReceivers(
     typeParametersFromContext: List<IrTypeParameter> = listOf()
 ): IrSimpleFunction {
     val descriptor = (oldFunction.descriptor as? DescriptorWithContainerSource)?.let {
-        WrappedFunctionDescriptorWithContainerSource(it.containerSource)
+        WrappedFunctionDescriptorWithContainerSource()
     } ?: WrappedSimpleFunctionDescriptor(Annotations.EMPTY, oldFunction.descriptor.source)
     return createFunction(
         oldFunction.startOffset, oldFunction.endOffset,
@@ -525,7 +525,8 @@ fun IrFactory.createStaticFunctionWithReceivers(
         isExpect = oldFunction.isExpect,
         isFakeOverride = isFakeOverride,
         isOperator = oldFunction is IrSimpleFunction && oldFunction.isOperator,
-        isInfix = oldFunction is IrSimpleFunction && oldFunction.isInfix
+        isInfix = oldFunction is IrSimpleFunction && oldFunction.isInfix,
+        containerSource = oldFunction.containerSource,
     ).apply {
         descriptor.bind(this)
         parent = irParent

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt

@@ -537,7 +537,7 @@ private fun IrFunction.generateDefaultsFunctionImpl(
                 visibility = newVisibility
             }
         is IrSimpleFunction ->
-            factory.buildFun(descriptor) {
+            factory.buildFun {
                 updateFrom(this@generateDefaultsFunctionImpl)
                 name = Name.identifier("${this@generateDefaultsFunctionImpl.name}\$default")
                 origin = newOrigin

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LocalDeclarationsLowering.kt

@@ -595,7 +595,7 @@ class LocalDeclarationsLowering(
             // TODO: consider using fields to access the closure of enclosing class.
             val (capturedValues, capturedTypeParameters) = localFunctionContext.closure
 
-            val newDeclaration = context.irFactory.buildFun(oldDeclaration.descriptor) {
+            val newDeclaration = context.irFactory.buildFun {
                 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 = context.irFactory.buildConstructor(oldDeclaration.descriptor) {
+            val newDeclaration = context.irFactory.buildConstructor {
                 updateFrom(oldDeclaration)
                 visibility = visibilityPolicy.forConstructor(oldDeclaration, constructorContext.inInlineFunctionScope)
                 returnType = oldDeclaration.returnType

compiler/ir/backend.common/src/org/jetbrains/kotlin/ir/builders/declarations/declarationBuilders.kt

@@ -10,6 +10,8 @@ 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.IrVariableImpl
+import org.jetbrains.kotlin.ir.declarations.lazy.IrLazyFunction
+import org.jetbrains.kotlin.ir.declarations.lazy.IrLazyProperty
 import org.jetbrains.kotlin.ir.descriptors.*
 import org.jetbrains.kotlin.ir.symbols.impl.*
 import org.jetbrains.kotlin.ir.types.IrType
@@ -74,32 +76,30 @@ fun IrClass.addField(fieldName: String, fieldType: IrType, fieldVisibility: Visi
     addField(Name.identifier(fieldName), fieldType, fieldVisibility)
 
 @PublishedApi
-internal fun IrFactory.buildProperty(
-    builder: IrPropertyBuilder,
-    originalDescriptor: PropertyDescriptor? = null
-): IrProperty = with(builder) {
-    val wrappedDescriptor = when (originalDescriptor) {
-        is DescriptorWithContainerSource -> WrappedPropertyDescriptorWithContainerSource(originalDescriptor.containerSource)
-        else -> WrappedPropertyDescriptor()
-    }
+internal fun IrFactory.buildProperty(builder: IrPropertyBuilder): IrProperty = with(builder) {
+    val wrappedDescriptor = if (originalDeclaration is IrLazyProperty || containerSource != null)
+        WrappedPropertyDescriptorWithContainerSource()
+    else WrappedPropertyDescriptor()
+
     createProperty(
         startOffset, endOffset, origin,
         IrPropertySymbolImpl(wrappedDescriptor),
         name, visibility, modality,
-        isVar, isConst, isLateinit, isDelegated, isExternal, isExpect, isFakeOverride
+        isVar, isConst, isLateinit, isDelegated, isExternal, isExpect, isFakeOverride,
+        containerSource,
     ).also {
         wrappedDescriptor.bind(it)
     }
 }
 
-inline fun IrFactory.buildProperty(originalDescriptor: PropertyDescriptor? = null, builder: IrPropertyBuilder.() -> Unit) =
+inline fun IrFactory.buildProperty(builder: IrPropertyBuilder.() -> Unit) =
     IrPropertyBuilder().run {
         builder()
-        buildProperty(this, originalDescriptor)
+        buildProperty(this)
     }
 
-inline fun IrClass.addProperty(originalDescriptor: PropertyDescriptor? = null, builder: IrPropertyBuilder.() -> Unit): IrProperty =
-    factory.buildProperty(originalDescriptor, builder).also { property ->
+inline fun IrClass.addProperty(builder: IrPropertyBuilder.() -> Unit): IrProperty =
+    factory.buildProperty(builder).also { property ->
         declarations.add(property)
         property.parent = this@addProperty
     }
@@ -116,57 +116,44 @@ inline fun IrProperty.addGetter(builder: IrFunctionBuilder.() -> Unit = {}): IrS
     }
 
 @PublishedApi
-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) {
-        is DescriptorWithContainerSource -> WrappedFunctionDescriptorWithContainerSource(originalDescriptor.containerSource)
-        is PropertyGetterDescriptor -> WrappedPropertyGetterDescriptor(originalDescriptor.annotations, originalDescriptor.source)
-        is PropertySetterDescriptor -> WrappedPropertySetterDescriptor(originalDescriptor.annotations, originalDescriptor.source)
-        null -> WrappedSimpleFunctionDescriptor()
-        else -> WrappedSimpleFunctionDescriptor(originalDescriptor)
-    }
+internal fun IrFactory.buildFunction(builder: IrFunctionBuilder): IrSimpleFunction = with(builder) {
+    val wrappedDescriptor = if (originalDeclaration is IrLazyFunction || containerSource != null)
+        WrappedFunctionDescriptorWithContainerSource()
+    else WrappedSimpleFunctionDescriptor()
     createFunction(
         startOffset, endOffset, origin,
         IrSimpleFunctionSymbolImpl(wrappedDescriptor),
         name, visibility, modality, returnType,
-        isInline, isExternal, isTailrec, isSuspend, isOperator, isInfix, isExpect, isFakeOverride
+        isInline, isExternal, isTailrec, isSuspend, isOperator, isInfix, isExpect, isFakeOverride,
+        containerSource,
     ).also {
         wrappedDescriptor.bind(it)
     }
 }
 
 @PublishedApi
-internal fun IrFactory.buildConstructor(
-    builder: IrFunctionBuilder, originalDescriptor: ConstructorDescriptor?
-): IrConstructor = with(builder) {
-    val wrappedDescriptor =
-        if (originalDescriptor != null) WrappedClassConstructorDescriptor(originalDescriptor.annotations, originalDescriptor.source)
-        else WrappedClassConstructorDescriptor()
+internal fun IrFactory.buildConstructor(builder: IrFunctionBuilder): IrConstructor = with(builder) {
+    val wrappedDescriptor = WrappedClassConstructorDescriptor()
     return createConstructor(
         startOffset, endOffset, origin,
         IrConstructorSymbolImpl(wrappedDescriptor),
         Name.special("<init>"),
         visibility, returnType,
-        isInline = isInline, isExternal = isExternal, isPrimary = isPrimary, isExpect = isExpect
+        isInline = isInline, isExternal = isExternal, isPrimary = isPrimary, isExpect = isExpect,
+        containerSource = containerSource
     ).also {
         wrappedDescriptor.bind(it)
     }
 }
 
-inline fun IrFactory.buildFun(
-    originalDescriptor: FunctionDescriptor? = null, builder: IrFunctionBuilder.() -> Unit
-): IrSimpleFunction =
+inline fun IrFactory.buildFun(builder: IrFunctionBuilder.() -> Unit): IrSimpleFunction =
     IrFunctionBuilder().run {
         builder()
-        buildFunction(this, originalDescriptor)
+        buildFunction(this)
     }
 
 inline fun IrFactory.addFunction(klass: IrDeclarationContainer, builder: IrFunctionBuilder.() -> Unit): IrSimpleFunction =
-    buildFun(null, builder).also { function ->
+    buildFun(builder).also { function ->
         klass.declarations.add(function)
         function.parent = klass
     }
@@ -198,13 +185,10 @@ fun IrClass.addFunction(
         }
     }
 
-inline fun IrFactory.buildConstructor(
-    originalDescriptor: ConstructorDescriptor? = null,
-    builder: IrFunctionBuilder.() -> Unit
-): IrConstructor =
+inline fun IrFactory.buildConstructor(builder: IrFunctionBuilder.() -> Unit): IrConstructor =
     IrFunctionBuilder().run {
         builder()
-        buildConstructor(this, originalDescriptor)
+        buildConstructor(this)
     }
 
 inline fun IrClass.addConstructor(builder: IrFunctionBuilder.() -> Unit = {}): IrConstructor =