[IR] Move IrGetValue.actualize() to IrUtils and rename it

^KT-62292

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

@@ -172,9 +172,9 @@ open class ExpectDeclarationRemover(val symbolTable: ReferenceSymbolTable, priva
             .transform(object : IrElementTransformerVoid() {
                 override fun visitGetValue(expression: IrGetValue): IrExpression {
                     expression.transformChildrenVoid()
-                    return expression.actualize(
-                        classActualizer = { symbolTable.descriptorExtension.referenceClass(it.descriptor.findActualForExpect() as ClassDescriptor).owner },
-                        functionActualizer = { symbolTable.referenceFunction(it.descriptor.findActualForExpect() as FunctionDescriptor).owner }
+                    return expression.remapSymbolParent(
+                        classRemapper = { symbolTable.descriptorExtension.referenceClass(it.descriptor.findActualForExpect() as ClassDescriptor).owner },
+                        functionRemapper = { symbolTable.referenceFunction(it.descriptor.findActualForExpect() as FunctionDescriptor).owner }
                     )
                 }
             }, data = null)

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

@@ -248,35 +248,4 @@ fun ParameterDescriptor.copyAsValueParameter(newOwner: CallableDescriptor, index
         source = source
     )
     else -> throw Error("Unexpected parameter descriptor: $this")
-}
-
-fun IrGetValue.actualize(classActualizer: (IrClass) -> IrClass, functionActualizer: (IrFunction) -> IrFunction): IrGetValue {
-    val symbol = symbol
-    if (symbol !is IrValueParameterSymbol) {
-        return this
-    }
-
-    val parameter = symbol.owner
-    val newSymbol = when (val parent = parameter.parent) {
-        is IrClass -> {
-            assert(parameter == parent.thisReceiver)
-            classActualizer(parent).thisReceiver!!
-        }
-
-        is IrFunction -> {
-            val actualizedFunction = functionActualizer(parent)
-            when (parameter) {
-                parent.dispatchReceiverParameter -> actualizedFunction.dispatchReceiverParameter!!
-                parent.extensionReceiverParameter -> actualizedFunction.extensionReceiverParameter!!
-                else -> {
-                    assert(parent.valueParameters[parameter.index] == parameter)
-                    actualizedFunction.valueParameters[parameter.index]
-                }
-            }
-        }
-
-        else -> error(parent)
-    }
-
-    return IrGetValueImpl(startOffset, endOffset, newSymbol.type, newSymbol.symbol, origin)
 }

compiler/ir/ir.actualization/src/main/kotlin/org/jetbrains/kotlin/backend/common/actualizer/FunctionDefaultParametersActualizer.kt

@@ -5,16 +5,12 @@
 
 package org.jetbrains.kotlin.backend.common.actualizer
 
-import org.jetbrains.kotlin.backend.common.lower.actualize
 import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.declarations.copyAttributes
 import org.jetbrains.kotlin.ir.expressions.IrGetValue
 import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
-import org.jetbrains.kotlin.ir.util.DeepCopyTypeRemapper
-import org.jetbrains.kotlin.ir.util.SymbolRemapper
-import org.jetbrains.kotlin.ir.util.TypeRemapper
-import org.jetbrains.kotlin.ir.util.deepCopyWithSymbols
+import org.jetbrains.kotlin.ir.util.*
 
 internal class FunctionDefaultParametersActualizer(
     symbolRemapper: ActualizerSymbolRemapper,
@@ -46,9 +42,9 @@ private class FunctionDefaultParametersActualizerVisitor(private val symbolRemap
     override fun visitGetValue(expression: IrGetValue): IrGetValue {
         // It performs actualization of dispatch/extension receivers
         // It's actual only for default parameter values of expect functions because expect functions don't have bodies
-        return expression.actualize(
-            classActualizer = { symbolRemapper.getReferencedClass(it.symbol).owner },
-            functionActualizer = { symbolRemapper.getReferencedFunction(it.symbol).owner }
+        return expression.remapSymbolParent(
+            classRemapper = { symbolRemapper.getReferencedClass(it.symbol).owner },
+            functionRemapper = { symbolRemapper.getReferencedFunction(it.symbol).owner }
         ).copyAttributes(expression)
     }
 }

compiler/ir/ir.actualization/src/main/kotlin/org/jetbrains/kotlin/backend/common/actualizer/IrExpectActualMatchingContext.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.backend.common.actualizer
 
 import org.jetbrains.kotlin.backend.common.actualizer.checker.areIrExpressionConstValuesEqual
-import org.jetbrains.kotlin.backend.common.sourceElement
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
@@ -540,7 +539,7 @@ internal abstract class IrExpectActualMatchingContext(
     override val DeclarationSymbolMarker.hasSourceAnnotationsErased: Boolean
         get() {
             val ir = asIr()
-            return ir.sourceElement() == null && ir.origin !is IrDeclarationOrigin.GeneratedByPlugin
+            return ir.startOffset < 0 && ir.origin !is IrDeclarationOrigin.GeneratedByPlugin
         }
 
     // IR checker traverses member scope itself and collects mappings

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

@@ -788,6 +788,37 @@ fun IrExpression.remapReceiver(oldReceiver: IrValueParameter?, newReceiver: IrVa
     else -> shallowCopy()
 }
 
+fun IrGetValue.remapSymbolParent(classRemapper: (IrClass) -> IrClass, functionRemapper: (IrFunction) -> IrFunction): IrGetValue {
+    val symbol = symbol
+    if (symbol !is IrValueParameterSymbol) {
+        return this
+    }
+
+    val parameter = symbol.owner
+    val newSymbol = when (val parent = parameter.parent) {
+        is IrClass -> {
+            assert(parameter == parent.thisReceiver)
+            classRemapper(parent).thisReceiver!!
+        }
+
+        is IrFunction -> {
+            val remappedFunction = functionRemapper(parent)
+            when (parameter) {
+                parent.dispatchReceiverParameter -> remappedFunction.dispatchReceiverParameter!!
+                parent.extensionReceiverParameter -> remappedFunction.extensionReceiverParameter!!
+                else -> {
+                    assert(parent.valueParameters[parameter.index] == parameter)
+                    remappedFunction.valueParameters[parameter.index]
+                }
+            }
+        }
+
+        else -> error(parent)
+    }
+
+    return IrGetValueImpl(startOffset, endOffset, newSymbol.type, newSymbol.symbol, origin)
+}
+
 val IrDeclarationParent.isFacadeClass: Boolean
     get() = this is IrClass &&
             (origin == IrDeclarationOrigin.JVM_MULTIFILE_CLASS ||