[FIR] Prohibit expect class members with default values actualized

...by fake-override.
It is error without deprecation cycle because `expect` and `actual`
classes are still in Beta and expected impact of change is negligible.

^KT-62036 Fixed

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

@@ -3628,6 +3628,16 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
             token,
         )
     }
+    add(FirErrors.DEFAULT_ARGUMENTS_IN_EXPECT_ACTUALIZED_BY_FAKE_OVERRIDE) { firDiagnostic ->
+        DefaultArgumentsInExpectActualizedByFakeOverrideImpl(
+            firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a),
+            firDiagnostic.b.map { firNamedFunctionSymbol ->
+                firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol(firNamedFunctionSymbol)
+            },
+            firDiagnostic as KtPsiDiagnostic,
+            token,
+        )
+    }
     add(FirErrors.EXPECTED_FUNCTION_SOURCE_WITH_DEFAULT_ARGUMENTS_NOT_FOUND) { firDiagnostic ->
         ExpectedFunctionSourceWithDefaultArgumentsNotFoundImpl(
             firDiagnostic as KtPsiDiagnostic,

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

@@ -2548,6 +2548,12 @@ sealed interface KtFirDiagnostic<PSI : PsiElement> : KtDiagnosticWithPsi<PSI> {
         val members: List<KtCallableSymbol>
     }
 
+    interface DefaultArgumentsInExpectActualizedByFakeOverride : KtFirDiagnostic<KtClass> {
+        override val diagnosticClass get() = DefaultArgumentsInExpectActualizedByFakeOverride::class
+        val expectClassSymbol: KtClassLikeSymbol
+        val members: List<KtFunctionLikeSymbol>
+    }
+
     interface ExpectedFunctionSourceWithDefaultArgumentsNotFound : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ExpectedFunctionSourceWithDefaultArgumentsNotFound::class
     }

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

@@ -3069,6 +3069,13 @@ internal class DefaultArgumentsInExpectWithActualTypealiasImpl(
     token: KtLifetimeToken,
 ) : KtAbstractFirDiagnostic<KtTypeAlias>(firDiagnostic, token), KtFirDiagnostic.DefaultArgumentsInExpectWithActualTypealias
 
+internal class DefaultArgumentsInExpectActualizedByFakeOverrideImpl(
+    override val expectClassSymbol: KtClassLikeSymbol,
+    override val members: List<KtFunctionLikeSymbol>,
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClass>(firDiagnostic, token), KtFirDiagnostic.DefaultArgumentsInExpectActualizedByFakeOverride
+
 internal class ExpectedFunctionSourceWithDefaultArgumentsNotFoundImpl(
     firDiagnostic: KtPsiDiagnostic,
     token: KtLifetimeToken,

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendMPPDiagnosticsWithLightTreeTestGenerated.java

@@ -1111,6 +1111,12 @@ public class FirOldFrontendMPPDiagnosticsWithLightTreeTestGenerated extends Abst
                 runTest("compiler/testData/diagnostics/tests/multiplatform/defaultArguments/methodDefaultArgsViaActualFakeOverride/delegation.kt");
             }
 
+            @Test
+            @TestMetadata("disabledFeature.kt")
+            public void testDisabledFeature() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/multiplatform/defaultArguments/methodDefaultArgsViaActualFakeOverride/disabledFeature.kt");
+            }
+
             @Test
             @TestMetadata("intersectionOverride.kt")
             public void testIntersectionOverride() throws Exception {

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendMPPDiagnosticsWithPsiTestGenerated.java

@@ -1111,6 +1111,12 @@ public class FirOldFrontendMPPDiagnosticsWithPsiTestGenerated extends AbstractFi
                 runTest("compiler/testData/diagnostics/tests/multiplatform/defaultArguments/methodDefaultArgsViaActualFakeOverride/delegation.kt");
             }
 
+            @Test
+            @TestMetadata("disabledFeature.kt")
+            public void testDisabledFeature() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/multiplatform/defaultArguments/methodDefaultArgsViaActualFakeOverride/disabledFeature.kt");
+            }
+
             @Test
             @TestMetadata("intersectionOverride.kt")
             public void testIntersectionOverride() throws Exception {

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

@@ -1231,6 +1231,10 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
             parameter<FirClassSymbol<*>>("expectClassSymbol")
             parameter<Collection<FirCallableSymbol<*>>>("members")
         }
