Use new default settings for java nullability annotations in JavaTypeEnhancementState and get rid of all hardcoded defaults

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

@@ -6,8 +6,8 @@
 package org.jetbrains.kotlin.jvm.compiler
 
 import org.jetbrains.kotlin.load.java.NULLABILITY_ANNOTATIONS
+import org.jetbrains.kotlin.load.java.nullabilityAnnotationSettings
 import org.jetbrains.kotlin.name.isChildOf
-import org.jetbrains.kotlin.resolve.jvm.annotations.nullabilityAnnotationSettings
 import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
 
 class AllNullabilityAnnotationsAreSetUpTest : KtUsefulTestCase() {

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

@@ -29,12 +29,12 @@ import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
 import org.jetbrains.kotlin.test.*
 import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
 import org.jetbrains.kotlin.test.util.KtTestUtil
-import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
+import org.jetbrains.kotlin.load.java.JavaTypeEnhancementState
 import java.io.File
 
 class LoadJavaPackageAnnotationsTest : KtUsefulTestCase() {
     companion object {
-        private val TEST_DATA_PATH = "compiler/testData/loadJavaPackageAnnotations/"
+        private const val TEST_DATA_PATH = "compiler/testData/loadJavaPackageAnnotations/"
     }
 
     private fun doTest(useJavac: Boolean, configurator: (CompilerConfiguration) -> Unit) {
@@ -45,27 +45,26 @@ class LoadJavaPackageAnnotationsTest : KtUsefulTestCase() {
                 put(JVMConfigurationKeys.USE_JAVAC, true)
             }
             languageVersionSettings = LanguageVersionSettingsImpl(
-                    LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE, mapOf(JvmAnalysisFlags.javaTypeEnhancementState to JavaTypeEnhancementState.STRICT)
+                LanguageVersion.LATEST_STABLE,
+                ApiVersion.LATEST_STABLE,
+                mapOf(JvmAnalysisFlags.javaTypeEnhancementState to JavaTypeEnhancementState.DEFAULT)
             )
             configurator(this)
         }
-        val environment =
-                KotlinCoreEnvironment.createForTests(
-                        testRootDisposable,
-                        configuration,
-                        EnvironmentConfigFiles.JVM_CONFIG_FILES
-                ).apply {
-                    if (useJavac) {
-                        registerJavac()
-                    }
-                }
+        val environment = KotlinCoreEnvironment.createForTests(
+            testRootDisposable,
+            configuration,
+            EnvironmentConfigFiles.JVM_CONFIG_FILES
+        ).apply {
+            if (useJavac) {
+                registerJavac()
+            }
+        }
         val moduleDescriptor = JvmResolveUtil.analyze(environment).moduleDescriptor
 
-        val packageFragmentDescriptor =
-                moduleDescriptor.getPackage(FqName("test")).fragments
-                        .singleOrNull {
-                            it.getMemberScope().getContributedClassifier(Name.identifier("A"), NoLookupLocation.FROM_TEST) != null
-                        }.let { assertInstanceOf(it, LazyJavaPackageFragment::class.java) }
+        val packageFragmentDescriptor = moduleDescriptor.getPackage(FqName("test")).fragments
+            .singleOrNull { it.getMemberScope().getContributedClassifier(Name.identifier("A"), NoLookupLocation.FROM_TEST) != null }
+            .let { assertInstanceOf(it, LazyJavaPackageFragment::class.java) }
 
         val annotation = packageFragmentDescriptor.annotations.findAnnotation(FqName("test.Ann"))
         assertNotNull(annotation)

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

@@ -36,39 +36,39 @@ import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
 import org.jetbrains.kotlin.test.*
 import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
 import org.jetbrains.kotlin.test.util.KtTestUtil
-import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
+import org.jetbrains.kotlin.load.java.JavaTypeEnhancementState
 import java.io.File
 
 class TypeQualifierAnnotationResolverTest : KtUsefulTestCase() {
     companion object {
-        private val TEST_DATA_PATH = "compiler/testData/typeQualifierNickname/"
+        private const val TEST_DATA_PATH = "compiler/testData/typeQualifierNickname/"
     }
 
     fun testBasicJSRNullabilityAnnotations() {
         val (typeQualifierResolver, aClass) = buildTypeQualifierResolverAndFindClass("A")
 
         assertMethodHasUnwrappedAnnotation(
-                aClass, typeQualifierResolver,
-                "nullable",
-                "@javax.annotation.Nonnull(when = When.UNKNOWN)"
+            aClass, typeQualifierResolver,
+            "nullable",
+            "@javax.annotation.Nonnull(when = When.UNKNOWN)"
         )
 
         assertMethodHasUnwrappedAnnotation(
-                aClass, typeQualifierResolver,
-                "checkForNull",
-                "@javax.annotation.CheckForNull()"
+            aClass, typeQualifierResolver,
+            "checkForNull",
+            "@javax.annotation.CheckForNull()"
         )
 
         assertMethodHasUnwrappedAnnotation(
-                aClass, typeQualifierResolver,
-                "nonNull",
-                "@javax.annotation.Nonnull()"
+            aClass, typeQualifierResolver,
+            "nonNull",
+            "@javax.annotation.Nonnull()"
         )
 
         assertMethodHasUnwrappedAnnotation(
-                aClass, typeQualifierResolver,
-                "nonNullExplicitArgument",
-                "@javax.annotation.Nonnull(when = When.ALWAYS)"
+            aClass, typeQualifierResolver,
+            "nonNullExplicitArgument",
+            "@javax.annotation.Nonnull(when = When.ALWAYS)"
         )
     }
 
@@ -76,9 +76,9 @@ class TypeQualifierAnnotationResolverTest : KtUsefulTestCase() {
         val (typeQualifierResolver, aClass) = buildTypeQualifierResolverAndFindClass("B")
 
         assertMethodHasUnwrappedAnnotation(
-                aClass, typeQualifierResolver,
-                "myNullable",
-                "@javax.annotation.CheckForNull()"
+            aClass, typeQualifierResolver,
+            "myNullable",
+            "@javax.annotation.CheckForNull()"
         )
     }
 
@@ -86,16 +86,18 @@ class TypeQualifierAnnotationResolverTest : KtUsefulTestCase() {
         val configuration = KotlinTestUtils.newConfiguration(
             ConfigurationKind.ALL, TestJdkKind.FULL_JDK,
             listOf(
-                    KtTestUtil.getAnnotationsJar(),
-                    MockLibraryUtilExt.compileJavaFilesLibraryToJar(
-                                FOREIGN_ANNOTATIONS_SOURCES_PATH,
-                                "foreign-annotations"
-                        )
-                ),
+                KtTestUtil.getAnnotationsJar(),
+                MockLibraryUtilExt.compileJavaFilesLibraryToJar(
+                    FOREIGN_ANNOTATIONS_SOURCES_PATH,
+                    "foreign-annotations"
+                )
+            ),
             listOf(File(TEST_DATA_PATH))
         ).apply {
             languageVersionSettings = LanguageVersionSettingsImpl(
-                    LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE, mapOf(JvmAnalysisFlags.javaTypeEnhancementState to JavaTypeEnhancementState.STRICT)
+                LanguageVersion.LATEST_STABLE,
+                ApiVersion.LATEST_STABLE,
+                mapOf(JvmAnalysisFlags.javaTypeEnhancementState to JavaTypeEnhancementState.DEFAULT)
             )
         }
 
@@ -109,28 +111,28 @@ class TypeQualifierAnnotationResolverTest : KtUsefulTestCase() {
     }
 
     private fun assertMethodHasUnwrappedAnnotation(
-            aClass: ClassDescriptor,
-            typeQualifierResolver: AnnotationTypeQualifierResolver,
-            methodName: String,
-            annotationText: String
+        aClass: ClassDescriptor,
+        typeQualifierResolver: AnnotationTypeQualifierResolver,
+        methodName: String,
+        annotationText: String
     ) {
         assertEquals(
-                annotationText,
-                DescriptorRenderer.withOptions {
-                    annotationArgumentsRenderingPolicy = AnnotationArgumentsRenderingPolicy.ALWAYS_PARENTHESIZED
-                }.renderAnnotation(
-                        aClass.findSingleTypeQualifierAnnotationOnMethod(methodName, typeQualifierResolver)
-                )
+            annotationText,
+            DescriptorRenderer.withOptions {
+                annotationArgumentsRenderingPolicy = AnnotationArgumentsRenderingPolicy.ALWAYS_PARENTHESIZED
+            }.renderAnnotation(
+                aClass.findSingleTypeQualifierAnnotationOnMethod(methodName, typeQualifierResolver)
+            )
         )
     }
 
     private fun ClassDescriptor.findSingleTypeQualifierAnnotationOnMethod(
-            name: String,
-            typeQualifierResolver: AnnotationTypeQualifierResolver
+        name: String,
+        typeQualifierResolver: AnnotationTypeQualifierResolver
     ): AnnotationDescriptor = unsubstitutedMemberScope
-            .getContributedFunctions(Name.identifier(name), NoLookupLocation.FROM_TEST)
-            .single()
-            .annotations.single()
-            .let(typeQualifierResolver::resolveTypeQualifierAnnotation)
-            .also(::assertNotNull)!!
+        .getContributedFunctions(Name.identifier(name), NoLookupLocation.FROM_TEST)
+        .single()
+        .annotations.single()
+        .let(typeQualifierResolver::resolveTypeQualifierAnnotation)
+        .also(::assertNotNull)!!
 }