Raw FIR: get rid of array gets, use array sets only for modifications

(a[b] += c etc. cannot be replaced with get/set calls easily)

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt

@@ -471,9 +471,21 @@ internal fun KtExpression?.generateAssignment(
     }
     if (this is KtArrayAccessExpression) {
         val arrayExpression = this.arrayExpression
-        val arraySet = FirArraySetCallImpl(session, psi, value, operation).apply {
-            for (indexExpression in indexExpressions) {
-                indexes += indexExpression.convert()
+        val firArrayExpression = arrayExpression?.convert() ?: FirErrorExpressionImpl(session, arrayExpression, "No array expression")
+        val arraySet = if (operation != FirOperation.ASSIGN) {
+            FirArraySetCallImpl(session, psi, value, operation).apply {
+                for (indexExpression in indexExpressions) {
+                    indexes += indexExpression.convert()
+                }
+            }
+        } else {
+            return FirFunctionCallImpl(session, psi).apply {
+                calleeReference = FirSimpleNamedReference(session, psi, OperatorNameConventions.SET)
+                explicitReceiver = firArrayExpression
+                for (indexExpression in indexExpressions) {
+                    arguments += indexExpression.convert()
+                }
+                arguments += value
             }
         }
         if (arrayExpression is KtSimpleNameExpression) {
@@ -483,10 +495,7 @@ internal fun KtExpression?.generateAssignment(
         }
         return FirBlockImpl(session, arrayExpression).apply {
             val name = Name.special("<array-set>")
-            statements += generateTemporaryVariable(
-                session, this@generateAssignment, name,
-                arrayExpression?.convert() ?: FirErrorExpressionImpl(session, arrayExpression, "No array expression")
-            )
+            statements += generateTemporaryVariable(session, this@generateAssignment, name, firArrayExpression)
             statements += arraySet.apply { lValue = FirSimpleNamedReference(session, arrayExpression, name) }
         }
     }

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt

@@ -1251,7 +1251,9 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
 
         override fun visitArrayAccessExpression(expression: KtArrayAccessExpression, data: Unit): FirElement {
             val arrayExpression = expression.arrayExpression
-            return FirArrayGetCallImpl(session, expression, arrayExpression.toFirExpression("No array expression")).apply {
+            return FirFunctionCallImpl(session, expression).apply {
+                calleeReference = FirSimpleNamedReference(this@RawFirBuilder.session, expression, OperatorNameConventions.GET)
+                explicitReceiver = arrayExpression.toFirExpression("No array expression")
                 for (indexExpression in expression.indexExpressions) {
                     arguments += indexExpression.toFirExpression("Incorrect index expression")
                 }

compiler/fir/psi2fir/testData/rawBuilder/expressions/arrayAccess.txt

@@ -12,5 +12,5 @@ FILE: arrayAccess.kt
 
     }
     public? final? fun test(a: IntArray, w: Wrapper): <implicit> {
-        ^test a#[Int(0)].plus#(a#[p#]).plus#(a#[foo#()]).plus#(w#.v#[Int(0)])
+        ^test a#.get#(Int(0)).plus#(a#.get#(p#)).plus#(a#.get#(foo#())).plus#(w#.v#.get#(Int(0)))
     }

compiler/fir/psi2fir/testData/rawBuilder/expressions/arrayAssignment.txt

@@ -1,12 +1,11 @@
 FILE: arrayAssignment.kt
     public? final? fun test(): kotlin/Unit {
         lval x: <implicit> = intArrayOf#(Int(1), Int(2), Int(3))
-        x#[Int(1)] = Int(0)
+        x#.set#(Int(1), Int(0))
     }
     public? final? fun foo(): <implicit> {
         ^foo Int(1)
     }
     public? final? fun test2(): kotlin/Unit {
-        lval <array-set>: <implicit> = intArrayOf#(Int(1), Int(2), Int(3))
-        <array-set>#[foo#()] = Int(1)
+        intArrayOf#(Int(1), Int(2), Int(3)).set#(foo#(), Int(1))
     }

compiler/fir/psi2fir/testData/rawBuilder/expressions/unary.txt

@@ -58,15 +58,15 @@ FILE: unary.kt
     }
     public? final? fun test3(arr: Array<Int>): kotlin/Unit {
         lval x1: <implicit> =  {
-            lval <unary>: <implicit> = arr#[Int(0)]
-            arr#[Int(0)] = inc#(<unary>#)
+            lval <unary>: <implicit> = arr#.get#(Int(0))
+            arr#.set#(Int(0), inc#(<unary>#))
             <unary>#
         }
 
         lval x2: <implicit> =  {
-            lval <unary>: <implicit> = arr#[Int(1)]
+            lval <unary>: <implicit> = arr#.get#(Int(1))
             lval <unary-result>: <implicit> = inc#(<unary>#)
-            arr#[Int(1)] = <unary-result>#
+            arr#.set#(Int(1), <unary-result>#)
             <unary-result>#
         }
 
@@ -80,17 +80,15 @@ FILE: unary.kt
     }
     public? final? fun test4(y: Y): kotlin/Unit {
         lval x1: <implicit> =  {
-            lval <unary>: <implicit> = y#.arr#[Int(0)]
-            lval <array-set>: <implicit> = y#.arr#
-            <array-set>#[Int(0)] = inc#(<unary>#)
+            lval <unary>: <implicit> = y#.arr#.get#(Int(0))
+            y#.arr#.set#(Int(0), inc#(<unary>#))
             <unary>#
         }
 
         lval x2: <implicit> =  {
-            lval <unary>: <implicit> = y#.arr#[Int(1)]
+            lval <unary>: <implicit> = y#.arr#.get#(Int(1))
             lval <unary-result>: <implicit> = inc#(<unary>#)
-            lval <array-set>: <implicit> = y#.arr#
-            <array-set>#[Int(1)] = <unary-result>#
+            y#.arr#.set#(Int(1), <unary-result>#)
             <unary-result>#
         }