Disable JSR-305 annotations by default, introduce CLI argument

No package annotations are going to be loaded, and
TypeQualifierDefault/TypeQualifierNickname are no longer recognized by
default. Use the CLI argument "-Xload-jsr305-annotations" to enable this
behavior back

 #KT-10942

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.java

@@ -157,6 +157,9 @@ public class K2JVMCompilerArguments extends CommonCompilerArguments {
             description = "Java compiler arguments")
     public String[] javacArguments;
 
+    @Argument(value = "-Xload-jsr305-annotations", description = "Load JSR-305 nullability annotations")
+    public boolean loadJsr305annotations;
+
     // Paths to output directories for friend modules.
     public String[] friendPaths;
 }

compiler/cli/src/org/jetbrains/kotlin/cli/common/CLICompiler.java

@@ -122,8 +122,8 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> extends CLI
         }
     }
 
-    private static void setupCommonArgumentsAndServices(
+    private void setupCommonArgumentsAndServices(
-            @NotNull CompilerConfiguration configuration, @NotNull CommonCompilerArguments arguments, @NotNull Services services
+            @NotNull CompilerConfiguration configuration, @NotNull A arguments, @NotNull Services services
     ) {
         if (arguments.noInline) {
             configuration.put(CommonConfigurationKeys.DISABLE_INLINE, true);
@@ -143,9 +143,7 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> extends CLI
         setupLanguageVersionSettings(configuration, arguments);
     }
 
-    private static void setupLanguageVersionSettings(
+    private void setupLanguageVersionSettings(@NotNull CompilerConfiguration configuration, @NotNull A arguments) {
-            @NotNull CompilerConfiguration configuration, @NotNull CommonCompilerArguments arguments
-    ) {
         LanguageVersion languageVersion = parseVersion(configuration, arguments.languageVersion, "language");
         LanguageVersion apiVersion = parseVersion(configuration, arguments.apiVersion, "API");
 
@@ -195,9 +193,13 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> extends CLI
                 new LanguageVersionSettingsImpl(languageVersion, ApiVersion.createByLanguageVersion(apiVersion), extraLanguageFeatures);
         settings.switchFlag(AnalysisFlags.getSkipMetadataVersionCheck(), arguments.skipMetadataVersionCheck);
         settings.switchFlag(AnalysisFlags.getMultiPlatformDoNotCheckImpl(), arguments.noCheckImpl);
+        configureAnalysisFlags(settings, arguments);
         CommonConfigurationKeysKt.setLanguageVersionSettings(configuration, settings);
     }
 
+    protected void configureAnalysisFlags(@NotNull LanguageVersionSettingsImpl settings, @NotNull A arguments) {
+    }
+
     @Nullable
     private static LanguageFeature.State chooseCoroutinesApplicabilityLevel(
             @NotNull CompilerConfiguration configuration,

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt

@@ -310,6 +310,10 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
         }
     }
 
+    override fun configureAnalysisFlags(settings: LanguageVersionSettingsImpl, arguments: K2JVMCompilerArguments) {
+        settings.switchFlag(AnalysisFlags.loadJsr305Annotations, arguments.loadJsr305annotations)
+    }
+
     override fun createArguments(): K2JVMCompilerArguments = K2JVMCompilerArguments().apply {
         if (System.getenv("KOTLIN_REPORT_PERF") != null) {
             reportPerf = true

compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.frontend.java.di
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.builtins.JvmBuiltInsPackageFragmentProvider
+import org.jetbrains.kotlin.config.AnalysisFlags
 import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
@@ -28,9 +29,7 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.frontend.di.configureModule
 import org.jetbrains.kotlin.incremental.components.LookupTracker
-import org.jetbrains.kotlin.load.java.AbstractJavaClassFinder
+import org.jetbrains.kotlin.load.java.*
-import org.jetbrains.kotlin.load.java.InternalFlexibleTypeTransformer
-import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
 import org.jetbrains.kotlin.load.java.components.*
 import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolver
 import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl
@@ -104,6 +103,13 @@ fun createContainerForLazyResolveWithJava(
 
     useInstance(languageVersionSettings)
 
+    if (languageVersionSettings.isFlagEnabled(AnalysisFlags.loadJsr305Annotations)) {
+        useImpl<AnnotationTypeQualifierResolverImpl>()
+    }
+    else {
+        useInstance(AnnotationTypeQualifierResolver.Empty)
+    }
+
     if (useBuiltInsProvider) {
         useInstance((moduleContext.module.builtIns as JvmBuiltIns).settings)
         useImpl<JvmBuiltInsPackageFragmentProvider>()

compiler/testData/cli/jvm/extraHelp.out

@@ -20,6 +20,7 @@ where advanced options include:
                              Script resolver environment in key-value pairs (the value could be quoted and escaped)
   -Xuse-javac                Use javac for Java source and class files analysis
   -Xjavac-arguments=<option[,]> Java compiler arguments
+  -Xload-jsr305-annotations  Load JSR-305 nullability annotations
   -Xno-inline                Disable method inlining
   -Xrepeat=<count>           Repeat compilation (for performance analysis)
   -Xskip-metadata-version-check Load classes with bad metadata version anyway (incl. pre-release classes)

compiler/tests-common/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt

@@ -203,7 +203,7 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() {
         // To be overridden by diagnostic-like tests.
     }
 
-    private fun loadLanguageVersionSettings(module: List<TestFile>): LanguageVersionSettings {
+    protected open fun loadLanguageVersionSettings(module: List<TestFile>): LanguageVersionSettings {
         var result: LanguageVersionSettings? = null
         for (file in module) {
             val current = file.customLanguageVersionSettings

compiler/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.checkers
 
+import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.test.MockLibraryUtil
 import java.io.File
 
@@ -27,4 +28,10 @@ abstract class AbstractForeignAnnotationsTest : AbstractDiagnosticsWithFullJdkTe
 
     open protected val annotationsPath: String
         get() = FOREIGN_ANNOTATIONS_SOURCES_PATH
+
+    override fun loadLanguageVersionSettings(module: List<TestFile>): LanguageVersionSettings {
+        return LanguageVersionSettingsImpl(LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE).apply {
+            switchFlag(AnalysisFlags.loadJsr305Annotations, true)
+        }
+    }
 }

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

@@ -20,8 +20,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.config.addJavaSourceRoots
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoot
-import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.*
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaPackageFragment
 import org.jetbrains.kotlin.name.FqName
@@ -41,26 +40,28 @@ class LoadJavaPackageAnnotationsTest : KtUsefulTestCase() {
     }
 
     private fun doTest(useJavac: Boolean, configurator: (CompilerConfiguration) -> Unit) {
+        val configuration = KotlinTestUtils.newConfiguration(
+                ConfigurationKind.ALL, TestJdkKind.FULL_JDK, KotlinTestUtils.getAnnotationsJar()
+        ).apply {
+            if (useJavac) {
+                put(JVMConfigurationKeys.USE_JAVAC, true)
+            }
+            languageVersionSettings = LanguageVersionSettingsImpl(LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE).apply {
+                switchFlag(AnalysisFlags.loadJsr305Annotations, true)
+            }
+            configurator(this)
+        }
         val environment =
                 KotlinCoreEnvironment.createForTests(
                         myTestRootDisposable,
-                        KotlinTestUtils.newConfiguration(
+                        configuration,
-                                ConfigurationKind.ALL, TestJdkKind.FULL_JDK, KotlinTestUtils.getAnnotationsJar()
-                        ).also {
-                            if (useJavac) {
-                                it.put(JVMConfigurationKeys.USE_JAVAC, true)
-                            }
-                            configurator(it)
-                        },
                         EnvironmentConfigFiles.JVM_CONFIG_FILES
                 ).apply {
                     if (useJavac) {
                         registerJavac()
                     }
                 }
-        val moduleDescriptor = JvmResolveUtil.analyze(
+        val moduleDescriptor = JvmResolveUtil.analyze(environment).moduleDescriptor
-                environment
-        ).moduleDescriptor
 
         val packageFragmentDescriptor =
                 moduleDescriptor.getPackage(FqName("test")).fragments

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

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.jvm.compiler
 import org.jetbrains.kotlin.checkers.FOREIGN_ANNOTATIONS_SOURCES_PATH
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
@@ -82,33 +83,27 @@ class TypeQualifierAnnotationResolverTest : KtUsefulTestCase() {
     }
 
     private fun buildTypeQualifierResolverAndFindClass(className: String): Pair<AnnotationTypeQualifierResolver, ClassDescriptor> {
-        val environment =
+        val configuration = KotlinTestUtils.newConfiguration(
-                KotlinCoreEnvironment.createForTests(
+                ConfigurationKind.ALL, TestJdkKind.FULL_JDK,
-                    myTestRootDisposable,
+                listOf(
-                    KotlinTestUtils.newConfiguration(
+                        KotlinTestUtils.getAnnotationsJar(),
-                            ConfigurationKind.ALL, TestJdkKind.FULL_JDK,
+                        MockLibraryUtil.compileJavaFilesLibraryToJar(
-                            listOf(
+                                FOREIGN_ANNOTATIONS_SOURCES_PATH,
-                                    KotlinTestUtils.getAnnotationsJar(),
+                                "foreign-annotations"
-                                    MockLibraryUtil.compileJavaFilesLibraryToJar(
+                        )
-                                        FOREIGN_ANNOTATIONS_SOURCES_PATH,
+                ),
-                                        "foreign-annotations"
+                listOf(File(TEST_DATA_PATH))
-                                    )
+        ).apply {
-                            ),
+            languageVersionSettings = LanguageVersionSettingsImpl(LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE).apply {
-                            listOf(File(TEST_DATA_PATH))
+                switchFlag(AnalysisFlags.loadJsr305Annotations, true)
-
+            }
-                    ),
+        }
-                    EnvironmentConfigFiles.JVM_CONFIG_FILES
-                )
 
+        val environment = KotlinCoreEnvironment.createForTests(myTestRootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
         val container = JvmResolveUtil.createContainer(environment)
-
         val typeQualifierResolver = container.get<JavaResolverComponents>().annotationTypeQualifierResolver
 
-        val aClass =
+        val aClass = container.get<ModuleDescriptor>().resolveClassByFqName(FqName(className), NoLookupLocation.FROM_TEST)!!
-                container
-                        .get<ModuleDescriptor>()
-                        .resolveClassByFqName(FqName(className), NoLookupLocation.FROM_TEST)!!
-
 
         return typeQualifierResolver to aClass
     }

compiler/util/src/org/jetbrains/kotlin/config/AnalysisFlags.kt

@@ -29,7 +29,7 @@ class AnalysisFlag internal constructor(private val name: String) {
     companion object
 }
 
-private operator fun AnalysisFlag.Companion.provideDelegate(instance: Any?, property: KProperty<*>) =
+private operator fun @Suppress("unused") AnalysisFlag.Companion.provideDelegate(instance: Any?, property: KProperty<*>) =
         object : ReadOnlyProperty<Any?, AnalysisFlag> {
             private val flag = AnalysisFlag(property.name)
 
@@ -42,4 +42,7 @@ object AnalysisFlags {
 
     @JvmStatic
     val multiPlatformDoNotCheckImpl by AnalysisFlag
+
+    @JvmStatic
+    val loadJsr305Annotations by AnalysisFlag
 }

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt

@@ -19,6 +19,8 @@ package org.jetbrains.kotlin.load.java
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
+import org.jetbrains.kotlin.load.java.AnnotationTypeQualifierResolver.QualifierApplicabilityType
+import org.jetbrains.kotlin.load.java.AnnotationTypeQualifierResolver.TypeQualifierWithApplicability
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.constants.ArrayValue
 import org.jetbrains.kotlin.resolve.constants.ConstantValue
@@ -31,28 +33,10 @@ private val TYPE_QUALIFIER_NICKNAME_FQNAME = FqName("javax.annotation.meta.TypeQ
 private val TYPE_QUALIFIER_FQNAME = FqName("javax.annotation.meta.TypeQualifier")
 private val TYPE_QUALIFIER_DEFAULT_FQNAME = FqName("javax.annotation.meta.TypeQualifierDefault")
 
-class AnnotationTypeQualifierResolver(storageManager: StorageManager) {
+interface AnnotationTypeQualifierResolver {
-    private val resolvedNicknames =
+    fun resolveTypeQualifierAnnotation(annotationDescriptor: AnnotationDescriptor): AnnotationDescriptor?
-            storageManager.createMemoizedFunctionWithNullableValues(this::computeTypeQualifierNickname)
 
-    private fun computeTypeQualifierNickname(classDescriptor: ClassDescriptor): AnnotationDescriptor? {
+    fun resolveTypeQualifierDefaultAnnotation(annotationDescriptor: AnnotationDescriptor): TypeQualifierWithApplicability?
-        if (!classDescriptor.annotations.hasAnnotation(TYPE_QUALIFIER_NICKNAME_FQNAME)) return null
-
-        return classDescriptor.annotations.firstNotNullResult(this::resolveTypeQualifierAnnotation)
-    }
-
-    private fun resolveTypeQualifierNickname(classDescriptor: ClassDescriptor): AnnotationDescriptor? {
-        if (classDescriptor.kind != ClassKind.ANNOTATION_CLASS) return null
-
-        return resolvedNicknames(classDescriptor)
-    }
-
-    fun resolveTypeQualifierAnnotation(annotationDescriptor: AnnotationDescriptor): AnnotationDescriptor? {
-        val annotationClass = annotationDescriptor.annotationClass ?: return null
-        if (annotationClass.isAnnotatedWithTypeQualifier) return annotationDescriptor
-
-        return resolveTypeQualifierNickname(annotationClass)
-    }
 
     enum class QualifierApplicabilityType {
         METHOD_RETURN_TYPE, VALUE_PARAMETER, FIELD, TYPE_USE
@@ -68,7 +52,37 @@ class AnnotationTypeQualifierResolver(storageManager: StorageManager) {
         operator fun component2() = QualifierApplicabilityType.values().filter(this::isApplicableTo)
     }
 
-    fun resolveTypeQualifierDefaultAnnotation(annotationDescriptor: AnnotationDescriptor): TypeQualifierWithApplicability? {
+    object Empty : AnnotationTypeQualifierResolver {
+        override fun resolveTypeQualifierAnnotation(annotationDescriptor: AnnotationDescriptor): AnnotationDescriptor? = null
+
+        override fun resolveTypeQualifierDefaultAnnotation(annotationDescriptor: AnnotationDescriptor): TypeQualifierWithApplicability? = null
+    }
+}
+
+class AnnotationTypeQualifierResolverImpl(storageManager: StorageManager) : AnnotationTypeQualifierResolver {
+    private val resolvedNicknames =
+            storageManager.createMemoizedFunctionWithNullableValues(this::computeTypeQualifierNickname)
+
+    private fun computeTypeQualifierNickname(classDescriptor: ClassDescriptor): AnnotationDescriptor? {
+        if (!classDescriptor.annotations.hasAnnotation(TYPE_QUALIFIER_NICKNAME_FQNAME)) return null
+
+        return classDescriptor.annotations.firstNotNullResult(this::resolveTypeQualifierAnnotation)
+    }
+
+    private fun resolveTypeQualifierNickname(classDescriptor: ClassDescriptor): AnnotationDescriptor? {
+        if (classDescriptor.kind != ClassKind.ANNOTATION_CLASS) return null
+
+        return resolvedNicknames(classDescriptor)
+    }
+
+    override fun resolveTypeQualifierAnnotation(annotationDescriptor: AnnotationDescriptor): AnnotationDescriptor? {
+        val annotationClass = annotationDescriptor.annotationClass ?: return null
+        if (annotationClass.isAnnotatedWithTypeQualifier) return annotationDescriptor
+
+        return resolveTypeQualifierNickname(annotationClass)
+    }
+
+    override fun resolveTypeQualifierDefaultAnnotation(annotationDescriptor: AnnotationDescriptor): TypeQualifierWithApplicability? {
         val typeQualifierDefaultAnnotatedClass =
                 annotationDescriptor.annotationClass?.takeIf { it.annotations.hasAnnotation(TYPE_QUALIFIER_DEFAULT_FQNAME) }
                 ?: return null

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaPackageFragmentProvider.kt

@@ -26,7 +26,7 @@ class LazyJavaPackageFragmentProvider(
         components: JavaResolverComponents
 ) : PackageFragmentProvider {
 
-    private val c = LazyJavaResolverContext(components, TypeParameterResolver.EMPTY) { null }
+    private val c = LazyJavaResolverContext(components, TypeParameterResolver.EMPTY, lazyOf(null))
 
     private val packageFragments: MemoizedFunctionToNullable<FqName, LazyJavaPackageFragment> =
             c.storageManager.createMemoizedFunctionWithNullableValues {

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaPackageFragment.kt

@@ -18,7 +18,9 @@ package org.jetbrains.kotlin.load.java.lazy.descriptors
 
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.SourceElement
+import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.impl.PackageFragmentDescriptorImpl
+import org.jetbrains.kotlin.load.java.AnnotationTypeQualifierResolver
 import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext
 import org.jetbrains.kotlin.load.java.lazy.childForClassOrPackage
 import org.jetbrains.kotlin.load.java.lazy.resolveAnnotations
@@ -52,7 +54,10 @@ class LazyJavaPackageFragment(
             onRecursiveCall = listOf()
     )
 
-    override val annotations = c.resolveAnnotations(jPackage)
+    override val annotations =
+            // Do not resolve package annotations if JSR-305 is disabled
+            if (c.components.annotationTypeQualifierResolver == AnnotationTypeQualifierResolver.Empty) Annotations.EMPTY
+            else c.resolveAnnotations(jPackage)
 
     internal fun getSubPackageFqNames(): List<FqName> = subPackages()
 

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt

@@ -48,16 +48,18 @@ import java.util.*
 class SignatureEnhancement(private val annotationTypeQualifierResolver: AnnotationTypeQualifierResolver) {
 
     fun extractNullability(annotationDescriptor: AnnotationDescriptor): NullabilityQualifier? {
-        when (annotationDescriptor.annotationClass?.fqNameSafe) {
+        val annotationFqName = annotationDescriptor.annotationClass?.fqNameSafe ?: return null
+        when (annotationFqName) {
             in NULLABLE_ANNOTATIONS -> return NullabilityQualifier.NULLABLE
             in NOT_NULL_ANNOTATIONS -> return NullabilityQualifier.NOT_NULL
         }
 
         val typeQualifier =
-                annotationTypeQualifierResolver
+                when {
-                        .resolveTypeQualifierAnnotation(annotationDescriptor)
+                    annotationFqName == JAVAX_NONNULL_ANNOTATION -> annotationDescriptor
-                        ?.takeIf { it.annotationClass?.fqNameSafe == JAVAX_NONNULL_ANNOTATION }
+                    else -> annotationTypeQualifierResolver.resolveTypeQualifierAnnotation(annotationDescriptor)
-                ?: return null
+                            ?.takeIf { it.annotationClass?.fqNameSafe == JAVAX_NONNULL_ANNOTATION }
+                } ?: return null
 
         val enumEntryDescriptor =
                 typeQualifier.allValueArguments.values.singleOrNull()?.value

core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt

@@ -58,7 +58,7 @@ class RuntimeModuleData private constructor(
             val runtimePackagePartProvider = RuntimePackagePartProvider(classLoader)
             val javaResolverCache = JavaResolverCache.EMPTY
             val notFoundClasses = NotFoundClasses(storageManager, module)
-            val annotationTypeQualifierResolver = AnnotationTypeQualifierResolver(storageManager)
+            val annotationTypeQualifierResolver = AnnotationTypeQualifierResolver.Empty
             val globalJavaResolverContext = JavaResolverComponents(
                     storageManager, ReflectJavaClassFinder(classLoader), reflectKotlinClassFinder, deserializedDescriptorResolver,
                     ExternalAnnotationResolver.EMPTY, SignaturePropagator.DO_NOTHING, RuntimeErrorReporter, javaResolverCache,