Adjust tests for JSR305 annotations being extracted

See the previous commits

compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt

@@ -60,8 +60,18 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() {
         super.tearDown()
     }
 
-    private fun createJarWithForeignAnnotations(): File =
-        MockLibraryUtilExt.compileJavaFilesLibraryToJar(FOREIGN_ANNOTATIONS_SOURCES_PATH, "foreign-annotations")
+    private fun createJarWithForeignAnnotations(): List<File> {
+        val jsr305Jar =
+            MockLibraryUtilExt.compileJavaFilesLibraryToJar(JSR_305_SOURCES_PATH, "jsr305")
+
+        return listOf(
+            MockLibraryUtilExt.compileJavaFilesLibraryToJar(
+                FOREIGN_ANNOTATIONS_SOURCES_PATH, "foreign-annotations",
+                extraClasspath = listOf(jsr305Jar.absolutePath),
+            ),
+            jsr305Jar,
+        )
+    }
 
     private fun createEnvironment(content: String): KotlinCoreEnvironment {
         val classpath = mutableListOf(getAnnotationsJar(), ForTestCompileRuntime.runtimeJarForTests())
@@ -69,7 +79,7 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() {
             classpath.add(ForTestCompileRuntime.jvmAnnotationsForTests())
         }
         if (InTextDirectivesUtils.isDirectiveDefined(content, "FOREIGN_ANNOTATIONS")) {
-            classpath.add(createJarWithForeignAnnotations())
+            classpath.addAll(createJarWithForeignAnnotations())
         }
         return KotlinCoreEnvironment.createForTests(
             testRootDisposable,
@@ -176,6 +186,7 @@ abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() {
 
     companion object {
         private const val FOREIGN_ANNOTATIONS_SOURCES_PATH = "third-party/annotations"
+        private const val JSR_305_SOURCES_PATH = "third-party/jsr305"
     }
 }
 

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JvmEnvironmentConfigurator.kt

@@ -251,6 +251,12 @@ class JvmEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfig
                 }
                 configuration.addJavaSourceRoot(testServices.sourceFileProvider.javaSourceDirectory)
             }
+
+            // We add that as a part of the classpath only when Java files are being analyzed as sources, so the relevant annotations
+            // are being resolved classes are being resolved properly.
+            configuration.addJvmClasspathRoots(
+                testServices.additionalClassPathForJavaCompilationOrAnalysis?.classPath?.map(::File).orEmpty()
+            )
         }
 
         if (javaBinaryFiles.isNotEmpty()) {
@@ -268,7 +274,9 @@ class JvmEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfig
                     compileJavaFilesLibraryToJar(
                         testServices.sourceFileProvider.javaBinaryDirectory.path,
                         JAVA_BINARIES_JAR_NAME,
-                        extraClasspath = configuration.jvmClasspathRoots.map { it.absolutePath },
+                        extraClasspath =
+                        configuration.jvmClasspathRoots.map { it.absolutePath } +
+                                testServices.additionalClassPathForJavaCompilationOrAnalysis?.classPath.orEmpty(),
                         assertions = JUnit5Assertions,
                         useJava11 = useJava11ToCompileIncludedJavaFiles
                     )
@@ -428,3 +436,12 @@ class JvmEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfig
 
 
 }
+
+// This should be used as a classpath entries when Java classes are being compiled/analyzed to become a binary/source dependencies of kt-files
+// But in case the Java files are compiled it should not belong to the classpath of the module where test kt-files belong.
+// Currently, it's used for jsr305.jar, for which it's necessary to make sure that once some library uses the annotation from that jar,
+// we still don't need the jar itself when using the library to read the annotations.
+// (as they have been written to the class-files as fully-qualified names)
+class AdditionalClassPathForJavaCompilationOrAnalysis(val classPath: List<String>) : TestService
+
+val TestServices.additionalClassPathForJavaCompilationOrAnalysis by TestServices.nullableTestServiceAccessor<AdditionalClassPathForJavaCompilationOrAnalysis>()

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JvmForeignAnnotationsConfigurator.kt

