[FIR] SUPER_CALL_WITH_DEFAULT_PARAMETERS diagnostic

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

@@ -55,4 +55,10 @@ object JVM_DIAGNOSTICS_LIST : DiagnosticList("FirJvmErrors") {
         val JVM_PACKAGE_NAME_NOT_SUPPORTED_IN_FILES_WITH_CLASSES by error<KtAnnotationEntry>()
     }
 
+    val SUPER by object : DiagnosticGroup("Super") {
+        val SUPER_CALL_WITH_DEFAULT_PARAMETERS by error<PsiElement>() {
+            parameter<String>("name")
+        }
+    }
+
 }

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

@@ -46,4 +46,7 @@ object FirJvmErrors {
     val JVM_PACKAGE_NAME_MUST_BE_VALID_NAME by error0<KtAnnotationEntry>()
     val JVM_PACKAGE_NAME_NOT_SUPPORTED_IN_FILES_WITH_CLASSES by error0<KtAnnotationEntry>()
 
+    // Super
+    val SUPER_CALL_WITH_DEFAULT_PARAMETERS by error1<PsiElement, String>()
+
 }

compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/JvmExpressionCheckers.kt

@@ -11,11 +11,13 @@ import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirFunctionCallChec
 import org.jetbrains.kotlin.fir.analysis.jvm.checkers.expression.FirDeprecatedJavaAnnotationsChecker
 import org.jetbrains.kotlin.fir.analysis.jvm.checkers.expression.FirJavaGenericVarianceViolationTypeChecker
 import org.jetbrains.kotlin.fir.analysis.jvm.checkers.expression.FirJvmPackageNameAnnotationsChecker
+import org.jetbrains.kotlin.fir.analysis.jvm.checkers.expression.FirSuperCallWithDefaultsChecker
 
 object JvmExpressionCheckers : ExpressionCheckers() {
     override val functionCallCheckers: Set<FirFunctionCallChecker>
         get() = setOf(
             FirJavaGenericVarianceViolationTypeChecker,
+            FirSuperCallWithDefaultsChecker,
         )
 
     override val annotationCallCheckers: Set<FirAnnotationCallChecker>

compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirSuperCallWithDefaultsChecker.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2010-2021 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.jvm.checkers.expression
+
+import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
+import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirFunctionCallChecker
+import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors
+import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
+import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
+import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
+import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedArgumentList
+import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
+import org.jetbrains.kotlin.fir.references.FirSuperReference
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
+import org.jetbrains.kotlin.utils.addToStdlib.safeAs
+
+object FirSuperCallWithDefaultsChecker : FirFunctionCallChecker() {
+
+    override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) {
+        expression.explicitReceiver.safeAs<FirQualifiedAccessExpression>()
+            ?.calleeReference.safeAs<FirSuperReference>()
+            ?: return
+
+        val functionSymbol =
+            (expression.calleeReference as? FirResolvedNamedReference)?.resolvedSymbol as? FirNamedFunctionSymbol ?: return
+        if (!functionSymbol.valueParameterSymbols.any { it.hasDefaultValue }) return
+        val arguments = expression.argumentList as? FirResolvedArgumentList ?: return
+        if (arguments.arguments.size < functionSymbol.valueParameterSymbols.size) {
+            reporter.reportOn(
+                expression.calleeReference.source,
+                FirJvmErrors.SUPER_CALL_WITH_DEFAULT_PARAMETERS,
+                functionSymbol.name.asString(),
+                context
+            )
+        }
+    }
+}

compiler/testData/diagnostics/tests/defaultArguments/superCall.fir.kt

@@ -1,28 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER -ABSTRACT_SUPER_CALL
-
-abstract class A {
-    open fun foo(a: String = "default") {
-    }
-
-    final fun foo2(a: String = "default") {
-    }
-
-    abstract fun foo3(a: String = "default")
-}
-
-open class B : A() {
-    fun test() {
-        super.foo("123")
-        super.foo()
-
-        super.foo2("123")
-        super.foo2()
-
-        super.foo3("123")
-        super.foo3()
-    }
-
-    override fun foo3(a: String) {
-        throw UnsupportedOperationException()
-    }
-}

compiler/testData/diagnostics/tests/defaultArguments/superCall.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER -ABSTRACT_SUPER_CALL
 
 abstract class A {

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

@@ -345,26 +345,8 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
             token,
         )
     }
