Support reading from class files of the type use annotations on type parameters and type arguments

^KT-11454 Fixed

compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.load.java.structure.impl.classFiles
 
 import org.jetbrains.kotlin.load.java.structure.*
+import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaAnnotation.Companion.computeTargetType
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -56,10 +57,7 @@ internal class AnnotationsAndParameterCollectorMethodVisitor(
     }
 
     override fun visitAnnotation(desc: String, visible: Boolean) =
-            BinaryJavaAnnotation.addAnnotation(
-                    member.annotations as MutableCollection<JavaAnnotation>,
-                    desc, context, signatureParser
-            )
+        BinaryJavaAnnotation.addAnnotation(member, desc, context, signatureParser)
 
     @Suppress("NOTHING_TO_OVERRIDE")
     override fun visitAnnotableParameterCount(parameterCount: Int, visible: Boolean) {
@@ -76,33 +74,38 @@ internal class AnnotationsAndParameterCollectorMethodVisitor(
         val index = absoluteParameterIndex - parametersToSkipNumber
         if (index < 0) return null
 
-        val annotations =
-                member.valueParameters[index].annotations as MutableCollection<JavaAnnotation>?
-                ?: return null
-
-        return BinaryJavaAnnotation.addAnnotation(annotations, desc, context, signatureParser)
+        return BinaryJavaAnnotation.addAnnotation(member.valueParameters[index], desc, context, signatureParser)
     }
 
     override fun visitTypeAnnotation(typeRef: Int, typePath: TypePath?, desc: String, visible: Boolean): AnnotationVisitor? {
-        // TODO: support annotations on type arguments
-        if (typePath != null) return null
-
         val typeReference = TypeReference(typeRef)
 
-        return when (typeReference.sort) {
-            TypeReference.METHOD_RETURN -> member.safeAs<BinaryJavaMethod>()?.returnType?.let {
-                BinaryJavaAnnotation.addTypeAnnotation(it, desc, context, signatureParser)
-            }
+        if (typePath != null) {
+            val baseType = when (typeReference.sort) {
+                TypeReference.METHOD_RETURN -> member.safeAs<BinaryJavaMethod>()?.returnType
+                TypeReference.METHOD_FORMAL_PARAMETER -> member.valueParameters[typeReference.formalParameterIndex].type
+                TypeReference.METHOD_TYPE_PARAMETER_BOUND ->
+                    BinaryJavaAnnotation.computeTypeParameterBound(member.typeParameters, typeReference)
+                else -> null
+            } ?: return null
 
-            TypeReference.METHOD_FORMAL_PARAMETER ->
-                    BinaryJavaAnnotation.addTypeAnnotation(
-                            member.valueParameters[typeReference.formalParameterIndex].type,
-                            desc, context, signatureParser
-                    )
-
-            else -> null
+            return BinaryJavaAnnotation.addAnnotation(
+                computeTargetType(baseType, translatePath(typePath)) as JavaPlainType, desc, context, signatureParser
+            )
         }
+
+        val targetType = when (typeReference.sort) {
+            TypeReference.METHOD_RETURN -> (member as? BinaryJavaMethod)?.returnType as JavaPlainType
+            TypeReference.METHOD_TYPE_PARAMETER -> member.typeParameters[typeReference.typeParameterIndex] as BinaryJavaTypeParameter
+            TypeReference.METHOD_FORMAL_PARAMETER -> member.valueParameters[typeReference.formalParameterIndex].type as JavaPlainType
+            TypeReference.METHOD_TYPE_PARAMETER_BOUND -> BinaryJavaAnnotation.computeTypeParameterBound(member.typeParameters, typeReference) as JavaPlainType
+            else -> null
+        } ?: return null
+
+        return BinaryJavaAnnotation.addAnnotation(targetType, desc, context, signatureParser)
     }
+
+    enum class PathElementType { ARRAY_ELEMENT, WILDCARD_BOUND, ENCLOSING_CLASS, TYPE_ARGUMENT }
 }
 
 class BinaryJavaAnnotation private constructor(
@@ -125,29 +128,76 @@ class BinaryJavaAnnotation private constructor(
         }
 
         fun addAnnotation(
-                annotations: MutableCollection<JavaAnnotation>,
-                desc: String,
-                context: ClassifierResolutionContext,
-                signatureParser: BinaryClassSignatureParser
+            annotationOwner: MutableJavaAnnotationOwner,
+            desc: String,
+            context: ClassifierResolutionContext,
+            signatureParser: BinaryClassSignatureParser
         ): AnnotationVisitor {
             val (javaAnnotation, annotationVisitor) = createAnnotationAndVisitor(desc, context, signatureParser)
-            annotations.add(javaAnnotation)
-
+            annotationOwner.annotations.add(javaAnnotation)
             return annotationVisitor
         }
 
-        fun addTypeAnnotation(
-                type: JavaType,
-                desc: String,
-                context: ClassifierResolutionContext,
-                signatureParser: BinaryClassSignatureParser
-        ): AnnotationVisitor? {
-            type as? PlainJavaClassifierType ?: return null
+        internal fun translatePath(path: TypePath): List<Pair<AnnotationsAndParameterCollectorMethodVisitor.PathElementType, Int?>> {
+            val length = path.length
+            val list = mutableListOf<Pair<AnnotationsAndParameterCollectorMethodVisitor.PathElementType, Int?>>()
+            for (i in 0 until length) {
+                when (path.getStep(i)) {
+                    TypePath.INNER_TYPE -> {
+                        continue
+                    }
+                    TypePath.ARRAY_ELEMENT -> {
+                        list.add(AnnotationsAndParameterCollectorMethodVisitor.PathElementType.ARRAY_ELEMENT to null)
+                    }
+                    TypePath.WILDCARD_BOUND -> {
+                        list.add(AnnotationsAndParameterCollectorMethodVisitor.PathElementType.WILDCARD_BOUND to null)
+                    }
+                    TypePath.TYPE_ARGUMENT -> {
+                        list.add(AnnotationsAndParameterCollectorMethodVisitor.PathElementType.TYPE_ARGUMENT to path.getStepArgument(i))
+                    }
+                }
+            }
+            return list
+        }
 
-            val (javaAnnotation, annotationVisitor) = createAnnotationAndVisitor(desc, context, signatureParser)
-            type.addAnnotation(javaAnnotation)
+        internal fun computeTargetType(
+            baseType: JavaType,
+            typePath: List<Pair<AnnotationsAndParameterCollectorMethodVisitor.PathElementType, Int?>>
+        ): JavaType {
+            var targetType = baseType
 
-            return annotationVisitor
+            for (element in typePath) {
+                when (element.first) {
+                    AnnotationsAndParameterCollectorMethodVisitor.PathElementType.TYPE_ARGUMENT -> {
+                        if (targetType is JavaClassifierType) {
+                            targetType = targetType.typeArguments[element.second!!]!!
+                        }
+                    }
+                    AnnotationsAndParameterCollectorMethodVisitor.PathElementType.WILDCARD_BOUND -> {
+                        if (targetType is JavaWildcardType) {
+                            targetType = targetType.bound!!
+                        }
+                    }
+                    AnnotationsAndParameterCollectorMethodVisitor.PathElementType.ARRAY_ELEMENT -> {
+                        if (targetType is JavaArrayType) {
+                            targetType = targetType.componentType
+                        }
+                    }
+                }
+            }
+
+            return targetType
+        }
+
+        internal fun computeTypeParameterBound(
+            typeParameters: List<JavaTypeParameter>,
+            typeReference: TypeReference
+        ): JavaClassifierType {
+            val typeParameter = typeParameters[typeReference.typeParameterIndex] as BinaryJavaTypeParameter
+            val boundIndex =
+                if (typeParameter.hasImplicitObjectClassBound) typeReference.typeParameterBoundIndex - 1 else typeReference.typeParameterBoundIndex
+
+            return typeParameters[typeReference.typeParameterIndex].upperBounds.toList()[boundIndex]
         }
     }
 

compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryClassSignatureParser.kt

@@ -66,13 +66,20 @@ class BinaryClassSignatureParser {
 
         // postpone list allocation till a second bound is seen; ignore sole Object bound
         val bounds: MutableList<JavaClassifierType> = SmartList()
+        var hasImplicitObjectBound = false
         while (signature.current() == ':') {
             signature.next()
-            val bound = parseClassifierRefSignature(signature, context) ?: continue
-            bounds.add(bound)
+
+            // '::' means that the implicit object bound is between ':'
+            if (signature.current() == ':') {
+                hasImplicitObjectBound = true
+                continue
+            }
+
+            bounds.add(parseClassifierRefSignature(signature, context) ?: continue)
         }
 
-        return BinaryJavaTypeParameter(Name.identifier(parameterName), bounds)
+        return BinaryJavaTypeParameter(Name.identifier(parameterName), bounds, hasImplicitObjectBound)
     }
 
     fun parseClassifierRefSignature(signature: CharacterIterator, context: ClassifierResolutionContext): JavaClassifierType? {
@@ -83,7 +90,7 @@ class BinaryClassSignatureParser {
         }
     }
 
-    private fun parseTypeVariableRefSignature(signature: CharacterIterator, context: ClassifierResolutionContext): JavaClassifierType? {
+    private fun parseTypeVariableRefSignature(signature: CharacterIterator, context: ClassifierResolutionContext): JavaClassifierType {
         val id = StringBuilder()
 
         signature.next()

compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt

@@ -22,6 +22,7 @@ import gnu.trove.THashMap
 import org.jetbrains.kotlin.builtins.PrimitiveType
 import org.jetbrains.kotlin.load.java.structure.*
 import org.jetbrains.kotlin.load.java.structure.impl.VirtualFileBoundJavaClass
+import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaAnnotation.Companion.computeTypeParameterBound
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.utils.SmartList
@@ -38,12 +39,12 @@ class BinaryJavaClass(
     override var access: Int = 0,
     override val outerClass: JavaClass?,
     classContent: ByteArray? = null
-) : ClassVisitor(ASM_API_VERSION_FOR_CLASS_READING), VirtualFileBoundJavaClass, BinaryJavaModifierListOwner, MapBasedJavaAnnotationOwner {
-    private lateinit var myInternalName: String
-
+) : ClassVisitor(ASM_API_VERSION_FOR_CLASS_READING), VirtualFileBoundJavaClass, BinaryJavaModifierListOwner, MutableJavaAnnotationOwner {
     override val annotations: MutableCollection<JavaAnnotation> = SmartList()
+
     override lateinit var typeParameters: List<JavaTypeParameter>
-    override lateinit var supertypes: Collection<JavaClassifierType>
+    override lateinit var supertypes: List<JavaClassifierType>
+
     override val methods = arrayListOf<JavaMethod>()
     override val fields = arrayListOf<JavaField>()
     override val constructors = arrayListOf<JavaConstructor>()
@@ -51,6 +52,12 @@ class BinaryJavaClass(
 
     override fun hasDefaultConstructor() = false // never: all constructors explicit in bytecode
 
+    private lateinit var myInternalName: String
+
+    // In accordance with JVMS, super class always comes before the interface list
+    private val superclass: JavaClassifierType? get() = supertypes.firstOrNull()
+    private val interfaces: List<JavaClassifierType> get() = supertypes.drop(1)
+
     override val annotationsByFqName by buildLazyValueForMap()
 
     // Short name of a nested class of this class -> access flags as seen in the InnerClasses attribute value.
@@ -75,6 +82,37 @@ class BinaryJavaClass(
 
     override fun isFromSourceCodeInScope(scope: SearchScope): Boolean = false
 
+    override fun visitTypeAnnotation(typeRef: Int, typePath: TypePath?, descriptor: String?, visible: Boolean): AnnotationVisitor? {
+        val typeReference = TypeReference(typeRef)
+        if (descriptor == null)
+            return null
+
+        if (typePath != null) {
+            val translatedPath = BinaryJavaAnnotation.translatePath(typePath)
+
+            when (typeReference.sort) {
+                TypeReference.CLASS_TYPE_PARAMETER_BOUND -> {
+                    val baseType = computeTypeParameterBound(typeParameters, typeReference)
+                    val targetType = BinaryJavaAnnotation.computeTargetType(baseType, translatedPath)
+
+                    return BinaryJavaAnnotation.addAnnotation(targetType as JavaPlainType, descriptor, context, signatureParser)
+                }
+            }
+        }
+
+        return when (typeReference.sort) {
+            TypeReference.CLASS_TYPE_PARAMETER ->
+                BinaryJavaAnnotation.addAnnotation(
+                    typeParameters[typeReference.typeParameterIndex] as BinaryJavaTypeParameter, descriptor, context, signatureParser
+                )
+            TypeReference.CLASS_TYPE_PARAMETER_BOUND ->
+                BinaryJavaAnnotation.addAnnotation(
+                    computeTypeParameterBound(typeParameters, typeReference) as JavaPlainType, descriptor, context, signatureParser
+                )
+            else -> null
+        }
+    }
+
     override fun visitEnd() {
         methods.trimToSize()
         fields.trimToSize()
@@ -181,11 +219,11 @@ class BinaryJavaClass(
 
             object : FieldVisitor(ASM_API_VERSION_FOR_CLASS_READING) {
                 override fun visitAnnotation(desc: String, visible: Boolean) =
-                    BinaryJavaAnnotation.addAnnotation(this@run.annotations, desc, context, signatureParser)
+                    BinaryJavaAnnotation.addAnnotation(this@run, desc, context, signatureParser)
 
                 override fun visitTypeAnnotation(typeRef: Int, typePath: TypePath?, desc: String, visible: Boolean) =
                     if (typePath == null)
-                        BinaryJavaAnnotation.addTypeAnnotation(type, desc, context, signatureParser)
+                        BinaryJavaAnnotation.addAnnotation(type as JavaPlainType, desc, context, signatureParser)
                     else
                         null
             }
@@ -222,7 +260,7 @@ class BinaryJavaClass(
     }
 
     override fun visitAnnotation(desc: String, visible: Boolean) =
-        BinaryJavaAnnotation.addAnnotation(annotations, desc, context, signatureParser)
+        BinaryJavaAnnotation.addAnnotation(this, desc, context, signatureParser)
 
     override fun findInnerClass(name: Name): JavaClass? = findInnerClass(name, classFileContent = null)
 

compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt.201

@@ -22,6 +22,7 @@ import gnu.trove.THashMap
 import org.jetbrains.kotlin.builtins.PrimitiveType
 import org.jetbrains.kotlin.load.java.structure.*
 import org.jetbrains.kotlin.load.java.structure.impl.VirtualFileBoundJavaClass
+import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaAnnotation.Companion.computeTypeParameterBound
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.utils.SmartList
@@ -38,12 +39,12 @@ class BinaryJavaClass(
     override var access: Int = 0,
     override val outerClass: JavaClass?,
     classContent: ByteArray? = null
-) : ClassVisitor(ASM_API_VERSION_FOR_CLASS_READING), VirtualFileBoundJavaClass, BinaryJavaModifierListOwner, MapBasedJavaAnnotationOwner {
-    private lateinit var myInternalName: String
-
+) : ClassVisitor(ASM_API_VERSION_FOR_CLASS_READING), VirtualFileBoundJavaClass, BinaryJavaModifierListOwner, MutableJavaAnnotationOwner {
     override val annotations: MutableCollection<JavaAnnotation> = SmartList()
+
     override lateinit var typeParameters: List<JavaTypeParameter>
-    override lateinit var supertypes: Collection<JavaClassifierType>
+    override lateinit var supertypes: List<JavaClassifierType>
+
     override val methods = arrayListOf<JavaMethod>()
     override val fields = arrayListOf<JavaField>()
     override val constructors = arrayListOf<JavaConstructor>()
@@ -51,6 +52,12 @@ class BinaryJavaClass(
 
     override fun hasDefaultConstructor() = false // never: all constructors explicit in bytecode
 
+    private lateinit var myInternalName: String
+
+    // In accordance with JVMS, super class always comes before the interface list
+    private val superclass: JavaClassifierType? get() = supertypes.firstOrNull()
+    private val implementedInterfaces: List<JavaClassifierType> get() = supertypes.drop(1)
+
     override val annotationsByFqName by buildLazyValueForMap()
 
     // Short name of a nested class of this class -> access flags as seen in the InnerClasses attribute value.
@@ -69,11 +76,34 @@ class BinaryJavaClass(
     override val isRecord get() = false
 
     override val lightClassOriginKind: LightClassOriginKind? get() = null
+
     override val isSealed: Boolean get() = permittedTypes.isNotEmpty()
     override val permittedTypes = arrayListOf<JavaClassifierType>()
 
     override fun isFromSourceCodeInScope(scope: SearchScope): Boolean = false
 
+    override fun visitTypeAnnotation(typeRef: Int, typePath: TypePath?, descriptor: String?, visible: Boolean): AnnotationVisitor? {
+        if (descriptor == null)
+            return null
+
+        fun getTargetType(baseType: JavaType) =
+            if (typePath != null) BinaryJavaAnnotation.computeTargetType(baseType, typePath) else baseType
+
+        val typeReference = TypeReference(typeRef)
+
+        val annotationOwner = when (typeReference.sort) {
+            TypeReference.CLASS_EXTENDS ->
+                getTargetType(if (typeReference.superTypeIndex == -1) superclass!! else implementedInterfaces[typeReference.superTypeIndex])
+            TypeReference.CLASS_TYPE_PARAMETER -> typeParameters[typeReference.typeParameterIndex]
+            TypeReference.CLASS_TYPE_PARAMETER_BOUND -> getTargetType(computeTypeParameterBound(typeParameters, typeReference))
+            else -> return null
+        }
+
+        if (annotationOwner !is MutableJavaAnnotationOwner) return null
+
+        return BinaryJavaAnnotation.addAnnotation(annotationOwner, descriptor, context, signatureParser, isFreshlySupportedAnnotation = true)
+    }
+
     override fun visitEnd() {
         methods.trimToSize()
         fields.trimToSize()
@@ -172,23 +202,12 @@ class BinaryJavaClass(
         if (access.isSet(Opcodes.ACC_SYNTHETIC)) return null
 
         val type = signatureParser.parseTypeString(StringCharacterIterator(signature ?: desc), context)
-
         val processedValue = processValue(value, type)
+        val filed = BinaryJavaField(Name.identifier(name), access, this, access.isSet(Opcodes.ACC_ENUM), type, processedValue)
 
-        return BinaryJavaField(Name.identifier(name), access, this, access.isSet(Opcodes.ACC_ENUM), type, processedValue).run {
-            fields.add(this)
+        fields.add(filed)
 
-            object : FieldVisitor(ASM_API_VERSION_FOR_CLASS_READING) {
-                override fun visitAnnotation(desc: String, visible: Boolean) =
-                    BinaryJavaAnnotation.addAnnotation(this@run.annotations, desc, context, signatureParser)
-
-                override fun visitTypeAnnotation(typeRef: Int, typePath: TypePath?, desc: String, visible: Boolean) =
-                    if (typePath == null)
-                        BinaryJavaAnnotation.addTypeAnnotation(type, desc, context, signatureParser)
-                    else
-                        null
-            }
-        }
+        return AnnotationsCollectorFieldVisitor(filed, context, signatureParser)
     }
 
     /**
@@ -211,7 +230,7 @@ class BinaryJavaClass(
     }
 
     override fun visitAnnotation(desc: String, visible: Boolean) =
-        BinaryJavaAnnotation.addAnnotation(annotations, desc, context, signatureParser)
+        BinaryJavaAnnotation.addAnnotation(this, desc, context, signatureParser)
 
     override fun findInnerClass(name: Name): JavaClass? = findInnerClass(name, classFileContent = null)
 

compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Methods.kt

@@ -29,31 +29,30 @@ import java.text.CharacterIterator
 import java.text.StringCharacterIterator
 
 abstract class BinaryJavaMethodBase(
-        override val access: Int,
-        override val containingClass: JavaClass,
-        val valueParameters: List<BinaryJavaValueParameter>,
-        val typeParameters: List<JavaTypeParameter>,
-        override val name: Name
-) : JavaMember, MapBasedJavaAnnotationOwner, BinaryJavaModifierListOwner {
+    override val access: Int,
+    override val containingClass: JavaClass,
+    val valueParameters: List<BinaryJavaValueParameter>,
+    val typeParameters: List<JavaTypeParameter>,
+    override val name: Name
+) : JavaMember, BinaryJavaModifierListOwner, MutableJavaAnnotationOwner {
+    override val annotations: MutableCollection<JavaAnnotation> = SmartList()
     override val annotationsByFqName by buildLazyValueForMap()
 
-    override val annotations: Collection<JavaAnnotation> = SmartList()
-
     companion object {
         private class MethodInfo(
-                val returnType: JavaType,
-                val typeParameters: List<JavaTypeParameter>,
-                val valueParameterTypes: List<JavaType>
+            val returnType: JavaType,
+            val typeParameters: List<JavaTypeParameter>,
+            val valueParameterTypes: List<JavaType>
         )
 
         fun create(
-                name: String,
-                access: Int,
-                desc: String,
-                signature: String?,
-                containingClass: JavaClass,
-                parentContext: ClassifierResolutionContext,
-                signatureParser: BinaryClassSignatureParser
+            name: String,
+            access: Int,
+            desc: String,
+            signature: String?,
+            containingClass: JavaClass,
+            parentContext: ClassifierResolutionContext,
+            signatureParser: BinaryClassSignatureParser
         ): Pair<JavaMember, MethodVisitor> {
             val isConstructor = "<init>" == name
             val isVarargs = access.isSet(Opcodes.ACC_VARARGS)
@@ -61,23 +60,23 @@ abstract class BinaryJavaMethodBase(
             val isInnerClassConstructor = isConstructor && containingClass.outerClass != null && !containingClass.isStatic
             val isEnumConstructor = containingClass.isEnum && isConstructor
             val info: MethodInfo =
-                    if (signature != null) {
-                        val contextForMethod = parentContext.copyForMember()
-                        parseMethodSignature(signature, signatureParser, contextForMethod).also {
-                            contextForMethod.addTypeParameters(it.typeParameters)
-                        }
-                    } else
-                        parseMethodDescription(desc, parentContext, signatureParser).let {
-                            when {
-                                isEnumConstructor ->
-                                    // skip ordinal/name parameters for enum constructors
-                                    MethodInfo(it.returnType, it.typeParameters, it.valueParameterTypes.drop(2))
-                                isInnerClassConstructor ->
-                                    // omit synthetic inner class constructor parameter
-                                    MethodInfo(it.returnType, it.typeParameters, it.valueParameterTypes.drop(1))
-                                else -> it
-                            }
+                if (signature != null) {
+                    val contextForMethod = parentContext.copyForMember()
+                    parseMethodSignature(signature, signatureParser, contextForMethod).also {
+                        contextForMethod.addTypeParameters(it.typeParameters)
+                    }
+                } else
+                    parseMethodDescription(desc, parentContext, signatureParser).let {
+                        when {
+                            isEnumConstructor ->
+                                // skip ordinal/name parameters for enum constructors
+                                MethodInfo(it.returnType, it.typeParameters, it.valueParameterTypes.drop(2))
+                            isInnerClassConstructor ->
+                                // omit synthetic inner class constructor parameter
+                                MethodInfo(it.returnType, it.typeParameters, it.valueParameterTypes.drop(1))
+                            else -> it
                         }
+                    }
 
             val parameterTypes = info.valueParameterTypes
             val paramCount = parameterTypes.size
@@ -87,15 +86,15 @@ abstract class BinaryJavaMethodBase(
             }
 
             val member: BinaryJavaMethodBase =
-                    if (isConstructor)
-                        BinaryJavaConstructor(access, containingClass, parameterList, info.typeParameters)
-                    else
-                        BinaryJavaMethod(
-                                access, containingClass,
-                                parameterList,
-                                info.typeParameters,
-                                Name.identifier(name), info.returnType
-                        )
+                if (isConstructor)
+                    BinaryJavaConstructor(access, containingClass, parameterList, info.typeParameters)
+                else
+                    BinaryJavaMethod(
+                        access, containingClass,
+                        parameterList,
+                        info.typeParameters,
+                        Name.identifier(name), info.returnType
+                    )
 
             val paramIgnoreCount = when {
                 isEnumConstructor -> 2
@@ -114,9 +113,9 @@ abstract class BinaryJavaMethodBase(
         }
 
         private fun parseMethodDescription(
-                desc: String,
-                context: ClassifierResolutionContext,
-                signatureParser: BinaryClassSignatureParser
+            desc: String,
+            context: ClassifierResolutionContext,
+            signatureParser: BinaryClassSignatureParser
         ): MethodInfo {
             val returnType = signatureParser.mapAsmType(Type.getReturnType(desc), context)
             val parameterTypes = Type.getArgumentTypes(desc).map { signatureParser.mapAsmType(it, context) }
@@ -125,9 +124,9 @@ abstract class BinaryJavaMethodBase(
         }
 
         private fun parseMethodSignature(
-                signature: String,
-                signatureParser: BinaryClassSignatureParser,
-                context: ClassifierResolutionContext
+            signature: String,
+            signatureParser: BinaryClassSignatureParser,
+            context: ClassifierResolutionContext
         ): MethodInfo {
             val iterator = StringCharacterIterator(signature)
             val typeParameters = signatureParser.parseTypeParametersDeclaration(iterator, context)
@@ -137,8 +136,7 @@ abstract class BinaryJavaMethodBase(
             var paramTypes: List<JavaType>
             if (iterator.current() == ')') {
                 paramTypes = emptyList()
-            }
-            else {
+            } else {
                 paramTypes = mutableListOf()
                 while (iterator.current() != ')' && iterator.current() != CharacterIterator.DONE) {
                     paramTypes.add(signatureParser.parseTypeString(iterator, context))
@@ -157,14 +155,14 @@ abstract class BinaryJavaMethodBase(
 }
 
 class BinaryJavaMethod(
-        flags: Int,
-        containingClass: JavaClass,
-        valueParameters: List<BinaryJavaValueParameter>,
-        typeParameters: List<JavaTypeParameter>,
-        name: Name,
-        override val returnType: JavaType
+    flags: Int,
+    containingClass: JavaClass,
+    valueParameters: List<BinaryJavaValueParameter>,
+    typeParameters: List<JavaTypeParameter>,
+    name: Name,
+    override val returnType: JavaType
 ) : BinaryJavaMethodBase(
-        flags, containingClass, valueParameters, typeParameters, name
+    flags, containingClass, valueParameters, typeParameters, name
 ), JavaMethod {
     override var annotationParameterDefaultValue: JavaAnnotationArgument? = null
         internal set(value) {
@@ -178,11 +176,11 @@ class BinaryJavaMethod(
 }
 
 class BinaryJavaConstructor(
-        flags: Int,
-        containingClass: JavaClass,
-        valueParameters: List<BinaryJavaValueParameter>,
-        typeParameters: List<JavaTypeParameter>
+    flags: Int,
+    containingClass: JavaClass,
+    valueParameters: List<BinaryJavaValueParameter>,
+    typeParameters: List<JavaTypeParameter>
 ) : BinaryJavaMethodBase(
-        flags, containingClass, valueParameters, typeParameters,
-        SpecialNames.NO_NAME_PROVIDED
+    flags, containingClass, valueParameters, typeParameters,
+    SpecialNames.NO_NAME_PROVIDED
 ), JavaConstructor

compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Other.kt

@@ -17,20 +17,19 @@
 package org.jetbrains.kotlin.load.java.structure.impl.classFiles
 
 import org.jetbrains.kotlin.load.java.structure.*
-import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.utils.SmartList
 import org.jetbrains.org.objectweb.asm.ClassReader
 import org.jetbrains.org.objectweb.asm.ClassVisitor
 
 class BinaryJavaField(
-        override val name: Name,
-        override val access: Int,
-        override val containingClass: JavaClass,
-        override val isEnumEntry: Boolean,
-        override val type: JavaType,
-        override val initializerValue: Any?
-) : JavaField, MapBasedJavaAnnotationOwner, BinaryJavaModifierListOwner {
+    override val name: Name,
+    override val access: Int,
+    override val containingClass: JavaClass,
+    override val isEnumEntry: Boolean,
+    override val type: JavaType,
+    override val initializerValue: Any?
+) : JavaField, BinaryJavaModifierListOwner, MutableJavaAnnotationOwner {
     override val annotations: MutableCollection<JavaAnnotation> = SmartList()
     override val annotationsByFqName by buildLazyValueForMap()
 
@@ -39,20 +38,19 @@ class BinaryJavaField(
 }
 
 class BinaryJavaTypeParameter(
-        override val name: Name,
-        override val upperBounds: Collection<JavaClassifierType>
-) : JavaTypeParameter {
-    // TODO: support annotations on type parameters
-    override val annotations get() = emptyList<JavaAnnotation>()
-    override fun findAnnotation(fqName: FqName) = null
-
-    override val isDeprecatedInJavaDoc get() = false
+    override val name: Name,
+    override val upperBounds: Collection<JavaClassifierType>,
+    // If all bounds are interfaces then a type parameter has implicit Object class bound
+    val hasImplicitObjectClassBound: Boolean
+) : JavaTypeParameter, ListBasedJavaAnnotationOwner, MutableJavaAnnotationOwner {
+    override val annotations: MutableCollection<JavaAnnotation> = SmartList()
+    override val isDeprecatedInJavaDoc = false
 }
 
 class BinaryJavaValueParameter(
-        override val type: JavaType,
-        override val isVararg: Boolean
-) : JavaValueParameter, MapBasedJavaAnnotationOwner {
+    override val type: JavaType,
+    override val isVararg: Boolean
+) : JavaValueParameter, MapBasedJavaAnnotationOwner, MutableJavaAnnotationOwner {
     override val annotations: MutableCollection<JavaAnnotation> = SmartList()
     override val annotationsByFqName by buildLazyValueForMap()
 

compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Types.kt

@@ -18,21 +18,25 @@ package org.jetbrains.kotlin.load.java.structure.impl.classFiles
 
 import org.jetbrains.kotlin.builtins.PrimitiveType
 import org.jetbrains.kotlin.load.java.structure.*
-import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.utils.SmartList
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
+internal abstract class JavaPlainType : ListBasedJavaAnnotationOwner, MutableJavaAnnotationOwner {
+    override val annotations: MutableCollection<JavaAnnotation> = SmartList()
+    override val isDeprecatedInJavaDoc = false
+}
+
 // They are only used for java class files, but potentially may be used in other cases
 // It would be better to call them like JavaSomeTypeImpl, but these names are already occupied by the PSI based types
-internal class PlainJavaArrayType(override val componentType: JavaType) : JavaArrayType
-internal class PlainJavaWildcardType(override val bound: JavaType?, override val isExtends: Boolean) : JavaWildcardType
-internal class PlainJavaPrimitiveType(override val type: PrimitiveType?) : JavaPrimitiveType
+internal class PlainJavaArrayType(override val componentType: JavaType) : JavaPlainType(), JavaArrayType
+internal class PlainJavaWildcardType(override val bound: JavaType?, override val isExtends: Boolean) : JavaPlainType(), JavaWildcardType
+internal class PlainJavaPrimitiveType(override val type: PrimitiveType?) : JavaPlainType(), JavaPrimitiveType
 
 internal class PlainJavaClassifierType(
-        // calculation of classifier and canonicalText
-        classifierComputation: () -> ClassifierResolutionContext.Result,
-        override val typeArguments: List<JavaType>
-) : JavaClassifierType {
+    // calculation of classifier and canonicalText
+    classifierComputation: () -> ClassifierResolutionContext.Result,
+    override val typeArguments: List<JavaType>
+) : JavaPlainType(), JavaClassifierType {
     private val classifierResolverResult by lazy(LazyThreadSafetyMode.NONE, classifierComputation)
 
     override val classifier get() = classifierResolverResult.classifier
@@ -40,21 +44,6 @@ internal class PlainJavaClassifierType(
         get() = typeArguments.isEmpty() &&
                 classifierResolverResult.classifier?.safeAs<JavaClass>()?.typeParameters?.isNotEmpty() == true
 
-    private var _annotations = emptyList<JavaAnnotation>()
-    override val annotations get() = _annotations
-
-    override fun findAnnotation(fqName: FqName) = annotations.find { it.classId?.asSingleFqName() == fqName }
-
-    internal fun addAnnotation(annotation: JavaAnnotation) {
-        if (_annotations.isEmpty()) {
-            _annotations = SmartList()
-        }
-
-        (_annotations as MutableList).add(annotation)
-    }
-
-    override val isDeprecatedInJavaDoc get() = false
-
     override val classifierQualifiedName: String
         get() = classifierResolverResult.qualifiedName
 

compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.javac.txt

@@ -1,14 +0,0 @@
-package test
-
-public open class TypeParameterAnnotations {
-    public constructor TypeParameterAnnotations()
-
-    @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) public final annotation class A : kotlin.Annotation {
-        public constructor A(/*0*/ value: kotlin.String = ...)
-        public final val value: kotlin.String
-    }
-
-    public interface G</*0*/ @test.TypeParameterAnnotations.A T : kotlin.Any!> {
-        public abstract fun </*0*/ @test.TypeParameterAnnotations.A(value = "abc") R : kotlin.Any!> foo(/*0*/ p0: R!): kotlin.Unit
-    }
-}

compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.runtime.txt

@@ -1,14 +0,0 @@
-package test
-
-public open class TypeParameterAnnotations {
-    public constructor TypeParameterAnnotations()
-
-    @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) @kotlin.annotation.Retention(value = ...) public final annotation class A : kotlin.Annotation {
-        public final val value: kotlin.String
-            public final fun <get-value>(): kotlin.String
-    }
-
-    public interface G</*0*/ @test.TypeParameterAnnotations.A(value = "") T : kotlin.Any!> {
-        public abstract fun </*0*/ @test.TypeParameterAnnotations.A(value = "abc") R : kotlin.Any!> foo(/*0*/ R!): kotlin.Unit
-    }
-}

compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java

@@ -2,15 +2,21 @@
 package test;
 
 import java.lang.annotation.*;
-public class TypeParameterAnnotations {
+public class Basic {
     @Target(ElementType.TYPE_PARAMETER)
     public @interface A {
         String value() default "";
     }
 
-    // Currently annotations on type parameters and arguments are not loaded from compiled code because of IDEA-153093
-    // Once it will be fixed check if KT-11454 is ready to be resolved
     public interface G<@A T> {
         <@A("abc") R> void foo(R r);
     }
+
+    public interface G1<T, E extends T, @A X> {
+        <R, @A("abc") _A extends R> void foo(R r);
+    }
+
+    <R, @A("abc") _A extends R, @A("abc") K> void foo(R r) {
+
+    }
 }

compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.javac.txt

@@ -0,0 +1,14 @@
+package test
+
+public open class Basic {
+    public constructor Basic()
+
+    @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) public final annotation class A : kotlin.Annotation {
+        public constructor A(/*0*/ value: kotlin.String = ...)
+        public final val value: kotlin.String
+    }
+
+    public interface G</*0*/ @test.Basic.A T : kotlin.Any!> {
+        public abstract fun </*0*/ @test.Basic.A(value = "abc") R : kotlin.Any!> foo(/*0*/ p0: R!): kotlin.Unit
+    }
+}

compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.runtime.txt

@@ -0,0 +1,14 @@
+package test
+
+public open class Basic {
+    public constructor Basic()
+
+    @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) @kotlin.annotation.Retention(value = ...) public final annotation class A : kotlin.Annotation {
+        public final val value: kotlin.String
+            public final fun <get-value>(): kotlin.String
+    }
+
+    public interface G</*0*/ @test.Basic.A(value = "") T : kotlin.Any!> {
+        public abstract fun </*0*/ @test.Basic.A(value = "abc") R : kotlin.Any!> foo(/*0*/ R!): kotlin.Unit
+    }
+}

compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.txt

@@ -0,0 +1,19 @@
+package test
+
+public open class Basic {
+    public constructor Basic()
+    public/*package*/ open fun </*0*/ R : kotlin.Any!, /*1*/ @test.Basic.A(value = "abc") _A : R!, /*2*/ @test.Basic.A(value = "abc") K : kotlin.Any!> foo(/*0*/ p0: R!): kotlin.Unit
+
+    @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) public final annotation class A : kotlin.Annotation {
+        public constructor A(/*0*/ value: kotlin.String = ...)
+        public final val value: kotlin.String
+    }
+
+    public interface G</*0*/ @test.Basic.A T : kotlin.Any!> {
+        public abstract fun </*0*/ @test.Basic.A(value = "abc") R : kotlin.Any!> foo(/*0*/ p0: R!): kotlin.Unit
+    }
+
+    public interface G1</*0*/ T : kotlin.Any!, /*1*/ E : T!, /*2*/ @test.Basic.A X : kotlin.Any!> {
+        public abstract fun </*0*/ R : kotlin.Any!, /*1*/ @test.Basic.A(value = "abc") _A : R!> foo(/*0*/ p0: R!): kotlin.Unit
+    }
+}

compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java

@@ -0,0 +1,26 @@
+package test;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE_USE)
+@interface A {
+    String value() default "";
+}
+
+interface I1<T> {}
+interface I2<T, K> {}
+interface I3<T, K, L> {}
+
+class A2<T, K> {}
+class A3<T, K, L> {}
+
+public class BaseClassTypeArguments<B> extends A3<@A B [][][][][], I1<I1<@A int @A [][]>>, A2<B, int [] [] @A []>> implements I1<@A Integer @A [][][]>, I2<@A B, B>, I3<@A B [][][][][], B, @A B> {
+    class ImplementedInterfacesTypeArguments<B> implements I1<I2<I1<@A Integer @A [][][]>, I1<@A int [] @A []>>>, I2<@A B, B>, I3<@A B [][][][][], I1<I1<@A int @A [][]>>, I2<B, int [] [] @A []>> {
+        public class BaseClassTypeArguments1<B> extends A3<@A B [][][][][], I1<I1<@A int @A [][]>>, A2<B, int [] [] @A []>> {
+
+        }
+    }
+    static class BaseClassTypeArguments2<B> extends A3<@A B [][][][][], I1<I1<@A int @A [][]>>, A2<B, int [] [] @A []>> {
+
+    }
+}

compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.txt

@@ -0,0 +1,39 @@
+package test
+
+@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation {
+    public/*package*/ constructor A(/*0*/ value: kotlin.String = ...)
+    public final val value: kotlin.String
+}
+
+public/*package*/ open class A2</*0*/ T : kotlin.Any!, /*1*/ K : kotlin.Any!> {
+    public/*package*/ constructor A2</*0*/ T : kotlin.Any!, /*1*/ K : kotlin.Any!>()
+}
+
+public/*package*/ open class A3</*0*/ T : kotlin.Any!, /*1*/ K : kotlin.Any!, /*2*/ L : kotlin.Any!> {
+    public/*package*/ constructor A3</*0*/ T : kotlin.Any!, /*1*/ K : kotlin.Any!, /*2*/ L : kotlin.Any!>()
+}
+
+public open class BaseClassTypeArguments</*0*/ B : kotlin.Any!> : test.A3<kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A B!>!>!>!>!>!, test.I1<test.I1<(@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!>!, test.A2<B!, kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!>, test.I1<(@test.A kotlin.Array<kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>?)>, test.I2<@test.A B!, B!>, test.I3<kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A B!>!>!>!>!>!, B!, @test.A B!> {
+    public constructor BaseClassTypeArguments</*0*/ B : kotlin.Any!>()
+
+    public/*package*/ open class BaseClassTypeArguments2</*0*/ B : kotlin.Any!> : test.A3<kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A B!>!>!>!>!>!, test.I1<test.I1<(@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!>!, test.A2<B!, kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!> {
+        public/*package*/ constructor BaseClassTypeArguments2</*0*/ B : kotlin.Any!>()
+    }
+
+    public/*package*/ open inner class ImplementedInterfacesTypeArguments</*0*/ B : kotlin.Any!> /*captured type parameters: /*1*/ B : kotlin.Any!*/ : test.I1<test.I2<test.I1<(@test.A kotlin.Array<kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>?)>!, test.I1<kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!>, test.I2<@test.A B!, B!>, test.I3<kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A B!>!>!>!>!>!, test.I1<test.I1<(@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!>!, test.I2<B!, kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!> {
+        public/*package*/ constructor ImplementedInterfacesTypeArguments</*0*/ B : kotlin.Any!>()
+
+        public open inner class BaseClassTypeArguments1</*0*/ B : kotlin.Any!> /*captured type parameters: /*1*/ B : kotlin.Any!, /*2*/ B : kotlin.Any!*/ : test.A3<kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A B!>!>!>!>!>!, test.I1<test.I1<(@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!>!, test.A2<B!, kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!> {
+            public constructor BaseClassTypeArguments1</*0*/ B : kotlin.Any!>()
+        }
+    }
+}
+
+public/*package*/ interface I1</*0*/ T : kotlin.Any!> {
+}
+
+public/*package*/ interface I2</*0*/ T : kotlin.Any!, /*1*/ K : kotlin.Any!> {
+}
+
+public/*package*/ interface I3</*0*/ T : kotlin.Any!, /*1*/ K : kotlin.Any!, /*2*/ L : kotlin.Any!> {
+}

compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java

@@ -1,7 +1,7 @@
 package test;
 
 import java.lang.annotation.*;
-public class TypeAnnotations {
+public class Basic {
     @Target(ElementType.TYPE_USE)
     @interface A {
         String value() default "";

compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.txt

@@ -1,7 +1,7 @@
 package test
 
-public open class TypeAnnotations {
-    public constructor TypeAnnotations()
+public open class Basic {
+    public constructor Basic()
 
     @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation {
         public/*package*/ constructor A(/*0*/ value: kotlin.String = ...)
@@ -15,7 +15,7 @@ public open class TypeAnnotations {
     }
 
     public interface MyClass</*0*/ TT : kotlin.Any!> {
-        public abstract fun f(/*0*/ p: test.TypeAnnotations.G2<@test.TypeAnnotations.A kotlin.String!, @test.TypeAnnotations.A(value = "abc") kotlin.Int!>!): kotlin.Unit
-        public abstract fun f(/*0*/ p: test.TypeAnnotations.G<@test.TypeAnnotations.A kotlin.String!>!): kotlin.Unit
+        public abstract fun f(/*0*/ p0: test.Basic.G2<@test.Basic.A kotlin.String!, @test.Basic.A(value = "abc") kotlin.Int!>!): kotlin.Unit
+        public abstract fun f(/*0*/ p0: test.Basic.G<@test.Basic.A kotlin.String!>!): kotlin.Unit
     }
 }

compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java

@@ -0,0 +1,33 @@
+// JAVAC_EXPECTED_FILE
+
+package test;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE_USE)
+@interface A {
+    String value() default "";
+}
+
+public class ClassTypeParameterBounds {
+    interface I1 {}
+    interface I2<T> {}
+    interface I3<T> {}
+    interface I4<T> {}
+
+    interface G1<T extends @A Object> { }
+    class G2<_A, B extends @A Integer> { }
+    interface G3<_A, B extends Object & @A I1> { }
+    class G4<_A extends @A B, B> { }
+    interface G5<_A, B extends @A _A> { }
+    class G6<_A extends @A I1, B, C, D extends @A E, E, F> { }
+    interface G7<_A extends Object & I2<@A Integer> & @A I3<String>> { }
+    interface G8<_A extends Object & I2<? super @A Integer> & @A I3<? extends String>> { }
+
+    interface G9<_A extends I4<Integer @A []> & I2<? extends @A Integer @A []> & @A I3<? extends Integer @A []>> { }
+    interface G10<_A extends I4<int @A []> & I2<? extends @A int @A []> & @A I3<? extends int @A []>> { }
+    interface G11<_A extends I4<Integer [] [] @A []> & I2<? extends @A Integer @A [] [] [] []> & @A I3<? extends Integer [] @A []>> { }
+    interface G12<_A extends I4<int @A [][]> & I2<? extends @A int [] [] @A []> & @A I3<? extends int []@A [] []>> { }
+
+    // class G13<_A extends Object, B extends I3<@A _A> & @A I2<_A>> { }
+}

compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.txt

@@ -0,0 +1,61 @@
+package test
+
+@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation {
+    public/*package*/ constructor A(/*0*/ value: kotlin.String = ...)
+    public final val value: kotlin.String
+}
+
+public open class ClassTypeParameterBounds {
+    public constructor ClassTypeParameterBounds()
+
+    public/*package*/ interface G1</*0*/ T : @test.A kotlin.Any!> {
+    }
+
+    public/*package*/ interface G10</*0*/ _A : test.ClassTypeParameterBounds.I4<@test.A kotlin.IntArray!>!> where _A : test.ClassTypeParameterBounds.I2<out @test.A kotlin.IntArray!>!, _A : @test.A test.ClassTypeParameterBounds.I3<out @test.A kotlin.IntArray!>! {
+    }
+
+    public/*package*/ interface G11</*0*/ _A : test.ClassTypeParameterBounds.I4<kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!>!>!> where _A : test.ClassTypeParameterBounds.I2<out (@test.A kotlin.Array<kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>!>?)>!, _A : @test.A test.ClassTypeParameterBounds.I3<out kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!>! {
+    }
+
+    public/*package*/ interface G12</*0*/ _A : test.ClassTypeParameterBounds.I4<(@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!> where _A : test.ClassTypeParameterBounds.I2<out kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!, _A : @test.A test.ClassTypeParameterBounds.I3<out kotlin.Array<(out) (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!>! {
+    }
+
+    public/*package*/ open inner class G2</*0*/ _A : kotlin.Any!, /*1*/ B : @test.A kotlin.Int!> {
+        public/*package*/ constructor G2</*0*/ _A : kotlin.Any!, /*1*/ B : @test.A kotlin.Int!>()
+    }
+
+    public/*package*/ interface G3</*0*/ _A : kotlin.Any!, /*1*/ B : kotlin.Any!> where B : @test.A test.ClassTypeParameterBounds.I1! {
+    }
+
+    public/*package*/ open inner class G4</*0*/ _A : @test.A B!, /*1*/ B : kotlin.Any!> {
+        public/*package*/ constructor G4</*0*/ _A : @test.A B!, /*1*/ B : kotlin.Any!>()
+    }
+
+    public/*package*/ interface G5</*0*/ _A : kotlin.Any!, /*1*/ B : @test.A _A!> {
+    }
+
+    public/*package*/ open inner class G6</*0*/ _A : @test.A test.ClassTypeParameterBounds.I1!, /*1*/ B : kotlin.Any!, /*2*/ C : kotlin.Any!, /*3*/ D : @test.A E!, /*4*/ E : kotlin.Any!, /*5*/ F : kotlin.Any!> {
+        public/*package*/ constructor G6</*0*/ _A : @test.A test.ClassTypeParameterBounds.I1!, /*1*/ B : kotlin.Any!, /*2*/ C : kotlin.Any!, /*3*/ D : @test.A E!, /*4*/ E : kotlin.Any!, /*5*/ F : kotlin.Any!>()
+    }
+
+    public/*package*/ interface G7</*0*/ _A : kotlin.Any!> where _A : test.ClassTypeParameterBounds.I2<@test.A kotlin.Int!>!, _A : @test.A test.ClassTypeParameterBounds.I3<kotlin.String!>! {
+    }
+
+    public/*package*/ interface G8</*0*/ _A : kotlin.Any!> where _A : test.ClassTypeParameterBounds.I2<in @test.A kotlin.Int!>!, _A : @test.A test.ClassTypeParameterBounds.I3<out kotlin.String!>! {
+    }
+
+    public/*package*/ interface G9</*0*/ _A : test.ClassTypeParameterBounds.I4<(@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!> where _A : test.ClassTypeParameterBounds.I2<out (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!, _A : @test.A test.ClassTypeParameterBounds.I3<out (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>! {
+    }
+
+    public/*package*/ interface I1 {
+    }
+
+    public/*package*/ interface I2</*0*/ T : kotlin.Any!> {
+    }
+
+    public/*package*/ interface I3</*0*/ T : kotlin.Any!> {
+    }
+
+    public/*package*/ interface I4</*0*/ T : kotlin.Any!> {
+    }
+}

compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java

@@ -0,0 +1,23 @@
+// JAVAC_EXPECTED_FILE
+
+package test;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE_USE)
+@interface A {
+    String value() default "";
+}
+
+/*
+ * Note that a receiver type doesn't get into signatures used by the Kotlin compiler
+ * So in this test, annotated types shouldn't be reflected in the signatures dump
+ */
+
+public class MethodReceiver<T> {
+    public void f1(MethodReceiver<@A T> this) { }
+
+    class MethodReceiver3<T, K, L> {
+        public void f1(@A MethodReceiver3<@A T, K, @A L> this) { }
+    }
+}

compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.txt

@@ -0,0 +1,16 @@
+package test
+
+@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation {
+    public/*package*/ constructor A(/*0*/ value: kotlin.String = ...)
+    public final val value: kotlin.String
+}
+
+public open class MethodReceiver</*0*/ T : kotlin.Any!> {
+    public constructor MethodReceiver</*0*/ T : kotlin.Any!>()
+    public open fun f1(): kotlin.Unit
+
+    public/*package*/ open inner class MethodReceiver3</*0*/ T : kotlin.Any!, /*1*/ K : kotlin.Any!, /*2*/ L : kotlin.Any!> /*captured type parameters: /*3*/ T : kotlin.Any!*/ {
+        public/*package*/ constructor MethodReceiver3</*0*/ T : kotlin.Any!, /*1*/ K : kotlin.Any!, /*2*/ L : kotlin.Any!>()
+        public open fun f1(): kotlin.Unit
+    }
+}

compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java

@@ -0,0 +1,33 @@
+// JAVAC_EXPECTED_FILE
+
+package test;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE_USE)
+@interface A {
+    String value() default "";
+}
+
+abstract class MethodTypeParameterBounds {
+    interface I1 {}
+    interface I2<T> {}
+    interface I3<T> {}
+    interface I4<T> {}
+
+    <T extends @A Object> void f1(T x) { }
+    <_A, B extends @A Integer> void f2(_A x, B y) { }
+    <_A, B extends Object & @A I1> void f3(_A x, B y) { }
+    <_A extends @A B, B> void f4(_A x, B y) { }
+    <_A, B extends @A _A> void f5(_A x, B y) { }
+    <_A extends @A I1> void f6() { }
+    abstract <_A, B extends @A _A> void f7(_A x, B y);
+    abstract <_A extends @A I1, B, C, D extends @A E, E, F> void f8(_A x1, B x2, C x3, D x4, E x5, F x6);
+    <_A extends Object & I2<@A Integer> & @A I3<String>> void f9(_A x) { }
+    <_A extends Object & I2<? super @A Integer> & @A I3<? extends String>> void f10(_A x) { }
+    <_A extends I4<Integer @A []> & I2<? extends @A Integer @A []> & @A I3<? extends Integer @A []>> void f11(_A x) { }
+    <_A extends I4<int @A []> & I2<? extends @A int @A []> & @A I3<? extends int @A []>> void f12(_A x) { }
+    <_A extends I4<Integer [] [] @A []> & I2<? extends @A Integer @A [] [] [] []> & @A I3<? extends Integer [] @A []>> void f13(_A x) { }
+    abstract <_A extends I4<int @A [][]> & I2<? extends @A int [] [] @A []> & @A I3<? extends int []@A [] []>> void f14(_A x);
+    <_A extends Object, B extends I3<@A A> & @A I2<A>> void f15(_A x) { }
+}

compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.txt

@@ -0,0 +1,37 @@
+package test
+
+@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation {
+    public/*package*/ constructor A(/*0*/ value: kotlin.String = ...)
+    public final val value: kotlin.String
+}
+
+public/*package*/ abstract class MethodTypeParameterBounds {
+    public/*package*/ constructor MethodTypeParameterBounds()
+    public/*package*/ open fun </*0*/ T : @test.A kotlin.Any!> f1(/*0*/ p0: T!): kotlin.Unit
+    public/*package*/ open fun </*0*/ _A : kotlin.Any!> f10(/*0*/ p0: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2<in @test.A kotlin.Int!>!, _A : @test.A test.MethodTypeParameterBounds.I3<out kotlin.String!>!
+    public/*package*/ open fun </*0*/ _A : test.MethodTypeParameterBounds.I4<(@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!> f11(/*0*/ p0: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2<out (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!, _A : @test.A test.MethodTypeParameterBounds.I3<out (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!
+    public/*package*/ open fun </*0*/ _A : test.MethodTypeParameterBounds.I4<@test.A kotlin.IntArray!>!> f12(/*0*/ p0: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2<out @test.A kotlin.IntArray!>!, _A : @test.A test.MethodTypeParameterBounds.I3<out @test.A kotlin.IntArray!>!
+    public/*package*/ open fun </*0*/ _A : test.MethodTypeParameterBounds.I4<kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!>!>!> f13(/*0*/ p0: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2<out (@test.A kotlin.Array<kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>!>?)>!, _A : @test.A test.MethodTypeParameterBounds.I3<out kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!>!
+    public/*package*/ abstract fun </*0*/ _A : test.MethodTypeParameterBounds.I4<(@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!> f14(/*0*/ p0: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2<out kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!, _A : @test.A test.MethodTypeParameterBounds.I3<out kotlin.Array<(out) (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!>!
+    public/*package*/ open fun </*0*/ _A : kotlin.Any!, /*1*/ B : test.MethodTypeParameterBounds.I3<@test.A test.A!>!> f15(/*0*/ p0: _A!): kotlin.Unit where B : @test.A test.MethodTypeParameterBounds.I2<test.A!>!
+    public/*package*/ open fun </*0*/ _A : kotlin.Any!, /*1*/ B : @test.A kotlin.Int!> f2(/*0*/ p0: _A!, /*1*/ p1: B!): kotlin.Unit
+    public/*package*/ open fun </*0*/ _A : kotlin.Any!, /*1*/ B : kotlin.Any!> f3(/*0*/ p0: _A!, /*1*/ p1: B!): kotlin.Unit where B : @test.A test.MethodTypeParameterBounds.I1!
+    public/*package*/ open fun </*0*/ _A : @test.A B!, /*1*/ B : kotlin.Any!> f4(/*0*/ p0: _A!, /*1*/ p1: B!): kotlin.Unit
+    public/*package*/ open fun </*0*/ _A : kotlin.Any!, /*1*/ B : @test.A _A!> f5(/*0*/ p0: _A!, /*1*/ p1: B!): kotlin.Unit
+    public/*package*/ open fun </*0*/ _A : @test.A test.MethodTypeParameterBounds.I1!> f6(): kotlin.Unit
+    public/*package*/ abstract fun </*0*/ _A : kotlin.Any!, /*1*/ B : @test.A _A!> f7(/*0*/ p0: _A!, /*1*/ p1: B!): kotlin.Unit
+    public/*package*/ abstract fun </*0*/ _A : @test.A test.MethodTypeParameterBounds.I1!, /*1*/ B : kotlin.Any!, /*2*/ C : kotlin.Any!, /*3*/ D : @test.A E!, /*4*/ E : kotlin.Any!, /*5*/ F : kotlin.Any!> f8(/*0*/ p0: _A!, /*1*/ p1: B!, /*2*/ p2: C!, /*3*/ p3: D!, /*4*/ p4: E!, /*5*/ p5: F!): kotlin.Unit
+    public/*package*/ open fun </*0*/ _A : kotlin.Any!> f9(/*0*/ p0: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2<@test.A kotlin.Int!>!, _A : @test.A test.MethodTypeParameterBounds.I3<kotlin.String!>!
+
+    public/*package*/ interface I1 {
+    }
+
+    public/*package*/ interface I2</*0*/ T : kotlin.Any!> {
+    }
+
+    public/*package*/ interface I3</*0*/ T : kotlin.Any!> {
+    }
+
+    public/*package*/ interface I4</*0*/ T : kotlin.Any!> {
+    }
+}

compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java

@@ -0,0 +1,95 @@
+package test;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE_USE)
+@interface A {
+    String value() default "";
+}
+
+interface G0 { }
+interface G1<T> { }
+interface G2<A, B> { }
+
+interface ReturnType {
+    // simplpe type arguments
+    G1<@A G0> f0();
+    G1<G1<G1<G1<@A G0>>>> f1();
+    G1<@A String> f2();
+    G2<@A String, G2<@A("abc") Integer, G2<@A("abc") G2<Integer, @A Integer>, @A("abc") Integer>>> f3();
+
+    // wildcards
+    G1<? extends @A G0> f4 = null;
+    G1<G1<G1<G1<? extends @A G0>>>> f5();
+    G1<? extends @A String> f6();
+    G2<? extends @A String, G2<? extends @A("abc") Integer, G2<? extends @A("abc") G2<Integer, ? extends @A Integer>, ? extends @A("abc") Integer>>> f7();
+
+    G1<? super @A G0> f8();
+    G1<G1<G1<G1<? super @A G0>>>> f9();
+    G1<? super @A String> f10 = null;
+    G2<? super @A String, G2<? super @A("abc") Integer, G2<? super @A("abc") G2<Integer, ? super @A Integer>, ? super @A("abc") Integer>>> f11();
+
+    G2<? super @A String, G2<? extends @A("abc") Integer, G2<? extends @A("abc") G2<Integer, ? super @A Integer>, ? extends @A("abc") Integer>>> f12 = null;
+
+    // arrays
+    Integer @A [] f13();
+    int @A [] f14();
+    @A Integer [] f15();
+    @A int [] f16();
+    @A Integer @A [] f17();
+    @A int @A [] f18 = null;
+
+    // multidementional arrays
+    Integer @A [] [] f19();
+    int @A [] @A [] f20();
+    @A Integer [] [] [] f21 = null;
+    @A int @A [] @A [] [] @A [] f22();
+    @A Integer @A [] [] @A [] [] f23();
+    @A int @A [] @A [] f24 = null;
+    int [] @A [] f25();
+    Object [] @A [] f26();
+    @A Object [] [] [] [] @A [] f27();
+
+    // arrays in type arguments
+    G1<Integer @A []> f28();
+    G2<Integer, int @A []> f29();
+    G1<@A Integer []> f30();
+    G1<G1<@A int []>> f31();
+    G1<G2<G1<@A Integer @A []>, G1<@A int @A []>>> f32();
+    G1<@A int @A []> f33();
+    G1<Integer [] @A []> f34();
+    G2<Integer, int @A [][]> f35 = null;
+    G1<@A Integer @A [] []> f36();
+    G1<G1<@A int [][][]>> f37();
+    G1<G2<G1<@A Integer @A []>, G1<@A int [] [] @A []>>> f38();
+    G1<@A int @A [] @A [] []> f39();
+
+    // arrays in wildcard bounds
+    G1<? extends Integer @A []> f40();
+    G2<? extends Integer, ? super int @A []> f41();
+    G1<? super @A Integer []> f42();
+    G1<? super G1<? super @A int []>> f43();
+    G1<? extends G2<G1<? super @A Integer @A []>, G1<? extends @A int @A []>>> f44();
+    G1<? extends G2<? super G1<@A Integer @A []>, G1<? extends @A int @A []>>> f45 = null;
+    G1<? super @A int @A []> f46();
+    G1<? extends Integer [] @A []> f47();
+    G2<? extends Integer, ? super int [] [] @A []> f48 = null;
+    G1<? super @A Integer [][][][][]> f49();
+    G1<? super G1<? super @A int @A [][]>> f50();
+    G1<? extends G2<G1<? super @A Integer [] [] @A []>, G1<? extends @A int @A [] @A [] @A []>>> f51();
+    G1<? extends G2<? super G1<@A Integer @A [][][]>, G1<? extends @A int [] @A []>>> f52 = null;
+    G1<? super @A int @A [][]> f53();
+
+    class ReturnType2 {
+        G1<? extends @A G0> f4 = null;
+        G1<? super @A String> f10 = null;
+        G2<? super @A String, G2<? extends @A("abc") Integer, G2<? extends @A("abc") G2<Integer, ? super @A Integer>, ? extends @A("abc") Integer>>> f12 = null;
+        @A int @A [] f18 = null;
+        @A Integer [] [] [] f21 = null;
+        @A int @A [] @A [] f24 = null;
+        G2<Integer, int @A [][]> f35 = null;
+        G1<? extends G2<? super G1<@A Integer @A []>, G1<? extends @A int @A []>>> f45 = null;
+        G2<? extends Integer, ? super int [] [] @A []> f48 = null;
+        G1<? extends G2<? super G1<@A Integer @A [][][]>, G1<? extends @A int [] @A []>>> f52 = null;
+    }
+}

compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.txt

@@ -0,0 +1,88 @@
+package test
+
+@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation {
+    public/*package*/ constructor A(/*0*/ value: kotlin.String = ...)
+    public final val value: kotlin.String
+}
+
+public/*package*/ interface G0 {
+}
+
+public/*package*/ interface G1</*0*/ T : kotlin.Any!> {
+}
+
+public/*package*/ interface G2</*0*/ A : kotlin.Any!, /*1*/ B : kotlin.Any!> {
+}
+
+public/*package*/ interface ReturnType {
+    public abstract fun f0(): test.G1<@test.A test.G0!>!
+    public abstract fun f1(): test.G1<test.G1<test.G1<test.G1<@test.A test.G0!>!>!>!>!
+    public abstract fun f11(): test.G2<in @test.A kotlin.String!, test.G2<in @test.A(value = "abc") kotlin.Int!, test.G2<in @test.A(value = "abc") test.G2<kotlin.Int!, in @test.A kotlin.Int!>!, in @test.A(value = "abc") kotlin.Int!>!>!>!
+    public abstract fun f13(): (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)
+    public abstract fun f14(): @test.A kotlin.IntArray!
+    public abstract fun f15(): kotlin.Array<(out) @test.A kotlin.Int!>!
+    public abstract fun f16(): kotlin.IntArray!
+    public abstract fun f17(): (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)
+    public abstract fun f19(): (@test.A kotlin.Array<kotlin.Array<(out) kotlin.Int!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Int!>!>?)
+    public abstract fun f2(): test.G1<@test.A kotlin.String!>!
+    public abstract fun f20(): (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)
+    public abstract fun f22(): (@test.A kotlin.Array<(@test.A kotlin.Array<kotlin.Array<(out) @test.A kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) @test.A kotlin.IntArray!>!>?)>..@test.A kotlin.Array<out (@test.A kotlin.Array<kotlin.Array<(out) @test.A kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) @test.A kotlin.IntArray!>!>?)>?)
+    public abstract fun f23(): (@test.A kotlin.Array<kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Array<(out) @test.A kotlin.Int!>!>..@test.A kotlin.Array<out kotlin.Array<(out) @test.A kotlin.Int!>!>?)>!>..@test.A kotlin.Array<out kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Array<(out) @test.A kotlin.Int!>!>..@test.A kotlin.Array<out kotlin.Array<(out) @test.A kotlin.Int!>!>?)>!>?)
+    public abstract fun f25(): kotlin.Array<(out) @test.A kotlin.IntArray!>!
+    public abstract fun f26(): kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Any!>..@test.A kotlin.Array<out kotlin.Any!>?)>!
+    public abstract fun f27(): kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Any!>..@test.A kotlin.Array<out @test.A kotlin.Any!>?)>!>!>!>!
+    public abstract fun f28(): test.G1<(@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!
+    public abstract fun f29(): test.G2<kotlin.Int!, @test.A kotlin.IntArray!>!
+    public abstract fun f3(): test.G2<@test.A kotlin.String!, test.G2<@test.A(value = "abc") kotlin.Int!, test.G2<@test.A(value = "abc") test.G2<kotlin.Int!, @test.A kotlin.Int!>!, @test.A(value = "abc") kotlin.Int!>!>!>!
+    public abstract fun f30(): test.G1<kotlin.Array<(out) @test.A kotlin.Int!>!>!
+    public abstract fun f31(): test.G1<test.G1<kotlin.IntArray!>!>!
+    public abstract fun f32(): test.G1<test.G2<test.G1<(@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!, test.G1<@test.A kotlin.IntArray!>!>!>!
+    public abstract fun f33(): test.G1<@test.A kotlin.IntArray!>!
+    public abstract fun f34(): test.G1<kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!>!
+    public abstract fun f36(): test.G1<(@test.A kotlin.Array<kotlin.Array<(out) @test.A kotlin.Int!>!>..@test.A kotlin.Array<out kotlin.Array<(out) @test.A kotlin.Int!>!>?)>!
+    public abstract fun f37(): test.G1<test.G1<kotlin.Array<(out) kotlin.Array<(out) kotlin.IntArray!>!>!>!>!
+    public abstract fun f38(): test.G1<test.G2<test.G1<(@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!, test.G1<kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!>!>!
+    public abstract fun f39(): test.G1<(@test.A kotlin.Array<(@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>..@test.A kotlin.Array<out (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>?)>!
+    public abstract fun f40(): test.G1<out (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!
+    public abstract fun f41(): test.G2<out kotlin.Int!, in @test.A kotlin.IntArray!>!
+    public abstract fun f42(): test.G1<in kotlin.Array<(out) @test.A kotlin.Int!>!>!
+    public abstract fun f43(): test.G1<in test.G1<in kotlin.IntArray!>!>!
+    public abstract fun f44(): test.G1<out test.G2<test.G1<in (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!, test.G1<out @test.A kotlin.IntArray!>!>!>!
+    public abstract fun f46(): test.G1<in @test.A kotlin.IntArray!>!
+    public abstract fun f47(): test.G1<out kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!>!
+    public abstract fun f49(): test.G1<in kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>!>!>!>!
+    public abstract fun f5(): test.G1<test.G1<test.G1<test.G1<out @test.A test.G0!>!>!>!>!
+    public abstract fun f50(): test.G1<in test.G1<in (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!>!
+    public abstract fun f51(): test.G1<out test.G2<test.G1<in kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!>!>!, test.G1<out (@test.A kotlin.Array<(@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)>..@test.A kotlin.Array<out (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)>?)>!>!>!
+    public abstract fun f53(): test.G1<in (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!
+    public abstract fun f6(): test.G1<out @test.A kotlin.String!>!
+    public abstract fun f7(): test.G2<out @test.A kotlin.String!, test.G2<out @test.A(value = "abc") kotlin.Int!, test.G2<out @test.A(value = "abc") test.G2<kotlin.Int!, out @test.A kotlin.Int!>!, out @test.A(value = "abc") kotlin.Int!>!>!>!
+    public abstract fun f8(): test.G1<in @test.A test.G0!>!
+    public abstract fun f9(): test.G1<test.G1<test.G1<test.G1<in @test.A test.G0!>!>!>!>!
+
+    public open class ReturnType2 {
+        public constructor ReturnType2()
+        public/*package*/ final var f10: test.G1<in kotlin.String!>!
+        public/*package*/ final var f12: test.G2<in kotlin.String!, test.G2<out kotlin.Int!, test.G2<out test.G2<kotlin.Int!, in kotlin.Int!>!, out kotlin.Int!>!>!>!
+        public/*package*/ final var f18: @test.A kotlin.IntArray!
+        public/*package*/ final var f21: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Int!>!>!>!
+        public/*package*/ final var f24: (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)
+        public/*package*/ final var f35: test.G2<kotlin.Int!, kotlin.Array<(out) kotlin.IntArray!>!>!
+        public/*package*/ final var f4: test.G1<out test.G0!>!
+        public/*package*/ final var f45: test.G1<out test.G2<in test.G1<kotlin.Array<(out) kotlin.Int!>!>!, test.G1<out kotlin.IntArray!>!>!>!
+        public/*package*/ final var f48: test.G2<out kotlin.Int!, in kotlin.Array<(out) kotlin.Array<(out) kotlin.IntArray!>!>!>!
+        public/*package*/ final var f52: test.G1<out test.G2<in test.G1<kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Int!>!>!>!>!, test.G1<out kotlin.Array<(out) kotlin.IntArray!>!>!>!>!
+    }
+
+    // Static members
+    public final val f10: test.G1<in kotlin.String!>!
+    public final val f12: test.G2<in kotlin.String!, test.G2<out kotlin.Int!, test.G2<out test.G2<kotlin.Int!, in kotlin.Int!>!, out kotlin.Int!>!>!>!
+    public final val f18: @test.A kotlin.IntArray!
+    public final val f21: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Int!>!>!>!
+    public final val f24: (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)
+    public final val f35: test.G2<kotlin.Int!, kotlin.Array<(out) kotlin.IntArray!>!>!
+    public final val f4: test.G1<out test.G0!>!
+    public final val f45: test.G1<out test.G2<in test.G1<kotlin.Array<(out) kotlin.Int!>!>!, test.G1<out kotlin.IntArray!>!>!>!
+    public final val f48: test.G2<out kotlin.Int!, in kotlin.Array<(out) kotlin.Array<(out) kotlin.IntArray!>!>!>!
+    public final val f52: test.G1<out test.G2<in test.G1<kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Int!>!>!>!>!, test.G1<out kotlin.Array<(out) kotlin.IntArray!>!>!>!>!
+}

compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java

@@ -0,0 +1,117 @@
+package test;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE_USE)
+@interface A {
+    String value() default "";
+}
+
+interface G0 { }
+interface G1<T> { }
+interface G2<A, B> { }
+
+interface ValueArguments {
+    // simplpe type arguments
+    void f0(G1<@A G0> p);
+    void f1(G1<G1<G1<G1<@A G0>>>> p);
+    void f2(G1<@A String> p);
+    void f3(G2<@A String, G2<@A("abc") Integer, G2<@A("abc") G2<Integer, @A Integer>, @A("abc") Integer>>> p);
+
+    // wildcards
+    void f4(G1<? extends @A G0> p);
+    void f5(G1<G1<G1<G1<? extends @A G0>>>> p);
+    void f6(G1<? extends @A String> p1, G1<G1<G1<G1<? extends @A G0>>>> p2);
+    void f7(G2<? extends @A String, G2<? extends @A("abc") Integer, G2<? extends @A("abc") G2<Integer, ? extends @A Integer>, ? extends @A("abc") Integer>>> p);
+
+    void f8(G1<? super @A G0> p);
+    void f9(G1<G1<G1<G1<? super @A G0>>>> p);
+    void f10(G1<? super @A String> p);
+    void f11(G2<? super @A String, G2<? super @A("abc") Integer, G2<? super @A("abc") G2<Integer, ? super @A Integer>, ? super @A("abc") Integer>>> p);
+
+    void f12(G2<? super @A String, G2<? extends @A("abc") Integer, G2<? extends @A("abc") G2<Integer, ? super @A Integer>, ? extends @A("abc") Integer>>> p);
+
+    // arrays
+    void f13(Integer @A [] p);
+    void f14(int @A [] p);
+    void f15(@A Integer [] p);
+    void f16(@A int [] p);
+    void f17(@A Integer @A [] p);
+    void f18(@A int @A [] p1, Integer @A [] p2, @A int [] p3);
+
+    // multidementional arrays
+    void f19(Integer @A [] [] p);
+    void f20(int @A [] @A [] p);
+    void f21(@A Integer [] [] [] p);
+    void f22(@A int @A [] @A [] [] @A [] p);
+    void f23(@A Integer @A [] [] @A [] [] p);
+    void f24(@A int @A [] @A [] p);
+    void f25(int [] @A [] p);
+    void f26(Object [] @A [] p1, int [] @A [] p2, @A int @A [] @A [] [] @A [] p3);
+    void f27(@A Object [] [] [] [] @A [] p);
+
+    // arrays in type arguments
+    void f28(G1<Integer @A []> p);
+    void f29(G2<Integer, int @A []> p);
+    void f30(G1<@A Integer []> p);
+    void f31(G1<G1<@A int []>> p);
+    void f32(G1<G2<G1<@A Integer @A []>, G1<@A int @A []>>> p);
+    void f33(G1<@A int @A []> p);
+    void f34(G1<Integer [] @A []> p);
+    void f35(G2<Integer, int @A [][]> p1, G1<@A Integer @A [] []> p2, G1<G1<@A int []>> p3);
+    void f36(G1<@A Integer @A [] []> p);
+    void f37(G1<G1<@A int [][][]>> p);
+    void f38(G1<G2<G1<@A Integer @A []>, G1<@A int [] [] @A []>>> p);
+    void f39(G1<@A int @A [] @A [] []> p);
+
+    // arrays in wildcard bounds
+    void f40(G1<? extends Integer @A []> p);
+    void f41(G2<? extends Integer, ? super int @A []> p);
+    void f42(G1<? super @A Integer []> p);
+    void f43(G1<? super G1<? super @A int []>> p);
+    void f44(G1<? extends G2<G1<? super @A Integer @A []>, G1<? extends @A int @A []>>> p);
+    void f45(G1<? extends G2<? super G1<@A Integer @A []>, G1<? extends @A int @A []>>> p);
+    void f46(G1<? super @A int @A []> p);
+    void f47(G1<? extends Integer [] @A []> p);
+    void f48(G2<? extends Integer, ? super int [] [] @A []> p);
+    void f49(G1<? super @A Integer [][][][][]> p1, G1<? super G1<? super @A int @A [][]>> p2, G2<? extends Integer, ? super int [] [] @A []> p3);
+    void f50(G1<? super G1<? super @A int @A [][]>> p);
+    void f51(G1<? extends G2<G1<? super @A Integer [] [] @A []>, G1<? extends @A int @A [] @A [] @A []>>> p);
+    void f52(G1<? extends G2<? super G1<@A Integer @A [][][]>, G1<? extends @A int [] @A []>>> p);
+    void f53(G1<? super @A int @A [][]> p);
+
+    void f54(G1<? extends G2<? super G1<@A Integer @A [][][]>, G1<? extends @A int [] @A []>>> p1, G1<@A int @A [] @A [] []> p2, @A Object [] [] [] [] @A [] p3, @A int @A [] p4, G2<? super @A String, G2<? extends @A("abc") Integer, G2<? extends @A("abc") G2<Integer, ? super @A Integer>, ? extends @A("abc") Integer>>> p5);
+
+    // varargs
+    void f55(@A String ... x);
+    void f56(String @A ... x);
+    void f57(@A String @A ... x);
+    void f58(@A int ... x);
+    void f59(int @A ... x);
+    void f60(@A int @A ... x);
+
+    // varargs + arrays
+    void f61(@A String [] ... x);
+    void f62(String @A [] ... x);
+    void f63(String [] @A ... x);
+    void f64(@A String @A [] @A ... x);
+    void f65(@A int [] ... x);
+    void f66(int @A [] ... x);
+    void f67(int [] @A ... x);
+    void f68(@A int @A [] @A ... x);
+
+    void f69(@A String [] [] ... x);
+    void f70(String [] @A [] ... x);
+    void f71(String [] [] [] @A ... x);
+    void f72(@A String @A [] [] @A [] @A ... x);
+    void f73(@A int [] @A [] ... x);
+    void f74(int @A [][][] @A [] ... x);
+    void f75(int [] [] [] @A ... x);
+    void f76(@A int @A [] [] @A ... x);
+
+    class Test {
+        public Test(G2<? super @A String, G2<? extends @A("abc") Integer, G2<? extends @A("abc") G2<Integer, ? super @A Integer>, ? extends @A("abc") Integer>>> p1, Object [] @A [] p2, int [] @A [] p3, @A int @A [] @A [] [] @A [] p4, @A int @A [] [] @A ... p5) {
+
+        }
+    }
+}

compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.txt

@@ -0,0 +1,99 @@
+package test
+
+@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation {
+    public/*package*/ constructor A(/*0*/ value: kotlin.String = ...)
+    public final val value: kotlin.String
+}
+
+public/*package*/ interface G0 {
+}
+
+public/*package*/ interface G1</*0*/ T : kotlin.Any!> {
+}
+
+public/*package*/ interface G2</*0*/ A : kotlin.Any!, /*1*/ B : kotlin.Any!> {
+}
+
+public/*package*/ interface ValueArguments {
+    public abstract fun f0(/*0*/ p0: test.G1<@test.A test.G0!>!): kotlin.Unit
+    public abstract fun f1(/*0*/ p0: test.G1<test.G1<test.G1<test.G1<@test.A test.G0!>!>!>!>!): kotlin.Unit
+    public abstract fun f10(/*0*/ p0: test.G1<in @test.A kotlin.String!>!): kotlin.Unit
+    public abstract fun f11(/*0*/ p0: test.G2<in @test.A kotlin.String!, test.G2<in @test.A(value = "abc") kotlin.Int!, test.G2<in @test.A(value = "abc") test.G2<kotlin.Int!, in @test.A kotlin.Int!>!, in @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit
+    public abstract fun f12(/*0*/ p0: test.G2<in @test.A kotlin.String!, test.G2<out @test.A(value = "abc") kotlin.Int!, test.G2<out @test.A(value = "abc") test.G2<kotlin.Int!, in @test.A kotlin.Int!>!, out @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit
+    public abstract fun f13(/*0*/ p0: (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)): kotlin.Unit
+    public abstract fun f14(/*0*/ p0: @test.A kotlin.IntArray!): kotlin.Unit
+    public abstract fun f15(/*0*/ p0: kotlin.Array<(out) @test.A kotlin.Int!>!): kotlin.Unit
+    public abstract fun f16(/*0*/ p0: kotlin.IntArray!): kotlin.Unit
+    public abstract fun f17(/*0*/ p0: (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)): kotlin.Unit
+    public abstract fun f18(/*0*/ p0: @test.A kotlin.IntArray!, /*1*/ p1: (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?), /*2*/ p2: kotlin.IntArray!): kotlin.Unit
+    public abstract fun f19(/*0*/ p0: (@test.A kotlin.Array<kotlin.Array<(out) kotlin.Int!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Int!>!>?)): kotlin.Unit
+    public abstract fun f2(/*0*/ p0: test.G1<@test.A kotlin.String!>!): kotlin.Unit
+    public abstract fun f20(/*0*/ p0: (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)): kotlin.Unit
+    public abstract fun f21(/*0*/ p0: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>!): kotlin.Unit
+    public abstract fun f22(/*0*/ p0: (@test.A kotlin.Array<(@test.A kotlin.Array<kotlin.Array<(out) @test.A kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) @test.A kotlin.IntArray!>!>?)>..@test.A kotlin.Array<out (@test.A kotlin.Array<kotlin.Array<(out) @test.A kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) @test.A kotlin.IntArray!>!>?)>?)): kotlin.Unit
+    public abstract fun f23(/*0*/ p0: (@test.A kotlin.Array<kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Array<(out) @test.A kotlin.Int!>!>..@test.A kotlin.Array<out kotlin.Array<(out) @test.A kotlin.Int!>!>?)>!>..@test.A kotlin.Array<out kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Array<(out) @test.A kotlin.Int!>!>..@test.A kotlin.Array<out kotlin.Array<(out) @test.A kotlin.Int!>!>?)>!>?)): kotlin.Unit
+    public abstract fun f24(/*0*/ p0: (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)): kotlin.Unit
+    public abstract fun f25(/*0*/ p0: kotlin.Array<(out) @test.A kotlin.IntArray!>!): kotlin.Unit
+    public abstract fun f26(/*0*/ p0: kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Any!>..@test.A kotlin.Array<out kotlin.Any!>?)>!, /*1*/ p1: kotlin.Array<(out) @test.A kotlin.IntArray!>!, /*2*/ p2: (@test.A kotlin.Array<(@test.A kotlin.Array<kotlin.Array<(out) @test.A kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) @test.A kotlin.IntArray!>!>?)>..@test.A kotlin.Array<out (@test.A kotlin.Array<kotlin.Array<(out) @test.A kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) @test.A kotlin.IntArray!>!>?)>?)): kotlin.Unit
+    public abstract fun f27(/*0*/ p0: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Any!>..@test.A kotlin.Array<out @test.A kotlin.Any!>?)>!>!>!>!): kotlin.Unit
+    public abstract fun f28(/*0*/ p0: test.G1<(@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!): kotlin.Unit
+    public abstract fun f29(/*0*/ p0: test.G2<kotlin.Int!, @test.A kotlin.IntArray!>!): kotlin.Unit
+    public abstract fun f3(/*0*/ p0: test.G2<@test.A kotlin.String!, test.G2<@test.A(value = "abc") kotlin.Int!, test.G2<@test.A(value = "abc") test.G2<kotlin.Int!, @test.A kotlin.Int!>!, @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit
+    public abstract fun f30(/*0*/ p0: test.G1<kotlin.Array<(out) @test.A kotlin.Int!>!>!): kotlin.Unit
+    public abstract fun f31(/*0*/ p0: test.G1<test.G1<kotlin.IntArray!>!>!): kotlin.Unit
+    public abstract fun f32(/*0*/ p0: test.G1<test.G2<test.G1<(@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!, test.G1<@test.A kotlin.IntArray!>!>!>!): kotlin.Unit
+    public abstract fun f33(/*0*/ p0: test.G1<@test.A kotlin.IntArray!>!): kotlin.Unit
+    public abstract fun f34(/*0*/ p0: test.G1<kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!>!): kotlin.Unit
+    public abstract fun f35(/*0*/ p0: test.G2<kotlin.Int!, (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!, /*1*/ p1: test.G1<(@test.A kotlin.Array<kotlin.Array<(out) @test.A kotlin.Int!>!>..@test.A kotlin.Array<out kotlin.Array<(out) @test.A kotlin.Int!>!>?)>!, /*2*/ p2: test.G1<test.G1<kotlin.IntArray!>!>!): kotlin.Unit
+    public abstract fun f36(/*0*/ p0: test.G1<(@test.A kotlin.Array<kotlin.Array<(out) @test.A kotlin.Int!>!>..@test.A kotlin.Array<out kotlin.Array<(out) @test.A kotlin.Int!>!>?)>!): kotlin.Unit
+    public abstract fun f37(/*0*/ p0: test.G1<test.G1<kotlin.Array<(out) kotlin.Array<(out) kotlin.IntArray!>!>!>!>!): kotlin.Unit
+    public abstract fun f38(/*0*/ p0: test.G1<test.G2<test.G1<(@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!, test.G1<kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!>!>!): kotlin.Unit
+    public abstract fun f39(/*0*/ p0: test.G1<(@test.A kotlin.Array<(@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>..@test.A kotlin.Array<out (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>?)>!): kotlin.Unit
+    public abstract fun f4(/*0*/ p0: test.G1<out @test.A test.G0!>!): kotlin.Unit
+    public abstract fun f40(/*0*/ p0: test.G1<out (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!): kotlin.Unit
+    public abstract fun f41(/*0*/ p0: test.G2<out kotlin.Int!, in @test.A kotlin.IntArray!>!): kotlin.Unit
+    public abstract fun f42(/*0*/ p0: test.G1<in kotlin.Array<(out) @test.A kotlin.Int!>!>!): kotlin.Unit
+    public abstract fun f43(/*0*/ p0: test.G1<in test.G1<in kotlin.IntArray!>!>!): kotlin.Unit
+    public abstract fun f44(/*0*/ p0: test.G1<out test.G2<test.G1<in (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!, test.G1<out @test.A kotlin.IntArray!>!>!>!): kotlin.Unit
+    public abstract fun f45(/*0*/ p0: test.G1<out test.G2<in test.G1<(@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!, test.G1<out @test.A kotlin.IntArray!>!>!>!): kotlin.Unit
+    public abstract fun f46(/*0*/ p0: test.G1<in @test.A kotlin.IntArray!>!): kotlin.Unit
+    public abstract fun f47(/*0*/ p0: test.G1<out kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!>!): kotlin.Unit
+    public abstract fun f48(/*0*/ p0: test.G2<out kotlin.Int!, in kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!): kotlin.Unit
+    public abstract fun f49(/*0*/ p0: test.G1<in kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>!>!>!>!, /*1*/ p1: test.G1<in test.G1<in (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!>!, /*2*/ p2: test.G2<out kotlin.Int!, in kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!): kotlin.Unit
+    public abstract fun f5(/*0*/ p0: test.G1<test.G1<test.G1<test.G1<out @test.A test.G0!>!>!>!>!): kotlin.Unit
+    public abstract fun f50(/*0*/ p0: test.G1<in test.G1<in (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!>!): kotlin.Unit
+    public abstract fun f51(/*0*/ p0: test.G1<out test.G2<test.G1<in kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!>!>!, test.G1<out (@test.A kotlin.Array<(@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)>..@test.A kotlin.Array<out (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)>?)>!>!>!): kotlin.Unit
+    public abstract fun f52(/*0*/ p0: test.G1<out test.G2<in test.G1<(@test.A kotlin.Array<kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>?)>!, test.G1<out kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!>!): kotlin.Unit
+    public abstract fun f53(/*0*/ p0: test.G1<in (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!): kotlin.Unit
+    public abstract fun f54(/*0*/ p0: test.G1<out test.G2<in test.G1<(@test.A kotlin.Array<kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>?)>!, test.G1<out kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!>!, /*1*/ p1: test.G1<(@test.A kotlin.Array<(@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>..@test.A kotlin.Array<out (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>?)>!, /*2*/ p2: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Any!>..@test.A kotlin.Array<out @test.A kotlin.Any!>?)>!>!>!>!, /*3*/ p3: @test.A kotlin.IntArray!, /*4*/ p4: test.G2<in @test.A kotlin.String!, test.G2<out @test.A(value = "abc") kotlin.Int!, test.G2<out @test.A(value = "abc") test.G2<kotlin.Int!, in @test.A kotlin.Int!>!, out @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit
+    public abstract fun f55(/*0*/ vararg p0: @test.A kotlin.String! /*kotlin.Array<(out) @test.A kotlin.String!>!*/): kotlin.Unit
+    public abstract fun f56(/*0*/ vararg p0: kotlin.String! /*(@test.A kotlin.Array<kotlin.String!>..@test.A kotlin.Array<out kotlin.String!>?)*/): kotlin.Unit
+    public abstract fun f57(/*0*/ vararg p0: @test.A kotlin.String! /*(@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array<out @test.A kotlin.String!>?)*/): kotlin.Unit
+    public abstract fun f58(/*0*/ vararg p0: kotlin.Int /*kotlin.IntArray!*/): kotlin.Unit
+    public abstract fun f59(/*0*/ vararg p0: kotlin.Int /*@test.A kotlin.IntArray!*/): kotlin.Unit
+    public abstract fun f6(/*0*/ p0: test.G1<out @test.A kotlin.String!>!, /*1*/ p1: test.G1<test.G1<test.G1<test.G1<out @test.A test.G0!>!>!>!>!): kotlin.Unit
+    public abstract fun f60(/*0*/ vararg p0: kotlin.Int /*@test.A kotlin.IntArray!*/): kotlin.Unit
+    public abstract fun f61(/*0*/ vararg p0: kotlin.Array<(out) @test.A kotlin.String!>! /*kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.String!>!>!*/): kotlin.Unit
+    public abstract fun f62(/*0*/ vararg p0: kotlin.Array<(out) kotlin.String!>! /*(@test.A kotlin.Array<kotlin.Array<(out) kotlin.String!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.String!>!>?)*/): kotlin.Unit
+    public abstract fun f63(/*0*/ vararg p0: (@test.A kotlin.Array<kotlin.String!>..@test.A kotlin.Array<out kotlin.String!>?) /*kotlin.Array<(out) (@test.A kotlin.Array<kotlin.String!>..@test.A kotlin.Array<out kotlin.String!>?)>!*/): kotlin.Unit
+    public abstract fun f64(/*0*/ vararg p0: (@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array<out @test.A kotlin.String!>?) /*(@test.A kotlin.Array<(@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array<out @test.A kotlin.String!>?)>..@test.A kotlin.Array<out (@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array<out @test.A kotlin.String!>?)>?)*/): kotlin.Unit
+    public abstract fun f65(/*0*/ vararg p0: kotlin.IntArray! /*kotlin.Array<(out) kotlin.IntArray!>!*/): kotlin.Unit
+    public abstract fun f66(/*0*/ vararg p0: kotlin.IntArray! /*(@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)*/): kotlin.Unit
+    public abstract fun f67(/*0*/ vararg p0: @test.A kotlin.IntArray! /*kotlin.Array<(out) @test.A kotlin.IntArray!>!*/): kotlin.Unit
+    public abstract fun f68(/*0*/ vararg p0: @test.A kotlin.IntArray! /*(@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)*/): kotlin.Unit
+    public abstract fun f69(/*0*/ vararg p0: kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.String!>!>! /*kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.String!>!>!>!*/): kotlin.Unit
+    public abstract fun f7(/*0*/ p0: test.G2<out @test.A kotlin.String!, test.G2<out @test.A(value = "abc") kotlin.Int!, test.G2<out @test.A(value = "abc") test.G2<kotlin.Int!, out @test.A kotlin.Int!>!, out @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit
+    public abstract fun f70(/*0*/ vararg p0: (@test.A kotlin.Array<kotlin.Array<(out) kotlin.String!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.String!>!>?) /*kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Array<(out) kotlin.String!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.String!>!>?)>!*/): kotlin.Unit
+    public abstract fun f71(/*0*/ vararg p0: kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<kotlin.String!>..@test.A kotlin.Array<out kotlin.String!>?)>!>! /*kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<kotlin.String!>..@test.A kotlin.Array<out kotlin.String!>?)>!>!>!*/): kotlin.Unit
+    public abstract fun f72(/*0*/ vararg p0: kotlin.Array<(out) (@test.A kotlin.Array<(@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array<out @test.A kotlin.String!>?)>..@test.A kotlin.Array<out (@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array<out @test.A kotlin.String!>?)>?)>! /*(@test.A kotlin.Array<kotlin.Array<(out) (@test.A kotlin.Array<(@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array<out @test.A kotlin.String!>?)>..@test.A kotlin.Array<out (@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array<out @test.A kotlin.String!>?)>?)>!>..@test.A kotlin.Array<out kotlin.Array<(out) (@test.A kotlin.Array<(@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array<out @test.A kotlin.String!>?)>..@test.A kotlin.Array<out (@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array<out @test.A kotlin.String!>?)>?)>!>?)*/): kotlin.Unit
+    public abstract fun f73(/*0*/ vararg p0: (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?) /*kotlin.Array<(out) (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!*/): kotlin.Unit
+    public abstract fun f74(/*0*/ vararg p0: kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!>! /*(@test.A kotlin.Array<kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!>!>?)*/): kotlin.Unit
+    public abstract fun f75(/*0*/ vararg p0: kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.IntArray!>!>! /*kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!*/): kotlin.Unit
+    public abstract fun f76(/*0*/ vararg p0: kotlin.Array<(out) @test.A kotlin.IntArray!>! /*(@test.A kotlin.Array<kotlin.Array<(out) @test.A kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) @test.A kotlin.IntArray!>!>?)*/): kotlin.Unit
+    public abstract fun f8(/*0*/ p0: test.G1<in @test.A test.G0!>!): kotlin.Unit
+    public abstract fun f9(/*0*/ p0: test.G1<test.G1<test.G1<test.G1<in @test.A test.G0!>!>!>!>!): kotlin.Unit
+
+    public open class Test {
+        public constructor Test(/*0*/ p0: test.G2<in @test.A kotlin.String!, test.G2<out @test.A(value = "abc") kotlin.Int!, test.G2<out @test.A(value = "abc") test.G2<kotlin.Int!, in @test.A kotlin.Int!>!, out @test.A(value = "abc") kotlin.Int!>!>!>!, /*1*/ p1: kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Any!>..@test.A kotlin.Array<out kotlin.Any!>?)>!, /*2*/ p2: kotlin.Array<(out) @test.A kotlin.IntArray!>!, /*3*/ p3: (@test.A kotlin.Array<(@test.A kotlin.Array<kotlin.Array<(out) @test.A kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) @test.A kotlin.IntArray!>!>?)>..@test.A kotlin.Array<out (@test.A kotlin.Array<kotlin.Array<(out) @test.A kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) @test.A kotlin.IntArray!>!>?)>?), /*4*/ vararg p4: kotlin.Array<(out) @test.A kotlin.IntArray!>! /*(@test.A kotlin.Array<kotlin.Array<(out) @test.A kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) @test.A kotlin.IntArray!>!>?)*/)
+    }
+}

compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.java

@@ -0,0 +1,22 @@
+// JAVAC_EXPECTED_FILE
+package test;
+
+import java.lang.annotation.*;
+public class Basic {
+    @Target(ElementType.TYPE_PARAMETER)
+    public @interface A {
+        String value() default "";
+    }
+
+    public interface G<@A T> {
+        <@A("abc") R> void foo(R r);
+    }
+
+    public interface G1<T, E extends T, @A X> {
+        <R, @A("abc") _A extends R> void foo(R r);
+    }
+
+    <R, @A("abc") _A extends R, @A("abc") K> void foo(R r) {
+
+    }
+}

compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.javac.txt

@@ -1,14 +1,14 @@
 package test
 
-public open class TypeParameterAnnotations {
-    public constructor TypeParameterAnnotations()
+public open class Basic {
+    public constructor Basic()
 
     @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) public final annotation class A : kotlin.Annotation {
         public constructor A(/*0*/ value: kotlin.String = ...)
         public final val value: kotlin.String
     }
 
-    public interface G</*0*/ T : kotlin.Any!> {
-        public abstract fun </*0*/ R : kotlin.Any!> foo(/*0*/ p0: R!): kotlin.Unit
+    public interface G</*0*/ @test.Basic.A T : kotlin.Any!> {
+        public abstract fun </*0*/ @test.Basic.A(value = "abc") R : kotlin.Any!> foo(/*0*/ r: R!): kotlin.Unit
     }
 }

compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.runtime.txt

@@ -0,0 +1,14 @@
+package test
+
+public open class Basic {
+    public constructor Basic()
+
+    @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) @kotlin.annotation.Retention(value = ...) public final annotation class A : kotlin.Annotation {
+        public final val value: kotlin.String
+            public final fun <get-value>(): kotlin.String
+    }
+
+    public interface G</*0*/ @test.Basic.A(value = "") T : kotlin.Any!> {
+        public abstract fun </*0*/ @test.Basic.A(value = "abc") R : kotlin.Any!> foo(/*0*/ R!): kotlin.Unit
+    }
+}

compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.txt

@@ -0,0 +1,19 @@
+package test
+
+public open class Basic {
+    public constructor Basic()
+    public/*package*/ open fun </*0*/ R : kotlin.Any!, /*1*/ @test.Basic.A(value = "abc") _A : R!, /*2*/ @test.Basic.A(value = "abc") K : kotlin.Any!> foo(/*0*/ r: R!): kotlin.Unit
+
+    @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) public final annotation class A : kotlin.Annotation {
+        public constructor A(/*0*/ value: kotlin.String = ...)
+        public final val value: kotlin.String
+    }
+
+    public interface G</*0*/ @test.Basic.A T : kotlin.Any!> {
+        public abstract fun </*0*/ @test.Basic.A(value = "abc") R : kotlin.Any!> foo(/*0*/ r: R!): kotlin.Unit
+    }
+
+    public interface G1</*0*/ T : kotlin.Any!, /*1*/ E : T!, /*2*/ @test.Basic.A X : kotlin.Any!> {
+        public abstract fun </*0*/ R : kotlin.Any!, /*1*/ @test.Basic.A(value = "abc") _A : R!> foo(/*0*/ r: R!): kotlin.Unit
+    }
+}

compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.java

@@ -0,0 +1,26 @@
+package test;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE_USE)
+@interface A {
+    String value() default "";
+}
+
+interface I1<T> {}
+interface I2<T, K> {}
+interface I3<T, K, L> {}
+
+class A2<T, K> {}
+class A3<T, K, L> {}
+
+public class BaseClassTypeArguments<B> extends A3<@A B [][][][][], I1<I1<@A int @A [][]>>, A2<B, int [] [] @A []>> implements I1<@A Integer @A [][][]>, I2<@A B, B>, I3<@A B [][][][][], B, @A B> {
+    class ImplementedInterfacesTypeArguments<B> implements I1<I2<I1<@A Integer @A [][][]>, I1<@A int [] @A []>>>, I2<@A B, B>, I3<@A B [][][][][], I1<I1<@A int @A [][]>>, I2<B, int [] [] @A []>> {
+        public class BaseClassTypeArguments1<B> extends A3<@A B [][][][][], I1<I1<@A int @A [][]>>, A2<B, int [] [] @A []>> {
+
+        }
+    }
+    static class BaseClassTypeArguments2<B> extends A3<@A B [][][][][], I1<I1<@A int @A [][]>>, A2<B, int [] [] @A []>> {
+
+    }
+}

compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.txt

@@ -0,0 +1,17 @@
+package test
+
+public open class BaseClassTypeArguments</*0*/ B : kotlin.Any!> : test.A3<kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A B!>!>!>!>!>!, test.I1<test.I1<kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!, test.A2<B!, (@test.A kotlin.Array<kotlin.Array<(out) kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.IntArray!>!>?)>!>, test.I1<kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!>!>, test.I2<@test.A B!, B!>, test.I3<kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A B!>!>!>!>!>!, B!, @test.A B!> {
+    public constructor BaseClassTypeArguments</*0*/ B : kotlin.Any!>()
+
+    public/*package*/ open class BaseClassTypeArguments2</*0*/ B : kotlin.Any!> : test.A3<kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A B!>!>!>!>!>!, test.I1<test.I1<kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!, test.A2<B!, (@test.A kotlin.Array<kotlin.Array<(out) kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.IntArray!>!>?)>!> {
+        public/*package*/ constructor BaseClassTypeArguments2</*0*/ B : kotlin.Any!>()
+    }
+
+    public/*package*/ open inner class ImplementedInterfacesTypeArguments</*0*/ B : kotlin.Any!> /*captured type parameters: /*1*/ B : kotlin.Any!*/ : test.I1<test.I2<test.I1<kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!>!>!, test.I1<(@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!>!>, test.I2<@test.A B!, B!>, test.I3<kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A B!>!>!>!>!>!, test.I1<test.I1<kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!, test.I2<B!, (@test.A kotlin.Array<kotlin.Array<(out) kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.IntArray!>!>?)>!> {
+        public/*package*/ constructor ImplementedInterfacesTypeArguments</*0*/ B : kotlin.Any!>()
+
+        public open inner class BaseClassTypeArguments1</*0*/ B : kotlin.Any!> /*captured type parameters: /*1*/ B : kotlin.Any!, /*2*/ B : kotlin.Any!*/ : test.A3<kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A B!>!>!>!>!>!, test.I1<test.I1<kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!, test.A2<B!, (@test.A kotlin.Array<kotlin.Array<(out) kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.IntArray!>!>?)>!> {
+            public constructor BaseClassTypeArguments1</*0*/ B : kotlin.Any!>()
+        }
+    }
+}

compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java

@@ -1,7 +1,7 @@
 package test;
 
 import java.lang.annotation.*;
-public class TypeAnnotations {
+public class Basic {
     @Target(ElementType.TYPE_USE)
     @interface A {
         String value() default "";
@@ -13,8 +13,6 @@ public class TypeAnnotations {
     interface G2<A, B> {
     }
 
-    // Currently annotations on type parameters and arguments are not loaded from compiled code because of IDEA-153093
-    // Once it will be fixed check if KT-11454 is ready to be resolved
     public interface MyClass<TT> {
         void f(G<@A String> p);
 

compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.txt

@@ -1,7 +1,7 @@
 package test
 
-public open class TypeAnnotations {
-    public constructor TypeAnnotations()
+public open class Basic {
+    public constructor Basic()
 
     @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation {
         public/*package*/ constructor A(/*0*/ value: kotlin.String = ...)
@@ -15,7 +15,7 @@ public open class TypeAnnotations {
     }
 
     public interface MyClass</*0*/ TT : kotlin.Any!> {
-        public abstract fun f(/*0*/ p0: test.TypeAnnotations.G2<kotlin.String!, kotlin.Int!>!): kotlin.Unit
-        public abstract fun f(/*0*/ p0: test.TypeAnnotations.G<kotlin.String!>!): kotlin.Unit
+        public abstract fun f(/*0*/ p: test.Basic.G2<@test.Basic.A kotlin.String!, @test.Basic.A(value = "abc") kotlin.Int!>!): kotlin.Unit
+        public abstract fun f(/*0*/ p: test.Basic.G<@test.Basic.A kotlin.String!>!): kotlin.Unit
     }
 }

compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.java

@@ -0,0 +1,33 @@
+// JAVAC_EXPECTED_FILE
+
+package test;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE_USE)
+@interface A {
+    String value() default "";
+}
+
+public class ClassTypeParameterBounds {
+    interface I1 {}
+    interface I2<T> {}
+    interface I3<T> {}
+    interface I4<T> {}
+
+    interface G1<T extends @A Object> { }
+    class G2<_A, B extends @A Integer> { }
+    interface G3<_A, B extends Object & @A I1> { }
+    class G4<_A extends @A B, B> { }
+    interface G5<_A, B extends @A _A> { }
+    class G6<_A extends @A I1, B, C, D extends @A E, E, F> { }
+    interface G7<_A extends Object & I2<@A Integer> & @A I3<String>> { }
+    interface G8<_A extends Object & I2<? super @A Integer> & @A I3<? extends String>> { }
+
+    interface G9<_A extends I4<Integer @A []> & I2<? extends @A Integer @A []> & @A I3<? extends Integer @A []>> { }
+    interface G10<_A extends I4<int @A []> & I2<? extends @A int @A []> & @A I3<? extends int @A []>> { }
+    interface G11<_A extends I4<Integer [] [] @A []> & I2<? extends @A Integer @A [] [] [] []> & @A I3<? extends Integer [] @A []>> { }
+    interface G12<_A extends I4<int @A [][]> & I2<? extends @A int [] [] @A []> & @A I3<? extends int []@A [] []>> { }
+
+    // class G13<_A extends Object, B extends I3<@A _A> & @A I2<_A>> { }
+}

compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.txt

@@ -0,0 +1,56 @@
+package test
+
+public open class ClassTypeParameterBounds {
+    public constructor ClassTypeParameterBounds()
+
+    public/*package*/ interface G1</*0*/ T : @test.A kotlin.Any!> {
+    }
+
+    public/*package*/ interface G10</*0*/ _A : test.ClassTypeParameterBounds.I4<@test.A kotlin.IntArray!>!> where _A : test.ClassTypeParameterBounds.I2<out @test.A kotlin.IntArray!>!, _A : @test.A test.ClassTypeParameterBounds.I3<out @test.A kotlin.IntArray!>! {
+    }
+
+    public/*package*/ interface G11</*0*/ _A : test.ClassTypeParameterBounds.I4<(@test.A kotlin.Array<kotlin.Array<(out) kotlin.Array<(out) kotlin.Int!>!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Array<(out) kotlin.Int!>!>!>?)>!> where _A : test.ClassTypeParameterBounds.I2<out kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!>!>!>!, _A : @test.A test.ClassTypeParameterBounds.I3<out (@test.A kotlin.Array<kotlin.Array<(out) kotlin.Int!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Int!>!>?)>! {
+    }
+
+    public/*package*/ interface G12</*0*/ _A : test.ClassTypeParameterBounds.I4<kotlin.Array<(out) @test.A kotlin.IntArray!>!>!> where _A : test.ClassTypeParameterBounds.I2<out (@test.A kotlin.Array<kotlin.Array<(out) kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.IntArray!>!>?)>!, _A : @test.A test.ClassTypeParameterBounds.I3<out kotlin.Array<(out) (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!>! {
+    }
+
+    public/*package*/ open inner class G2</*0*/ _A : kotlin.Any!, /*1*/ B : @test.A kotlin.Int!> {
+        public/*package*/ constructor G2</*0*/ _A : kotlin.Any!, /*1*/ B : @test.A kotlin.Int!>()
+    }
+
+    public/*package*/ interface G3</*0*/ _A : kotlin.Any!, /*1*/ B : kotlin.Any!> where B : @test.A test.ClassTypeParameterBounds.I1! {
+    }
+
+    public/*package*/ open inner class G4</*0*/ _A : @test.A B!, /*1*/ B : kotlin.Any!> {
+        public/*package*/ constructor G4</*0*/ _A : @test.A B!, /*1*/ B : kotlin.Any!>()
+    }
+
+    public/*package*/ interface G5</*0*/ _A : kotlin.Any!, /*1*/ B : @test.A _A!> {
+    }
+
+    public/*package*/ open inner class G6</*0*/ _A : @test.A test.ClassTypeParameterBounds.I1!, /*1*/ B : kotlin.Any!, /*2*/ C : kotlin.Any!, /*3*/ D : @test.A E!, /*4*/ E : kotlin.Any!, /*5*/ F : kotlin.Any!> {
+        public/*package*/ constructor G6</*0*/ _A : @test.A test.ClassTypeParameterBounds.I1!, /*1*/ B : kotlin.Any!, /*2*/ C : kotlin.Any!, /*3*/ D : @test.A E!, /*4*/ E : kotlin.Any!, /*5*/ F : kotlin.Any!>()
+    }
+
+    public/*package*/ interface G7</*0*/ _A : kotlin.Any!> where _A : test.ClassTypeParameterBounds.I2<@test.A kotlin.Int!>!, _A : @test.A test.ClassTypeParameterBounds.I3<kotlin.String!>! {
+    }
+
+    public/*package*/ interface G8</*0*/ _A : kotlin.Any!> where _A : test.ClassTypeParameterBounds.I2<in @test.A kotlin.Int!>!, _A : @test.A test.ClassTypeParameterBounds.I3<out kotlin.String!>! {
+    }
+
+    public/*package*/ interface G9</*0*/ _A : test.ClassTypeParameterBounds.I4<(@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!> where _A : test.ClassTypeParameterBounds.I2<out (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!, _A : @test.A test.ClassTypeParameterBounds.I3<out (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>! {
+    }
+
+    public/*package*/ interface I1 {
+    }
+
+    public/*package*/ interface I2</*0*/ T : kotlin.Any!> {
+    }
+
+    public/*package*/ interface I3</*0*/ T : kotlin.Any!> {
+    }
+
+    public/*package*/ interface I4</*0*/ T : kotlin.Any!> {
+    }
+}

compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.java

@@ -0,0 +1,23 @@
+// JAVAC_EXPECTED_FILE
+
+package test;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE_USE)
+@interface A {
+    String value() default "";
+}
+
+/*
+ * Note that a receiver type doesn't get into signatures used by the Kotlin compiler
+ * So in this test, annotated types shouldn't be reflected in the signatures dump
+ */
+
+public class MethodReceiver<T> {
+    public void f1(MethodReceiver<@A T> this) { }
+
+    class MethodReceiver3<T, K, L> {
+        public void f1(@A MethodReceiver3<@A T, K, @A L> this) { }
+    }
+}

compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.txt

@@ -0,0 +1,11 @@
+package test
+
+public open class MethodReceiver</*0*/ T : kotlin.Any!> {
+    public constructor MethodReceiver</*0*/ T : kotlin.Any!>()
+    public open fun f1(): kotlin.Unit
+
+    public/*package*/ open inner class MethodReceiver3</*0*/ T : kotlin.Any!, /*1*/ K : kotlin.Any!, /*2*/ L : kotlin.Any!> /*captured type parameters: /*3*/ T : kotlin.Any!*/ {
+        public/*package*/ constructor MethodReceiver3</*0*/ T : kotlin.Any!, /*1*/ K : kotlin.Any!, /*2*/ L : kotlin.Any!>()
+        public open fun f1(): kotlin.Unit
+    }
+}

compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.java

@@ -0,0 +1,33 @@
+// JAVAC_EXPECTED_FILE
+
+package test;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE_USE)
+@interface A {
+    String value() default "";
+}
+
+abstract class MethodTypeParameterBounds {
+    interface I1 {}
+    interface I2<T> {}
+    interface I3<T> {}
+    interface I4<T> {}
+
+    <T extends @A Object> void f1(T x) { }
+    <_A, B extends @A Integer> void f2(_A x, B y) { }
+    <_A, B extends Object & @A I1> void f3(_A x, B y) { }
+    <_A extends @A B, B> void f4(_A x, B y) { }
+    <_A, B extends @A _A> void f5(_A x, B y) { }
+    <_A extends @A I1> void f6() { }
+    abstract <_A, B extends @A _A> void f7(_A x, B y);
+    abstract <_A extends @A I1, B, C, D extends @A E, E, F> void f8(_A x1, B x2, C x3, D x4, E x5, F x6);
+    <_A extends Object & I2<@A Integer> & @A I3<String>> void f9(_A x) { }
+    <_A extends Object & I2<? super @A Integer> & @A I3<? extends String>> void f10(_A x) { }
+    <_A extends I4<Integer @A []> & I2<? extends @A Integer @A []> & @A I3<? extends Integer @A []>> void f11(_A x) { }
+    <_A extends I4<int @A []> & I2<? extends @A int @A []> & @A I3<? extends int @A []>> void f12(_A x) { }
+    <_A extends I4<Integer [] [] @A []> & I2<? extends @A Integer @A [] [] [] []> & @A I3<? extends Integer [] @A []>> void f13(_A x) { }
+    abstract <_A extends I4<int @A [][]> & I2<? extends @A int [] [] @A []> & @A I3<? extends int []@A [] []>> void f14(_A x);
+    <_A extends Object, B extends I3<@A A> & @A I2<A>> void f15(_A x) { }
+}

compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.txt

@@ -0,0 +1,32 @@
+package test
+
+public/*package*/ abstract class MethodTypeParameterBounds {
+    public/*package*/ constructor MethodTypeParameterBounds()
+    public/*package*/ open fun </*0*/ T : @test.A kotlin.Any!> f1(/*0*/ x: T!): kotlin.Unit
+    public/*package*/ open fun </*0*/ _A : kotlin.Any!> f10(/*0*/ x: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2<in @test.A kotlin.Int!>!, _A : @test.A test.MethodTypeParameterBounds.I3<out kotlin.String!>!
+    public/*package*/ open fun </*0*/ _A : test.MethodTypeParameterBounds.I4<(@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!> f11(/*0*/ x: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2<out (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!, _A : @test.A test.MethodTypeParameterBounds.I3<out (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!
+    public/*package*/ open fun </*0*/ _A : test.MethodTypeParameterBounds.I4<@test.A kotlin.IntArray!>!> f12(/*0*/ x: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2<out @test.A kotlin.IntArray!>!, _A : @test.A test.MethodTypeParameterBounds.I3<out @test.A kotlin.IntArray!>!
+    public/*package*/ open fun </*0*/ _A : test.MethodTypeParameterBounds.I4<(@test.A kotlin.Array<kotlin.Array<(out) kotlin.Array<(out) kotlin.Int!>!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Array<(out) kotlin.Int!>!>!>?)>!> f13(/*0*/ x: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2<out kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!>!>!>!, _A : @test.A test.MethodTypeParameterBounds.I3<out (@test.A kotlin.Array<kotlin.Array<(out) kotlin.Int!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Int!>!>?)>!
+    public/*package*/ abstract fun </*0*/ _A : test.MethodTypeParameterBounds.I4<kotlin.Array<(out) @test.A kotlin.IntArray!>!>!> f14(/*0*/ x: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2<out (@test.A kotlin.Array<kotlin.Array<(out) kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.IntArray!>!>?)>!, _A : @test.A test.MethodTypeParameterBounds.I3<out kotlin.Array<(out) (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!>!
+    public/*package*/ open fun </*0*/ _A : kotlin.Any!, /*1*/ B : test.MethodTypeParameterBounds.I3<@test.A test.A!>!> f15(/*0*/ x: _A!): kotlin.Unit where B : @test.A test.MethodTypeParameterBounds.I2<test.A!>!
+    public/*package*/ open fun </*0*/ _A : kotlin.Any!, /*1*/ B : @test.A kotlin.Int!> f2(/*0*/ x: _A!, /*1*/ y: B!): kotlin.Unit
+    public/*package*/ open fun </*0*/ _A : kotlin.Any!, /*1*/ B : kotlin.Any!> f3(/*0*/ x: _A!, /*1*/ y: B!): kotlin.Unit where B : @test.A test.MethodTypeParameterBounds.I1!
+    public/*package*/ open fun </*0*/ _A : @test.A B!, /*1*/ B : kotlin.Any!> f4(/*0*/ x: _A!, /*1*/ y: B!): kotlin.Unit
+    public/*package*/ open fun </*0*/ _A : kotlin.Any!, /*1*/ B : @test.A _A!> f5(/*0*/ x: _A!, /*1*/ y: B!): kotlin.Unit
+    public/*package*/ open fun </*0*/ _A : @test.A test.MethodTypeParameterBounds.I1!> f6(): kotlin.Unit
+    public/*package*/ abstract fun </*0*/ _A : kotlin.Any!, /*1*/ B : @test.A _A!> f7(/*0*/ x: _A!, /*1*/ y: B!): kotlin.Unit
+    public/*package*/ abstract fun </*0*/ _A : @test.A test.MethodTypeParameterBounds.I1!, /*1*/ B : kotlin.Any!, /*2*/ C : kotlin.Any!, /*3*/ D : @test.A E!, /*4*/ E : kotlin.Any!, /*5*/ F : kotlin.Any!> f8(/*0*/ x1: _A!, /*1*/ x2: B!, /*2*/ x3: C!, /*3*/ x4: D!, /*4*/ x5: E!, /*5*/ x6: F!): kotlin.Unit
+    public/*package*/ open fun </*0*/ _A : kotlin.Any!> f9(/*0*/ x: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2<@test.A kotlin.Int!>!, _A : @test.A test.MethodTypeParameterBounds.I3<kotlin.String!>!
+
+    public/*package*/ interface I1 {
+    }
+
+    public/*package*/ interface I2</*0*/ T : kotlin.Any!> {
+    }
+
+    public/*package*/ interface I3</*0*/ T : kotlin.Any!> {
+    }
+
+    public/*package*/ interface I4</*0*/ T : kotlin.Any!> {
+    }
+}

compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.java

@@ -0,0 +1,95 @@
+package test;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE_USE)
+@interface A {
+    String value() default "";
+}
+
+interface G0 { }
+interface G1<T> { }
+interface G2<A, B> { }
+
+interface ReturnType {
+    // simplpe type arguments
+    G1<@A G0> f0();
+    G1<G1<G1<G1<@A G0>>>> f1();
+    G1<@A String> f2();
+    G2<@A String, G2<@A("abc") Integer, G2<@A("abc") G2<Integer, @A Integer>, @A("abc") Integer>>> f3();
+
+    // wildcards
+    G1<? extends @A G0> f4 = null;
+    G1<G1<G1<G1<? extends @A G0>>>> f5();
+    G1<? extends @A String> f6();
+    G2<? extends @A String, G2<? extends @A("abc") Integer, G2<? extends @A("abc") G2<Integer, ? extends @A Integer>, ? extends @A("abc") Integer>>> f7();
+
+    G1<? super @A G0> f8();
+    G1<G1<G1<G1<? super @A G0>>>> f9();
+    G1<? super @A String> f10 = null;
+    G2<? super @A String, G2<? super @A("abc") Integer, G2<? super @A("abc") G2<Integer, ? super @A Integer>, ? super @A("abc") Integer>>> f11();
+
+    G2<? super @A String, G2<? extends @A("abc") Integer, G2<? extends @A("abc") G2<Integer, ? super @A Integer>, ? extends @A("abc") Integer>>> f12 = null;
+
+    // arrays
+    Integer @A [] f13();
+    int @A [] f14();
+    @A Integer [] f15();
+    @A int [] f16();
+    @A Integer @A [] f17();
+    @A int @A [] f18 = null;
+
+    // multidementional arrays
+    Integer @A [] [] f19();
+    int @A [] @A [] f20();
+    @A Integer [] [] [] f21 = null;
+    @A int @A [] @A [] [] @A [] f22();
+    @A Integer @A [] [] @A [] [] f23();
+    @A int @A [] @A [] f24 = null;
+    int [] @A [] f25();
+    Object [] @A [] f26();
+    @A Object [] [] [] [] @A [] f27();
+
+    // arrays in type arguments
+    G1<Integer @A []> f28();
+    G2<Integer, int @A []> f29();
+    G1<@A Integer []> f30();
+    G1<G1<@A int []>> f31();
+    G1<G2<G1<@A Integer @A []>, G1<@A int @A []>>> f32();
+    G1<@A int @A []> f33();
+    G1<Integer [] @A []> f34();
+    G2<Integer, int @A [][]> f35 = null;
+    G1<@A Integer @A [] []> f36();
+    G1<G1<@A int [][][]>> f37();
+    G1<G2<G1<@A Integer @A []>, G1<@A int [] [] @A []>>> f38();
+    G1<@A int @A [] @A [] []> f39();
+
+    // arrays in wildcard bounds
+    G1<? extends Integer @A []> f40();
+    G2<? extends Integer, ? super int @A []> f41();
+    G1<? super @A Integer []> f42();
+    G1<? super G1<? super @A int []>> f43();
+    G1<? extends G2<G1<? super @A Integer @A []>, G1<? extends @A int @A []>>> f44();
+    G1<? extends G2<? super G1<@A Integer @A []>, G1<? extends @A int @A []>>> f45 = null;
+    G1<? super @A int @A []> f46();
+    G1<? extends Integer [] @A []> f47();
+    G2<? extends Integer, ? super int [] [] @A []> f48 = null;
+    G1<? super @A Integer [][][][][]> f49();
+    G1<? super G1<? super @A int @A [][]>> f50();
+    G1<? extends G2<G1<? super @A Integer [] [] @A []>, G1<? extends @A int @A [] @A [] @A []>>> f51();
+    G1<? extends G2<? super G1<@A Integer @A [][][]>, G1<? extends @A int [] @A []>>> f52 = null;
+    G1<? super @A int @A [][]> f53();
+
+    class ReturnType2 {
+        G1<? extends @A G0> f4 = null;
+        G1<? super @A String> f10 = null;
+        G2<? super @A String, G2<? extends @A("abc") Integer, G2<? extends @A("abc") G2<Integer, ? super @A Integer>, ? extends @A("abc") Integer>>> f12 = null;
+        @A int @A [] f18 = null;
+        @A Integer [] [] [] f21 = null;
+        @A int @A [] @A [] f24 = null;
+        G2<Integer, int @A [][]> f35 = null;
+        G1<? extends G2<? super G1<@A Integer @A []>, G1<? extends @A int @A []>>> f45 = null;
+        G2<? extends Integer, ? super int [] [] @A []> f48 = null;
+        G1<? extends G2<? super G1<@A Integer @A [][][]>, G1<? extends @A int [] @A []>>> f52 = null;
+    }
+}

compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.txt

@@ -0,0 +1,74 @@
+package test
+
+public/*package*/ interface ReturnType {
+    public abstract fun f0(): test.G1<@test.A test.G0!>!
+    public abstract fun f1(): test.G1<test.G1<test.G1<test.G1<@test.A test.G0!>!>!>!>!
+    public abstract fun f11(): test.G2<in @test.A kotlin.String!, test.G2<in @test.A(value = "abc") kotlin.Int!, test.G2<in @test.A(value = "abc") test.G2<kotlin.Int!, in @test.A kotlin.Int!>!, in @test.A(value = "abc") kotlin.Int!>!>!>!
+    public abstract fun f13(): (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)
+    public abstract fun f14(): @test.A kotlin.IntArray!
+    @test.A public abstract fun f15(): kotlin.Array<(out) @test.A kotlin.Int!>!
+    @test.A public abstract fun f16(): kotlin.IntArray!
+    @test.A public abstract fun f17(): (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)
+    public abstract fun f19(): kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!
+    public abstract fun f2(): test.G1<@test.A kotlin.String!>!
+    public abstract fun f20(): (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)
+    @test.A public abstract fun f22(): (@test.A kotlin.Array<kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)>!>..@test.A kotlin.Array<out kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)>!>?)
+    @test.A public abstract fun f23(): kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!>..@test.A kotlin.Array<out kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!>?)>!
+    public abstract fun f25(): (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)
+    public abstract fun f26(): (@test.A kotlin.Array<kotlin.Array<(out) kotlin.Any!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Any!>!>?)
+    @test.A public abstract fun f27(): (@test.A kotlin.Array<kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Any!>!>!>!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Any!>!>!>!>!>?)
+    public abstract fun f28(): test.G1<(@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!
+    public abstract fun f29(): test.G2<kotlin.Int!, @test.A kotlin.IntArray!>!
+    public abstract fun f3(): test.G2<@test.A kotlin.String!, test.G2<@test.A(value = "abc") kotlin.Int!, test.G2<@test.A(value = "abc") test.G2<kotlin.Int!, @test.A kotlin.Int!>!, @test.A(value = "abc") kotlin.Int!>!>!>!
+    public abstract fun f30(): test.G1<kotlin.Array<(out) @test.A kotlin.Int!>!>!
+    public abstract fun f31(): test.G1<test.G1<kotlin.IntArray!>!>!
+    public abstract fun f32(): test.G1<test.G2<test.G1<(@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!, test.G1<@test.A kotlin.IntArray!>!>!>!
+    public abstract fun f33(): test.G1<@test.A kotlin.IntArray!>!
+    public abstract fun f34(): test.G1<(@test.A kotlin.Array<kotlin.Array<(out) kotlin.Int!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Int!>!>?)>!
+    public abstract fun f36(): test.G1<kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!>!
+    public abstract fun f37(): test.G1<test.G1<kotlin.Array<(out) kotlin.Array<(out) kotlin.IntArray!>!>!>!>!
+    public abstract fun f38(): test.G1<test.G2<test.G1<(@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!, test.G1<(@test.A kotlin.Array<kotlin.Array<(out) kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.IntArray!>!>?)>!>!>!
+    public abstract fun f39(): test.G1<kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)>!>!
+    public abstract fun f40(): test.G1<out (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!
+    public abstract fun f41(): test.G2<out kotlin.Int!, in @test.A kotlin.IntArray!>!
+    public abstract fun f42(): test.G1<in kotlin.Array<(out) @test.A kotlin.Int!>!>!
+    public abstract fun f43(): test.G1<in test.G1<in kotlin.IntArray!>!>!
+    public abstract fun f44(): test.G1<out test.G2<test.G1<in (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!, test.G1<out @test.A kotlin.IntArray!>!>!>!
+    public abstract fun f46(): test.G1<in @test.A kotlin.IntArray!>!
+    public abstract fun f47(): test.G1<out (@test.A kotlin.Array<kotlin.Array<(out) kotlin.Int!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Int!>!>?)>!
+    public abstract fun f49(): test.G1<in kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>!>!>!>!
+    public abstract fun f5(): test.G1<test.G1<test.G1<test.G1<out @test.A test.G0!>!>!>!>!
+    public abstract fun f50(): test.G1<in test.G1<in kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!
+    public abstract fun f51(): test.G1<out test.G2<test.G1<in (@test.A kotlin.Array<kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>?)>!, test.G1<out (@test.A kotlin.Array<(@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)>..@test.A kotlin.Array<out (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)>?)>!>!>!
+    public abstract fun f53(): test.G1<in kotlin.Array<(out) @test.A kotlin.IntArray!>!>!
+    public abstract fun f6(): test.G1<out @test.A kotlin.String!>!
+    public abstract fun f7(): test.G2<out @test.A kotlin.String!, test.G2<out @test.A(value = "abc") kotlin.Int!, test.G2<out @test.A(value = "abc") test.G2<kotlin.Int!, out @test.A kotlin.Int!>!, out @test.A(value = "abc") kotlin.Int!>!>!>!
+    public abstract fun f8(): test.G1<in @test.A test.G0!>!
+    public abstract fun f9(): test.G1<test.G1<test.G1<test.G1<in @test.A test.G0!>!>!>!>!
+
+    public open class ReturnType2 {
+        public constructor ReturnType2()
+        public/*package*/ final var f10: test.G1<in @test.A kotlin.String!>!
+        public/*package*/ final var f12: test.G2<in @test.A kotlin.String!, test.G2<out @test.A(value = "abc") kotlin.Int!, test.G2<out @test.A(value = "abc") test.G2<kotlin.Int!, in @test.A kotlin.Int!>!, out @test.A(value = "abc") kotlin.Int!>!>!>!
+        @test.A public/*package*/ final var f18: @test.A kotlin.IntArray!
+        @test.A public/*package*/ final var f21: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>!
+        @test.A public/*package*/ final var f24: (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)
+        public/*package*/ final var f35: test.G2<kotlin.Int!, kotlin.Array<(out) @test.A kotlin.IntArray!>!>!
+        public/*package*/ final var f4: test.G1<out @test.A test.G0!>!
+        public/*package*/ final var f45: test.G1<out test.G2<in test.G1<(@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!, test.G1<out @test.A kotlin.IntArray!>!>!>!
+        public/*package*/ final var f48: test.G2<out kotlin.Int!, in (@test.A kotlin.Array<kotlin.Array<(out) kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.IntArray!>!>?)>!
+        public/*package*/ final var f52: test.G1<out test.G2<in test.G1<kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!>!>!, test.G1<out (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!>!>!
+    }
+
+    // Static members
+    public final val f10: test.G1<in @test.A kotlin.String!>!
+    public final val f12: test.G2<in @test.A kotlin.String!, test.G2<out @test.A(value = "abc") kotlin.Int!, test.G2<out @test.A(value = "abc") test.G2<kotlin.Int!, in @test.A kotlin.Int!>!, out @test.A(value = "abc") kotlin.Int!>!>!>!
+    @test.A public final val f18: @test.A kotlin.IntArray!
+    @test.A public final val f21: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>!
+    @test.A public final val f24: (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)
+    public final val f35: test.G2<kotlin.Int!, kotlin.Array<(out) @test.A kotlin.IntArray!>!>!
+    public final val f4: test.G1<out @test.A test.G0!>!
+    public final val f45: test.G1<out test.G2<in test.G1<(@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!, test.G1<out @test.A kotlin.IntArray!>!>!>!
+    public final val f48: test.G2<out kotlin.Int!, in (@test.A kotlin.Array<kotlin.Array<(out) kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.IntArray!>!>?)>!
+    public final val f52: test.G1<out test.G2<in test.G1<kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!>!>!, test.G1<out (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!>!>!
+}

compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.java

@@ -0,0 +1,117 @@
+package test;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.TYPE_USE)
+@interface A {
+    String value() default "";
+}
+
+interface G0 { }
+interface G1<T> { }
+interface G2<A, B> { }
+
+interface ValueArguments {
+    // simplpe type arguments
+    void f0(G1<@A G0> p);
+    void f1(G1<G1<G1<G1<@A G0>>>> p);
+    void f2(G1<@A String> p);
+    void f3(G2<@A String, G2<@A("abc") Integer, G2<@A("abc") G2<Integer, @A Integer>, @A("abc") Integer>>> p);
+
+    // wildcards
+    void f4(G1<? extends @A G0> p);
+    void f5(G1<G1<G1<G1<? extends @A G0>>>> p);
+    void f6(G1<? extends @A String> p1, G1<G1<G1<G1<? extends @A G0>>>> p2);
+    void f7(G2<? extends @A String, G2<? extends @A("abc") Integer, G2<? extends @A("abc") G2<Integer, ? extends @A Integer>, ? extends @A("abc") Integer>>> p);
+
+    void f8(G1<? super @A G0> p);
+    void f9(G1<G1<G1<G1<? super @A G0>>>> p);
+    void f10(G1<? super @A String> p);
+    void f11(G2<? super @A String, G2<? super @A("abc") Integer, G2<? super @A("abc") G2<Integer, ? super @A Integer>, ? super @A("abc") Integer>>> p);
+
+    void f12(G2<? super @A String, G2<? extends @A("abc") Integer, G2<? extends @A("abc") G2<Integer, ? super @A Integer>, ? extends @A("abc") Integer>>> p);
+
+    // arrays
+    void f13(Integer @A [] p);
+    void f14(int @A [] p);
+    void f15(@A Integer [] p);
+    void f16(@A int [] p);
+    void f17(@A Integer @A [] p);
+    void f18(@A int @A [] p1, Integer @A [] p2, @A int [] p3);
+
+    // multidementional arrays
+    void f19(Integer @A [] [] p);
+    void f20(int @A [] @A [] p);
+    void f21(@A Integer [] [] [] p);
+    void f22(@A int @A [] @A [] [] @A [] p);
+    void f23(@A Integer @A [] [] @A [] [] p);
+    void f24(@A int @A [] @A [] p);
+    void f25(int [] @A [] p);
+    void f26(Object [] @A [] p1, int [] @A [] p2, @A int @A [] @A [] [] @A [] p3);
+    void f27(@A Object [] [] [] [] @A [] p);
+
+    // arrays in type arguments
+    void f28(G1<Integer @A []> p);
+    void f29(G2<Integer, int @A []> p);
+    void f30(G1<@A Integer []> p);
+    void f31(G1<G1<@A int []>> p);
+    void f32(G1<G2<G1<@A Integer @A []>, G1<@A int @A []>>> p);
+    void f33(G1<@A int @A []> p);
+    void f34(G1<Integer [] @A []> p);
+    void f35(G2<Integer, int @A [][]> p1, G1<@A Integer @A [] []> p2, G1<G1<@A int []>> p3);
+    void f36(G1<@A Integer @A [] []> p);
+    void f37(G1<G1<@A int [][][]>> p);
+    void f38(G1<G2<G1<@A Integer @A []>, G1<@A int [] [] @A []>>> p);
+    void f39(G1<@A int @A [] @A [] []> p);
+
+    // arrays in wildcard bounds
+    void f40(G1<? extends Integer @A []> p);
+    void f41(G2<? extends Integer, ? super int @A []> p);
+    void f42(G1<? super @A Integer []> p);
+    void f43(G1<? super G1<? super @A int []>> p);
+    void f44(G1<? extends G2<G1<? super @A Integer @A []>, G1<? extends @A int @A []>>> p);
+    void f45(G1<? extends G2<? super G1<@A Integer @A []>, G1<? extends @A int @A []>>> p);
+    void f46(G1<? super @A int @A []> p);
+    void f47(G1<? extends Integer [] @A []> p);
+    void f48(G2<? extends Integer, ? super int [] [] @A []> p);
+    void f49(G1<? super @A Integer [][][][][]> p1, G1<? super G1<? super @A int @A [][]>> p2, G2<? extends Integer, ? super int [] [] @A []> p3);
+    void f50(G1<? super G1<? super @A int @A [][]>> p);
+    void f51(G1<? extends G2<G1<? super @A Integer [] [] @A []>, G1<? extends @A int @A [] @A [] @A []>>> p);
+    void f52(G1<? extends G2<? super G1<@A Integer @A [][][]>, G1<? extends @A int [] @A []>>> p);
+    void f53(G1<? super @A int @A [][]> p);
+
+    void f54(G1<? extends G2<? super G1<@A Integer @A [][][]>, G1<? extends @A int [] @A []>>> p1, G1<@A int @A [] @A [] []> p2, @A Object [] [] [] [] @A [] p3, @A int @A [] p4, G2<? super @A String, G2<? extends @A("abc") Integer, G2<? extends @A("abc") G2<Integer, ? super @A Integer>, ? extends @A("abc") Integer>>> p5);
+
+    // varargs
+    void f55(@A String ... x);
+    void f56(String @A ... x);
+    void f57(@A String @A ... x);
+    void f58(@A int ... x);
+    void f59(int @A ... x);
+    void f60(@A int @A ... x);
+
+    // varargs + arrays
+    void f61(@A String [] ... x);
+    void f62(String @A [] ... x);
+    void f63(String [] @A ... x);
+    void f64(@A String @A [] @A ... x);
+    void f65(@A int [] ... x);
+    void f66(int @A [] ... x);
+    void f67(int [] @A ... x);
+    void f68(@A int @A [] @A ... x);
+
+    void f69(@A String [] [] ... x);
+    void f70(String [] @A [] ... x);
+    void f71(String [] [] [] @A ... x);
+    void f72(@A String @A [] [] @A [] @A ... x);
+    void f73(@A int [] @A [] ... x);
+    void f74(int @A [][][] @A [] ... x);
+    void f75(int [] [] [] @A ... x);
+    void f76(@A int @A [] [] @A ... x);
+
+    class Test {
+        public Test(G2<? super @A String, G2<? extends @A("abc") Integer, G2<? extends @A("abc") G2<Integer, ? super @A Integer>, ? extends @A("abc") Integer>>> p1, Object [] @A [] p2, int [] @A [] p3, @A int @A [] @A [] [] @A [] p4, @A int @A [] [] @A ... p5) {
+
+        }
+    }
+}

compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.txt

@@ -0,0 +1,85 @@
+package test
+
+public/*package*/ interface ValueArguments {
+    public abstract fun f0(/*0*/ p: test.G1<@test.A test.G0!>!): kotlin.Unit
+    public abstract fun f1(/*0*/ p: test.G1<test.G1<test.G1<test.G1<@test.A test.G0!>!>!>!>!): kotlin.Unit
+    public abstract fun f10(/*0*/ p: test.G1<in @test.A kotlin.String!>!): kotlin.Unit
+    public abstract fun f11(/*0*/ p: test.G2<in @test.A kotlin.String!, test.G2<in @test.A(value = "abc") kotlin.Int!, test.G2<in @test.A(value = "abc") test.G2<kotlin.Int!, in @test.A kotlin.Int!>!, in @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit
+    public abstract fun f12(/*0*/ p: test.G2<in @test.A kotlin.String!, test.G2<out @test.A(value = "abc") kotlin.Int!, test.G2<out @test.A(value = "abc") test.G2<kotlin.Int!, in @test.A kotlin.Int!>!, out @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit
+    public abstract fun f13(/*0*/ p: (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)): kotlin.Unit
+    public abstract fun f14(/*0*/ p: @test.A kotlin.IntArray!): kotlin.Unit
+    public abstract fun f15(/*0*/ @test.A p: kotlin.Array<(out) @test.A kotlin.Int!>!): kotlin.Unit
+    public abstract fun f16(/*0*/ @test.A p: kotlin.IntArray!): kotlin.Unit
+    public abstract fun f17(/*0*/ @test.A p: (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)): kotlin.Unit
+    public abstract fun f18(/*0*/ @test.A p1: @test.A kotlin.IntArray!, /*1*/ p2: (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?), /*2*/ @test.A p3: kotlin.IntArray!): kotlin.Unit
+    public abstract fun f19(/*0*/ p: kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!): kotlin.Unit
+    public abstract fun f2(/*0*/ p: test.G1<@test.A kotlin.String!>!): kotlin.Unit
+    public abstract fun f20(/*0*/ p: (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)): kotlin.Unit
+    public abstract fun f21(/*0*/ @test.A p: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>!): kotlin.Unit
+    public abstract fun f22(/*0*/ @test.A p: (@test.A kotlin.Array<kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)>!>..@test.A kotlin.Array<out kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)>!>?)): kotlin.Unit
+    public abstract fun f23(/*0*/ @test.A p: kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!>..@test.A kotlin.Array<out kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!>?)>!): kotlin.Unit
+    public abstract fun f24(/*0*/ @test.A p: (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)): kotlin.Unit
+    public abstract fun f25(/*0*/ p: (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)): kotlin.Unit
+    public abstract fun f26(/*0*/ p1: (@test.A kotlin.Array<kotlin.Array<(out) kotlin.Any!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Any!>!>?), /*1*/ p2: (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?), /*2*/ @test.A p3: (@test.A kotlin.Array<kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)>!>..@test.A kotlin.Array<out kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)>!>?)): kotlin.Unit
+    public abstract fun f27(/*0*/ @test.A p: (@test.A kotlin.Array<kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Any!>!>!>!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Any!>!>!>!>!>?)): kotlin.Unit
+    public abstract fun f28(/*0*/ p: test.G1<(@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!): kotlin.Unit
+    public abstract fun f29(/*0*/ p: test.G2<kotlin.Int!, @test.A kotlin.IntArray!>!): kotlin.Unit
+    public abstract fun f3(/*0*/ p: test.G2<@test.A kotlin.String!, test.G2<@test.A(value = "abc") kotlin.Int!, test.G2<@test.A(value = "abc") test.G2<kotlin.Int!, @test.A kotlin.Int!>!, @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit
+    public abstract fun f30(/*0*/ p: test.G1<kotlin.Array<(out) @test.A kotlin.Int!>!>!): kotlin.Unit
+    public abstract fun f31(/*0*/ p: test.G1<test.G1<kotlin.IntArray!>!>!): kotlin.Unit
+    public abstract fun f32(/*0*/ p: test.G1<test.G2<test.G1<(@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!, test.G1<@test.A kotlin.IntArray!>!>!>!): kotlin.Unit
+    public abstract fun f33(/*0*/ p: test.G1<@test.A kotlin.IntArray!>!): kotlin.Unit
+    public abstract fun f34(/*0*/ p: test.G1<(@test.A kotlin.Array<kotlin.Array<(out) kotlin.Int!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Int!>!>?)>!): kotlin.Unit
+    public abstract fun f35(/*0*/ p1: test.G2<kotlin.Int!, kotlin.Array<(out) @test.A kotlin.IntArray!>!>!, /*1*/ p2: test.G1<kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!>!, /*2*/ p3: test.G1<test.G1<kotlin.IntArray!>!>!): kotlin.Unit
+    public abstract fun f36(/*0*/ p: test.G1<kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!>!): kotlin.Unit
+    public abstract fun f37(/*0*/ p: test.G1<test.G1<kotlin.Array<(out) kotlin.Array<(out) kotlin.IntArray!>!>!>!>!): kotlin.Unit
+    public abstract fun f38(/*0*/ p: test.G1<test.G2<test.G1<(@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!, test.G1<(@test.A kotlin.Array<kotlin.Array<(out) kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.IntArray!>!>?)>!>!>!): kotlin.Unit
+    public abstract fun f39(/*0*/ p: test.G1<kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)>!>!): kotlin.Unit
+    public abstract fun f4(/*0*/ p: test.G1<out @test.A test.G0!>!): kotlin.Unit
+    public abstract fun f40(/*0*/ p: test.G1<out (@test.A kotlin.Array<kotlin.Int!>..@test.A kotlin.Array<out kotlin.Int!>?)>!): kotlin.Unit
+    public abstract fun f41(/*0*/ p: test.G2<out kotlin.Int!, in @test.A kotlin.IntArray!>!): kotlin.Unit
+    public abstract fun f42(/*0*/ p: test.G1<in kotlin.Array<(out) @test.A kotlin.Int!>!>!): kotlin.Unit
+    public abstract fun f43(/*0*/ p: test.G1<in test.G1<in kotlin.IntArray!>!>!): kotlin.Unit
+    public abstract fun f44(/*0*/ p: test.G1<out test.G2<test.G1<in (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!, test.G1<out @test.A kotlin.IntArray!>!>!>!): kotlin.Unit
+    public abstract fun f45(/*0*/ p: test.G1<out test.G2<in test.G1<(@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!, test.G1<out @test.A kotlin.IntArray!>!>!>!): kotlin.Unit
+    public abstract fun f46(/*0*/ p: test.G1<in @test.A kotlin.IntArray!>!): kotlin.Unit
+    public abstract fun f47(/*0*/ p: test.G1<out (@test.A kotlin.Array<kotlin.Array<(out) kotlin.Int!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Int!>!>?)>!): kotlin.Unit
+    public abstract fun f48(/*0*/ p: test.G2<out kotlin.Int!, in (@test.A kotlin.Array<kotlin.Array<(out) kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.IntArray!>!>?)>!): kotlin.Unit
+    public abstract fun f49(/*0*/ p1: test.G1<in kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>!>!>!>!, /*1*/ p2: test.G1<in test.G1<in kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!, /*2*/ p3: test.G2<out kotlin.Int!, in (@test.A kotlin.Array<kotlin.Array<(out) kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.IntArray!>!>?)>!): kotlin.Unit
+    public abstract fun f5(/*0*/ p: test.G1<test.G1<test.G1<test.G1<out @test.A test.G0!>!>!>!>!): kotlin.Unit
+    public abstract fun f50(/*0*/ p: test.G1<in test.G1<in kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!): kotlin.Unit
+    public abstract fun f51(/*0*/ p: test.G1<out test.G2<test.G1<in (@test.A kotlin.Array<kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>?)>!, test.G1<out (@test.A kotlin.Array<(@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)>..@test.A kotlin.Array<out (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)>?)>!>!>!): kotlin.Unit
+    public abstract fun f52(/*0*/ p: test.G1<out test.G2<in test.G1<kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!>!>!, test.G1<out (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!>!>!): kotlin.Unit
+    public abstract fun f53(/*0*/ p: test.G1<in kotlin.Array<(out) @test.A kotlin.IntArray!>!>!): kotlin.Unit
+    public abstract fun f54(/*0*/ p1: test.G1<out test.G2<in test.G1<kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array<out @test.A kotlin.Int!>?)>!>!>!, test.G1<out (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!>!>!, /*1*/ p2: test.G1<kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)>!>!, /*2*/ @test.A p3: (@test.A kotlin.Array<kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Any!>!>!>!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Any!>!>!>!>!>?), /*3*/ @test.A p4: @test.A kotlin.IntArray!, /*4*/ p5: test.G2<in @test.A kotlin.String!, test.G2<out @test.A(value = "abc") kotlin.Int!, test.G2<out @test.A(value = "abc") test.G2<kotlin.Int!, in @test.A kotlin.Int!>!, out @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit
+    public abstract fun f55(/*0*/ @test.A vararg x: @test.A kotlin.String! /*kotlin.Array<(out) @test.A kotlin.String!>!*/): kotlin.Unit
+    public abstract fun f56(/*0*/ vararg x: kotlin.String! /*(@test.A kotlin.Array<kotlin.String!>..@test.A kotlin.Array<out kotlin.String!>?)*/): kotlin.Unit
+    public abstract fun f57(/*0*/ @test.A vararg x: @test.A kotlin.String! /*(@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array<out @test.A kotlin.String!>?)*/): kotlin.Unit
+    public abstract fun f58(/*0*/ @test.A vararg x: kotlin.Int /*kotlin.IntArray!*/): kotlin.Unit
+    public abstract fun f59(/*0*/ vararg x: kotlin.Int /*@test.A kotlin.IntArray!*/): kotlin.Unit
+    public abstract fun f6(/*0*/ p1: test.G1<out @test.A kotlin.String!>!, /*1*/ p2: test.G1<test.G1<test.G1<test.G1<out @test.A test.G0!>!>!>!>!): kotlin.Unit
+    public abstract fun f60(/*0*/ @test.A vararg x: kotlin.Int /*@test.A kotlin.IntArray!*/): kotlin.Unit
+    public abstract fun f61(/*0*/ @test.A vararg x: kotlin.Array<(out) @test.A kotlin.String!>! /*kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.String!>!>!*/): kotlin.Unit
+    public abstract fun f62(/*0*/ vararg x: (@test.A kotlin.Array<kotlin.String!>..@test.A kotlin.Array<out kotlin.String!>?) /*kotlin.Array<(out) (@test.A kotlin.Array<kotlin.String!>..@test.A kotlin.Array<out kotlin.String!>?)>!*/): kotlin.Unit
+    public abstract fun f63(/*0*/ vararg x: kotlin.Array<(out) kotlin.String!>! /*(@test.A kotlin.Array<kotlin.Array<(out) kotlin.String!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.String!>!>?)*/): kotlin.Unit
+    public abstract fun f64(/*0*/ @test.A vararg x: (@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array<out @test.A kotlin.String!>?) /*(@test.A kotlin.Array<(@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array<out @test.A kotlin.String!>?)>..@test.A kotlin.Array<out (@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array<out @test.A kotlin.String!>?)>?)*/): kotlin.Unit
+    public abstract fun f65(/*0*/ @test.A vararg x: kotlin.IntArray! /*kotlin.Array<(out) kotlin.IntArray!>!*/): kotlin.Unit
+    public abstract fun f66(/*0*/ vararg x: @test.A kotlin.IntArray! /*kotlin.Array<(out) @test.A kotlin.IntArray!>!*/): kotlin.Unit
+    public abstract fun f67(/*0*/ vararg x: kotlin.IntArray! /*(@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)*/): kotlin.Unit
+    public abstract fun f68(/*0*/ @test.A vararg x: @test.A kotlin.IntArray! /*(@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)*/): kotlin.Unit
+    public abstract fun f69(/*0*/ @test.A vararg x: kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.String!>!>! /*kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.String!>!>!>!*/): kotlin.Unit
+    public abstract fun f7(/*0*/ p: test.G2<out @test.A kotlin.String!, test.G2<out @test.A(value = "abc") kotlin.Int!, test.G2<out @test.A(value = "abc") test.G2<kotlin.Int!, out @test.A kotlin.Int!>!, out @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit
+    public abstract fun f70(/*0*/ vararg x: (@test.A kotlin.Array<kotlin.Array<(out) kotlin.String!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.String!>!>?) /*kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Array<(out) kotlin.String!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.String!>!>?)>!*/): kotlin.Unit
+    public abstract fun f71(/*0*/ vararg x: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.String!>!>!>! /*(@test.A kotlin.Array<kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.String!>!>!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.String!>!>!>!>?)*/): kotlin.Unit
+    public abstract fun f72(/*0*/ @test.A vararg x: (@test.A kotlin.Array<kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array<out @test.A kotlin.String!>?)>!>..@test.A kotlin.Array<out kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array<out @test.A kotlin.String!>?)>!>?) /*(@test.A kotlin.Array<(@test.A kotlin.Array<kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array<out @test.A kotlin.String!>?)>!>..@test.A kotlin.Array<out kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array<out @test.A kotlin.String!>?)>!>?)>..@test.A kotlin.Array<out (@test.A kotlin.Array<kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array<out @test.A kotlin.String!>?)>!>..@test.A kotlin.Array<out kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array<out @test.A kotlin.String!>?)>!>?)>?)*/): kotlin.Unit
+    public abstract fun f73(/*0*/ @test.A vararg x: (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?) /*kotlin.Array<(out) (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?)>!*/): kotlin.Unit
+    public abstract fun f74(/*0*/ vararg x: (@test.A kotlin.Array<kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>?) /*kotlin.Array<(out) (@test.A kotlin.Array<kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>?)>!*/): kotlin.Unit
+    public abstract fun f75(/*0*/ vararg x: kotlin.Array<(out) kotlin.Array<(out) kotlin.IntArray!>!>! /*(@test.A kotlin.Array<kotlin.Array<(out) kotlin.Array<(out) kotlin.IntArray!>!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Array<(out) kotlin.IntArray!>!>!>?)*/): kotlin.Unit
+    public abstract fun f76(/*0*/ @test.A vararg x: kotlin.Array<(out) @test.A kotlin.IntArray!>! /*(@test.A kotlin.Array<kotlin.Array<(out) @test.A kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) @test.A kotlin.IntArray!>!>?)*/): kotlin.Unit
+    public abstract fun f8(/*0*/ p: test.G1<in @test.A test.G0!>!): kotlin.Unit
+    public abstract fun f9(/*0*/ p: test.G1<test.G1<test.G1<test.G1<in @test.A test.G0!>!>!>!>!): kotlin.Unit
+
+    public open class Test {
+        public constructor Test(/*0*/ p1: test.G2<in @test.A kotlin.String!, test.G2<out @test.A(value = "abc") kotlin.Int!, test.G2<out @test.A(value = "abc") test.G2<kotlin.Int!, in @test.A kotlin.Int!>!, out @test.A(value = "abc") kotlin.Int!>!>!>!, /*1*/ p2: (@test.A kotlin.Array<kotlin.Array<(out) kotlin.Any!>!>..@test.A kotlin.Array<out kotlin.Array<(out) kotlin.Any!>!>?), /*2*/ p3: (@test.A kotlin.Array<kotlin.IntArray!>..@test.A kotlin.Array<out kotlin.IntArray!>?), /*3*/ @test.A p4: (@test.A kotlin.Array<kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)>!>..@test.A kotlin.Array<out kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array<out @test.A kotlin.IntArray!>?)>!>?), /*4*/ @test.A vararg p5: kotlin.Array<(out) @test.A kotlin.IntArray!>! /*(@test.A kotlin.Array<kotlin.Array<(out) @test.A kotlin.IntArray!>!>..@test.A kotlin.Array<out kotlin.Array<(out) @test.A kotlin.IntArray!>!>?)*/)
+    }
+}

compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8TestGenerated.java

@@ -46,14 +46,70 @@ public class LoadJava8TestGenerated extends AbstractLoadJava8Test {
             runTest("compiler/testData/loadJava8/compiledJava/ParameterNames.java");
         }
 
-        @TestMetadata("TypeAnnotations.java")
-        public void testTypeAnnotations() throws Exception {
-            runTest("compiler/testData/loadJava8/compiledJava/TypeAnnotations.java");
+        @TestMetadata("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class TypeParameterAnnotations extends AbstractLoadJava8Test {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestCompiledJava, this, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInTypeParameterAnnotations() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true);
+            }
+
+            @TestMetadata("Basic.java")
+            public void testBasic() throws Exception {
+                runTest("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java");
+            }
         }
 
-        @TestMetadata("TypeParameterAnnotations.java")
-        public void testTypeParameterAnnotations() throws Exception {
-            runTest("compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java");
+        @TestMetadata("compiler/testData/loadJava8/compiledJava/typeUseAnnotations")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class TypeUseAnnotations extends AbstractLoadJava8Test {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestCompiledJava, this, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInTypeUseAnnotations() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true);
+            }
+
+            @TestMetadata("BaseClassTypeArguments.java")
+            public void testBaseClassTypeArguments() throws Exception {
+                runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java");
+            }
+
+            @TestMetadata("Basic.java")
+            public void testBasic() throws Exception {
+                runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java");
+            }
+
+            @TestMetadata("ClassTypeParameterBounds.java")
+            public void testClassTypeParameterBounds() throws Exception {
+                runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java");
+            }
+
+            @TestMetadata("MethodReceiver.java")
+            public void testMethodReceiver() throws Exception {
+                runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java");
+            }
+
+            @TestMetadata("MethodTypeParameterBounds.java")
+            public void testMethodTypeParameterBounds() throws Exception {
+                runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java");
+            }
+
+            @TestMetadata("ReturnType.java")
+            public void testReturnType() throws Exception {
+                runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java");
+            }
+
+            @TestMetadata("ValueArguments.java")
+            public void testValueArguments() throws Exception {
+                runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java");
+            }
         }
     }
 
@@ -74,14 +130,75 @@ public class LoadJava8TestGenerated extends AbstractLoadJava8Test {
             runTest("compiler/testData/loadJava8/sourceJava/MapRemove.java");
         }
 
-        @TestMetadata("TypeAnnotations.java")
-        public void testTypeAnnotations() throws Exception {
-            runTest("compiler/testData/loadJava8/sourceJava/TypeAnnotations.java");
-        }
-
         @TestMetadata("TypeParameterAnnotations.java")
         public void testTypeParameterAnnotations() throws Exception {
             runTest("compiler/testData/loadJava8/sourceJava/TypeParameterAnnotations.java");
         }
+
+        @TestMetadata("compiler/testData/loadJava8/sourceJava/typeParameterAnnotations")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class TypeParameterAnnotations extends AbstractLoadJava8Test {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestSourceJava, this, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInTypeParameterAnnotations() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/sourceJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true);
+            }
+
+            @TestMetadata("Basic.java")
+            public void testBasic() throws Exception {
+                runTest("compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.java");
+            }
+        }
+
+        @TestMetadata("compiler/testData/loadJava8/sourceJava/typeUseAnnotations")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class TypeUseAnnotations extends AbstractLoadJava8Test {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestSourceJava, this, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInTypeUseAnnotations() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/sourceJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true);
+            }
+
+            @TestMetadata("BaseClassTypeArguments.java")
+            public void testBaseClassTypeArguments() throws Exception {
+                runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.java");
+            }
+
+            @TestMetadata("Basic.java")
+            public void testBasic() throws Exception {
+                runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java");
+            }
+
+            @TestMetadata("ClassTypeParameterBounds.java")
+            public void testClassTypeParameterBounds() throws Exception {
+                runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.java");
+            }
+
+            @TestMetadata("MethodReceiver.java")
+            public void testMethodReceiver() throws Exception {
+                runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.java");
+            }
+
+            @TestMetadata("MethodTypeParameterBounds.java")
+            public void testMethodTypeParameterBounds() throws Exception {
+                runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.java");
+            }
+
+            @TestMetadata("ReturnType.java")
+            public void testReturnType() throws Exception {
+                runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.java");
+            }
+
+            @TestMetadata("ValueArguments.java")
+            public void testValueArguments() throws Exception {
+                runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.java");
+            }
+        }
     }
 }

compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8WithPsiClassReadingTestGenerated.java

@@ -44,13 +44,69 @@ public class LoadJava8WithPsiClassReadingTestGenerated extends AbstractLoadJava8
         runTest("compiler/testData/loadJava8/compiledJava/ParameterNames.java");
     }
 
-    @TestMetadata("TypeAnnotations.java")
-    public void testTypeAnnotations() throws Exception {
-        runTest("compiler/testData/loadJava8/compiledJava/TypeAnnotations.java");
+    @TestMetadata("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class TypeParameterAnnotations extends AbstractLoadJava8WithPsiClassReadingTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestCompiledJava, this, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInTypeParameterAnnotations() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true);
+        }
+
+        @TestMetadata("Basic.java")
+        public void testBasic() throws Exception {
+            runTest("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java");
+        }
     }
 
-    @TestMetadata("TypeParameterAnnotations.java")
-    public void testTypeParameterAnnotations() throws Exception {
-        runTest("compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java");
+    @TestMetadata("compiler/testData/loadJava8/compiledJava/typeUseAnnotations")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class TypeUseAnnotations extends AbstractLoadJava8WithPsiClassReadingTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTestCompiledJava, this, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInTypeUseAnnotations() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true);
+        }
+
+        @TestMetadata("BaseClassTypeArguments.java")
+        public void testBaseClassTypeArguments() throws Exception {
+            runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java");
+        }
+
+        @TestMetadata("Basic.java")
+        public void testBasic() throws Exception {
+            runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java");
+        }
+
+        @TestMetadata("ClassTypeParameterBounds.java")
+        public void testClassTypeParameterBounds() throws Exception {
+            runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java");
+        }
+
+        @TestMetadata("MethodReceiver.java")
+        public void testMethodReceiver() throws Exception {
+            runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java");
+        }
+
+        @TestMetadata("MethodTypeParameterBounds.java")
+        public void testMethodTypeParameterBounds() throws Exception {
+            runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java");
+        }
+
+        @TestMetadata("ReturnType.java")
+        public void testReturnType() throws Exception {
+            runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java");
+        }
+
+        @TestMetadata("ValueArguments.java")
+        public void testValueArguments() throws Exception {
+            runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java");
+        }
     }
 }

compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJava8UsingJavacTestGenerated.java

@@ -46,14 +46,70 @@ public class LoadJava8UsingJavacTestGenerated extends AbstractLoadJava8UsingJava
             runTest("compiler/testData/loadJava8/compiledJava/ParameterNames.java");
         }
 
-        @TestMetadata("TypeAnnotations.java")
-        public void testTypeAnnotations() throws Exception {
-            runTest("compiler/testData/loadJava8/compiledJava/TypeAnnotations.java");
+        @TestMetadata("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class TypeParameterAnnotations extends AbstractLoadJava8UsingJavacTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestCompiledJava, this, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInTypeParameterAnnotations() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true);
+            }
+
+            @TestMetadata("Basic.java")
+            public void testBasic() throws Exception {
+                runTest("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java");
+            }
         }
 
-        @TestMetadata("TypeParameterAnnotations.java")
-        public void testTypeParameterAnnotations() throws Exception {
-            runTest("compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java");
+        @TestMetadata("compiler/testData/loadJava8/compiledJava/typeUseAnnotations")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class TypeUseAnnotations extends AbstractLoadJava8UsingJavacTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestCompiledJava, this, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInTypeUseAnnotations() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true);
+            }
+
+            @TestMetadata("BaseClassTypeArguments.java")
+            public void testBaseClassTypeArguments() throws Exception {
+                runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java");
+            }
+
+            @TestMetadata("Basic.java")
+            public void testBasic() throws Exception {
+                runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java");
+            }
+
+            @TestMetadata("ClassTypeParameterBounds.java")
+            public void testClassTypeParameterBounds() throws Exception {
+                runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java");
+            }
+
+            @TestMetadata("MethodReceiver.java")
+            public void testMethodReceiver() throws Exception {
+                runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java");
+            }
+
+            @TestMetadata("MethodTypeParameterBounds.java")
+            public void testMethodTypeParameterBounds() throws Exception {
+                runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java");
+            }
+
+            @TestMetadata("ReturnType.java")
+            public void testReturnType() throws Exception {
+                runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java");
+            }
+
+            @TestMetadata("ValueArguments.java")
+            public void testValueArguments() throws Exception {
+                runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java");
+            }
         }
     }
 
@@ -74,14 +130,75 @@ public class LoadJava8UsingJavacTestGenerated extends AbstractLoadJava8UsingJava
             runTest("compiler/testData/loadJava8/sourceJava/MapRemove.java");
         }
 
-        @TestMetadata("TypeAnnotations.java")
-        public void testTypeAnnotations() throws Exception {
-            runTest("compiler/testData/loadJava8/sourceJava/TypeAnnotations.java");
-        }
-
         @TestMetadata("TypeParameterAnnotations.java")
         public void testTypeParameterAnnotations() throws Exception {
             runTest("compiler/testData/loadJava8/sourceJava/TypeParameterAnnotations.java");
         }
+
+        @TestMetadata("compiler/testData/loadJava8/sourceJava/typeParameterAnnotations")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class TypeParameterAnnotations extends AbstractLoadJava8UsingJavacTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestSourceJava, this, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInTypeParameterAnnotations() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/sourceJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true);
+            }
+
+            @TestMetadata("Basic.java")
+            public void testBasic() throws Exception {
+                runTest("compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.java");
+            }
+        }
+
+        @TestMetadata("compiler/testData/loadJava8/sourceJava/typeUseAnnotations")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class TypeUseAnnotations extends AbstractLoadJava8UsingJavacTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTestSourceJava, this, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInTypeUseAnnotations() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/sourceJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true);
+            }
+
+            @TestMetadata("BaseClassTypeArguments.java")
+            public void testBaseClassTypeArguments() throws Exception {
+                runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.java");
+            }
+
+            @TestMetadata("Basic.java")
+            public void testBasic() throws Exception {
+                runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java");
+            }
+
+            @TestMetadata("ClassTypeParameterBounds.java")
+            public void testClassTypeParameterBounds() throws Exception {
+                runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.java");
+            }
+
+            @TestMetadata("MethodReceiver.java")
+            public void testMethodReceiver() throws Exception {
+                runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.java");
+            }
+
+            @TestMetadata("MethodTypeParameterBounds.java")
+            public void testMethodTypeParameterBounds() throws Exception {
+                runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.java");
+            }
+
+            @TestMetadata("ReturnType.java")
+            public void testReturnType() throws Exception {
+                runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.java");
+            }
+
+            @TestMetadata("ValueArguments.java")
+            public void testValueArguments() throws Exception {
+                runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.java");
+            }
+        }
     }
 }

core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/structure/javaElements.kt

@@ -29,9 +29,9 @@ interface JavaNamedElement : JavaElement {
 
 interface JavaAnnotationOwner : JavaElement {
     val annotations: Collection<JavaAnnotation>
-    fun findAnnotation(fqName: FqName): JavaAnnotation?
-
     val isDeprecatedInJavaDoc: Boolean
+
+    fun findAnnotation(fqName: FqName): JavaAnnotation?
 }
 
 interface JavaModifierListOwner : JavaElement {
@@ -56,9 +56,17 @@ interface JavaAnnotation : JavaElement {
 
 interface MapBasedJavaAnnotationOwner : JavaAnnotationOwner {
     val annotationsByFqName: Map<FqName?, JavaAnnotation>
+
+    override val isDeprecatedInJavaDoc: Boolean get() = false
     override fun findAnnotation(fqName: FqName) = annotationsByFqName[fqName]
-    override val isDeprecatedInJavaDoc: Boolean
-        get() = false
+}
+
+interface ListBasedJavaAnnotationOwner : JavaAnnotationOwner {
+    override fun findAnnotation(fqName: FqName) = annotations.find { it.classId?.asSingleFqName() == fqName }
+}
+
+interface MutableJavaAnnotationOwner : JavaAnnotationOwner {
+    override val annotations: MutableCollection<JavaAnnotation>
 }
 
 fun JavaAnnotationOwner.buildLazyValueForMap() = lazy {

core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/structure/javaTypes.kt

@@ -18,13 +18,13 @@ package org.jetbrains.kotlin.load.java.structure
 
 import org.jetbrains.kotlin.builtins.PrimitiveType
 
-interface JavaType
+interface JavaType : ListBasedJavaAnnotationOwner
 
 interface JavaArrayType : JavaType {
     val componentType: JavaType
 }
 
-interface JavaClassifierType : JavaType, JavaAnnotationOwner {
+interface JavaClassifierType : JavaType {
     val classifier: JavaClassifier?
     val typeArguments: List<JavaType?>
 

core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/structure/ReflectJavaArrayType.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.descriptors.runtime.structure
 
+import org.jetbrains.kotlin.load.java.structure.JavaAnnotation
 import org.jetbrains.kotlin.load.java.structure.JavaArrayType
 import java.lang.reflect.GenericArrayType
 import java.lang.reflect.Type
@@ -28,4 +29,8 @@ class ReflectJavaArrayType(override val reflectType: Type) : ReflectJavaType(),
             else -> throw IllegalArgumentException("Not an array type (${reflectType::class.java}): $reflectType")
         }
     }
+
+    // TODO: support type use annotations in reflection
+    override val annotations: Collection<JavaAnnotation> = emptyList()
+    override val isDeprecatedInJavaDoc = false
 }

core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/structure/ReflectJavaPrimitiveType.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.descriptors.runtime.structure
 
 import org.jetbrains.kotlin.builtins.PrimitiveType
+import org.jetbrains.kotlin.load.java.structure.JavaAnnotation
 import org.jetbrains.kotlin.load.java.structure.JavaPrimitiveType
 import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType
 
@@ -26,4 +27,8 @@ class ReflectJavaPrimitiveType(override val reflectType: Class<*>) : ReflectJava
             null
         else
             JvmPrimitiveType.get(reflectType.name).primitiveType
+
+    // TODO: support type use annotations in reflection
+    override val annotations: Collection<JavaAnnotation> = emptyList()
+    override val isDeprecatedInJavaDoc = false
 }

core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/structure/ReflectJavaWildcardType.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.descriptors.runtime.structure
 
+import org.jetbrains.kotlin.load.java.structure.JavaAnnotation
 import org.jetbrains.kotlin.load.java.structure.JavaWildcardType
 import java.lang.reflect.WildcardType
 
@@ -36,4 +37,8 @@ class ReflectJavaWildcardType(override val reflectType: WildcardType) : ReflectJ
 
     override val isExtends: Boolean
         get() = reflectType.upperBounds.firstOrNull() != Any::class.java
+
+    // TODO: support type use annotations in reflection
+    override val annotations: Collection<JavaAnnotation> = emptyList()
+    override val isDeprecatedInJavaDoc = false
 }

core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/Jvm8RuntimeDescriptorLoaderTestGenerated.java

@@ -44,13 +44,69 @@ public class Jvm8RuntimeDescriptorLoaderTestGenerated extends AbstractJvm8Runtim
         runTest("compiler/testData/loadJava8/compiledJava/ParameterNames.java");
     }
 
-    @TestMetadata("TypeAnnotations.java")
-    public void testTypeAnnotations() throws Exception {
-        runTest("compiler/testData/loadJava8/compiledJava/TypeAnnotations.java");
+    @TestMetadata("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class TypeParameterAnnotations extends AbstractJvm8RuntimeDescriptorLoaderTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInTypeParameterAnnotations() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true);
+        }
+
+        @TestMetadata("Basic.java")
+        public void testBasic() throws Exception {
+            runTest("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java");
+        }
     }
 
-    @TestMetadata("TypeParameterAnnotations.java")
-    public void testTypeParameterAnnotations() throws Exception {
-        runTest("compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java");
+    @TestMetadata("compiler/testData/loadJava8/compiledJava/typeUseAnnotations")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class TypeUseAnnotations extends AbstractJvm8RuntimeDescriptorLoaderTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInTypeUseAnnotations() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true);
+        }
+
+        @TestMetadata("BaseClassTypeArguments.java")
+        public void testBaseClassTypeArguments() throws Exception {
+            runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java");
+        }
+
+        @TestMetadata("Basic.java")
+        public void testBasic() throws Exception {
+            runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java");
+        }
+
+        @TestMetadata("ClassTypeParameterBounds.java")
+        public void testClassTypeParameterBounds() throws Exception {
+            runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java");
+        }
+
+        @TestMetadata("MethodReceiver.java")
+        public void testMethodReceiver() throws Exception {
+            runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java");
+        }
+
+        @TestMetadata("MethodTypeParameterBounds.java")
+        public void testMethodTypeParameterBounds() throws Exception {
+            runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java");
+        }
+
+        @TestMetadata("ReturnType.java")
+        public void testReturnType() throws Exception {
+            runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java");
+        }
+
+        @TestMetadata("ValueArguments.java")
+        public void testValueArguments() throws Exception {
+            runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java");
+        }
     }
 }