[FIR] Treat package-info.java nullness annotations as warnings

With the fix of reading package-info.java nullness annotations in more
situations, many new errors are introduced which could disrupt mixed
Java and Kotlin projects. As such, these errors should temporarily be
treated as warnings, even when the mode is set to strict. Since they
weren't previously reported, we need a short migration period.

^KT-77729

Author: bnorm

compiler/cli/cli-base/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCliJavaFileManagerImpl.kt

@@ -31,6 +31,7 @@ import org.jetbrains.kotlin.cli.jvm.index.SingleJavaFileRootsIndex
 import org.jetbrains.kotlin.load.java.JavaClassFinder
 import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
+import org.jetbrains.kotlin.load.java.structure.impl.source.SingleFileRootPsiPackage
 import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryClassSignatureParser
 import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaClass
 import org.jetbrains.kotlin.load.java.structure.impl.classFiles.ClassifierResolutionContext
@@ -245,27 +246,20 @@ class KotlinCliJavaFileManagerImpl(private val myPsiManager: PsiManager) : CoreJ
         if (!found) {
             found = packagePartProviders.any { it.findPackageParts(packageName).isNotEmpty() }
         }
-        if (!found) {
-            found = singleJavaFileRootsIndex.hasPackage(packageFqName)
+        if (!found && singleJavaFileRootsIndex.hasPackage(packageFqName)) {
+            val packageInfoClassId = ClassId(packageFqName, SingleJavaFileRootsIndex.PACKAGE_INFO_CLASS_NAME)
+            val packageInfoVirtualFile = singleJavaFileRootsIndex.findJavaSourceClass(packageInfoClassId)
+            val packageInfoPsiFile = packageInfoVirtualFile?.let { myPsiManager.findFile(it) } as? PsiJavaFile
+            val annotationsList = packageInfoPsiFile?.packageStatement?.annotationList
+            return SingleFileRootPsiPackage(myPsiManager, packageName, annotationsList)
         }
 
         if (!found) return null
 
         return object : PsiPackageImpl(myPsiManager, packageName) {
-            private val packageInfoAnnotations by lazy {
-                val packageInfoClassId = ClassId(packageFqName, SingleJavaFileRootsIndex.PACKAGE_INFO_CLASS_NAME)
-                val packageInfoVirtualFile = singleJavaFileRootsIndex.findJavaSourceClass(packageInfoClassId)
-                val packageInfoPsiFile = packageInfoVirtualFile?.let { myPsiManager.findFile(it) } as? PsiJavaFile
-                packageInfoPsiFile?.packageStatement?.annotationList
-            }
-
             // Do not check validness for packages we just made sure are actually present
             // It might be important for source roots that have non-trivial package prefix
             override fun isValid() = true
-
-            override fun getAnnotationList(): PsiModifierList? {
-                return packageInfoAnnotations ?: super.getAnnotationList()
-            }
         }
     }
 

compiler/fir/fir-jvm/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.java.enhancement
 
 import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.fakeElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSessionComponent
