From 13febaf978a0f438e87c5a4b76e7f57bc08e65cd Mon Sep 17 00:00:00 2001 From: "Denis.Zharkov" Date: Fri, 24 Feb 2023 18:45:54 +0100 Subject: [PATCH] Adjust tests for JSR305 annotations being extracted See the previous commits --- .../java/AbstractFirTypeEnhancementTest.kt | 17 ++++++++++--- .../JvmEnvironmentConfigurator.kt | 19 ++++++++++++++- .../JvmForeignAnnotationsConfigurator.kt | 24 ++++++++++++++++--- .../TypeQualifierAnnotationResolverTest.kt | 17 +++++++++---- 4 files changed, 66 insertions(+), 11 deletions(-) diff --git a/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt b/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt index 6da4f715484..d96a5184993 100644 --- a/compiler/fir/analysis-tests/legacy-fir-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt +++ b/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 { + 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" } } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JvmEnvironmentConfigurator.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JvmEnvironmentConfigurator.kt index 2794fb7ffd4..c3432f3b1d9 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JvmEnvironmentConfigurator.kt +++ b/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) : TestService + +val TestServices.additionalClassPathForJavaCompilationOrAnalysis by TestServices.nullableTestServiceAccessor() diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JvmForeignAnnotationsConfigurator.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JvmForeignAnnotationsConfigurator.kt index d2eac8dcdda..5e12e646ae9 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JvmForeignAnnotationsConfigurator.kt +++ b/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 }, + ) + } } diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt index fb35a59fbfd..a0247eada2c 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt +++ b/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 { + 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 {