[FIR] Rename FirArraySetCall to FirAugmentedArraySetCall

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt

@@ -1257,8 +1257,8 @@ class Fir2IrVisitor(
         }
     }
 
-    override fun visitArraySetCall(arraySetCall: FirArraySetCall, data: Any?): IrElement {
+    override fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: Any?): IrElement {
-        return arraySetCall.convertWithOffsets { startOffset, endOffset ->
+        return augmentedArraySetCall.convertWithOffsets { startOffset, endOffset ->
             IrErrorCallExpressionImpl(
                 startOffset, endOffset, typeConverter.unitType,
                 "FirArraySetCall (resolve isn't supported yet)"

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

@@ -479,7 +479,7 @@ abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Conte
             return if (operation == FirOperation.ASSIGN) {
                 this.convert()
             } else {
-                generateArraySetCall(baseSource, operation, rhs, convert)
+                generateAugmentedArraySetCall(baseSource, operation, rhs, convert)
             }
         }
 
@@ -506,13 +506,13 @@ abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Conte
         }
     }
 
-    private fun T.generateArraySetCall(
+    private fun T.generateAugmentedArraySetCall(
         baseSource: FirSourceElement?,
         operation: FirOperation,
         rhs: T?,
         convert: T.() -> FirExpression
     ): FirStatement {
-        return buildArraySetCall {
+        return buildAugmentedArraySetCall {
             source = baseSource
             this.operation = operation
             assignCall = generateAugmentedCallForAugmentedArraySetCall(operation, rhs, convert)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt

@@ -169,8 +169,8 @@ open class FirBodyResolveTransformer(
         return expressionsTransformer.transformDelegatedConstructorCall(delegatedConstructorCall, data)
     }
 
-    override fun transformArraySetCall(arraySetCall: FirArraySetCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
+    override fun transformAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
-        return expressionsTransformer.transformArraySetCall(arraySetCall, data)
+        return expressionsTransformer.transformAugmentedArraySetCall(augmentedArraySetCall, data)
     }
 
     // ------------------------------------- Declarations -------------------------------------

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt

@@ -629,13 +629,13 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
     }
 
     @OptIn(ExperimentalStdlibApi::class)
-    override fun transformArraySetCall(arraySetCall: FirArraySetCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
+    override fun transformAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
-        assert(arraySetCall.operation in FirOperation.ASSIGNMENTS)
+        assert(augmentedArraySetCall.operation in FirOperation.ASSIGNMENTS)
-        assert(arraySetCall.operation != FirOperation.ASSIGN)
+        assert(augmentedArraySetCall.operation != FirOperation.ASSIGN)
 
-        val operatorName = FirOperationNameConventions.ASSIGNMENTS.getValue(arraySetCall.operation)
+        val operatorName = FirOperationNameConventions.ASSIGNMENTS.getValue(augmentedArraySetCall.operation)
 
-        val firstCalls = with(arraySetCall.setGetBlock.statements.last() as FirFunctionCall) setCall@{
+        val firstCalls = with(augmentedArraySetCall.setGetBlock.statements.last() as FirFunctionCall) setCall@{
             buildList {
                 add(this@setCall)
                 with(arguments.last() as FirFunctionCall) plusCall@{
@@ -645,25 +645,25 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
             }
         }
         val secondCalls = listOf(
-            arraySetCall.assignCall,
+            augmentedArraySetCall.assignCall,
-            arraySetCall.assignCall.explicitReceiver as FirFunctionCall
+            augmentedArraySetCall.assignCall.explicitReceiver as FirFunctionCall
         )
 
         val firstResult = withLocalScopeCleanup {
-            arraySetCall.setGetBlock.transformSingle(transformer, ResolutionMode.ContextIndependent)
+            augmentedArraySetCall.setGetBlock.transformSingle(transformer, ResolutionMode.ContextIndependent)
         }
-        val secondResult = arraySetCall.assignCall.transformSingle(transformer, ResolutionMode.ContextIndependent)
+        val secondResult = augmentedArraySetCall.assignCall.transformSingle(transformer, ResolutionMode.ContextIndependent)
 
         val firstSucceed = firstCalls.all { it.typeRef !is FirErrorTypeRef }
         val secondSucceed = secondCalls.all { it.typeRef !is FirErrorTypeRef }
 
         val result: FirStatement = when {
             firstSucceed && secondSucceed -> {
-                arraySetCall.also {
+                augmentedArraySetCall.also {
                     it.replaceCalleeReference(
                         buildErrorNamedReference {
                             // TODO: add better diagnostic
-                            source = arraySetCall.source
+                            source = augmentedArraySetCall.source
                             diagnostic = FirAmbiguityError(operatorName, emptyList())
                         }
                     )
@@ -672,10 +672,10 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
             firstSucceed -> firstResult
             secondSucceed -> secondResult
             else -> {
-                arraySetCall.also {
+                augmentedArraySetCall.also {
                     it.replaceCalleeReference(
                         buildErrorNamedReference {
-                            source = arraySetCall.source
+                            source = augmentedArraySetCall.source
                             diagnostic = FirUnresolvedNameError(operatorName)
                         }
                     )

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirAugmentedArraySetCall.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirArraySetCall : FirPureAbstractElement(), FirStatement {
+abstract class FirAugmentedArraySetCall : FirPureAbstractElement(), FirStatement {
     abstract override val source: FirSourceElement?
     abstract override val annotations: List<FirAnnotationCall>
     abstract val assignCall: FirFunctionCall
@@ -23,7 +23,7 @@ abstract class FirArraySetCall : FirPureAbstractElement(), FirStatement {
     abstract val operation: FirOperation
     abstract val calleeReference: FirReference
 
-    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitArraySetCall(this, data)
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAugmentedArraySetCall(this, data)
 
     abstract fun replaceCalleeReference(newCalleeReference: FirReference)
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirAugmentedArraySetCallBuilder.kt

@@ -10,11 +10,11 @@ import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.FirArraySetCall
+import org.jetbrains.kotlin.fir.expressions.FirAugmentedArraySetCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.FirOperation
-import org.jetbrains.kotlin.fir.expressions.impl.FirArraySetCallImpl
+import org.jetbrains.kotlin.fir.expressions.impl.FirAugmentedArraySetCallImpl
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.references.impl.FirStubReference
 import org.jetbrains.kotlin.fir.visitors.*
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 @FirBuilderDsl
-class FirArraySetCallBuilder : FirAnnotationContainerBuilder {
+class FirAugmentedArraySetCallBuilder : FirAnnotationContainerBuilder {
     override var source: FirSourceElement? = null
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
     lateinit var assignCall: FirFunctionCall
@@ -33,8 +33,8 @@ class FirArraySetCallBuilder : FirAnnotationContainerBuilder {
     lateinit var operation: FirOperation
     var calleeReference: FirReference = FirStubReference
 
-    override fun build(): FirArraySetCall {
+    override fun build(): FirAugmentedArraySetCall {
-        return FirArraySetCallImpl(
+        return FirAugmentedArraySetCallImpl(
             source,
             annotations,
             assignCall,
@@ -47,9 +47,9 @@ class FirArraySetCallBuilder : FirAnnotationContainerBuilder {
 }
 
 @OptIn(ExperimentalContracts::class)
-inline fun buildArraySetCall(init: FirArraySetCallBuilder.() -> Unit): FirArraySetCall {
+inline fun buildAugmentedArraySetCall(init: FirAugmentedArraySetCallBuilder.() -> Unit): FirAugmentedArraySetCall {
     contract {
         callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE)
     }
-    return FirArraySetCallBuilder().apply(init).build()
+    return FirAugmentedArraySetCallBuilder().apply(init).build()
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirAugmentedArraySetCallImpl.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.expressions.impl
 
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.FirArraySetCall
+import org.jetbrains.kotlin.fir.expressions.FirAugmentedArraySetCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.FirOperation
@@ -19,14 +19,14 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-internal class FirArraySetCallImpl(
+internal class FirAugmentedArraySetCallImpl(
     override val source: FirSourceElement?,
     override val annotations: MutableList<FirAnnotationCall>,
     override var assignCall: FirFunctionCall,
     override var setGetBlock: FirBlock,
     override val operation: FirOperation,
     override var calleeReference: FirReference,
-) : FirArraySetCall() {
+) : FirAugmentedArraySetCall() {
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         annotations.forEach { it.accept(visitor, data) }
         assignCall.accept(visitor, data)
@@ -34,7 +34,7 @@ internal class FirArraySetCallImpl(
         calleeReference.accept(visitor, data)
     }
 
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirArraySetCallImpl {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAugmentedArraySetCallImpl {
         annotations.transformInplace(transformer, data)
         assignCall = assignCall.transformSingle(transformer, data)
         setGetBlock = setGetBlock.transformSingle(transformer, data)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt

@@ -74,7 +74,7 @@ import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessWithoutCallee
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall
 import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall
-import org.jetbrains.kotlin.fir.expressions.FirArraySetCall
+import org.jetbrains.kotlin.fir.expressions.FirAugmentedArraySetCall
 import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression
 import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
 import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
@@ -403,8 +403,8 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformElement(arrayOfCall, data)
     }
 
-    open fun transformArraySetCall(arraySetCall: FirArraySetCall, data: D): CompositeTransformResult<FirStatement> {
+    open fun transformAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformElement(arraySetCall, data)
+        return transformElement(augmentedArraySetCall, data)
     }
 
     open fun transformClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): CompositeTransformResult<FirStatement> {
@@ -863,8 +863,8 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformArrayOfCall(arrayOfCall, data)
     }
 
-    final override fun visitArraySetCall(arraySetCall: FirArraySetCall, data: D): CompositeTransformResult<FirStatement> {
+    final override fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformArraySetCall(arraySetCall, data)
+        return transformAugmentedArraySetCall(augmentedArraySetCall, data)
     }
 
     final override fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): CompositeTransformResult<FirStatement> {

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt

@@ -74,7 +74,7 @@ import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessWithoutCallee
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall
 import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall
-import org.jetbrains.kotlin.fir.expressions.FirArraySetCall
+import org.jetbrains.kotlin.fir.expressions.FirAugmentedArraySetCall
 import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression
 import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
 import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
@@ -265,7 +265,7 @@ abstract class FirVisitor<out R, in D> {
 
     open fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): R  = visitElement(arrayOfCall, data)
 
-    open fun visitArraySetCall(arraySetCall: FirArraySetCall, data: D): R  = visitElement(arraySetCall, data)
+    open fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: D): R  = visitElement(augmentedArraySetCall, data)
 
     open fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): R  = visitElement(classReferenceExpression, data)
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt

@@ -74,7 +74,7 @@ import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessWithoutCallee
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall
 import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall
-import org.jetbrains.kotlin.fir.expressions.FirArraySetCall
+import org.jetbrains.kotlin.fir.expressions.FirAugmentedArraySetCall
 import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression
 import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
 import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
@@ -401,8 +401,8 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitElement(arrayOfCall)
     }
 
-    open fun visitArraySetCall(arraySetCall: FirArraySetCall) {
+    open fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall) {
-        visitElement(arraySetCall)
+        visitElement(augmentedArraySetCall)
     }
 
     open fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression) {
@@ -861,8 +861,8 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitArrayOfCall(arrayOfCall)
     }
 
-    final override fun visitArraySetCall(arraySetCall: FirArraySetCall, data: Nothing?) {
+    final override fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: Nothing?) {
-        visitArraySetCall(arraySetCall)
+        visitAugmentedArraySetCall(augmentedArraySetCall)
     }
 
     final override fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: Nothing?) {

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt

@@ -997,10 +997,10 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
         visitAssignment(FirOperation.ASSIGN, variableAssignment.rValue)
     }
 
-    override fun visitArraySetCall(arraySetCall: FirArraySetCall) {
+    override fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall) {
-        arraySetCall.annotations.renderAnnotations()
+        augmentedArraySetCall.annotations.renderAnnotations()
         print("ArraySet:[")
-        arraySetCall.assignCall.accept(this)
+        augmentedArraySetCall.assignCall.accept(this)
         print("]")
     }
 

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt

@@ -89,7 +89,7 @@ object FirTreeBuilder : AbstractFirTreeBuilder() {
     val checkNotNullCall = element("CheckNotNullCall", Expression, expression, call, resolvable)
 
     val arrayOfCall = element("ArrayOfCall", Expression, expression, call)
-    val arraySetCall = element("ArraySetCall", Expression, statement)
+    val arraySetCall = element("AugmentedArraySetCall", Expression, statement)
     val classReferenceExpression = element("ClassReferenceExpression", Expression, expression)
     val errorExpression = element("ErrorExpression", Expression, expression, diagnosticHolder)
     val errorFunction = element("ErrorFunction", Declaration, function, diagnosticHolder)