@@ -34,7 +34,8 @@ import kotlin.io.path.createTempDirectory
 enum class JavaForeignAnnotationType(val path: String) {
     Annotations("third-party/annotations"),
     Java8Annotations("third-party/java8-annotations"),
-    Java9Annotations("third-party/java9-annotations");
+    Java9Annotations("third-party/java9-annotations"),
+    Jsr305("third-party/jsr305");
 }
 
 open class JvmForeignAnnotationsConfigurator(testServices: TestServices) : EnvironmentConfigurator(testServices) {
@@ -87,14 +88,18 @@ open class JvmForeignAnnotationsConfigurator(testServices: TestServices) : Envir
         val javaFilesDir = createTempDirectory().toFile().also {
             File(annotationPath.path).copyRecursively(it)
         }
+
+        val jsr305JarFile = createJsr305Jar(configuration)
+
         val foreignAnnotationsJar = MockLibraryUtil.compileJavaFilesLibraryToJar(
             javaFilesDir.path,
             "foreign-annotations",
             assertions = JUnit5Assertions,
-            extraClasspath = configuration.jvmClasspathRoots.map { it.absolutePath },
+            extraClasspath = configuration.jvmClasspathRoots.map { it.absolutePath } + jsr305JarFile.absolutePath,
             useJava11 = useJava11ToCompileIncludedJavaFiles
         )
         configuration.addModularRootIfNotNull(useJava11ToCompileIncludedJavaFiles, "java9_annotations", foreignAnnotationsJar)
+        testServices.register(AdditionalClassPathForJavaCompilationOrAnalysis::class, AdditionalClassPathForJavaCompilationOrAnalysis(listOf(jsr305JarFile.absolutePath)))
         configuration.addJvmClasspathRoot(testServices.standardLibrariesPathProvider.jvmAnnotationsForTests())
 
         if (JvmEnvironmentConfigurationDirectives.WITH_JSR305_TEST_ANNOTATIONS in registeredDirectives) {
@@ -106,10 +111,23 @@ open class JvmForeignAnnotationsConfigurator(testServices: TestServices) : Envir
                     jsr305AnnotationsDir.path,
                     "jsr-305-test-annotations",
                     assertions = JUnit5Assertions,
-                    extraClasspath = configuration.jvmClasspathRoots.map { it.absolutePath }
+                    extraClasspath = configuration.jvmClasspathRoots.map { it.absolutePath } + jsr305JarFile.absolutePath
                 )
             )
             configuration.addJvmClasspathRoot(KtTestUtil.getAnnotationsJar())
         }
     }
+
+    private fun createJsr305Jar(configuration: CompilerConfiguration): File {
+        val jsr305FilesDir = createTempDirectory().toFile().also {
+            File(JavaForeignAnnotationType.Jsr305.path).copyRecursively(it)
+        }
+
+        return MockLibraryUtil.compileJavaFilesLibraryToJar(
+            jsr305FilesDir.path,
+            "jsr305",
+            assertions = JUnit5Assertions,
+            extraClasspath = configuration.jvmClasspathRoots.map { it.absolutePath },
+        )
+    }
 }

compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.jvm.compiler
 
 import org.jetbrains.kotlin.checkers.FOREIGN_ANNOTATIONS_SOURCES_PATH
+import org.jetbrains.kotlin.checkers.JSR_305_SOURCES_PATH
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.*
@@ -27,16 +28,19 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.descriptors.resolveClassByFqName
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.load.java.AnnotationTypeQualifierResolver
+import org.jetbrains.kotlin.load.java.JavaTypeEnhancementState
 import org.jetbrains.kotlin.load.java.lazy.JavaResolverComponents
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.renderer.AnnotationArgumentsRenderingPolicy
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
-import org.jetbrains.kotlin.test.*
+import org.jetbrains.kotlin.test.ConfigurationKind
+import org.jetbrains.kotlin.test.KotlinTestUtils
+import org.jetbrains.kotlin.test.MockLibraryUtilExt
+import org.jetbrains.kotlin.test.TestJdkKind
 import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
 import org.jetbrains.kotlin.test.util.KtTestUtil
-import org.jetbrains.kotlin.load.java.JavaTypeEnhancementState
 import java.io.File
 
 class TypeQualifierAnnotationResolverTest : KtUsefulTestCase() {
@@ -83,14 +87,19 @@ class TypeQualifierAnnotationResolverTest : KtUsefulTestCase() {
     }
 
     private fun buildTypeQualifierResolverAndFindClass(className: String): Pair<AnnotationTypeQualifierResolver, ClassDescriptor> {
+        val jsr305Jar = MockLibraryUtilExt.compileJavaFilesLibraryToJar(JSR_305_SOURCES_PATH, "jsr305")
         val configuration = KotlinTestUtils.newConfiguration(
             ConfigurationKind.ALL, TestJdkKind.FULL_JDK,
             listOf(
                 KtTestUtil.getAnnotationsJar(),
                 MockLibraryUtilExt.compileJavaFilesLibraryToJar(
                     FOREIGN_ANNOTATIONS_SOURCES_PATH,
-                    "foreign-annotations"
-                )
+                    "foreign-annotations",
+                    extraClasspath = listOf(
+                        jsr305Jar.absolutePath
+                    )
+                ),
+                jsr305Jar,
             ),
             listOf(File(TEST_DATA_PATH))
         ).apply {