[FIR] Implement RETURN_TYPE_MISMATCH_BY_DELEGATION diagnostic

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt

@@ -588,11 +588,15 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
         }
 
         val RETURN_TYPE_MISMATCH_ON_INHERITANCE by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
-            parameter<FirClass<*>>("classOrObject")
             parameter<FirCallableDeclaration<*>>("conflictingDeclaration1")
             parameter<FirCallableDeclaration<*>>("conflictingDeclaration2")
         }
 
+        val RETURN_TYPE_MISMATCH_BY_DELEGATION by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
+            parameter<FirCallableDeclaration<*>>("delegateDeclaration")
+            parameter<FirCallableDeclaration<*>>("baseDeclaration")
+        }
+
         val ABSTRACT_MEMBER_NOT_IMPLEMENTED by error<KtClassOrObject>(PositioningStrategy.DECLARATION_NAME) {
             parameter<FirClass>("classOrObject")
             parameter<FirCallableDeclaration>("missingDeclaration")

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt

@@ -347,7 +347,8 @@ object FirErrors {
     val CANNOT_WEAKEN_ACCESS_PRIVILEGE by error3<KtModifierListOwner, Visibility, FirCallableDeclaration, Name>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
     val CANNOT_CHANGE_ACCESS_PRIVILEGE by error3<KtModifierListOwner, Visibility, FirCallableDeclaration, Name>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
     val OVERRIDING_FINAL_MEMBER by error2<KtNamedDeclaration, FirCallableDeclaration, Name>(SourceElementPositioningStrategies.OVERRIDE_MODIFIER)
-    val RETURN_TYPE_MISMATCH_ON_INHERITANCE by error3<KtClassOrObject, FirClass<*>, FirCallableDeclaration<*>, FirCallableDeclaration<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
+    val RETURN_TYPE_MISMATCH_ON_INHERITANCE by error2<KtClassOrObject, FirCallableDeclaration<*>, FirCallableDeclaration<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
+    val RETURN_TYPE_MISMATCH_BY_DELEGATION by error2<KtClassOrObject, FirCallableDeclaration<*>, FirCallableDeclaration<*>>(SourceElementPositioningStrategies.DECLARATION_NAME)
     val ABSTRACT_MEMBER_NOT_IMPLEMENTED by error2<KtClassOrObject, FirClass, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
     val ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED by error2<KtClassOrObject, FirClass, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
     val INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER by error2<KtClassOrObject, FirClass, FirCallableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirImplementationMismatchChecker.kt

@@ -60,7 +60,6 @@ object FirImplementationMismatchChecker : FirClassChecker() {
                 if (!(fir as FirCallableMemberDeclaration<*>).isAbstract) {
                     implementations.add(fir)
                 }
-//                val type = context.returnTypeCalculator.tryCalculateReturnType(intSymbol.fir).coneType
             }
 
             if (delegation != null || implementations.isNotEmpty()) {
@@ -70,7 +69,10 @@ object FirImplementationMismatchChecker : FirClassChecker() {
                 val (conflict, _) = withTypes.find { (_, type) ->
                     !AbstractTypeChecker.isSubtypeOf(typeCheckerContext, methodType, type)
                 } ?: return
-                dedupReporter.reportOn(source, FirErrors.RETURN_TYPE_MISMATCH_ON_INHERITANCE, declaration, method, conflict, context)
+                val error =
+                    if (delegation != null) FirErrors.RETURN_TYPE_MISMATCH_BY_DELEGATION
+                    else FirErrors.RETURN_TYPE_MISMATCH_ON_INHERITANCE
+                dedupReporter.reportOn(source, error, method, conflict, context)
             } else {
                 //if there is no implementation, check that there can be any type compatible (subtype of) with all
                 var clash: Pair<FirCallableDeclaration<*>, FirCallableDeclaration<*>>? = null
@@ -84,7 +86,7 @@ object FirImplementationMismatchChecker : FirClassChecker() {
                     }
                 }
                 clash?.takeIf { !compatible }?.let { (m1, m2) ->
-                    dedupReporter.reportOn(source, FirErrors.RETURN_TYPE_MISMATCH_ON_INHERITANCE, declaration, m1, m2, context)
+                    dedupReporter.reportOn(source, FirErrors.RETURN_TYPE_MISMATCH_ON_INHERITANCE, m1, m2, context)
                 }
             }
         }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt

@@ -299,6 +299,8 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RESULT_TYPE_MISMA
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RETURN_NOT_ALLOWED
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RETURN_TYPE_MISMATCH
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RETURN_TYPE_MISMATCH_BY_DELEGATION
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RETURN_TYPE_MISMATCH_ON_INHERITANCE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RETURN_TYPE_MISMATCH_ON_OVERRIDE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SEALED_CLASS_CONSTRUCTOR_CALL
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SEALED_SUPERTYPE
@@ -935,6 +937,20 @@ class FirDefaultErrorMessages {
                 "Inner class of generic class extending 'Throwable' is prohibited"
             )
 
+            map.put(
+                RETURN_TYPE_MISMATCH_ON_INHERITANCE,
+                "''{0}'' clashes with ''{1}'': return types are incompatible",
+                NAME,
+                NAME
+            )
+
+            map.put(
+                RETURN_TYPE_MISMATCH_BY_DELEGATION,
+                "Type of ''{0}'' is not a subtype of overridden by delegation ''{1}''",
+                NAME,
+                NAME
+            )
+
             // Redeclarations
             map.put(MANY_COMPANION_OBJECTS, "Only one companion object is allowed per class")
             map.put(CONFLICTING_OVERLOADS, "Conflicting overloads: {0}", SYMBOLS) // *

compiler/testData/diagnostics/tests/delegation/Delegation_ClashingFunctions.fir.kt

@@ -10,9 +10,9 @@ interface Three {
     public fun foo(): String
 }
 
-<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, RETURN_TYPE_MISMATCH_ON_INHERITANCE!>class Test123<!>(val v1: One, val v2: Two, val v3: Three) : One by v1, Two by v2, Three by v3 { }
+<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, RETURN_TYPE_MISMATCH_BY_DELEGATION!>class Test123<!>(val v1: One, val v2: Two, val v3: Three) : One by v1, Two by v2, Three by v3 { }
-<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, RETURN_TYPE_MISMATCH_ON_INHERITANCE!>class Test132<!>(val v1: One, val v2: Two, val v3: Three) : One by v1, Three by v3, Two by v2 { }
+<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, RETURN_TYPE_MISMATCH_BY_DELEGATION!>class Test132<!>(val v1: One, val v2: Two, val v3: Three) : One by v1, Three by v3, Two by v2 { }
 <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class Test312<!>(val v1: One, val v2: Two, val v3: Three) : Three by v3, One by v1, Two by v2 { }
 <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class Test321<!>(val v1: One, val v2: Two, val v3: Three) : Three by v3, Two by v2, One by v1 { }
-<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, RETURN_TYPE_MISMATCH_ON_INHERITANCE!>class Test231<!>(val v1: One, val v2: Two, val v3: Three) : Two by v2, Three by v3, One by v1 { }
+<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, RETURN_TYPE_MISMATCH_BY_DELEGATION!>class Test231<!>(val v1: One, val v2: Two, val v3: Three) : Two by v2, Three by v3, One by v1 { }
-<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, RETURN_TYPE_MISMATCH_ON_INHERITANCE!>class Test213<!>(val v1: One, val v2: Two, val v3: Three) : Two by v2, One by v1, Three by v3 { }
+<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, RETURN_TYPE_MISMATCH_BY_DELEGATION!>class Test213<!>(val v1: One, val v2: Two, val v3: Three) : Two by v2, One by v1, Three by v3 { }

compiler/testData/diagnostics/tests/delegation/clashes/returnTypeMismatch.fir.kt

@@ -32,28 +32,28 @@ class CGeneric<T> : IGeneric<T> {
     }
 }
 