-    add(FirErrors.SUPER_IS_NOT_AN_EXPRESSION) { firDiagnostic ->
+    add(FirJvmErrors.SUPER_CALL_WITH_DEFAULT_PARAMETERS) { firDiagnostic ->
-        SuperIsNotAnExpressionImpl(
+        SuperCallWithDefaultParametersImpl(
-            firDiagnostic as FirPsiDiagnostic,
-            token,
-        )
-    }
-    add(FirErrors.SUPER_NOT_AVAILABLE) { firDiagnostic ->
-        SuperNotAvailableImpl(
-            firDiagnostic as FirPsiDiagnostic,
-            token,
-        )
-    }
-    add(FirErrors.ABSTRACT_SUPER_CALL) { firDiagnostic ->
-        AbstractSuperCallImpl(
-            firDiagnostic as FirPsiDiagnostic,
-            token,
-        )
-    }
-    add(FirErrors.INSTANCE_ACCESS_BEFORE_SUPER_CALL) { firDiagnostic ->
-        InstanceAccessBeforeSuperCallImpl(
             firDiagnostic.a,
             firDiagnostic as FirPsiDiagnostic,
             token,

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

@@ -270,21 +270,9 @@ sealed class KtFirDiagnostic<PSI : PsiElement> : KtDiagnosticWithPsi<PSI> {
         abstract val classSymbol: KtClassLikeSymbol
     }
 
-    abstract class SuperIsNotAnExpression : KtFirDiagnostic<PsiElement>() {
+    abstract class SuperCallWithDefaultParameters : KtFirDiagnostic<PsiElement>() {
-        override val diagnosticClass get() = SuperIsNotAnExpression::class
+        override val diagnosticClass get() = SuperCallWithDefaultParameters::class
-    }
+        abstract val name: String
-
-    abstract class SuperNotAvailable : KtFirDiagnostic<PsiElement>() {
-        override val diagnosticClass get() = SuperNotAvailable::class
-    }
-
-    abstract class AbstractSuperCall : KtFirDiagnostic<PsiElement>() {
-        override val diagnosticClass get() = AbstractSuperCall::class
-    }
-
-    abstract class InstanceAccessBeforeSuperCall : KtFirDiagnostic<PsiElement>() {
-        override val diagnosticClass get() = InstanceAccessBeforeSuperCall::class
-        abstract val target: String
     }
 
     abstract class NotASupertype : KtFirDiagnostic<PsiElement>() {

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

@@ -400,32 +400,11 @@ internal class ResolutionToClassifierImpl(
     override val firDiagnostic: FirPsiDiagnostic by weakRef(firDiagnostic)
 }
 
-internal class SuperIsNotAnExpressionImpl(
+internal class SuperCallWithDefaultParametersImpl(
+    override val name: String,
     firDiagnostic: FirPsiDiagnostic,
     override val token: ValidityToken,
-) : KtFirDiagnostic.SuperIsNotAnExpression(), KtAbstractFirDiagnostic<PsiElement> {
+) : KtFirDiagnostic.SuperCallWithDefaultParameters(), KtAbstractFirDiagnostic<PsiElement> {
-    override val firDiagnostic: FirPsiDiagnostic by weakRef(firDiagnostic)
-}
-
-internal class SuperNotAvailableImpl(
-    firDiagnostic: FirPsiDiagnostic,
-    override val token: ValidityToken,
-) : KtFirDiagnostic.SuperNotAvailable(), KtAbstractFirDiagnostic<PsiElement> {
-    override val firDiagnostic: FirPsiDiagnostic by weakRef(firDiagnostic)
-}
-
-internal class AbstractSuperCallImpl(
-    firDiagnostic: FirPsiDiagnostic,
-    override val token: ValidityToken,
-) : KtFirDiagnostic.AbstractSuperCall(), KtAbstractFirDiagnostic<PsiElement> {
-    override val firDiagnostic: FirPsiDiagnostic by weakRef(firDiagnostic)
-}
-
-internal class InstanceAccessBeforeSuperCallImpl(
-    override val target: String,
-    firDiagnostic: FirPsiDiagnostic,
-    override val token: ValidityToken,
-) : KtFirDiagnostic.InstanceAccessBeforeSuperCall(), KtAbstractFirDiagnostic<PsiElement> {
     override val firDiagnostic: FirPsiDiagnostic by weakRef(firDiagnostic)
 }