[IR] Do a real copy in copyAttributes, not a link via attributeOwnerId

Such approach is more straightforward and more expected. Because
previously two or more elements shared the same map, one could be
accidentally changed by modifying the other. Another unexpected
behaviour is with chained copyAttributes calls (common example is
deepCopy + copyAttributes).

Now, even though attributeOwnerId is no longer used for actual
IR attributes, it still has many and rather unclear usages. So, while
it's not related to "copying attributes" anymore, it was left intact in
"copyAttributes()". Its actual purpose should be investigated later.

#KT-74331 Fixed

Author: mcpiroman

compiler/ir/backend.common/test/org/jetbrains/kotlin/backend/common/IrAttributeTests.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.backend.common
 
 import org.jetbrains.kotlin.ir.*
+import org.jetbrains.kotlin.ir.declarations.copyAttributes
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.impl.IrConstImpl
 import org.jetbrains.kotlin.ir.types.impl.IrErrorTypeImpl
@@ -112,16 +113,57 @@ class IrAttributeTests {
         }
     }
 
+    @Test
+    fun copyToEmpty() {
+        val element1 = createIrElement()
+        element1.foo = 10
+        element1.baz = "test"
+
+        val element2 = createIrElement()
+        element2.copyAttributes(element1)
+
+        assertEquals(element1.attributes, element2.attributes)
+    }
+
+    @Test
+    fun copyFromEmpty() {
+        val element1 = createIrElement()
+
+        val element2 = createIrElement()
+        element2.foo = 10
+        element2.baz = "test"
+        element2.copyAttributes(element1)
+
+        assertEquals(element2.foo, 10)
+        assertEquals(element2.baz, "test")
+    }
+
+    @Test
+    fun copyWithOverride() {
+        val element1 = createIrElement()
+        element1.foo = 10
+        element1.baz = "new"
+
+        val element2 = createIrElement()
+        element2.baz = "prev"
+        element2.bar = true
+        element2.copyAttributes(element1)
+
+        assertEquals(element2.foo, 10)
+        assertEquals(element2.bar, true)
+        assertEquals(element2.baz, "new")
+    }
+
     @Test
     fun stressTest() {
         val element = createIrElement()
-        val attributes = List(10) { irAttribute<IrExpression, Int>(followAttributeOwner = false).create(null, "attr$it") }
+        val attributes = List(10) { irAttribute<IrExpression, Int>(followAttributeOwner = true).create(null, "attr$it") }
         val realAttributeValues = mutableMapOf<IrAttribute<IrExpression, Int>, Int?>()
 
         val rng = Random(1)
         repeat(1000) { i ->
             val attr = attributes.random(rng)
-            when (rng.nextInt(5)) {
+            when (rng.nextInt(6)) {
                 0 -> {
                     element[attr] = i
                     realAttributeValues[attr] = i
@@ -131,6 +173,12 @@ class IrAttributeTests {
                     realAttributeValues.remove(attr)
                 }
                 2 -> {
+                    val srcEl = createIrElement()
+                    srcEl[attr] = i
+                    element.copyAttributes(srcEl)
+                    realAttributeValues[attr] = i
+                }
+                3 -> {
                     assertEquals<Map<out IrAttribute<*, *>, Any?>>(element.attributes, realAttributeValues)
                 }
                 else -> {

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/IrAttribute.kt

@@ -50,7 +50,7 @@ fun <E : IrElement> irFlag(followAttributeOwner: Boolean): IrAttribute.Flag.Dele
  * Returns a value of [attribute], or null if the value is missing.
  */
 operator fun <E : IrElement, T : Any> E.get(attribute: IrAttribute<E, T>): T? {
-    return (unwrapAttributeOwner(attribute) as IrElementBase).getAttributeInternal(attribute)
+    return (this as IrElementBase).getAttributeInternal(attribute)
 }
 
 /**
@@ -59,30 +59,9 @@ operator fun <E : IrElement, T : Any> E.get(attribute: IrAttribute<E, T>): T? {
  * @return The previous value associated with the attribute, or null if the attribute was not present.
  */
 operator fun <E : IrElement, T : Any> E.set(attribute: IrAttribute<E, T>, value: T?): T? {
-    return (unwrapAttributeOwner(attribute) as IrElementBase).setAttributeInternal(attribute, value)
+    return (this as IrElementBase).setAttributeInternal(attribute, value)
 }
 
-private fun <E : IrElement> E.unwrapAttributeOwner(attribute: IrAttribute<E, *>): IrElement {
-    // This mechanism is intended to aid with future migration off of attributeOwnerId.
-    // The main change would be that [copyAttributes] wouldn't just set attributeOwnerId to the copied element,
-    // but do a proper clone of an attribute array.
-    // Details:
-    // This place allows us to record if/when a given property is accessed via attributeOwnerId or not.
-    // If it always is, it means that this particular property should be copied in [copyAttributes] by default.
-    // Otherwise, we should probably still seek for a possibility to copy it by default. For that, we can also add tracking
-    // of properties' gets/sets, and check,during compiler execution, whether a value returned from a copy always
-    // matches the one returned via `attributeOwnerId.get`. If it does, it is probably safe to always copy it as well.
-    // There is one more peculiarity in the current implementation of [copyAttributes] via attributeOwnerId - it is
-    // essentially not a copy, but a link between two objects which share the same attributes - if
-    // those are accessed via attributeOwnerId, this is. However, attributes will employ a hard copy.
-    // To ensure the new behavior is the-same-or-better, the tracking and comparison can be used as well.
-
-    return if (attribute.followAttributeOwner)
-        this.attributeOwnerId
-    else this
-}
-
-
 /**
  * A key for storing additional data inside [IrElement].
  *

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/IrElementBase.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.ir
 
 import org.jetbrains.kotlin.ir.visitors.IrTransformer
 import org.jetbrains.kotlin.ir.visitors.IrVisitor
+import java.util.IdentityHashMap
 
 abstract class IrElementBase : IrElement {
     /**
@@ -151,4 +152,39 @@ abstract class IrElementBase : IrElement {
         attributes[lastKeyIndex] = null
         attributes[lastKeyIndex + 1] = null
     }
+
+    internal fun copyAttributesFrom(other: IrElementBase, includeAll: Boolean) {
+        val srcAttributes = other._attributes ?: return
+        var dstAttributes = _attributes
+        val mergedAttributes = IdentityHashMap<IrAttribute<*, *>, Any?>((srcAttributes.size + (dstAttributes?.size ?: 0)) / 2)
+
+        if (dstAttributes != null) {
+            for (i in dstAttributes.indices step 2) {
+                val attr = dstAttributes[i] as IrAttribute<*, *>? ?: break
+                mergedAttributes[attr] = dstAttributes[i + 1]
+            }
+        }
+        for (i in srcAttributes.indices step 2) {
+            val attr = srcAttributes[i] as IrAttribute<*, *>? ?: break
+            if (attr.followAttributeOwner || includeAll) {
+                mergedAttributes[attr] = srcAttributes[i + 1]
+            }
+        }
+
+        if (mergedAttributes.isEmpty()) {
+            return
+        }
+
+        if (dstAttributes == null || dstAttributes.size <= mergedAttributes.size * 2) {
+            dstAttributes = arrayOfNulls(mergedAttributes.size * 2)
+            this._attributes = dstAttributes
+        }
+
+        var i = 0
+        for ((attr, value) in mergedAttributes) {
+            dstAttributes[i] = attr
+            dstAttributes[i + 1] = value
+            i += 2
+        }
+    }
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarations.kt

@@ -9,18 +9,17 @@ import org.jetbrains.kotlin.CompilerVersionOfApiDeprecation
 import org.jetbrains.kotlin.DeprecatedForRemovalCompilerApi
 import org.jetbrains.kotlin.descriptors.InlineClassRepresentation
 import org.jetbrains.kotlin.descriptors.MultiFieldValueClassRepresentation
-import org.jetbrains.kotlin.descriptors.ParameterDescriptor
-import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
+import org.jetbrains.kotlin.ir.IrAttribute
 import org.jetbrains.kotlin.ir.IrElement
-import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
-import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
+import org.jetbrains.kotlin.ir.IrElementBase
 import org.jetbrains.kotlin.ir.originalBeforeInline
 import org.jetbrains.kotlin.ir.types.IrSimpleType
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.NameUtils.getPackagePartClassNamePrefix
 import java.io.File
 
-fun IrElement.copyAttributes(other: IrElement) {
+fun IrElement.copyAttributes(other: IrElement, includeAll: Boolean = false) {
+    (this as IrElementBase).copyAttributesFrom(other as IrElementBase, includeAll)
     attributeOwnerId = other.attributeOwnerId
     originalBeforeInline = other.originalBeforeInline
 }