@@ -14,13 +15,16 @@ import org.jetbrains.kotlin.fir.declarations.extractEnumValueArgumentInfo
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.java.convertAnnotationsToFir
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
+import org.jetbrains.kotlin.fir.languageVersionSettings
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.load.java.AbstractAnnotationTypeQualifierResolver
 import org.jetbrains.kotlin.load.java.JavaModuleAnnotationsProvider
 import org.jetbrains.kotlin.load.java.JavaTypeEnhancementState
 import org.jetbrains.kotlin.load.java.JavaTypeQualifiersByElementType
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames.DEFAULT_ANNOTATION_MEMBER_NAME
+import org.jetbrains.kotlin.load.java.structure.impl.JavaElementImpl
+import org.jetbrains.kotlin.load.java.structure.impl.source.SingleFileRootPsiPackage
 import org.jetbrains.kotlin.name.FqName
 
 class FirAnnotationTypeQualifierResolver(
@@ -64,10 +68,15 @@ class FirAnnotationTypeQualifierResolver(
                 ?.let { extractDefaultQualifiers(it) }
         } else {
             val fakeSource = firClass.source?.fakeElement(KtFakeSourceElementKind.Enhancement)
-            val forModule = javaModuleAnnotationsProvider.getAnnotationsForModuleOwnerOfClass(classId)
-                ?.let { extractAndMergeDefaultQualifiers(null, it.convertAnnotationsToFir(session, fakeSource)) }
-            val forPackage = (firClass as? FirJavaClass)?.javaPackage
-                ?.let { extractAndMergeDefaultQualifiers(forModule, it.convertAnnotationsToFir(session, fakeSource)) }
+            val forModule = javaModuleAnnotationsProvider.getAnnotationsForModuleOwnerOfClass(classId)?.let {
+                extractAndMergeDefaultQualifiers(null, it.convertAnnotationsToFir(session, fakeSource))
+            }
+            val forPackage = (firClass as? FirJavaClass)?.javaPackage?.let {
+                val isForWarningOnly =
+                    !session.languageVersionSettings.supportsFeature(LanguageFeature.CheckPackageInfoNullnessAnnotations) &&
+                            (it as? JavaElementImpl<*>)?.psi is SingleFileRootPsiPackage
+                extractAndMergeDefaultQualifiers(forModule, it.convertAnnotationsToFir(session, fakeSource), isForWarningOnly)
+            }
             forPackage ?: forModule
         }
         return extractAndMergeDefaultQualifiers(parentQualifiers, firClass.annotations)

compiler/frontend.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/source/SingleFileRootPsiPackage.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2010-2025 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.load.java.structure.impl.source
+
+import com.intellij.psi.PsiManager
+import com.intellij.psi.PsiModifierList
+import com.intellij.psi.impl.file.PsiPackageImpl
+
+class SingleFileRootPsiPackage(
+    manager: PsiManager,
+    qualifiedName: String,
+    private val annotationsList: PsiModifierList?,
+) : PsiPackageImpl(manager, qualifiedName) {
+    // Do not check validness for packages we just made sure are actually present
+    // It might be important for source roots that have non-trivial package prefix
+    override fun isValid() = true
+
+    override fun getAnnotationList(): PsiModifierList? {
+        return annotationsList
+    }
+}

compiler/testData/cli/jvm/XjspecifyAnnotation/jspecifyFileRoots.args renamed to compiler/testData/cli/jvm/XjspecifyAnnotation/jspecifyFileRootsProgressive.args

@@ -4,3 +4,4 @@ $TESTDATA_DIR$/jspecify/test/package-info.java
 $FOREIGN_JAVA8_ANNOTATIONS_DIR$
 -d
 $TEMP_DIR$
+-progressive

compiler/testData/cli/jvm/XjspecifyAnnotation/jspecifyFileRoots.out renamed to compiler/testData/cli/jvm/XjspecifyAnnotation/jspecifyFileRootsProgressive.out

@@ -0,0 +1,7 @@
+$TESTDATA_DIR$/jspecifyUsage.kt
+$TESTDATA_DIR$/jspecify/test/A.java
+$TESTDATA_DIR$/jspecify/test/package-info.java
+$FOREIGN_JAVA8_ANNOTATIONS_DIR$
+-d
+$TEMP_DIR$
+-Xreport-all-warnings

compiler/testData/cli/jvm/XjspecifyAnnotation/jspecifyFileRootsWarning.args

@@ -0,0 +1,7 @@
+compiler/testData/cli/jvm/XjspecifyAnnotation/jspecifyUsage.kt:4:11: warning: Java type mismatch: inferred type is 'Nothing?', but 'String' was expected.
+    a.foo(null)
+          ^^^^
+compiler/testData/cli/jvm/XjspecifyAnnotation/jspecifyUsage.kt:5:12: error: only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type 'String?'.
+    a.bar().length
+           ^
+COMPILATION_ERROR

compiler/testData/cli/jvm/XjspecifyAnnotation/jspecifyFileRootsWarning.out

@@ -455,6 +455,7 @@ enum class LanguageFeature(
     ForbidInlineEnumEntries(KOTLIN_2_4, enabledInProgressiveMode = true, "KTLC-361"),
     CheckOptInOnPureEnumEntries(KOTLIN_2_4, enabledInProgressiveMode = true, "KTLC-359"),
     ForbidExposingPackagePrivateInInternal(KOTLIN_2_4, enabledInProgressiveMode = true, "KTLC-271"),
+    CheckPackageInfoNullnessAnnotations(KOTLIN_2_4, enabledInProgressiveMode = true, "KT-77729"),
 
     // 2.5
 

compiler/tests-integration/tests-gen/org/jetbrains/kotlin/cli/CliTestGenerated.java

@@ -46,15 +46,16 @@ abstract class AbstractAnnotationTypeQualifierResolver<TAnnotation : Any>(
         }
     }
 
-    private fun resolveQualifierBuiltInDefaultAnnotation(annotation: TAnnotation): JavaDefaultQualifiers? {
+    private fun resolveQualifierBuiltInDefaultAnnotation(annotation: TAnnotation, isForWarningOnly: Boolean): JavaDefaultQualifiers? {
         if (javaTypeEnhancementState.disabledDefaultAnnotations) {
             return null
         }
 
         return BUILT_IN_TYPE_QUALIFIER_DEFAULT_ANNOTATIONS[annotation.fqName]?.let { qualifierForDefaultingAnnotation ->
             val state = resolveDefaultAnnotationState(annotation).takeIf { it != ReportLevel.IGNORE } ?: return null
             qualifierForDefaultingAnnotation.copy(
-                nullabilityQualifier = qualifierForDefaultingAnnotation.nullabilityQualifier.copy(isForWarningOnly = state.isWarning)
+                nullabilityQualifier = qualifierForDefaultingAnnotation.nullabilityQualifier
+                    .copy(isForWarningOnly = isForWarningOnly || state.isWarning)
             )
         }
     }
@@ -156,8 +157,8 @@ abstract class AbstractAnnotationTypeQualifierResolver<TAnnotation : Any>(
             }.also { if (found != null && found != it) return null /* inconsistent */ }
         }
 
-    private fun extractDefaultQualifiers(annotation: TAnnotation): JavaDefaultQualifiers? {
-        resolveQualifierBuiltInDefaultAnnotation(annotation)?.let { return it }
+    private fun extractDefaultQualifiers(annotation: TAnnotation, isForWarningOnly: Boolean): JavaDefaultQualifiers? {
+        resolveQualifierBuiltInDefaultAnnotation(annotation, isForWarningOnly)?.let { return it }
 
         val (typeQualifier, applicability) = resolveTypeQualifierDefaultAnnotation(annotation)
             ?: return null
@@ -166,15 +167,17 @@ abstract class AbstractAnnotationTypeQualifierResolver<TAnnotation : Any>(
         // TODO: since we override the warning status, whether we force it in `extractNullability` is irrelevant.
         //   However, this is probably not what was intended.
         val nullabilityQualifier = extractNullability(typeQualifier) { false } ?: return null
-        return JavaDefaultQualifiers(nullabilityQualifier.copy(isForWarningOnly = jsr305State.isWarning), applicability)
+        return JavaDefaultQualifiers(nullabilityQualifier.copy(isForWarningOnly = isForWarningOnly || jsr305State.isWarning), applicability)
     }
 
     fun extractAndMergeDefaultQualifiers(
-        oldQualifiers: JavaTypeQualifiersByElementType?, annotations: Iterable<TAnnotation>
+        oldQualifiers: JavaTypeQualifiersByElementType?,
+        annotations: Iterable<TAnnotation>,
+        isForWarningOnly: Boolean = false,
     ): JavaTypeQualifiersByElementType? {
         if (javaTypeEnhancementState.disabledDefaultAnnotations) return oldQualifiers
 
-        val extractedQualifiers = annotations.mapNotNull { extractDefaultQualifiers(it) }
+        val extractedQualifiers = annotations.mapNotNull { extractDefaultQualifiers(it, isForWarningOnly) }
         if (extractedQualifiers.isEmpty()) return oldQualifiers
 
         val newQualifiers = QualifierByApplicabilityType(AnnotationQualifierApplicabilityType::class.java)