[IR] Remove copyWithOffsets methods

^KT-75196 Fixed

Author: francescoo22

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

@@ -188,9 +188,11 @@ open class UpgradeCallableReferences(
                 val argument = expression.argument
                 if (argument !is IrRichFunctionReference) return expression
                 return argument.apply {
+                    startOffset = expression.startOffset
+                    endOffset = expression.endOffset
                     type = expression.typeOperand
                     overriddenFunctionSymbol = selectSAMOverriddenFunction(expression.typeOperand)
-                }.copyWithOffsets(expression.startOffset, expression.endOffset)
+                }
             }
             return super.visitTypeOperator(expression, data)
         }

compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOptimizationLowering.kt

@@ -412,10 +412,20 @@ internal class JvmOptimizationLowering(val context: JvmBackendContext) : FileLow
             // initializer with the constant initializer.
             val variable = expression.symbol.owner
             return when (val replacement = getInlineableValueForTemporaryVal(variable)) {
-                is IrConst ->
-                    replacement.copyWithOffsets(expression.startOffset, expression.endOffset)
-                is IrGetValue ->
-                    replacement.copyWithOffsets(expression.startOffset, expression.endOffset)
+                is IrConst -> IrConstImpl(
+                    expression.startOffset,
+                    expression.endOffset,
+                    replacement.type,
+                    replacement.kind,
+                    replacement.value
+                )
+                is IrGetValue -> IrGetValueImpl(
+                    expression.startOffset,
+                    expression.endOffset,
+                    replacement.type,
+                    replacement.symbol,
+                    replacement.origin
+                )
                 else ->
                     expression
             }

compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/FunctionInlining.kt

@@ -241,13 +241,12 @@ private class CallInlining(
 
             argument.transformChildrenVoid(this) // Default argument can contain subjects for substitution.
 
-            val ret =
-                if (argument is IrGetValue && argument in elementsWithLocationToPatch)
-                    argument.copyWithOffsets(newExpression.startOffset, newExpression.endOffset)
-                else
-                    argument.deepCopyWithSymbols()
-
-            return ret.doImplicitCastIfNeededTo(newExpression.type)
+            return argument.deepCopyWithSymbols().apply {
+                if (argument is IrGetValue && argument in elementsWithLocationToPatch) {
+                    startOffset = newExpression.startOffset
+                    endOffset = newExpression.endOffset
+                }
+            }.doImplicitCastIfNeededTo(newExpression.type)
         }
 
         override fun visitCall(expression: IrCall): IrExpression {
@@ -371,10 +370,11 @@ private class CallInlining(
                     val argument = when {
                         parameter !in unboundArgsSet -> {
                             val arg = boundFunctionParametersMap[parameter]!!
-                            if (arg is IrGetValue && arg in elementsWithLocationToPatch) {
-                                arg.copyWithOffsets(irCall.startOffset, irCall.endOffset)
-                            } else {
-                                arg.deepCopyWithSymbols()
+                            arg.deepCopyWithSymbols().apply {
+                                if (arg is IrGetValue && arg in elementsWithLocationToPatch) {
+                                    startOffset = irCall.startOffset
+                                    endOffset = irCall.endOffset
+                                }
                             }
                         }
                         unboundIndex == valueParameters.size && parameter.defaultValue != null -> {

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt

@@ -1488,32 +1488,6 @@ fun IrBlockImpl.inlineStatement(statement: IrStatement) {
     }
 }
 
-// TODO: KT-75196: please make `startOffset` and `endOffset` mutable, and remove this method
-fun IrConst.copyWithOffsets(startOffset: Int, endOffset: Int) =
-    IrConstImpl(startOffset, endOffset, type, kind, value)
-
-// TODO: KT-75196: please make `startOffset` and `endOffset` mutable, and remove this method
-fun IrGetValue.copyWithOffsets(newStartOffset: Int, newEndOffset: Int): IrGetValue =
-    IrGetValueImpl(newStartOffset, newEndOffset, type, symbol, origin)
-
-// TODO: KT-75196: please make `startOffset` and `endOffset` mutable, and remove this method
-fun IrRichFunctionReference.copyWithOffsets(newStartOffset: Int, newEndOffset: Int): IrRichFunctionReference =
-    IrRichFunctionReferenceImpl(
-        newStartOffset, newEndOffset,
-        type,
-        reflectionTargetSymbol,
-        overriddenFunctionSymbol,
-        invokeFunction,
-        origin,
-        hasUnitConversion,
-        hasSuspendConversion,
-        hasVarargConversion,
-        isRestrictedSuspension
-    ).apply {
-        copyAttributes(this@copyWithOffsets)
-        boundValues.addAll(this@copyWithOffsets.boundValues)
-    }
-
 fun IrModuleFragment.addFile(file: IrFile) {
     files.add(file)
     file.module = this

plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/lower/LiveLiteralTransformer.kt

@@ -370,25 +370,30 @@ open class LiveLiteralTransformer(
         // If live literals are enabled, don't do anything
         if (!liveLiteralsEnabled) return expression
 
+        val originalStartOffset = expression.startOffset
+        val originalEndOffset = expression.endOffset
         // create the getter function on the live literals class
         val getter = irLiveLiteralGetter(
             key = key,
             // Move the start/endOffsets to the call of the getter since we don't
             // want to step into <clinit> in the debugger.
-            literalValue = expression.copyWithOffsets(UNDEFINED_OFFSET, UNDEFINED_OFFSET),
+            literalValue = expression.apply {
+                startOffset = UNDEFINED_OFFSET
+                endOffset = UNDEFINED_OFFSET
+            },
             literalType = expression.type,
-            startOffset = expression.startOffset
+            startOffset = originalStartOffset
         )
 
         // return a call to the getter in place of the constant
         return IrCallImpl(
-            expression.startOffset,
-            expression.endOffset,
+            originalStartOffset,
+            originalEndOffset,
             expression.type,
             getter.symbol,
             getter.symbol.owner.typeParameters.size
         ).apply {
-            dispatchReceiver = irGetLiveLiteralsClass(expression.startOffset, expression.endOffset)
+            dispatchReceiver = irGetLiveLiteralsClass(originalStartOffset, originalEndOffset)
         }
     }