diff --git a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirJvmDiagnosticsList.kt b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirJvmDiagnosticsList.kt index 5434e11574c..83670155944 100644 --- a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirJvmDiagnosticsList.kt +++ b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirJvmDiagnosticsList.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.fir.checkers.generator.diagnostics import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.fir.PrivateForInline import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.model.DiagnosticList import org.jetbrains.kotlin.fir.types.ConeKotlinType @@ -18,12 +19,6 @@ import org.jetbrains.kotlin.psi.KtAnnotationEntry object JVM_DIAGNOSTICS_LIST : DiagnosticList("FirJvmErrors") { val DECLARATIONS by object : DiagnosticGroup("Declarations") { val CONFLICTING_JVM_DECLARATIONS by error() - val STRICTFP_ON_CLASS by error() - val VOLATILE_ON_VALUE by error() - val VOLATILE_ON_DELEGATE by error() - val SYNCHRONIZED_ON_ABSTRACT by error() - val SYNCHRONIZED_IN_INTERFACE by error() - val SYNCHRONIZED_ON_INLINE by warning() } val TYPES by object : DiagnosticGroup("Types") { @@ -32,4 +27,20 @@ object JVM_DIAGNOSTICS_LIST : DiagnosticList("FirJvmErrors") { parameter("actualType") } } + + val ANNOTATIONS by object : DiagnosticGroup("annotations") { + val STRICTFP_ON_CLASS by error() + val VOLATILE_ON_VALUE by error() + val VOLATILE_ON_DELEGATE by error() + val SYNCHRONIZED_ON_ABSTRACT by error() + val SYNCHRONIZED_IN_INTERFACE by error() + val SYNCHRONIZED_ON_INLINE by warning() + val OVERLOADS_WITHOUT_DEFAULT_ARGUMENTS by warning() + val OVERLOADS_ABSTRACT by error() + val OVERLOADS_INTERFACE by error() + val OVERLOADS_LOCAL by error() + val OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR by deprecationError(LanguageFeature.ProhibitJvmOverloadsOnConstructorsOfAnnotationClasses) + val OVERLOADS_PRIVATE by warning() + } + } diff --git a/compiler/fir/checkers/checkers.jvm/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/jvm/FirJvmErrors.kt b/compiler/fir/checkers/checkers.jvm/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/jvm/FirJvmErrors.kt index 4d2981b614f..83b36032ac6 100644 --- a/compiler/fir/checkers/checkers.jvm/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/jvm/FirJvmErrors.kt +++ b/compiler/fir/checkers/checkers.jvm/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/jvm/FirJvmErrors.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.fir.analysis.diagnostics.jvm import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.config.LanguageFeature.ProhibitJvmOverloadsOnConstructorsOfAnnotationClasses import org.jetbrains.kotlin.fir.analysis.diagnostics.* import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.psi.KtAnnotationEntry @@ -19,14 +20,22 @@ import org.jetbrains.kotlin.psi.KtExpression object FirJvmErrors { // Declarations val CONFLICTING_JVM_DECLARATIONS by error0() + + // Types + val JAVA_TYPE_MISMATCH by error2() + + // annotations val STRICTFP_ON_CLASS by error0() val VOLATILE_ON_VALUE by error0() val VOLATILE_ON_DELEGATE by error0() val SYNCHRONIZED_ON_ABSTRACT by error0() val SYNCHRONIZED_IN_INTERFACE by error0() val SYNCHRONIZED_ON_INLINE by warning0() - - // Types - val JAVA_TYPE_MISMATCH by error2() + val OVERLOADS_WITHOUT_DEFAULT_ARGUMENTS by warning0() + val OVERLOADS_ABSTRACT by error0() + val OVERLOADS_INTERFACE by error0() + val OVERLOADS_LOCAL by error0() + val OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR by deprecationError0(ProhibitJvmOverloadsOnConstructorsOfAnnotationClasses) + val OVERLOADS_PRIVATE by warning0() } diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/JvmDeclarationCheckers.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/JvmDeclarationCheckers.kt index 8a794305b7e..ee4d46dbc1b 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/JvmDeclarationCheckers.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/JvmDeclarationCheckers.kt @@ -6,10 +6,7 @@ package org.jetbrains.kotlin.fir.analysis.jvm.checkers import org.jetbrains.kotlin.fir.analysis.checkers.declaration.* -import org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration.FirJvmExternalDeclarationChecker -import org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration.FirStrictfpApplicabilityChecker -import org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration.FirSynchronizedAnnotationChecker -import org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration.FirVolatileAnnotationChecker +import org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration.* object JvmDeclarationCheckers : DeclarationCheckers() { override val basicDeclarationCheckers: Set @@ -30,5 +27,6 @@ object JvmDeclarationCheckers : DeclarationCheckers() { override val functionCheckers: Set get() = setOf( FirSynchronizedAnnotationChecker, + FirOverloadsChecker, ) } diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirOverloadsChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirOverloadsChecker.kt new file mode 100644 index 00000000000..688712f7573 --- /dev/null +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirOverloadsChecker.kt @@ -0,0 +1,55 @@ +/* + * 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.declaration + +import org.jetbrains.kotlin.descriptors.ClassKind +import org.jetbrains.kotlin.descriptors.Visibilities +import org.jetbrains.kotlin.fir.analysis.checkers.classKind +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirFunctionChecker +import org.jetbrains.kotlin.fir.analysis.checkers.getContainingClassSymbol +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.declarations.FirConstructor +import org.jetbrains.kotlin.fir.declarations.FirFunction +import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction +import org.jetbrains.kotlin.fir.declarations.getAnnotationByFqName +import org.jetbrains.kotlin.fir.declarations.utils.isAbstract +import org.jetbrains.kotlin.fir.declarations.utils.isActual +import org.jetbrains.kotlin.fir.declarations.utils.isLocal +import org.jetbrains.kotlin.fir.declarations.utils.visibility +import org.jetbrains.kotlin.fir.resolve.dfa.cfg.isLocalClassOrAnonymousObject +import org.jetbrains.kotlin.name.FqName + +object FirOverloadsChecker : FirFunctionChecker() { + + private val JVM_OVERLOADS_FQ_NAME = FqName("kotlin.jvm.JvmOverloads") + + override fun check(declaration: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) { + val annotation = declaration.getAnnotationByFqName(JVM_OVERLOADS_FQ_NAME) ?: return + //todo need to have expect declaration here to check if it has default values + if (declaration.isActual) return + + val containingDeclaration = declaration.getContainingClassSymbol(context.session) + when { + containingDeclaration?.classKind == ClassKind.INTERFACE -> + reporter.reportOn(annotation.source, FirJvmErrors.OVERLOADS_INTERFACE, context) + declaration.isAbstract -> + reporter.reportOn(annotation.source, FirJvmErrors.OVERLOADS_ABSTRACT, context) + (declaration is FirSimpleFunction && declaration.isLocal) || + context.containingDeclarations.any { it.isLocalClassOrAnonymousObject() } -> + reporter.reportOn(annotation.source, FirJvmErrors.OVERLOADS_LOCAL, context) + declaration is FirConstructor && containingDeclaration?.classKind == ClassKind.ANNOTATION_CLASS -> + reporter.reportOn(annotation.source, FirJvmErrors.OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR, context) + !declaration.visibility.isPublicAPI && declaration.visibility != Visibilities.Internal -> + reporter.reportOn(annotation.source, FirJvmErrors.OVERLOADS_PRIVATE, context) + declaration.valueParameters.none { it.defaultValue != null } -> + reporter.reportOn(annotation.source, FirJvmErrors.OVERLOADS_WITHOUT_DEFAULT_ARGUMENTS, context) + } + } + +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/JvmOverloadWithNoDefaults.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/JvmOverloadWithNoDefaults.fir.kt deleted file mode 100644 index 5ddbe4cea11..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/JvmOverloadWithNoDefaults.fir.kt +++ /dev/null @@ -1,7 +0,0 @@ -// !DIAGNOSTICS: -UNUSED_PARAMETER -class C { - @kotlin.jvm.JvmOverloads constructor() { - } - - @kotlin.jvm.JvmOverloads fun foo(s: String) {} -} \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/JvmOverloadWithNoDefaults.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/JvmOverloadWithNoDefaults.kt index 289c28f7c0e..05d4d1c783e 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/JvmOverloadWithNoDefaults.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/JvmOverloadWithNoDefaults.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_PARAMETER class C { @kotlin.jvm.JvmOverloads constructor() { diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAbstractMethods.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAbstractMethods.fir.kt deleted file mode 100644 index ab222d7bc41..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAbstractMethods.fir.kt +++ /dev/null @@ -1,11 +0,0 @@ -interface T { - @kotlin.jvm.JvmOverloads fun foo(s: String = "OK") - - @kotlin.jvm.JvmOverloads fun bar(s: String = "OK") { - } -} - - -abstract class C { - @kotlin.jvm.JvmOverloads abstract fun foo(s: String = "OK") -} \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAbstractMethods.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAbstractMethods.kt index d6ce7d76e21..845e2236834 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAbstractMethods.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAbstractMethods.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL interface T { @kotlin.jvm.JvmOverloads fun foo(s: String = "OK") diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_3.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_3.fir.kt deleted file mode 100644 index f28b42adf09..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_3.fir.kt +++ /dev/null @@ -1,4 +0,0 @@ -// !LANGUAGE: -ProhibitJvmOverloadsOnConstructorsOfAnnotationClasses - -annotation class A1 @JvmOverloads constructor(val x: Int = 1) -annotation class A2 @JvmOverloads constructor() diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_3.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_3.kt index eca392c64b8..c68459b038b 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_3.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_3.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !LANGUAGE: -ProhibitJvmOverloadsOnConstructorsOfAnnotationClasses annotation class A1 @JvmOverloads constructor(val x: Int = 1) diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_4.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_4.fir.kt deleted file mode 100644 index 576ebfa6b2f..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_4.fir.kt +++ /dev/null @@ -1,4 +0,0 @@ -// !LANGUAGE: +ProhibitJvmOverloadsOnConstructorsOfAnnotationClasses - -annotation class A1 @JvmOverloads constructor(val x: Int = 1) -annotation class A2 @JvmOverloads constructor() \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_4.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_4.kt index fbe69c9cd9e..b5c403c1381 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_4.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_4.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !LANGUAGE: +ProhibitJvmOverloadsOnConstructorsOfAnnotationClasses annotation class A1 @JvmOverloads constructor(val x: Int = 1) diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnPrivate.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnPrivate.fir.kt deleted file mode 100644 index 95fc927051a..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnPrivate.fir.kt +++ /dev/null @@ -1,23 +0,0 @@ -// !DIAGNOSTICS: -UNUSED_PARAMETER -class C { - @kotlin.jvm.JvmOverloads private fun foo(s: String = "OK") { - } - - @kotlin.jvm.JvmOverloads fun bar(s: String = "OK") { - } -} - -fun foo() { - @kotlin.jvm.JvmOverloads fun quux(s: String = "OK") { - } - - class D { - @kotlin.jvm.JvmOverloads fun foo(s: String = "OK") { - } - } - - val x = object { - @kotlin.jvm.JvmOverloads fun foo(s: String = "OK") { - } - } -} \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnPrivate.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnPrivate.kt index 670a2bf880d..e81baa9f33c 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnPrivate.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnPrivate.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_PARAMETER class C { @kotlin.jvm.JvmOverloads private fun foo(s: String = "OK") { diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt index 7a37354d3b5..cadb61b4abd 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt @@ -3439,6 +3439,14 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert token, ) } + add(FirJvmErrors.JAVA_TYPE_MISMATCH) { firDiagnostic -> + JavaTypeMismatchImpl( + firSymbolBuilder.typeBuilder.buildKtType(firDiagnostic.a), + firSymbolBuilder.typeBuilder.buildKtType(firDiagnostic.b), + firDiagnostic as FirPsiDiagnostic, + token, + ) + } add(FirJvmErrors.STRICTFP_ON_CLASS) { firDiagnostic -> StrictfpOnClassImpl( firDiagnostic as FirPsiDiagnostic, @@ -3475,10 +3483,44 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert token, ) } - add(FirJvmErrors.JAVA_TYPE_MISMATCH) { firDiagnostic -> - JavaTypeMismatchImpl( - firSymbolBuilder.typeBuilder.buildKtType(firDiagnostic.a), - firSymbolBuilder.typeBuilder.buildKtType(firDiagnostic.b), + add(FirJvmErrors.OVERLOADS_WITHOUT_DEFAULT_ARGUMENTS) { firDiagnostic -> + OverloadsWithoutDefaultArgumentsImpl( + firDiagnostic as FirPsiDiagnostic, + token, + ) + } + add(FirJvmErrors.OVERLOADS_ABSTRACT) { firDiagnostic -> + OverloadsAbstractImpl( + firDiagnostic as FirPsiDiagnostic, + token, + ) + } + add(FirJvmErrors.OVERLOADS_INTERFACE) { firDiagnostic -> + OverloadsInterfaceImpl( + firDiagnostic as FirPsiDiagnostic, + token, + ) + } + add(FirJvmErrors.OVERLOADS_LOCAL) { firDiagnostic -> + OverloadsLocalImpl( + firDiagnostic as FirPsiDiagnostic, + token, + ) + } + add(FirJvmErrors.OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR.errorFactory) { firDiagnostic -> + OverloadsAnnotationClassConstructorErrorImpl( + firDiagnostic as FirPsiDiagnostic, + token, + ) + } + add(FirJvmErrors.OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR.warningFactory) { firDiagnostic -> + OverloadsAnnotationClassConstructorWarningImpl( + firDiagnostic as FirPsiDiagnostic, + token, + ) + } + add(FirJvmErrors.OVERLOADS_PRIVATE) { firDiagnostic -> + OverloadsPrivateImpl( firDiagnostic as FirPsiDiagnostic, token, ) diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt index d48232a0a67..928bc254a28 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt @@ -2398,6 +2398,12 @@ sealed class KtFirDiagnostic : KtDiagnosticWithPsi { override val diagnosticClass get() = ConflictingJvmDeclarations::class } + abstract class JavaTypeMismatch : KtFirDiagnostic() { + override val diagnosticClass get() = JavaTypeMismatch::class + abstract val expectedType: KtType + abstract val actualType: KtType + } + abstract class StrictfpOnClass : KtFirDiagnostic() { override val diagnosticClass get() = StrictfpOnClass::class } @@ -2422,10 +2428,32 @@ sealed class KtFirDiagnostic : KtDiagnosticWithPsi { override val diagnosticClass get() = SynchronizedOnInline::class } - abstract class JavaTypeMismatch : KtFirDiagnostic() { - override val diagnosticClass get() = JavaTypeMismatch::class - abstract val expectedType: KtType - abstract val actualType: KtType + abstract class OverloadsWithoutDefaultArguments : KtFirDiagnostic() { + override val diagnosticClass get() = OverloadsWithoutDefaultArguments::class + } + + abstract class OverloadsAbstract : KtFirDiagnostic() { + override val diagnosticClass get() = OverloadsAbstract::class + } + + abstract class OverloadsInterface : KtFirDiagnostic() { + override val diagnosticClass get() = OverloadsInterface::class + } + + abstract class OverloadsLocal : KtFirDiagnostic() { + override val diagnosticClass get() = OverloadsLocal::class + } + + abstract class OverloadsAnnotationClassConstructorError : KtFirDiagnostic() { + override val diagnosticClass get() = OverloadsAnnotationClassConstructorError::class + } + + abstract class OverloadsAnnotationClassConstructorWarning : KtFirDiagnostic() { + override val diagnosticClass get() = OverloadsAnnotationClassConstructorWarning::class + } + + abstract class OverloadsPrivate : KtFirDiagnostic() { + override val diagnosticClass get() = OverloadsPrivate::class } } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt index 1908e1da7a6..2df1ceed35a 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt @@ -3878,6 +3878,15 @@ internal class ConflictingJvmDeclarationsImpl( override val firDiagnostic: FirPsiDiagnostic by weakRef(firDiagnostic) } +internal class JavaTypeMismatchImpl( + override val expectedType: KtType, + override val actualType: KtType, + firDiagnostic: FirPsiDiagnostic, + override val token: ValidityToken, +) : KtFirDiagnostic.JavaTypeMismatch(), KtAbstractFirDiagnostic { + override val firDiagnostic: FirPsiDiagnostic by weakRef(firDiagnostic) +} + internal class StrictfpOnClassImpl( firDiagnostic: FirPsiDiagnostic, override val token: ValidityToken, @@ -3920,12 +3929,52 @@ internal class SynchronizedOnInlineImpl( override val firDiagnostic: FirPsiDiagnostic by weakRef(firDiagnostic) } -internal class JavaTypeMismatchImpl( - override val expectedType: KtType, - override val actualType: KtType, +internal class OverloadsWithoutDefaultArgumentsImpl( firDiagnostic: FirPsiDiagnostic, override val token: ValidityToken, -) : KtFirDiagnostic.JavaTypeMismatch(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.OverloadsWithoutDefaultArguments(), KtAbstractFirDiagnostic { + override val firDiagnostic: FirPsiDiagnostic by weakRef(firDiagnostic) +} + +internal class OverloadsAbstractImpl( + firDiagnostic: FirPsiDiagnostic, + override val token: ValidityToken, +) : KtFirDiagnostic.OverloadsAbstract(), KtAbstractFirDiagnostic { + override val firDiagnostic: FirPsiDiagnostic by weakRef(firDiagnostic) +} + +internal class OverloadsInterfaceImpl( + firDiagnostic: FirPsiDiagnostic, + override val token: ValidityToken, +) : KtFirDiagnostic.OverloadsInterface(), KtAbstractFirDiagnostic { + override val firDiagnostic: FirPsiDiagnostic by weakRef(firDiagnostic) +} + +internal class OverloadsLocalImpl( + firDiagnostic: FirPsiDiagnostic, + override val token: ValidityToken, +) : KtFirDiagnostic.OverloadsLocal(), KtAbstractFirDiagnostic { + override val firDiagnostic: FirPsiDiagnostic by weakRef(firDiagnostic) +} + +internal class OverloadsAnnotationClassConstructorErrorImpl( + firDiagnostic: FirPsiDiagnostic, + override val token: ValidityToken, +) : KtFirDiagnostic.OverloadsAnnotationClassConstructorError(), KtAbstractFirDiagnostic { + override val firDiagnostic: FirPsiDiagnostic by weakRef(firDiagnostic) +} + +internal class OverloadsAnnotationClassConstructorWarningImpl( + firDiagnostic: FirPsiDiagnostic, + override val token: ValidityToken, +) : KtFirDiagnostic.OverloadsAnnotationClassConstructorWarning(), KtAbstractFirDiagnostic { + override val firDiagnostic: FirPsiDiagnostic by weakRef(firDiagnostic) +} + +internal class OverloadsPrivateImpl( + firDiagnostic: FirPsiDiagnostic, + override val token: ValidityToken, +) : KtFirDiagnostic.OverloadsPrivate(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic by weakRef(firDiagnostic) }