Do not add container annotaions to type artificially

It was only used for type-related nullability/mutability
annotations and it was necessary to remove them
in the descriptor renderer (duplicating their fqnames there).
At the same time they're only needed for types enhancement
where they can be simply restored from type owners' descriptors

The testData changes are more or less correct: this kind of annotations
is bound both to types themselves and their use because of their targets

compiler/testData/foreignAnnotations/tests/jsr305NullabilityNicknames.txt

@@ -4,10 +4,10 @@ public fun main(/*0*/ a: A): kotlin.Unit
 
 public open class A {
     public constructor A()
-    @MyNullable public final var field: @MyNullable kotlin.String?
+    @MyNullable public final var field: kotlin.String?
-    @MyNonnull public open fun bar(): @MyNonnull kotlin.String
+    @MyNonnull public open fun bar(): kotlin.String
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    @MyNullable public open fun foo(/*0*/ @MyNonnull x: @MyNonnull kotlin.String, /*1*/ @MyNullable y: @MyNullable kotlin.CharSequence?): @MyNullable kotlin.String?
+    @MyNullable public open fun foo(/*0*/ @MyNonnull x: kotlin.String, /*1*/ @MyNullable y: kotlin.CharSequence?): kotlin.String?
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }

compiler/testData/foreignAnnotationsJava8/tests/checkerFramework.txt

@@ -4,11 +4,11 @@ public fun main(/*0*/ a: A<kotlin.String>, /*1*/ a1: A<kotlin.String?>): kotlin.
 
 public open class A</*0*/ T : kotlin.Any!> {
     public constructor A</*0*/ T : kotlin.Any!>()
-    @org.checkerframework.checker.nullness.qual.Nullable public final var field: kotlin.String?
+    @org.checkerframework.checker.nullness.qual.Nullable public final var field: @org.checkerframework.checker.nullness.qual.Nullable kotlin.String?
-    @org.checkerframework.checker.nullness.qual.NonNull public open fun bar(): kotlin.String
+    @org.checkerframework.checker.nullness.qual.NonNull public open fun bar(): @org.checkerframework.checker.nullness.qual.NonNull kotlin.String
-    @org.checkerframework.checker.nullness.qual.Nullable public open fun baz(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: T): T?
+    @org.checkerframework.checker.nullness.qual.Nullable public open fun baz(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: @org.checkerframework.checker.nullness.qual.NonNull T): @org.checkerframework.checker.nullness.qual.Nullable T?
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    @org.checkerframework.checker.nullness.qual.Nullable public open fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: kotlin.String, /*1*/ @org.checkerframework.checker.nullness.qual.Nullable y: kotlin.CharSequence?): kotlin.String?
+    @org.checkerframework.checker.nullness.qual.Nullable public open fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: @org.checkerframework.checker.nullness.qual.NonNull kotlin.String, /*1*/ @org.checkerframework.checker.nullness.qual.Nullable y: @org.checkerframework.checker.nullness.qual.Nullable kotlin.CharSequence?): @org.checkerframework.checker.nullness.qual.Nullable kotlin.String?
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }

compiler/testData/foreignAnnotationsJava8/tests/eclipse.txt

