[IR] Rename IrElement.attributes

Debugger shows both the field and the property.
Rename them so it is clear that one is a backing filed of the other.

Author: mcpiroman

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

@@ -27,19 +27,19 @@ class IrAttributeTests {
         IrConstImpl.constNull(0, 0, IrErrorTypeImpl(null, listOf(), Variance.INVARIANT))
 
     private val IrElement.allAttributes: Map<IrAttribute<*, *>, Any>
-        get() = (this as IrElementBase).allAttributes
+        get() = (this as IrElementBase).attributes
 
 
     @Test
     fun simpleSet() {
         val element = createIrElement()
 
         assertEquals(null, element.foo)
-        assertTrue(element.allAttributes.isEmpty())
+        assertTrue(element.attributes.isEmpty())
 
         element.foo = 10
         assertEquals(10, element.foo)
-        assertEquals<Map<IrAttribute<*, *>, Any?>>(mapOf(fooAttr to 10), element.allAttributes)
+        assertEquals<Map<IrAttribute<*, *>, Any?>>(mapOf(fooAttr to 10), element.attributes)
     }
 
     @Test
@@ -83,7 +83,7 @@ class IrAttributeTests {
         assertEquals("test", element.baz)
         assertEquals<Map<IrAttribute<*, *>, Any?>>(
             mapOf(fooAttr to 10, barAttr to true, bazAttr to "test"),
-            element.allAttributes
+            element.attributes
         )
 
         element.foo = 200
@@ -92,7 +92,7 @@ class IrAttributeTests {
         assertEquals(null, element.bar)
         assertEquals<Map<IrAttribute<*, *>, Any?>>(
             mapOf(fooAttr to 200, bazAttr to "test"),
-            element.allAttributes
+            element.attributes
         )
     }
 
@@ -106,7 +106,7 @@ class IrAttributeTests {
             element.foo = it
             assertEquals(it, element.foo)
             assertEquals(true, element.bar)
-            assertEquals(2, element.allAttributes.size)
+            assertEquals(2, element.attributes.size)
 
             element.foo = null
         }
@@ -131,7 +131,7 @@ class IrAttributeTests {
                     realAttributeValues.remove(attr)
                 }
                 2 -> {
-                    assertEquals<Map<out IrAttribute<*, *>, Any?>>(element.allAttributes, realAttributeValues)
+                    assertEquals<Map<out IrAttribute<*, *>, Any?>>(element.attributes, realAttributeValues)
                 }
                 else -> {
                     assertEquals(realAttributeValues[attr], element[attr])

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

@@ -26,7 +26,7 @@ abstract class IrElementBase : IrElement {
      * Keys are of type [IrAttribute].
      * Values are arbitrary objects but cannot be null.
      */
-    private var attributeMap: Array<Any?>? = null
+    private var _attributes: Array<Any?>? = null
 
     override fun <D> transform(transformer: IrTransformer<D>, data: D): IrElement =
         accept(transformer, data)
@@ -44,15 +44,15 @@ abstract class IrElementBase : IrElement {
      * Returns a snapshot of all attributes held by this element.
      * Designated mainly for debugging.
      */
-    val allAttributes: Map<IrAttribute<*, *>, Any>
+    val attributes: Map<IrAttribute<*, *>, Any>
         get() {
-            val attributeMap = attributeMap
+            val attributes = _attributes
                 ?: return emptyMap()
-            return buildMap(attributeMap.size / 2) {
-                for (i in attributeMap.indices step 2) {
-                    val key = attributeMap[i] as IrAttribute<*, *>?
+            return buildMap(attributes.size / 2) {
+                for (i in attributes.indices step 2) {
+                    val key = attributes[i] as IrAttribute<*, *>?
                         ?: break
-                    val value = attributeMap[i + 1]!!
+                    val value = attributes[i + 1]!!
                     put(key, value)
                 }
             }
@@ -64,28 +64,28 @@ abstract class IrElementBase : IrElement {
             return null
         } else {
             @Suppress("UNCHECKED_CAST")
-            return attributeMap!![foundIndex + 1] as T
+            return _attributes!![foundIndex + 1] as T
         }
     }
 
     internal fun <T : Any> setAttributeInternal(key: IrAttribute<*, T>, value: T?): T? {
         val foundIndex = findAttributeIndex(key)
         val previousValue: T? = if (foundIndex >= 0) {
             @Suppress("UNCHECKED_CAST")
-            attributeMap!![foundIndex + 1] as T
+            _attributes!![foundIndex + 1] as T
         } else null
 
         putAttribute(foundIndex, key, value)
         return previousValue
     }
 
     private fun findAttributeIndex(key: IrAttribute<*, *>): Int {
-        val attributeMap = attributeMap
+        val attributes = _attributes
             ?: return -1
 
         var i = 0
-        while (i < attributeMap.size) {
-            val foundKey = attributeMap[i]
+        while (i < attributes.size) {
+            val foundKey = attributes[i]
                 ?: break
             if (foundKey === key) {
                 return i
@@ -98,21 +98,21 @@ abstract class IrElementBase : IrElement {
 
     private fun <T : Any> initializeAttributes(firstKey: IrAttribute<*, T>, firstValue: T) {
         val initialSlots = 1
-        val attributeMap = arrayOfNulls<Any?>(initialSlots * 2)
-        attributeMap[0] = firstKey
-        attributeMap[1] = firstValue
-        this.attributeMap = attributeMap
+        val attributes = arrayOfNulls<Any?>(initialSlots * 2)
+        attributes[0] = firstKey
+        attributes[1] = firstValue
+        this._attributes = attributes
     }
 
     private fun <T : Any> putAttribute(existingIndex: Int, key: IrAttribute<*, T>, value: T?) {
         if (existingIndex >= 0) {
             if (value == null) {
                 removeAttributeAt(existingIndex)
             } else {
-                attributeMap!![existingIndex + 1] = value
+                _attributes!![existingIndex + 1] = value
             }
         } else if (value != null) {
-            if (attributeMap == null) {
+            if (_attributes == null) {
                 initializeAttributes(key, value)
             } else {
                 val newEntryIndex = existingIndex.inv()
@@ -122,33 +122,33 @@ abstract class IrElementBase : IrElement {
     }
 
     private fun <T : Any> addAttributeAt(index: Int, key: IrAttribute<*, T>, value: T) {
-        var attributeMap = attributeMap!!
-        if (attributeMap.size <= index) {
+        var attributes = _attributes!!
+        if (attributes.size <= index) {
             val newSlots = 2
-            attributeMap = attributeMap.copyOf(attributeMap.size + newSlots * 2)
-            this.attributeMap = attributeMap
+            attributes = attributes.copyOf(attributes.size + newSlots * 2)
+            this._attributes = attributes
         }
 
-        attributeMap[index] = key
-        attributeMap[index + 1] = value
+        attributes[index] = key
+        attributes[index + 1] = value
     }
 
     private fun removeAttributeAt(keyIndex: Int) {
         // It is expected that during the compilation process, attributes are mostly appended
         // and rarely removed, hence no need to shrink the array.
 
-        val attributeMap = attributeMap!!
+        val attributes = _attributes!!
 
-        var lastKeyIndex = attributeMap.size - 2
-        while (lastKeyIndex > keyIndex && attributeMap[lastKeyIndex] == null) {
+        var lastKeyIndex = attributes.size - 2
+        while (lastKeyIndex > keyIndex && attributes[lastKeyIndex] == null) {
             lastKeyIndex -= 2
         }
 
         if (lastKeyIndex > keyIndex) {
-            attributeMap[keyIndex] = attributeMap[lastKeyIndex]
-            attributeMap[keyIndex + 1] = attributeMap[lastKeyIndex + 1]
+            attributes[keyIndex] = attributes[lastKeyIndex]
+            attributes[keyIndex + 1] = attributes[lastKeyIndex + 1]
         }
-        attributeMap[lastKeyIndex] = null
-        attributeMap[lastKeyIndex + 1] = null
+        attributes[lastKeyIndex] = null
+        attributes[lastKeyIndex + 1] = null
     }
 }