-abstract <!RETURN_TYPE_MISMATCH_ON_INHERITANCE!>class Test1<!> : IStr by CStr(), IInt
+abstract <!RETURN_TYPE_MISMATCH_BY_DELEGATION!>class Test1<!> : IStr by CStr(), IInt
 
-abstract <!RETURN_TYPE_MISMATCH_ON_INHERITANCE!>class Test2<!> : IStr, IInt by CInt()
+abstract <!RETURN_TYPE_MISMATCH_BY_DELEGATION!>class Test2<!> : IStr, IInt by CInt()
 
-abstract <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, RETURN_TYPE_MISMATCH_ON_INHERITANCE!>class Test3<!> : IStr by CStr(), IInt by CInt()
+abstract <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, RETURN_TYPE_MISMATCH_BY_DELEGATION!>class Test3<!> : IStr by CStr(), IInt by CInt()
 
 abstract class Test4 : IStr by CStr(), IGeneric<String>
 
 abstract class Test5 : IStr by CStr(), IGeneric<Any>
 
-abstract <!RETURN_TYPE_MISMATCH_ON_INHERITANCE!>class Test6<!> : IStr by CStr(), IGeneric<Int>
+abstract <!RETURN_TYPE_MISMATCH_BY_DELEGATION!>class Test6<!> : IStr by CStr(), IGeneric<Int>
 
 abstract class Test7 : IGeneric<String> by CGeneric<String>(), IStr
 
