JVM_IR: use .isFakeOverride instead of testing origin

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt

@@ -316,7 +316,7 @@ open class ClassCodegen protected constructor(
         ClassCodegen(klass, context, this, parentFunction)
 
     private fun generateField(field: IrField) {
-        if (field.origin == IrDeclarationOrigin.FAKE_OVERRIDE) return
+        if (field.isFakeOverride) return
 
         val fieldType = typeMapper.mapType(field)
         val fieldSignature =
@@ -349,7 +349,7 @@ open class ClassCodegen protected constructor(
     }
 
     private fun generateMethod(method: IrFunction) {
-        if (method.origin == IrDeclarationOrigin.FAKE_OVERRIDE) {
+        if (method.isFakeOverride) {
             jvmSignatureClashDetector.trackFakeOverrideMethod(method)
             return
         }

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/JvmDeclarationFactory.kt

@@ -180,8 +180,8 @@ class JvmDeclarationFactory(
     fun getStaticBackingField(irProperty: IrProperty): IrField? {
         // Only fields defined directly in objects should be made static.
         // Fake overrides never point to those, as objects are final.
-        if (irProperty.origin == IrDeclarationOrigin.FAKE_OVERRIDE) return null
         val oldField = irProperty.backingField ?: return null
+        if (oldField.isFakeOverride) return null
         val oldParent = irProperty.parent as? IrClass ?: return null
         if (!oldParent.isObject) return null
         return staticBackingFields.getOrPut(irProperty) {
@@ -226,7 +226,7 @@ class JvmDeclarationFactory(
                 // is supposed to allow using `I2.DefaultImpls.f` as if it was inherited from `I1.DefaultImpls`.
                 // The classes are not actually related and `I2.DefaultImpls.f` is not a fake override but a bridge.
                 origin = when {
-                    interfaceFun.origin != IrDeclarationOrigin.FAKE_OVERRIDE -> interfaceFun.origin
+                    !interfaceFun.isFakeOverride -> interfaceFun.origin
                     interfaceFun.resolveFakeOverride()!!.origin.isSynthetic -> JvmLoweredDeclarationOrigin.DEFAULT_IMPLS_BRIDGE_TO_SYNTHETIC
                     else -> JvmLoweredDeclarationOrigin.DEFAULT_IMPLS_BRIDGE
                 },
@@ -271,6 +271,7 @@ class JvmDeclarationFactory(
     fun getDefaultImplsRedirection(fakeOverride: IrSimpleFunction): IrSimpleFunction =
         defaultImplsRedirections.getOrPut(fakeOverride) {
             assert(fakeOverride.origin == IrDeclarationOrigin.FAKE_OVERRIDE)
+            assert(fakeOverride.isFakeOverride)
             val irClass = fakeOverride.parentAsClass
             val descriptor = DescriptorsToIrRemapper.remapDeclaredSimpleFunction(fakeOverride.descriptor)
             with(fakeOverride) {

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

@@ -50,7 +50,7 @@ internal class CollectionStubMethodLowering(val context: JvmBackendContext) : Cl
         // it means an abstract function in superclass that is not implemented yet,
         // stub generation is still needed to avoid invocation error.
         val existingMethodsBySignature = irClass.functions.filterNot {
-            it.modality == Modality.ABSTRACT && it.origin == IrDeclarationOrigin.FAKE_OVERRIDE
+            it.modality == Modality.ABSTRACT && it.isFakeOverride
         }.associateBy { it.toSignature() }
 
         for (member in methodStubsToGenerate) {

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

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.backend.jvm.lower
 
 import org.jetbrains.kotlin.backend.common.ClassLoweringPass
 import org.jetbrains.kotlin.backend.common.FileLoweringPass
+import org.jetbrains.kotlin.backend.common.ir.copyParameterDeclarationsFrom
 import org.jetbrains.kotlin.backend.common.ir.createImplicitParameterDeclarationWithWrappedDescriptor
 import org.jetbrains.kotlin.backend.common.ir.passTypeArgumentsFrom
 import org.jetbrains.kotlin.backend.common.lower
@@ -27,6 +28,7 @@ import org.jetbrains.kotlin.ir.*
 import org.jetbrains.kotlin.ir.builders.*
 import org.jetbrains.kotlin.ir.builders.declarations.addConstructor
 import org.jetbrains.kotlin.ir.builders.declarations.buildClass
+import org.jetbrains.kotlin.ir.builders.declarations.buildFun
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrFileImpl
 import org.jetbrains.kotlin.ir.expressions.*
@@ -204,21 +206,31 @@ private fun IrSimpleFunction.createMultifileDelegateIfNeeded(
     facadeClass: IrClass,
     shouldGeneratePartHierarchy: Boolean
 ): IrSimpleFunction? {
+    val target = this
+
     if (Visibilities.isPrivate(visibility) ||
         name == StaticInitializersLowering.clinitName ||
         origin == JvmLoweredDeclarationOrigin.SYNTHETIC_ACCESSOR
     ) return null
 
-    // TODO: perform copy of the signature only, without body
+    val function = buildFun {
-    val function = deepCopyWithSymbols(facadeClass)
+        updateFrom(target)
+        origin = if (shouldGeneratePartHierarchy) IrDeclarationOrigin.FAKE_OVERRIDE else JvmLoweredDeclarationOrigin.MULTIFILE_BRIDGE
+        name = target.name
+    }
+
+    function.copyParameterDeclarationsFrom(target)
+    function.returnType = target.returnType
+    function.parent = facadeClass
+    function.annotations = target.annotations
 
     if (shouldGeneratePartHierarchy) {
         function.body = null
-        function.origin = IrDeclarationOrigin.FAKE_OVERRIDE
         function.overriddenSymbols = listOf(symbol)
     } else {
+        function.overriddenSymbols = overriddenSymbols.toList()
         function.body = context.createIrBuilder(function.symbol).irBlockBody {
-            +irReturn(irCall(this@createMultifileDelegateIfNeeded).also { call ->
+            +irReturn(irCall(target).also { call ->
                 call.passTypeArgumentsFrom(function)
                 function.extensionReceiverParameter?.let { parameter ->
                     call.extensionReceiver = irGet(parameter)
@@ -228,7 +240,6 @@ private fun IrSimpleFunction.createMultifileDelegateIfNeeded(
                 }
             })
         }
-        function.origin = JvmLoweredDeclarationOrigin.MULTIFILE_BRIDGE
     }
 
     facadeClass.declarations.add(function)

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

@@ -95,7 +95,7 @@ internal class InterfaceLowering(val context: JvmBackendContext) : IrElementTran
                  *    interface B : A { class DefaultImpls { fun foo() = A.DefaultImpls.foo() } }
                  *    ```
                  */
-                function.origin == IrDeclarationOrigin.FAKE_OVERRIDE -> {
+                function.isFakeOverride -> {
                     // We check to see if this is a default stub function BEFORE finding the implementation because of a front-end bug
                     // (KT-36188) where there could be multiple implementations. (resolveFakeOverride() only returns the implementation if
                     // there's only one.)

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

@@ -113,7 +113,7 @@ private class FieldRenamer(private val newNames: Map<IrField, Name>) : IrElement
         return IrFieldImpl(
             declaration.startOffset, declaration.endOffset, declaration.origin, symbol, newName,
             declaration.type, declaration.visibility, declaration.isFinal, declaration.isExternal, declaration.isStatic,
-            isFakeOverride = declaration.origin == IrDeclarationOrigin.FAKE_OVERRIDE
+            isFakeOverride = declaration.isFakeOverride
         ).also {
             descriptor.bind(it)
             it.parent = declaration.parent