+        val DEFAULT_ARGUMENTS_IN_EXPECT_ACTUALIZED_BY_FAKE_OVERRIDE by error<KtClass>(PositioningStrategy.SUPERTYPES_LIST) {
+            parameter<FirRegularClassSymbol>("expectClassSymbol")
+            parameter<Collection<FirNamedFunctionSymbol>>("members")
+        }
         val EXPECTED_FUNCTION_SOURCE_WITH_DEFAULT_ARGUMENTS_NOT_FOUND by error<PsiElement>()
 
         val NO_ACTUAL_FOR_EXPECT by error<KtNamedDeclaration>(PositioningStrategy.INCOMPATIBLE_DECLARATION) {

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

@@ -650,6 +650,7 @@ object FirErrors {
     val ACTUAL_TYPE_ALIAS_TO_NOTHING by error0<KtTypeAlias>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
     val ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS by error0<KtFunction>(SourceElementPositioningStrategies.PARAMETERS_WITH_DEFAULT_VALUE)
     val DEFAULT_ARGUMENTS_IN_EXPECT_WITH_ACTUAL_TYPEALIAS by error2<KtTypeAlias, FirClassSymbol<*>, Collection<FirCallableSymbol<*>>>()
+    val DEFAULT_ARGUMENTS_IN_EXPECT_ACTUALIZED_BY_FAKE_OVERRIDE by error2<KtClass, FirRegularClassSymbol, Collection<FirNamedFunctionSymbol>>(SourceElementPositioningStrategies.SUPERTYPES_LIST)
     val EXPECTED_FUNCTION_SOURCE_WITH_DEFAULT_ARGUMENTS_NOT_FOUND by error0<PsiElement>()
     val NO_ACTUAL_FOR_EXPECT by error3<KtNamedDeclaration, FirBasedSymbol<*>, FirModuleData, Map<ExpectActualCompatibility<FirBasedSymbol<*>>, Collection<FirBasedSymbol<*>>>>(SourceElementPositioningStrategies.INCOMPATIBLE_DECLARATION)
     val ACTUAL_WITHOUT_EXPECT by error2<KtNamedDeclaration, FirBasedSymbol<*>, Map<ExpectActualCompatibility<FirBasedSymbol<*>>, Collection<FirBasedSymbol<*>>>>(SourceElementPositioningStrategies.DECLARATION_NAME_ONLY)

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

@@ -450,6 +450,7 @@ val FIR_NON_SUPPRESSIBLE_ERROR_NAMES: Set<String> = setOf(
     "ACTUAL_TYPE_ALIAS_TO_NOTHING",
     "ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS",
     "DEFAULT_ARGUMENTS_IN_EXPECT_WITH_ACTUAL_TYPEALIAS",
+    "DEFAULT_ARGUMENTS_IN_EXPECT_ACTUALIZED_BY_FAKE_OVERRIDE",
     "EXPECTED_FUNCTION_SOURCE_WITH_DEFAULT_ARGUMENTS_NOT_FOUND",
     "NO_ACTUAL_FOR_EXPECT",
     "ACTUAL_WITHOUT_EXPECT",

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt

@@ -137,6 +137,7 @@ object CommonDeclarationCheckers : DeclarationCheckers() {
             FirDelegateFieldTypeMismatchChecker,
             FirMultipleDefaultsInheritedFromSupertypesChecker,
             FirFiniteBoundRestrictionChecker,
+            FirDefaultArgumentsInExpectActualizedByFakeOverrideChecker,
         )
 
     override val constructorCheckers: Set<FirConstructorChecker>

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

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.analysis.checkers.declaration
+
+import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.diagnostics.reportOn
+import org.jetbrains.kotlin.fir.FirExpectActualMatchingContext
+import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.declarations.getSingleCompatibleExpectForActualOrNull
+import org.jetbrains.kotlin.fir.declarations.getSingleExpectForActualOrNull
+import org.jetbrains.kotlin.fir.declarations.utils.isActual
+import org.jetbrains.kotlin.fir.expectActualMatchingContextFactory
+import org.jetbrains.kotlin.fir.isDelegated
+import org.jetbrains.kotlin.fir.isSubstitutionOrIntersectionOverride
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
+import org.jetbrains.kotlin.fir.types.classId
+import org.jetbrains.kotlin.mpp.DeclarationSymbolMarker
+import org.jetbrains.kotlin.resolve.multiplatform.compatible
+
+internal object FirDefaultArgumentsInExpectActualizedByFakeOverrideChecker : FirRegularClassChecker() {
+    override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) {
+        if (!context.languageVersionSettings.supportsFeature(LanguageFeature.MultiPlatformProjects) ||
+            !context.languageVersionSettings.supportsFeature(LanguageFeature.ProhibitDefaultDefaultArgumentsInExpectActualizedByFakeOverride)) {
+            return
+        }
+        if (!declaration.isActual) {
+            return
+        }
+        val actualClassSymbol = declaration.symbol
+        // We want to report errors even if a candidate is incompatible, but it's single
+        val expectedSingleCandidate = actualClassSymbol.getSingleCompatibleExpectForActualOrNull()
+            ?: actualClassSymbol.getSingleExpectForActualOrNull()
+            ?: return
+        val expectClassSymbol = expectedSingleCandidate as FirRegularClassSymbol
+
+        val matchingContext = context.session.expectActualMatchingContextFactory.create(context.session, context.scopeSession)
+        val problematicExpectMembers = with(matchingContext) { findProblematicExpectMembers(expectClassSymbol, actualClassSymbol) }
+        if (problematicExpectMembers.isNotEmpty()) {
+            reporter.reportOn(
+                declaration.source, FirErrors.DEFAULT_ARGUMENTS_IN_EXPECT_ACTUALIZED_BY_FAKE_OVERRIDE,
+                expectClassSymbol, problematicExpectMembers, context
+            )
+        }
+    }
+
+    private fun FirExpectActualMatchingContext.findProblematicExpectMembers(
+        expectClassSymbol: FirRegularClassSymbol, actualClassSymbol: FirRegularClassSymbol,
+    ): List<FirNamedFunctionSymbol> {
+        val actualFakeOverrideMembers = actualClassSymbol.collectAllMembers(isActualDeclaration = true)
+            .filterIsInstance<FirNamedFunctionSymbol>()
+            .filter { isFakeOverride(it, actualClassSymbol) }
+
+        return actualFakeOverrideMembers
+            .mapNotNull { getSingleMatchingExpect(it, expectClassSymbol, actualClassSymbol) }
+            .filter(::hasDefaultArgumentValues)
+    }
+
+    private fun isFakeOverride(member: FirNamedFunctionSymbol, containingClassSymbol: FirRegularClassSymbol): Boolean {
+        val memberReceiverClassId = member.dispatchReceiverType?.classId ?: return false
+        if (memberReceiverClassId != containingClassSymbol.classId) {
+            return true
+        }
+        return member.isSubstitutionOrIntersectionOverride || member.isDelegated
+    }
+
+    private fun FirExpectActualMatchingContext.getSingleMatchingExpect(
+        actualMember: FirNamedFunctionSymbol,
+        expectSymbol: FirRegularClassSymbol,
+        actualSymbol: FirRegularClassSymbol
+    ): FirNamedFunctionSymbol? {
+        val potentialExpects = findPotentialExpectClassMembersForActual(
+            expectSymbol, actualSymbol, actualMember,
+            checkClassScopesCompatibility = false
+        )
+        val expectMember: DeclarationSymbolMarker = potentialExpects.entries.singleOrNull { it.value.compatible }?.key
+            ?: potentialExpects.keys.singleOrNull()
+            ?: return null
+        return expectMember as FirNamedFunctionSymbol
+    }
+
+    private fun hasDefaultArgumentValues(function: FirFunctionSymbol<*>): Boolean {
+        return function.valueParameterSymbols.any { it.hasDefaultValue }
+    }
+}

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

@@ -163,6 +163,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DATA_CLASS_WITHOU
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DATA_OBJECT_CUSTOM_EQUALS_OR_HASH_CODE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DECLARATION_CANT_BE_INLINED
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DECLARATION_CANT_BE_INLINED_DEPRECATION
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DEFAULT_ARGUMENTS_IN_EXPECT_ACTUALIZED_BY_FAKE_OVERRIDE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DEFAULT_ARGUMENTS_IN_EXPECT_WITH_ACTUAL_TYPEALIAS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DEFAULT_VALUE_NOT_ALLOWED_IN_OVERRIDE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DEFINITELY_NON_NULLABLE_AS_REIFIED
@@ -1969,6 +1970,13 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() {
             DECLARATION_NAME,
             SYMBOLS_ON_NEWLINE_WITH_INDENT,
         )
+        map.put(
+            DEFAULT_ARGUMENTS_IN_EXPECT_ACTUALIZED_BY_FAKE_OVERRIDE,
+            "Default argument values inside expect declaration ''{0}'' are not allowed for methods actualized via fake override. " +
+                    "Possible fix is to remove default argument values in members:{1}",
+            DECLARATION_NAME,
+            SYMBOLS_ON_NEWLINE_WITH_INDENT,
+        )
         map.put(
             EXPECTED_FUNCTION_SOURCE_WITH_DEFAULT_ARGUMENTS_NOT_FOUND,
             "Expected function source is not found, so generating default argument values declared there is impossible. Please add the corresponding file to compilation sources."

compiler/testData/diagnostics/tests/multiplatform/defaultArguments/methodDefaultArgsViaActualFakeOverride/delegation.fir.kt

@@ -14,4 +14,4 @@ object BaseImpl : Base {
     override fun foo(p: Int) {}
 }
 
-actual class <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>Foo<!> : Base by BaseImpl
+actual class <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>Foo<!> : <!DEFAULT_ARGUMENTS_IN_EXPECT_ACTUALIZED_BY_FAKE_OVERRIDE!>Base by BaseImpl<!>

compiler/testData/diagnostics/tests/multiplatform/defaultArguments/methodDefaultArgsViaActualFakeOverride/disabledFeature.kt

@@ -0,0 +1,15 @@
+// FIR_IDENTICAL
+// LANGUAGE: -ProhibitDefaultDefaultArgumentsInExpectActualizedByFakeOverride
+// MODULE: m1-common
+// FILE: common.kt
+expect class Foo {
+    fun foo(param: Int = 1)
+}
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+open class Base {
+    fun foo(param: Int) {}
+}
+
+actual class Foo : Base()

compiler/testData/diagnostics/tests/multiplatform/defaultArguments/methodDefaultArgsViaActualFakeOverride/intersectionOverride.fir.kt

@@ -0,0 +1,18 @@
+// MODULE: m1-common
+// FILE: common.kt
+expect interface Foo {
+    fun foo(p: Int = 1)
+}
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+interface Base1 {
+    fun foo(p: Int)
+}
+
+interface Base2 {
+    fun foo(p: Int)
+}
+
+@Suppress("ACTUAL_CLASSIFIER_MUST_HAVE_THE_SAME_SUPERTYPES_AS_NON_FINAL_EXPECT_CLASSIFIER")
+actual interface Foo : <!DEFAULT_ARGUMENTS_IN_EXPECT_ACTUALIZED_BY_FAKE_OVERRIDE!>Base1, Base2<!>

compiler/testData/diagnostics/tests/multiplatform/defaultArguments/methodDefaultArgsViaActualFakeOverride/intersectionOverride.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // MODULE: m1-common
 // FILE: common.kt
 expect interface Foo {

compiler/testData/diagnostics/tests/multiplatform/defaultArguments/methodDefaultArgsViaActualFakeOverride/nestedClass.fir.kt

@@ -0,0 +1,17 @@
+// MODULE: m1-common
+// FILE: common.kt
+expect class Foo {
+    class Bar() {
+        fun foo(p: Int = 1)
+    }
+}
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+open class Base {
+    fun foo(p: Int) {}
+}
+
+actual class Foo {
+    actual class Bar : <!DEFAULT_ARGUMENTS_IN_EXPECT_ACTUALIZED_BY_FAKE_OVERRIDE!>Base()<!>
+}

compiler/testData/diagnostics/tests/multiplatform/defaultArguments/methodDefaultArgsViaActualFakeOverride/nestedClass.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // MODULE: m1-common
 // FILE: common.kt
 expect class Foo {

compiler/testData/diagnostics/tests/multiplatform/defaultArguments/methodDefaultArgsViaActualFakeOverride/simple.fir.kt

@@ -0,0 +1,13 @@
+// MODULE: m1-common
+// FILE: common.kt
+expect class Foo {
+    fun foo(param: Int = 1)
+}
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+open class Base {
+    fun foo(param: Int) {}
+}
+
+actual class Foo : <!DEFAULT_ARGUMENTS_IN_EXPECT_ACTUALIZED_BY_FAKE_OVERRIDE!>Base()<!>

compiler/testData/diagnostics/tests/multiplatform/defaultArguments/methodDefaultArgsViaActualFakeOverride/simple.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // MODULE: m1-common
 // FILE: common.kt
 expect class Foo {

compiler/testData/diagnostics/tests/multiplatform/defaultArguments/methodDefaultArgsViaActualFakeOverride/simpleIncompatible.fir.kt

@@ -11,4 +11,4 @@ open class Base {
     fun foo(param: Int) {}
 }
 
-actual class <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>Foo<!> : Base()
+actual class <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>Foo<!> : <!DEFAULT_ARGUMENTS_IN_EXPECT_ACTUALIZED_BY_FAKE_OVERRIDE!>Base()<!>

compiler/testData/diagnostics/tests/multiplatform/defaultArguments/methodDefaultArgsViaActualFakeOverride/substitutionOverride.fir.kt

@@ -0,0 +1,13 @@
+// MODULE: m1-common
+// FILE: common.kt
+expect class Foo() {
+    fun foo(p: Int = 1)
+}
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+open class Base<T> {
+    fun foo(p: T) {}
+}
+
+actual class Foo : <!DEFAULT_ARGUMENTS_IN_EXPECT_ACTUALIZED_BY_FAKE_OVERRIDE!>Base<Int>()<!>

compiler/testData/diagnostics/tests/multiplatform/defaultArguments/methodDefaultArgsViaActualFakeOverride/substitutionOverride.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // MODULE: m1-common
 // FILE: common.kt
 expect class Foo() {

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java

@@ -24136,6 +24136,12 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest {
                         runTest("compiler/testData/diagnostics/tests/multiplatform/defaultArguments/methodDefaultArgsViaActualFakeOverride/delegation.kt");
                     }
 
+                    @Test
+                    @TestMetadata("disabledFeature.kt")
+                    public void testDisabledFeature() throws Exception {
+                        runTest("compiler/testData/diagnostics/tests/multiplatform/defaultArguments/methodDefaultArgsViaActualFakeOverride/disabledFeature.kt");
+                    }
+
                     @Test
                     @TestMetadata("intersectionOverride.kt")
                     public void testIntersectionOverride() throws Exception {

compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt

@@ -306,6 +306,7 @@ enum class LanguageFeature(
     ProhibitMissedMustBeInitializedWhenThereIsNoPrimaryConstructor(KOTLIN_2_0, kind = BUG_FIX), // KT-58472
     MangleCallsToJavaMethodsWithValueClasses(KOTLIN_2_0, kind = OTHER), // KT-55945
     ForbidInferringTypeVariablesIntoEmptyIntersection(KOTLIN_2_0, kind = BUG_FIX), // KT-51221
+    ProhibitDefaultDefaultArgumentsInExpectActualizedByFakeOverride(KOTLIN_2_0, kind = BUG_FIX), // KT-62036
 
     // 2.1