-abstract <!RETURN_TYPE_MISMATCH_ON_INHERITANCE!>class Test8<!> : IGeneric<String> by CGeneric<String>(), IInt
+abstract <!RETURN_TYPE_MISMATCH_BY_DELEGATION!>class Test8<!> : IGeneric<String> by CGeneric<String>(), IInt
 
 // Can't test due to https://youtrack.jetbrains.com/issue/KT-10258
 // abstract class Test9 : IGeneric<String> by CGeneric<String>(), IGeneric<Int>
 
-abstract <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, RETURN_TYPE_MISMATCH_ON_INHERITANCE!>class Test10<!> : IInt by CInt(), IStr by CStr(), IAny by CAny()
+abstract <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, RETURN_TYPE_MISMATCH_BY_DELEGATION!>class Test10<!> : IInt by CInt(), IStr by CStr(), IAny by CAny()
 
-abstract <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, RETURN_TYPE_MISMATCH_ON_INHERITANCE!>class Test11<!> : IInt, IStr by CStr(), IAny by CAny()
+abstract <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, RETURN_TYPE_MISMATCH_BY_DELEGATION!>class Test11<!> : IInt, IStr by CStr(), IAny by CAny()
 
-abstract <!RETURN_TYPE_MISMATCH_ON_INHERITANCE!>class Test12<!> : IInt, IStr, IAny by CAny()
+abstract <!RETURN_TYPE_MISMATCH_BY_DELEGATION!>class Test12<!> : IInt, IStr, IAny by CAny()
 

compiler/testData/diagnostics/tests/delegation/covariantOverrides/fromClass.fir.kt

@@ -6,7 +6,7 @@ open class IDerived1 : IBase1 {
     override fun foo(): String = "1"
 }
 
