Generate declarations for FAKE_OVERRIDE members

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt

@@ -35,6 +35,7 @@ import org.jetbrains.kotlin.renderer.OverrideRenderingPolicy
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import java.lang.AssertionError
 import java.util.*
 
@@ -53,6 +54,8 @@ class ClassGenerator(declarationGenerator: DeclarationGenerator) : DeclarationGe
 
         generateMembersDeclaredInClassBody(irClass, ktClassOrObject)
 
+        generateFakeOverrideMemberDeclarations(irClass)
+
         if (descriptor.isData) {
             generateAdditionalMembersForDataClass(irClass, ktClassOrObject)
         }
@@ -64,7 +67,20 @@ class ClassGenerator(declarationGenerator: DeclarationGenerator) : DeclarationGe
         return irClass
     }
 
-    private object StableDelegatesComparator : Comparator<CallableMemberDescriptor> {
+    private fun generateFakeOverrideMemberDeclarations(irClass: IrClass) {
+        irClass.descriptor.unsubstitutedMemberScope.getContributedDescriptors()
+                .mapNotNull {
+                    it.safeAs<CallableMemberDescriptor>().takeIf {
+                        it?.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE
+                    }
+                }
+                .sortedWith(StableCallableMembersComparator)
+                .forEach { fakeOverride ->
+                    irClass.addMember(declarationGenerator.generateFakeOverrideDeclaration(fakeOverride))
+                }
+    }
+
+    private object StableCallableMembersComparator : Comparator<CallableMemberDescriptor> {
         override fun compare(member1: CallableMemberDescriptor?, member2: CallableMemberDescriptor?): Int {
             if (member1 == member2) return 0
             if (member1 == null) return -1
@@ -91,7 +107,7 @@ class ClassGenerator(declarationGenerator: DeclarationGenerator) : DeclarationGe
                     .getContributedDescriptors(DescriptorKindFilter.CALLABLES)
                     .filterIsInstance<CallableMemberDescriptor>()
                     .filter { it.kind == CallableMemberDescriptor.Kind.DELEGATION }
-                    .sortedWith(StableDelegatesComparator)
+                    .sortedWith(StableCallableMembersComparator)
             if (delegatedMembers.isEmpty()) return
 
             for (ktEntry in ktSuperTypeList.entries) {

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DeclarationGenerator.kt

@@ -16,15 +16,10 @@
 
 package org.jetbrains.kotlin.psi2ir.generators
 
-import org.jetbrains.kotlin.descriptors.CallableDescriptor
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
+import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.declarations.impl.IrAnonymousInitializerImpl
-import org.jetbrains.kotlin.ir.declarations.impl.IrErrorDeclarationImpl
-import org.jetbrains.kotlin.ir.declarations.impl.IrTypeAliasImpl
-import org.jetbrains.kotlin.ir.declarations.impl.IrTypeParameterImpl
+import org.jetbrains.kotlin.ir.declarations.impl.*
 import org.jetbrains.kotlin.ir.expressions.IrBody
 import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 import org.jetbrains.kotlin.psi.*
@@ -99,6 +94,38 @@ class DeclarationGenerator(override val context: GeneratorContext) : Generator {
 
     fun generateInitializerBody(scopeOwner: CallableDescriptor, ktBody: KtExpression): IrExpressionBody =
             createBodyGenerator(scopeOwner).generateExpressionBody(ktBody)
+
+    fun generateFakeOverrideDeclaration(memberDescriptor: CallableMemberDescriptor, ktElement: KtElement? = null): IrDeclaration {
+        assert(memberDescriptor.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
+            "Fake override expected: $memberDescriptor"
+        }
+        return when (memberDescriptor) {
+            is FunctionDescriptor ->
+                generateFakeOverrideFunction(memberDescriptor, ktElement)
+            is PropertyDescriptor ->
+                generateFakeOverrideProperty(memberDescriptor, ktElement)
+            else ->
+                throw AssertionError("Unexpected member descriptor: $memberDescriptor")
+        }
+    }
+
+    private fun generateFakeOverrideProperty(propertyDescriptor: PropertyDescriptor, ktElement: KtElement?): IrProperty =
+            IrPropertyImpl(
+                    ktElement.startOffsetOrUndefined, ktElement.endOffsetOrUndefined,
+                    IrDeclarationOrigin.FAKE_OVERRIDE,
+                    false,
+                    propertyDescriptor,
+                    null,
+                    propertyDescriptor.getter?.let { generateFakeOverrideFunction(it, ktElement) },
+                    propertyDescriptor.setter?.let { generateFakeOverrideFunction(it, ktElement) }
+            )
+
+    private fun generateFakeOverrideFunction(functionDescriptor: FunctionDescriptor, ktElement: KtElement?): IrFunction =
+            IrFunctionImpl(
+                    ktElement.startOffsetOrUndefined, ktElement.endOffsetOrUndefined,
+                    IrDeclarationOrigin.FAKE_OVERRIDE,
+                    functionDescriptor
+            )
 }
 
 abstract class DeclarationGeneratorExtension(val declarationGenerator: DeclarationGenerator) : Generator {

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.ir.declarations
 
 interface IrDeclarationOrigin {
     object DEFINED : IrDeclarationOriginImpl("DEFINED")
+    object FAKE_OVERRIDE : IrDeclarationOriginImpl("FAKE_OVERRIDE")
     object PROPERTY_BACKING_FIELD : IrDeclarationOriginImpl("PROPERTY_BACKING_FIELD")
     object DEFAULT_PROPERTY_ACCESSOR : IrDeclarationOriginImpl("DEFAULT_PROPERTY_ACCESSOR")
     object DELEGATE : IrDeclarationOriginImpl("DELEGATE")