Kapt+JVM_IR: generate delegated members correctly

Generate a declaration for each delegated member without body. If we
don't generate delegated declarations, subclasses will have incorrect IR
with unbound symbols in fake overrides.

 #KT-58027 Fixed

(cherry picked from commit bc7aea1)

compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegationResolver.kt

@@ -151,7 +151,11 @@ class DelegationResolver<T : CallableMemberDescriptor> private constructor(
         //   descriptor = Foo
         //   toInterface = Bar
         //   delegateExpressionType = typeof(baz)
-        // return Map<member of Foo, corresponding member of typeOf(baz)>
+        //
+        // This method returns a map where keys are members of Foo, and values are members of typeof(baz).
+        //
+        // In case delegation is to an error type, which is useful for KAPT stub generation mode, typeof(baz) has no members, so we return
+        // a map from each element to it (so keys = values in the returned map).
         fun getDelegates(
             descriptor: ClassDescriptor,
             toInterface: ClassDescriptor,
@@ -175,18 +179,22 @@ class DelegationResolver<T : CallableMemberDescriptor> private constructor(
                     val actualDelegates = DescriptorUtils.getAllOverriddenDescriptors(delegatingMember)
                         .filter { it.containingDeclaration == toInterface }
                         .map { overriddenDescriptor ->
-                            val name = overriddenDescriptor.name
-                            // this is the actual member of delegateExpressionType that we are delegating to
-                            (scope.getContributedFunctions(name, NoLookupLocation.WHEN_CHECK_OVERRIDES) +
-                                    scope.getContributedVariables(name, NoLookupLocation.WHEN_CHECK_OVERRIDES))
-                                .firstOrNull {
-                                    it == overriddenDescriptor || OverridingUtil.overrides(
-                                        it,
-                                        overriddenDescriptor,
-                                        it.module.isTypeRefinementEnabled(),
-                                        true
-                                    )
-                                }
+                            if (scopeType.isError) {
+                                overriddenDescriptor
+                            } else {
+                                val name = overriddenDescriptor.name
+                                // This is the actual member of delegateExpressionType that we are delegating to.
+                                (scope.getContributedFunctions(name, NoLookupLocation.WHEN_CHECK_OVERRIDES) +
+                                        scope.getContributedVariables(name, NoLookupLocation.WHEN_CHECK_OVERRIDES))
+                                    .firstOrNull {
+                                        it == overriddenDescriptor || OverridingUtil.overrides(
+                                            it,
+                                            overriddenDescriptor,
+                                            it.module.isTypeRefinementEnabled(),
+                                            true
+                                        )
+                                    }
+                            }
                         }
 
                     actualDelegates.firstOrNull()

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

@@ -325,7 +325,9 @@ class ClassGenerator(
             // TODO could possibly refer to scoped type parameters for property accessors
             irFunction.returnType = delegatedDescriptor.returnType!!.toIrType()
 
-            irFunction.body = generateDelegateFunctionBody(irDelegate, delegatedDescriptor, delegateToDescriptor, irFunction)
+            if (context.configuration.generateBodies) {
+                irFunction.body = generateDelegateFunctionBody(irDelegate, delegatedDescriptor, delegateToDescriptor, irFunction)
+            }
         }
 
     private fun generateDelegateFunctionBody(

plugins/kapt3/kapt3-compiler/testData/converter/delegationAndCompanionObject.kt

@@ -0,0 +1,11 @@
+// CORRECT_ERROR_TYPES
+
+@Suppress("UNRESOLVED_REFERENCE")
+interface A {
+    fun inject(b: B)
+    val x: String
+
+    companion object : B()
+
+    abstract class B : A by Unresolved
+}

plugins/kapt3/kapt3-compiler/testData/converter/delegationAndCompanionObject.txt

@@ -0,0 +1,39 @@
+@kotlin.Metadata()
+@kotlin.Suppress(names = {"UNRESOLVED_REFERENCE"})
+public abstract interface A {
+    @org.jetbrains.annotations.NotNull()
+    public static final A.Companion Companion = null;
+
+    public abstract void inject(@org.jetbrains.annotations.NotNull()
+    A.B b);
+
+    @org.jetbrains.annotations.NotNull()
+    public abstract java.lang.String getX();
+
+    @kotlin.Metadata()
+    public static abstract class B implements A {
+
+        @java.lang.Override()
+        public void inject(@org.jetbrains.annotations.NotNull()
+        A.B b) {
+        }
+
+        @java.lang.Override()
+        @org.jetbrains.annotations.NotNull()
+        public java.lang.String getX() {
+            return null;
+        }
+
+        public B() {
+            super();
+        }
+    }
+
+    @kotlin.Metadata()
+    public static final class Companion extends A.B {
+
+        private Companion() {
+            super();
+        }
+    }
+}

plugins/kapt3/kapt3-compiler/testData/converter/delegationAndCompanionObject_ir.txt

@@ -0,0 +1,39 @@
+@kotlin.Metadata()
+@kotlin.Suppress(names = {"UNRESOLVED_REFERENCE"})
+public abstract interface A {
+    @org.jetbrains.annotations.NotNull()
+    public static final A.Companion Companion = null;
+
+    public abstract void inject(@org.jetbrains.annotations.NotNull()
+    A.B b);
+
+    @org.jetbrains.annotations.NotNull()
+    public abstract java.lang.String getX();
+
+    @kotlin.Metadata()
+    public static abstract class B implements A {
+
+        public B() {
+            super();
+        }
+
+        @java.lang.Override()
+        @org.jetbrains.annotations.NotNull()
+        public java.lang.String getX() {
+            return null;
+        }
+
+        @java.lang.Override()
+        public void inject(@org.jetbrains.annotations.NotNull()
+        A.B b) {
+        }
+    }
+
+    @kotlin.Metadata()
+    public static final class Companion extends A.B {
+
+        private Companion() {
+            super();
+        }
+    }
+}