[FIR] Add support for JVM_STATIC_NOT_IN_OBJECT_OR_COMPANION diagnostic

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

@@ -22,6 +22,8 @@ object JVM_DIAGNOSTICS_LIST : DiagnosticList("FirJvmErrors") {
         val CONFLICTING_JVM_DECLARATIONS by error<PsiElement>()
 
         val OVERRIDE_CANNOT_BE_STATIC by error<PsiElement>()
+        val JVM_STATIC_NOT_IN_OBJECT_OR_CLASS_COMPANION by error<PsiElement>(PositioningStrategy.DECLARATION_SIGNATURE)
+        val JVM_STATIC_NOT_IN_OBJECT_OR_COMPANION by error<PsiElement>(PositioningStrategy.DECLARATION_SIGNATURE)
 
         val INAPPLICABLE_JVM_NAME by error<PsiElement>()
         val ILLEGAL_JVM_NAME by error<PsiElement>()

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

@@ -23,6 +23,8 @@ object FirJvmErrors {
     // Declarations
     val CONFLICTING_JVM_DECLARATIONS by error0<PsiElement>()
     val OVERRIDE_CANNOT_BE_STATIC by error0<PsiElement>()
+    val JVM_STATIC_NOT_IN_OBJECT_OR_CLASS_COMPANION by error0<PsiElement>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
+    val JVM_STATIC_NOT_IN_OBJECT_OR_COMPANION by error0<PsiElement>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
     val INAPPLICABLE_JVM_NAME by error0<PsiElement>()
     val ILLEGAL_JVM_NAME by error0<PsiElement>()
 

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

@@ -5,7 +5,10 @@
 
 package org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration
 
+import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.isInterface
+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.FirBasicDeclarationChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.getContainingClassSymbol
@@ -13,41 +16,90 @@ 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.*
-import org.jetbrains.kotlin.fir.declarations.utils.*
+import org.jetbrains.kotlin.fir.declarations.utils.isCompanion
+import org.jetbrains.kotlin.fir.declarations.utils.isOverride
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.languageVersionSettings
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 object FirJvmStaticChecker : FirBasicDeclarationChecker() {
     override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+        if (declaration is FirConstructor) {
+            // WRONG_DECLARATION_TARGET
+            return
+        }
+
+        checkOverrideCannotBeStatic(declaration, context, reporter)
+        checkStaticNotInProperObject(declaration, context, reporter)
+    }
+
+    private fun checkStaticNotInProperObject(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration !is FirCallableDeclaration) {
             return
         }
 
-        if (!declaration.isOverride || !declaration.isContainerNotCompanionObject(context)) {
+        val containingClassSymbol = declaration.getContainingClassSymbol(context.session) ?: return
+        val supportJvmStaticInInterface = context.session.languageVersionSettings.supportsFeature(LanguageFeature.JvmStaticInInterface)
+
+        val properDiagnostic = if (supportJvmStaticInInterface) {
+            FirJvmErrors.JVM_STATIC_NOT_IN_OBJECT_OR_COMPANION
+        } else {
+            FirJvmErrors.JVM_STATIC_NOT_IN_OBJECT_OR_CLASS_COMPANION
+        }
+
+        var shouldReport = false
+
+        if (containingClassSymbol.classKind != ClassKind.OBJECT) {
+            shouldReport = true
+        } else {
+            val declaringClassSymbol = containingClassSymbol.getContainingClassSymbol(context.session) ?: return
+
+            if (declaringClassSymbol.classKind?.isInterface == true && !supportJvmStaticInInterface) {
+                shouldReport = true
+            }
+        }
+
+        if (!shouldReport) {
             return
         }
 
-        if (declaration is FirProperty) {
+        declaration.reportOnProperParts {
-            declaration.getter?.let {
+            if (it.hasAnnotationNamedAs(StandardClassIds.JvmStatic)) {
-                reportIfHasJvmStatic(it, context, reporter)
+                reporter.reportOn(it.source, properDiagnostic, context)
             }
-            declaration.setter?.let {
-                reportIfHasJvmStatic(it, context, reporter)
-            }
-        }
-
-        reportIfHasJvmStatic(declaration, context, reporter)
-    }
-
-    private fun reportIfHasJvmStatic(declaration: FirAnnotatedDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
-        if (declaration.hasJvmStaticAnnotation()) {
-            reporter.reportOn(declaration.source, FirJvmErrors.OVERRIDE_CANNOT_BE_STATIC, context)
         }
     }
 
-    private fun FirDeclaration.isContainerNotCompanionObject(context: CheckerContext): Boolean {
+    private fun checkOverrideCannotBeStatic(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+        if (declaration !is FirCallableDeclaration) {
+            return
+        }
+
+        if (!declaration.isOverride || !declaration.isContainerNonCompanionObject(context)) {
+            return
+        }
+
+        declaration.reportOnProperParts {
+            if (it.hasAnnotationNamedAs(StandardClassIds.JvmStatic)) {
+                reporter.reportOn(it.source, FirJvmErrors.OVERRIDE_CANNOT_BE_STATIC, context)
+            }
+        }
+    }
+
+    private fun FirAnnotatedDeclaration.reportOnProperParts(report: (FirAnnotatedDeclaration) -> Unit) {
+        if (this is FirProperty) {
+            // the setter is visited separately
+            this.getter?.let(report)
+        }
+        report(this)
+    }
+
+    private fun FirDeclaration.isContainerNonCompanionObject(context: CheckerContext): Boolean {
         val containingClassSymbol = this.getContainingClassSymbol(context.session) ?: return false
 
         @OptIn(SymbolInternals::class)
@@ -56,13 +108,13 @@ object FirJvmStaticChecker : FirBasicDeclarationChecker() {
         return containingClass.classKind == ClassKind.OBJECT && !containingClass.isCompanion
     }
 
-    private fun FirAnnotatedDeclaration.hasJvmStaticAnnotation(): Boolean {
+    private fun FirAnnotatedDeclaration.hasAnnotationNamedAs(classId: ClassId): Boolean {
-        return findJvmStaticAnnotation() != null
+        return findAnnotation(classId.shortClassName) != null
     }
 
-    private fun FirAnnotatedDeclaration.findJvmStaticAnnotation(): FirAnnotationCall? {
+    private fun FirAnnotatedDeclaration.findAnnotation(name: Name): FirAnnotationCall? {
         return annotations.firstOrNull {
-            it.calleeReference.safeAs<FirResolvedNamedReference>()?.name?.toString() == "JvmStatic"
+            it.calleeReference.safeAs<FirResolvedNamedReference>()?.name == name
         }
     }
 }

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

@@ -25,6 +25,8 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.JVM_RECORD
 import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.JVM_RECORD_NOT_LAST_VARARG_PARAMETER
 import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.JVM_RECORD_NOT_VAL_PARAMETER
 import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.JVM_RECORD_WITHOUT_PRIMARY_CONSTRUCTOR_PARAMETERS
+import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.JVM_STATIC_NOT_IN_OBJECT_OR_CLASS_COMPANION
+import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.JVM_STATIC_NOT_IN_OBJECT_OR_COMPANION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.LOCAL_JVM_RECORD
 import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.NON_DATA_CLASS_JVM_RECORD
 import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.NON_FINAL_JVM_RECORD
@@ -98,6 +100,14 @@ object FirJvmDefaultErrorMessages {
             map.put(ILLEGAL_JAVA_LANG_RECORD_SUPERTYPE, "Classes cannot have explicit 'java.lang.Record' supertype")
 
             map.put(OVERRIDE_CANNOT_BE_STATIC, "Override member cannot be '@JvmStatic' in object")
+            map.put(
+                JVM_STATIC_NOT_IN_OBJECT_OR_CLASS_COMPANION,
+                "Only members in named objects and companion objects of classes can be annotated with '@JvmStatic'"
+            )
+            map.put(
+                JVM_STATIC_NOT_IN_OBJECT_OR_COMPANION,
+                "Only members in named objects and companion objects can be annotated with '@JvmStatic'"
+            )
 
             map.put(INAPPLICABLE_JVM_NAME, "'@JvmName' annotation is not applicable to this declaration")
             map.put(ILLEGAL_JVM_NAME, "Illegal JVM name")

compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/annotationsOnUseSiteTargets.fir.kt

@@ -1,6 +1,6 @@
 interface Test {
-    @get:JvmStatic
+    <!JVM_STATIC_NOT_IN_OBJECT_OR_COMPANION!>@get:JvmStatic
-    val a: Int
+    val a: Int<!>
 
     @get:JvmName("1")
     val b: Int

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/constructorProperty.fir.kt

@@ -1,4 +0,0 @@
-// !LANGUAGE: -JvmStaticInInterface
-class A(@JvmStatic val z: Int) {
-
-}

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/constructorProperty.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !LANGUAGE: -JvmStaticInInterface
 class A(<!JVM_STATIC_NOT_IN_OBJECT_OR_CLASS_COMPANION!>@JvmStatic val z: Int<!>) {
 

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/constructorProperty_LL13.fir.kt

@@ -1,4 +0,0 @@
-// !LANGUAGE: +JvmStaticInInterface
-class A(@JvmStatic val z: Int) {
-
-}

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/constructorProperty_LL13.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !LANGUAGE: +JvmStaticInInterface
 class A(<!JVM_STATIC_NOT_IN_OBJECT_OR_COMPANION!>@JvmStatic val z: Int<!>) {
 

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/functions.fir.kt

@@ -21,7 +21,7 @@ class A {
         }
     }
 
-    @JvmStatic fun a4() {
+    <!JVM_STATIC_NOT_IN_OBJECT_OR_CLASS_COMPANION!>@JvmStatic fun a4()<!> {
 
     }
 }
@@ -47,7 +47,7 @@ interface B {
         }
     }
 
-    @JvmStatic fun a4() {
+    <!JVM_STATIC_NOT_IN_OBJECT_OR_CLASS_COMPANION!>@JvmStatic fun a4()<!> {
 
     }
 }

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/functions_LL13.fir.kt

@@ -21,7 +21,7 @@ class A {
         }
     }
 
-    @JvmStatic fun a4() {
+    <!JVM_STATIC_NOT_IN_OBJECT_OR_COMPANION!>@JvmStatic fun a4()<!> {
 
     }
 }
@@ -47,7 +47,7 @@ interface B {
         }
     }
 
-    @JvmStatic fun a4() {
+    <!JVM_STATIC_NOT_IN_OBJECT_OR_COMPANION!>@JvmStatic fun a4()<!> {
 
     }
 }

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/property.fir.kt

@@ -37,9 +37,9 @@ class A {
     }
 
     var p:Int = 1
-        @JvmStatic set(p1: Int) {
+        <!JVM_STATIC_NOT_IN_OBJECT_OR_CLASS_COMPANION!>@JvmStatic set(p1: Int)<!> {
             p = 1
         }
 
-    @JvmStatic val z2 = 1;
+    <!JVM_STATIC_NOT_IN_OBJECT_OR_CLASS_COMPANION!>@JvmStatic val z2<!> = 1;
 }

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/property_LL13.fir.kt

@@ -37,9 +37,9 @@ class A {
     }
 
     var p:Int = 1
-        @JvmStatic set(p1: Int) {
+        <!JVM_STATIC_NOT_IN_OBJECT_OR_COMPANION!>@JvmStatic set(p1: Int)<!> {
             p = 1
         }
 
-    @JvmStatic val z2 = 1;
+    <!JVM_STATIC_NOT_IN_OBJECT_OR_COMPANION!>@JvmStatic val z2<!> = 1;
 }

core/compiler.common/src/org/jetbrains/kotlin/name/StandardClassIds.kt

@@ -117,6 +117,7 @@ object StandardClassIds {
     val coroutineContext = CallableId(StandardNames.COROUTINES_PACKAGE_FQ_NAME, Name.identifier("coroutineContext"))
     val suspend = CallableId(BASE_KOTLIN_PACKAGE, Name.identifier("suspend"))
 
+    val JvmStatic = "JvmStatic".jvmId()
     val JvmName = "JvmName".jvmId()
 
     val Result = "Result".baseId()

gradle.properties

@@ -65,4 +65,3 @@ org.gradle.vfs.watch=true
 #kotlin.fir.modularized.testdata.kotlin=/path/to/kotlin/project/testdata
 #kotlin.fir.modularized.testdata.intellij=/path/to/intellij/project/testdata
 #kotlin.fir.modularized.testdata.youtrack=/path/to/youtrack/project/testdata
-

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

@@ -3670,6 +3670,18 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
             token,
         )
     }
+    add(FirJvmErrors.JVM_STATIC_NOT_IN_OBJECT_OR_CLASS_COMPANION) { firDiagnostic ->
+        JvmStaticNotInObjectOrClassCompanionImpl(
+            firDiagnostic as FirPsiDiagnostic,
+            token,
+        )
+    }
+    add(FirJvmErrors.JVM_STATIC_NOT_IN_OBJECT_OR_COMPANION) { firDiagnostic ->
+        JvmStaticNotInObjectOrCompanionImpl(
+            firDiagnostic as FirPsiDiagnostic,
+            token,
+        )
+    }
     add(FirJvmErrors.INAPPLICABLE_JVM_NAME) { firDiagnostic ->
         InapplicableJvmNameImpl(
             firDiagnostic as FirPsiDiagnostic,

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

@@ -2554,6 +2554,14 @@ sealed class KtFirDiagnostic<PSI : PsiElement> : KtDiagnosticWithPsi<PSI> {
         override val diagnosticClass get() = OverrideCannotBeStatic::class
     }
 
+    abstract class JvmStaticNotInObjectOrClassCompanion : KtFirDiagnostic<PsiElement>() {
+        override val diagnosticClass get() = JvmStaticNotInObjectOrClassCompanion::class
+    }
+
+    abstract class JvmStaticNotInObjectOrCompanion : KtFirDiagnostic<PsiElement>() {
+        override val diagnosticClass get() = JvmStaticNotInObjectOrCompanion::class
+    }
+
     abstract class InapplicableJvmName : KtFirDiagnostic<PsiElement>() {
         override val diagnosticClass get() = InapplicableJvmName::class
     }

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

@@ -4145,6 +4145,20 @@ internal class OverrideCannotBeStaticImpl(
     override val firDiagnostic: FirPsiDiagnostic by weakRef(firDiagnostic)
 }
 
+internal class JvmStaticNotInObjectOrClassCompanionImpl(
+    firDiagnostic: FirPsiDiagnostic,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.JvmStaticNotInObjectOrClassCompanion(), KtAbstractFirDiagnostic<PsiElement> {
+    override val firDiagnostic: FirPsiDiagnostic by weakRef(firDiagnostic)
+}
+
+internal class JvmStaticNotInObjectOrCompanionImpl(
+    firDiagnostic: FirPsiDiagnostic,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.JvmStaticNotInObjectOrCompanion(), KtAbstractFirDiagnostic<PsiElement> {
+    override val firDiagnostic: FirPsiDiagnostic by weakRef(firDiagnostic)
+}
+
 internal class InapplicableJvmNameImpl(
     firDiagnostic: FirPsiDiagnostic,
     override val token: ValidityToken,

plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/resolve/KSerializerDescriptorResolver.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.psi.synthetics.SyntheticClassOrObjectDescriptor
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.calls.components.isVararg
@@ -529,12 +530,7 @@ object KSerializerDescriptorResolver {
         else this.makeNullable()
 
     fun createWriteSelfFunctionDescriptor(thisClass: ClassDescriptor): SimpleFunctionDescriptor {
-        val jvmStaticClass = thisClass.module.findClassAcrossModuleDependencies(
+        val jvmStaticClass = thisClass.module.findClassAcrossModuleDependencies(StandardClassIds.JvmStatic)!!
-            ClassId(
-                FqName("kotlin.jvm"),
-                Name.identifier("JvmStatic")
-            )
-        )!!
         val jvmStaticAnnotation = AnnotationDescriptorImpl(jvmStaticClass.defaultType, mapOf(), jvmStaticClass.source)
         val annotations = Annotations.create(listOf(jvmStaticAnnotation))