@@ -4,11 +4,11 @@ public fun main(/*0*/ a: A<kotlin.String>, /*1*/ a1: A<kotlin.String?>): kotlin.
 
 public open class A</*0*/ T : kotlin.Any!> {
     public constructor A</*0*/ T : kotlin.Any!>()
-    @org.eclipse.jdt.annotation.Nullable public final var field: kotlin.String?
+    @org.eclipse.jdt.annotation.Nullable public final var field: @org.eclipse.jdt.annotation.Nullable kotlin.String?
-    @org.eclipse.jdt.annotation.NonNull public open fun bar(): kotlin.String
+    @org.eclipse.jdt.annotation.NonNull public open fun bar(): @org.eclipse.jdt.annotation.NonNull kotlin.String
-    @org.eclipse.jdt.annotation.Nullable public open fun baz(/*0*/ @org.eclipse.jdt.annotation.NonNull x: T): T?
+    @org.eclipse.jdt.annotation.Nullable public open fun baz(/*0*/ @org.eclipse.jdt.annotation.NonNull x: @org.eclipse.jdt.annotation.NonNull T): @org.eclipse.jdt.annotation.Nullable T?
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    @org.eclipse.jdt.annotation.Nullable public open fun foo(/*0*/ @org.eclipse.jdt.annotation.NonNull x: kotlin.String, /*1*/ @org.eclipse.jdt.annotation.Nullable y: kotlin.CharSequence?): kotlin.String?
+    @org.eclipse.jdt.annotation.Nullable public open fun foo(/*0*/ @org.eclipse.jdt.annotation.NonNull x: @org.eclipse.jdt.annotation.NonNull kotlin.String, /*1*/ @org.eclipse.jdt.annotation.Nullable y: @org.eclipse.jdt.annotation.Nullable kotlin.CharSequence?): @org.eclipse.jdt.annotation.Nullable kotlin.String?
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }

compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.txt

@@ -17,7 +17,7 @@ public/*package*/ open class AnnotatedTypeArguments {
     public/*package*/ open inner class B : AnnotatedTypeArguments.A {
         public/*package*/ constructor B()
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-        @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open override /*1*/ fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: L<P<L<kotlin.String?>, S<*>>!>): L<P<L<kotlin.String?>, S<*>>!>?
+        @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open override /*1*/ fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: @org.checkerframework.checker.nullness.qual.NonNull L<P<@org.checkerframework.checker.nullness.qual.NonNull L<@org.checkerframework.checker.nullness.qual.Nullable kotlin.String?>, @org.checkerframework.checker.nullness.qual.NonNull S<*>>!>): @org.checkerframework.checker.nullness.qual.Nullable L<P<@org.checkerframework.checker.nullness.qual.NonNull L<@org.checkerframework.checker.nullness.qual.Nullable kotlin.String?>, @org.checkerframework.checker.nullness.qual.NonNull S<*>>!>?
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
@@ -33,7 +33,7 @@ public/*package*/ open class AnnotatedTypeArguments {
     public/*package*/ open inner class D1 : AnnotatedTypeArguments.C {
         public/*package*/ constructor D1()
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-        public/*package*/ open override /*1*/ fun foo(/*0*/ x: L<P<L<kotlin.String!>, S<*>>!>): L<P<L<kotlin.String!>, S<*>>!>?
+        public/*package*/ open override /*1*/ fun foo(/*0*/ x: L<P<L<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String!>, S<*>>!>): L<P<L<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String!>, S<*>>!>?
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
@@ -41,7 +41,7 @@ public/*package*/ open class AnnotatedTypeArguments {
     public/*package*/ open inner class D2 : AnnotatedTypeArguments.C {
         public/*package*/ constructor D2()
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-        @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: L<P<L<kotlin.String?>, S<*>>!>!): L<P<L<kotlin.String?>, S<*>>!>
+        @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: @org.checkerframework.checker.nullness.qual.Nullable L<P<L<kotlin.String?>, S<*>>!>!): @org.checkerframework.checker.nullness.qual.NonNull L<P<L<kotlin.String?>, S<*>>!>
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }

compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.txt

@@ -17,9 +17,9 @@ public/*package*/ open class Outer {
 
     public/*package*/ open inner class B : Outer.A {
         public/*package*/ constructor B()
-        @java.lang.Override @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open override /*1*/ fun </*0*/ R : kotlin.Any!> bar(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: Y<R>): X<R!>?
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open override /*1*/ fun </*0*/ R : kotlin.Any!> bar(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: @org.checkerframework.checker.nullness.qual.NonNull Y<@org.checkerframework.checker.nullness.qual.NonNull R>): @org.checkerframework.checker.nullness.qual.Nullable X<@org.checkerframework.checker.nullness.qual.Nullable R!>?
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun </*0*/ T1 : kotlin.Any!, /*1*/ T2 : kotlin.Any!> foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: T1?): T2
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun </*0*/ T1 : kotlin.Any!, /*1*/ T2 : kotlin.Any!> foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: @org.checkerframework.checker.nullness.qual.Nullable T1?): @org.checkerframework.checker.nullness.qual.NonNull T2
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
@@ -35,9 +35,9 @@ public/*package*/ open class Outer {
 
     public/*package*/ open inner class D : Outer.C {
         public/*package*/ constructor D()
-        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun </*0*/ F : kotlin.Any!> bar(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: Y<F!>!): X<F!>
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun </*0*/ F : kotlin.Any!> bar(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: @org.checkerframework.checker.nullness.qual.Nullable Y<@org.checkerframework.checker.nullness.qual.Nullable F!>!): @org.checkerframework.checker.nullness.qual.NonNull X<@org.checkerframework.checker.nullness.qual.NonNull F!>
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun </*0*/ U : kotlin.Any!, /*1*/ W : kotlin.Any!> foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: U?): W
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun </*0*/ U : kotlin.Any!, /*1*/ W : kotlin.Any!> foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: @org.checkerframework.checker.nullness.qual.Nullable U?): @org.checkerframework.checker.nullness.qual.NonNull W
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }

compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.txt

@@ -9,7 +9,7 @@ public/*package*/ open class Outer {
     public/*package*/ open inner class A {
         public/*package*/ constructor A()
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-        @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open fun foo(): Base<kotlin.String>?
+        @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open fun foo(): @org.checkerframework.checker.nullness.qual.Nullable Base<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String>?
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
@@ -25,7 +25,7 @@ public/*package*/ open class Outer {
     public/*package*/ open inner class C : Outer.A {
         public/*package*/ constructor C()
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): Base<kotlin.String>
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): @org.checkerframework.checker.nullness.qual.NonNull Base<kotlin.String>
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
@@ -41,7 +41,7 @@ public/*package*/ open class Outer {
     public/*package*/ open inner class E : Outer.A {
         public/*package*/ constructor E()
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): Derived<kotlin.String!>
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): @org.checkerframework.checker.nullness.qual.NonNull Derived<kotlin.String!>
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
@@ -49,7 +49,7 @@ public/*package*/ open class Outer {
     public/*package*/ open inner class F : Outer.A {
         public/*package*/ constructor F()
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): Derived<kotlin.String!>
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): @org.checkerframework.checker.nullness.qual.NonNull Derived<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String!>
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }

compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.txt

@@ -6,7 +6,7 @@ public fun bar2(): Derived<kotlin.String?>
 public open class A {
     public constructor A()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open fun foo(): Base<kotlin.String>?
+    @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open fun foo(): @org.checkerframework.checker.nullness.qual.Nullable Base<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String>?
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }

compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.txt

@@ -3,7 +3,7 @@ package
 public/*package*/ open class A {
     public/*package*/ constructor A()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public/*package*/ open fun foo(): kotlin.collections.(Mutable)List<kotlin.String>!
+    public/*package*/ open fun foo(): kotlin.collections.(Mutable)List<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String>!
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }

compiler/tests-common/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt

@@ -25,7 +25,6 @@ import org.jetbrains.kotlin.descriptors.impl.PackageFragmentDescriptorImpl
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.jvm.compiler.ExpectedLoadErrorsUtil
 import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil
-import org.jetbrains.kotlin.load.java.ANNOTATIONS_COPIED_TO_TYPES
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor
 import org.jetbrains.kotlin.load.java.structure.reflect.classId
 import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader
@@ -55,9 +54,9 @@ abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdir() {
     companion object {
         private val renderer = DescriptorRenderer.withOptions {
             withDefinedIn = false
-            excludedAnnotationClasses = (listOf(
+            excludedAnnotationClasses = setOf(
                     FqName(ExpectedLoadErrorsUtil.ANNOTATION_CLASS_NAME)
-            ) + ANNOTATIONS_COPIED_TO_TYPES).toSet()
+            )
             overrideRenderingPolicy = OverrideRenderingPolicy.RENDER_OPEN_OVERRIDE
             parameterNameRenderingPolicy = ParameterNameRenderingPolicy.NONE
             includePropertyConstant = false

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

@@ -18,10 +18,7 @@ package org.jetbrains.kotlin.load.java
 
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
-import org.jetbrains.kotlin.descriptors.resolveClassByFqName
-import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
 import org.jetbrains.kotlin.storage.StorageManager
@@ -52,16 +49,6 @@ class AnnotationTypeQualifierResolver(storageManager: StorageManager) {
 
         return resolveTypeQualifierNickname(annotationClass)
     }
-
-    fun isTypeQualifier(moduleDescriptor: ModuleDescriptor, classFqName: FqName): Boolean {
-        val classDescriptor = moduleDescriptor.resolveClassByFqName(
-                classFqName, NoLookupLocation.FROM_JAVA_LOADER
-        ) ?: return false
-
-        if (classDescriptor.isTypeQualifierAnnotation) return true
-
-        return resolveTypeQualifierNickname(classDescriptor) != null
-    }
 }
 
 private val ClassDescriptor.isAnnotatedWithTypeQualifier: Boolean

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

@@ -52,10 +52,3 @@ val READ_ONLY_ANNOTATIONS = listOf(
 val MUTABLE_ANNOTATIONS = listOf(
         JvmAnnotationNames.JETBRAINS_MUTABLE_ANNOTATION
 )
-
-// When these annotations appear on a declaration, they are copied to the _type_ of the declaration, becoming type annotations
-// See also DescriptorRendererOptions#excludedTypeAnnotationClasses
-val ANNOTATIONS_COPIED_TO_TYPES: Set<FqName> = listOf(
-        NULLABLE_ANNOTATIONS, NOT_NULL_ANNOTATIONS, READ_ONLY_ANNOTATIONS, MUTABLE_ANNOTATIONS,
-        listOf(JAVAX_NONNULL_ANNOTATION)
-).flatMap { it }.toSet()

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

@@ -145,10 +145,8 @@ abstract class LazyJavaScope(protected val c: LazyJavaResolverContext) : MemberS
     protected fun computeMethodReturnType(method: JavaMethod, annotations: Annotations, c: LazyJavaResolverContext): KotlinType {
         val annotationMethod = method.containingClass.isAnnotationType
         val returnTypeAttrs = LazyJavaTypeAttributes(
-                TypeUsage.COMMON, annotations,
+                TypeUsage.COMMON,
-                isForAnnotationParameter = annotationMethod,
+                isForAnnotationParameter = annotationMethod
-                moduleDescriptor = c.module,
-                annotationTypeQualifierResolver = c.components.annotationTypeQualifierResolver
         )
         return c.typeResolver.transformJavaType(method.returnType, returnTypeAttrs)
     }
@@ -167,9 +165,7 @@ abstract class LazyJavaScope(protected val c: LazyJavaResolverContext) : MemberS
             val annotations = c.resolveAnnotations(javaParameter)
             val typeUsage =
                     LazyJavaTypeAttributes(
-                            TypeUsage.COMMON, annotations,
+                            TypeUsage.COMMON
-                            annotationTypeQualifierResolver = c.components.annotationTypeQualifierResolver,
-                            moduleDescriptor = c.module
                     )
             val (outType, varargElementType) =
                     if (javaParameter.isVararg) {
@@ -289,9 +285,7 @@ abstract class LazyJavaScope(protected val c: LazyJavaResolverContext) : MemberS
         val propertyType = c.typeResolver.transformJavaType(
                 field.type,
                 LazyJavaTypeAttributes(
-                        TypeUsage.COMMON, annotations,
+                        TypeUsage.COMMON
-                        annotationTypeQualifierResolver = c.components.annotationTypeQualifierResolver,
-                        moduleDescriptor = c.module
                 )
         )
         if (!isNotNullable) {

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

@@ -17,13 +17,7 @@
 package org.jetbrains.kotlin.load.java.lazy.types
 
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
-import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.descriptors.annotations.CompositeAnnotations
-import org.jetbrains.kotlin.descriptors.annotations.FilteredAnnotations
-import org.jetbrains.kotlin.load.java.ANNOTATIONS_COPIED_TO_TYPES
-import org.jetbrains.kotlin.load.java.AnnotationTypeQualifierResolver
 import org.jetbrains.kotlin.load.java.components.TypeUsage
 import org.jetbrains.kotlin.load.java.components.TypeUsage.COMMON
 import org.jetbrains.kotlin.load.java.components.TypeUsage.SUPERTYPE
@@ -64,29 +58,27 @@ class JavaTypeResolver(
     }
 
     fun transformArrayType(arrayType: JavaArrayType, attr: JavaTypeAttributes, isVararg: Boolean = false): KotlinType {
-        return run {
+        val javaComponentType = arrayType.componentType
-            val javaComponentType = arrayType.componentType
+        val primitiveType = (javaComponentType as? JavaPrimitiveType)?.type
-            val primitiveType = (javaComponentType as? JavaPrimitiveType)?.type
+        if (primitiveType != null) {
-            if (primitiveType != null) {
+            val jetType = c.module.builtIns.getPrimitiveArrayKotlinType(primitiveType)
-                val jetType = c.module.builtIns.getPrimitiveArrayKotlinType(primitiveType)
+            return if (attr.isForAnnotationParameter)
-                return@run if (attr.isForAnnotationParameter)
+                jetType
-                    jetType
+            else KotlinTypeFactory.flexibleType(jetType, jetType.makeNullableAsSpecified(true))
-                else KotlinTypeFactory.flexibleType(jetType, jetType.makeNullableAsSpecified(true))
+        }
-            }
 
-            val componentType = transformJavaType(javaComponentType,
+        val componentType = transformJavaType(javaComponentType,
-                                                  COMMON.toAttributes(attr.isForAnnotationParameter))
+                                              COMMON.toAttributes(attr.isForAnnotationParameter))
 
-            if (attr.isForAnnotationParameter) {
+        if (attr.isForAnnotationParameter) {
-                val projectionKind = if (isVararg) OUT_VARIANCE else INVARIANT
+            val projectionKind = if (isVararg) OUT_VARIANCE else INVARIANT
-                return@run c.module.builtIns.getArrayType(projectionKind, componentType)
+            return c.module.builtIns.getArrayType(projectionKind, componentType)
-            }
+        }
 
-            KotlinTypeFactory.flexibleType(
+        return KotlinTypeFactory.flexibleType(
-                    c.module.builtIns.getArrayType(INVARIANT, componentType),
+                c.module.builtIns.getArrayType(INVARIANT, componentType),
-                    c.module.builtIns.getArrayType(OUT_VARIANCE, componentType).makeNullableAsSpecified(true)
+                c.module.builtIns.getArrayType(OUT_VARIANCE, componentType).makeNullableAsSpecified(true)
-            )
+        )
-        }.replaceAnnotations(attr.typeAnnotations)
     }
 
     private fun transformJavaClassifierType(javaType: JavaClassifierType, attr: JavaTypeAttributes): KotlinType {
@@ -113,7 +105,7 @@ class JavaTypeResolver(
     }
 
     private fun computeSimpleJavaClassifierType(javaType: JavaClassifierType, attr: JavaTypeAttributes): SimpleType? {
-        val annotations = CompositeAnnotations(listOf(LazyJavaAnnotations(c, javaType), attr.typeAnnotations))
+        val annotations = LazyJavaAnnotations(c, javaType)
         val constructor = computeTypeConstructor(javaType, attr) ?: return null
         val arguments = computeArguments(javaType, attr, constructor)
         val isNullable = attr.isNullable()
@@ -294,7 +286,6 @@ interface JavaTypeAttributes {
     val howThisTypeIsUsed: TypeUsage
     val flexibility: JavaTypeFlexibility
         get() = INFLEXIBLE
-    val typeAnnotations: Annotations
     val isForAnnotationParameter: Boolean
         get() = false
     // Current type is upper bound of this type parameter
@@ -310,15 +301,8 @@ enum class JavaTypeFlexibility {
 
 class LazyJavaTypeAttributes(
         override val howThisTypeIsUsed: TypeUsage,
-        annotations: Annotations,
+        override val isForAnnotationParameter: Boolean = false
-        override val isForAnnotationParameter: Boolean = false,
+): JavaTypeAttributes
-        private val annotationTypeQualifierResolver: AnnotationTypeQualifierResolver,
-        private val moduleDescriptor: ModuleDescriptor
-): JavaTypeAttributes {
-    override val typeAnnotations = FilteredAnnotations(annotations) {
-        it in ANNOTATIONS_COPIED_TO_TYPES || annotationTypeQualifierResolver.isTypeQualifier(moduleDescriptor, it)
-    }
-}
 
 fun TypeUsage.toAttributes(
         isForAnnotationParameter: Boolean = false,
@@ -326,8 +310,6 @@ fun TypeUsage.toAttributes(
 ) = object : JavaTypeAttributes {
     override val howThisTypeIsUsed: TypeUsage = this@toAttributes
 
-    override val typeAnnotations: Annotations = Annotations.EMPTY
-
     override val isForAnnotationParameter: Boolean = isForAnnotationParameter
     override val upperBoundOfTypeParameter: TypeParameterDescriptor? = upperBoundForTypeParameter
 }

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

@@ -18,7 +18,9 @@ package org.jetbrains.kotlin.load.java.typeEnhancement
 
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.annotations.Annotated
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.descriptors.annotations.composeAnnotations
 import org.jetbrains.kotlin.load.java.*
 import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor
 import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor
@@ -54,7 +56,7 @@ class SignatureEnhancement(private val annotationTypeQualifierResolver: Annotati
 
         val receiverTypeEnhancement =
                 if (extensionReceiverParameter != null)
-                    parts(isCovariant = false) { it.extensionReceiverParameter!!.type }.enhance()
+                    parts(typeContainer = null, isCovariant = false) { it.extensionReceiverParameter!!.type }.enhance()
                 else null
 
 
@@ -72,11 +74,12 @@ class SignatureEnhancement(private val annotationTypeQualifierResolver: Annotati
 
         val valueParameterEnhancements = valueParameters.map {
             p ->
-            parts(isCovariant = false) { it.valueParameters[p.index].type }
+            parts(typeContainer = p, isCovariant = false) { it.valueParameters[p.index].type }
                     .enhance(predefinedEnhancementInfo?.parametersInfo?.getOrNull(p.index))
         }
 
-        val returnTypeEnhancement = parts(isCovariant = true) { it.returnType!! }.enhance(predefinedEnhancementInfo?.returnTypeInfo)
+        val returnTypeEnhancement =
+                parts(typeContainer = this, isCovariant = true) { it.returnType!! }.enhance(predefinedEnhancementInfo?.returnTypeInfo)
 
         if ((receiverTypeEnhancement?.wereChanges ?: false)
             || returnTypeEnhancement.wereChanges || valueParameterEnhancements.any { it.wereChanges }) {
@@ -88,6 +91,7 @@ class SignatureEnhancement(private val annotationTypeQualifierResolver: Annotati
     }
 
     private inner class SignatureParts(
+            private val typeContainer: Annotated?,
             private val fromOverride: KotlinType,
             private val fromOverridden: Collection<KotlinType>,
             private val isCovariant: Boolean
@@ -129,12 +133,19 @@ class SignatureEnhancement(private val annotationTypeQualifierResolver: Annotati
                     isNotNullTypeParameter = unwrap() is NotNullTypeParameter)
         }
 
-        private fun KotlinType.extractQualifiersFromAnnotations(): JavaTypeQualifiers {
+        private fun KotlinType.extractQualifiersFromAnnotations(isHeadTypeConstructor: Boolean): JavaTypeQualifiers {
-            fun <T: Any> List<FqName>.ifPresent(qualifier: T) = if (any { annotations.findAnnotation(it) != null}) qualifier else null
+            val composedAnnotation =
+                    if (isHeadTypeConstructor && typeContainer != null)
+                        composeAnnotations(typeContainer.annotations, annotations)
+                    else
+                        annotations
+
+            fun <T: Any> List<FqName>.ifPresent(qualifier: T) =
+                    if (any { composedAnnotation.findAnnotation(it) != null }) qualifier else null
 
             fun <T: Any> uniqueNotNull(x: T?, y: T?) = if (x == null || y == null || x == y) x ?: y else null
 
-            val nullability = annotations.extractNullability()
+            val nullability = composedAnnotation.extractNullability()
 
             return JavaTypeQualifiers(
                     nullability,
@@ -213,17 +224,20 @@ class SignatureEnhancement(private val annotationTypeQualifierResolver: Annotati
                 val verticalSlice = indexedFromSupertypes.mapNotNull { it.getOrNull(index) }
 
                 // Only the head type constructor is safely co-variant
-                qualifiers.computeQualifiersForOverride(verticalSlice, isCovariant && isHeadTypeConstructor)
+                qualifiers.computeQualifiersForOverride(verticalSlice, isCovariant && isHeadTypeConstructor, isHeadTypeConstructor)
             }
 
             return { index -> computedResult.getOrElse(index) { JavaTypeQualifiers.NONE } }
         }
 
-        private fun KotlinType.computeQualifiersForOverride(fromSupertypes: Collection<KotlinType>, isCovariant: Boolean): JavaTypeQualifiers {
+        private fun KotlinType.computeQualifiersForOverride(
+                fromSupertypes: Collection<KotlinType>, isCovariant: Boolean,
+                isHeadTypeConstructor: Boolean
+        ): JavaTypeQualifiers {
             val nullabilityFromSupertypes = fromSupertypes.mapNotNull { it.extractQualifiers().nullability }.toSet()
             val mutabilityFromSupertypes = fromSupertypes.mapNotNull { it.extractQualifiers().mutability }.toSet()
 
-            val own = extractQualifiersFromAnnotations()
+            val own = extractQualifiersFromAnnotations(isHeadTypeConstructor)
 
             val isAnyNonNullTypeParameter = own.isNotNullTypeParameter || fromSupertypes.any { it.extractQualifiers().isNotNullTypeParameter }
 
@@ -268,8 +282,13 @@ class SignatureEnhancement(private val annotationTypeQualifierResolver: Annotati
 
     private data class PartEnhancementResult(val type: KotlinType, val wereChanges: Boolean)
 
-    private fun <D : CallableMemberDescriptor> D.parts(isCovariant: Boolean, collector: (D) -> KotlinType): SignatureParts {
+    private fun <D : CallableMemberDescriptor> D.parts(
+            typeContainer: Annotated?,
+            isCovariant: Boolean,
+            collector: (D) -> KotlinType
+    ): SignatureParts {
         return SignatureParts(
+                typeContainer,
                 collector(this),
                 this.overriddenDescriptors.map {
                     @Suppress("UNCHECKED_CAST")

core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt

@@ -219,31 +219,6 @@ interface DescriptorRendererOptions {
 }
 
 object ExcludedTypeAnnotations {
-    val annotationsForNullabilityAndMutability = setOf(
-            FqName("org.jetbrains.annotations.ReadOnly"),
-            FqName("org.jetbrains.annotations.Mutable"),
-            FqName("org.jetbrains.annotations.NotNull"),
-            FqName("org.jetbrains.annotations.Nullable"),
-            FqName("android.support.annotation.Nullable"),
-            FqName("android.support.annotation.NonNull"),
-            FqName("com.android.annotations.Nullable"),
-            FqName("com.android.annotations.NonNull"),
-            FqName("org.eclipse.jdt.annotation.Nullable"),
-            FqName("org.eclipse.jdt.annotation.NonNull"),
-            FqName("org.checkerframework.checker.nullness.qual.Nullable"),
-            FqName("org.checkerframework.checker.nullness.qual.NonNull"),
-            FqName("javax.annotation.Nonnull"),
-            FqName("javax.annotation.Nullable"),
-            FqName("javax.annotation.CheckForNull"),
-            FqName("edu.umd.cs.findbugs.annotations.NonNull"),
-            FqName("edu.umd.cs.findbugs.annotations.CheckForNull"),
-            FqName("edu.umd.cs.findbugs.annotations.Nullable"),
-            FqName("edu.umd.cs.findbugs.annotations.PossiblyNull"),
-            FqName("lombok.NonNull"),
-            FqName("io.reactivex.annotations.Nullable"),
-            FqName("io.reactivex.annotations.NonNull")
-    )
-
     val internalAnnotationsForResolve = setOf(
             FqName("kotlin.internal.NoInfer"),
             FqName("kotlin.internal.Exact")

core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererOptionsImpl.kt

@@ -96,9 +96,7 @@ internal class DescriptorRendererOptionsImpl : DescriptorRendererOptions {
 
     override var excludedAnnotationClasses by property(emptySet<FqName>())
 
-    override var excludedTypeAnnotationClasses by property(
+    override var excludedTypeAnnotationClasses by property(ExcludedTypeAnnotations.internalAnnotationsForResolve)
-            ExcludedTypeAnnotations.annotationsForNullabilityAndMutability
-                    + ExcludedTypeAnnotations.internalAnnotationsForResolve)
 
     override var annotationArgumentsRenderingPolicy by property(AnnotationArgumentsRenderingPolicy.NO_ARGUMENTS)
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt

@@ -22,7 +22,6 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.isBuiltinFunctionClass
 import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 import org.jetbrains.kotlin.lexer.KtTokens
-import org.jetbrains.kotlin.load.java.ANNOTATIONS_COPIED_TO_TYPES
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -42,7 +41,7 @@ import org.jetbrains.kotlin.serialization.js.DynamicTypeDeserializer
 import java.util.*
 
 // TODO: see DescriptorRendererOptions.excludedTypeAnnotationClasses for decompiler
-private val ANNOTATIONS_NOT_LOADED_FOR_TYPES = (ANNOTATIONS_COPIED_TO_TYPES + KotlinBuiltIns.FQ_NAMES.parameterName).toSet()
+private val ANNOTATIONS_NOT_LOADED_FOR_TYPES = setOf(KotlinBuiltIns.FQ_NAMES.parameterName)
 
 class TypeClsStubBuilder(private val c: ClsStubBuilderContext) {
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/buildDecompiledText.kt

@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.renderer.DescriptorRendererModifier
 import org.jetbrains.kotlin.renderer.DescriptorRendererOptions
-import org.jetbrains.kotlin.renderer.ExcludedTypeAnnotations
 import org.jetbrains.kotlin.resolve.DataClassDescriptorResolver
 import org.jetbrains.kotlin.resolve.DescriptorUtils.isEnumEntry
 import org.jetbrains.kotlin.resolve.descriptorUtil.secondaryConstructors
@@ -38,7 +37,7 @@ fun DescriptorRendererOptions.defaultDecompilerRendererOptions() {
     classWithPrimaryConstructor = true
     secondaryConstructorsAsPrimary = false
     modifiers = DescriptorRendererModifier.ALL
-    excludedTypeAnnotationClasses = ExcludedTypeAnnotations.annotationsForNullabilityAndMutability
+    excludedTypeAnnotationClasses = emptySet()
     alwaysRenderModifiers = true
     parameterNamesInFunctionalTypes = false // to support parameters names in decompiled text we need to load annotation arguments
 }