-<!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE!>class Broken1<!>(val b: IBase1) : IBase1 by b, IDerived1()
+<!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, RETURN_TYPE_MISMATCH_BY_DELEGATION!>class Broken1<!>(val b: IBase1) : IBase1 by b, IDerived1()
 
 interface IBase2 {
     val foo: Any

compiler/testData/diagnostics/tests/delegation/covariantOverrides/irrelevant.fir.kt

@@ -6,7 +6,7 @@ interface IDerived1 {
     fun foo(): String
 }
 
-class Broken1(val b: IBase1) : IBase1 by b, IDerived1
+<!RETURN_TYPE_MISMATCH_BY_DELEGATION!>class Broken1<!>(val b: IBase1) : IBase1 by b, IDerived1
 
 interface IBase2 {
     val foo: Any

compiler/testData/diagnostics/tests/delegation/covariantOverrides/kt13952.fir.kt

@@ -10,7 +10,7 @@ object AImpl : IA {
     override fun foo() = 42
 }
 
-open class C : IA by AImpl, IB
+open <!RETURN_TYPE_MISMATCH_BY_DELEGATION!>class C<!> : IA by AImpl, IB
 
 class D : C() {
     override fun foo(): Double = 3.14

compiler/testData/diagnostics/tests/delegation/covariantOverrides/simple.fir.kt

@@ -6,7 +6,7 @@ interface IDerived1 : IBase1 {
     override fun foo(): String
 }
 
-class Broken1(val b: IBase1) : IBase1 by b, IDerived1
+<!RETURN_TYPE_MISMATCH_BY_DELEGATION!>class Broken1<!>(val b: IBase1) : IBase1 by b, IDerived1
 
 interface IBase2 {
     val foo: Any

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt

@@ -1654,9 +1654,16 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
     }
     add(FirErrors.RETURN_TYPE_MISMATCH_ON_INHERITANCE) { firDiagnostic ->
         ReturnTypeMismatchOnInheritanceImpl(
-            firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a),
+            firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a as FirCallableDeclaration),
+            firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration),
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.RETURN_TYPE_MISMATCH_BY_DELEGATION) { firDiagnostic ->
+        ReturnTypeMismatchByDelegationImpl(
+            firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a as FirCallableDeclaration),
             firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.b as FirCallableDeclaration),
-            firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.c as FirCallableDeclaration),
             firDiagnostic as FirPsiDiagnostic<*>,
             token,
         )

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt

@@ -1173,11 +1173,16 @@ sealed class KtFirDiagnostic<PSI: PsiElement> : KtDiagnosticWithPsi<PSI> {
 
     abstract class ReturnTypeMismatchOnInheritance : KtFirDiagnostic<KtClassOrObject>() {
         override val diagnosticClass get() = ReturnTypeMismatchOnInheritance::class
-        abstract val classOrObject: KtClassLikeSymbol
         abstract val conflictingDeclaration1: KtCallableSymbol
         abstract val conflictingDeclaration2: KtCallableSymbol
     }
 
+    abstract class ReturnTypeMismatchByDelegation : KtFirDiagnostic<KtClassOrObject>() {
+        override val diagnosticClass get() = ReturnTypeMismatchByDelegation::class
+        abstract val delegateDeclaration: KtCallableSymbol
+        abstract val baseDeclaration: KtCallableSymbol
+    }
+
     abstract class AbstractMemberNotImplemented : KtFirDiagnostic<KtClassOrObject>() {
         override val diagnosticClass get() = AbstractMemberNotImplemented::class
         abstract val classOrObject: KtClassLikeSymbol

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt

@@ -1884,7 +1884,6 @@ internal class OverridingFinalMemberImpl(
 }
 
 internal class ReturnTypeMismatchOnInheritanceImpl(
-    override val classOrObject: KtClassLikeSymbol,
     override val conflictingDeclaration1: KtCallableSymbol,
     override val conflictingDeclaration2: KtCallableSymbol,
     firDiagnostic: FirPsiDiagnostic<*>,
@@ -1893,6 +1892,15 @@ internal class ReturnTypeMismatchOnInheritanceImpl(
     override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
 }
 
+internal class ReturnTypeMismatchByDelegationImpl(
+    override val delegateDeclaration: KtCallableSymbol,
+    override val baseDeclaration: KtCallableSymbol,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.ReturnTypeMismatchByDelegation(), KtAbstractFirDiagnostic<KtClassOrObject> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
 internal class AbstractMemberNotImplementedImpl(
     override val classOrObject: KtClassLikeSymbol,
     override val missingDeclaration: KtCallableSymbol,