Support type enhancement for super classes' types

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

@@ -91,6 +91,12 @@ class BinaryJavaClass(
             val translatedPath = BinaryJavaAnnotation.translatePath(typePath)
 
             when (typeReference.sort) {
+                TypeReference.CLASS_EXTENDS -> {
+                    val baseType: JavaType = if (typeReference.superTypeIndex == -1) superclass!! else interfaces[typeReference.superTypeIndex]
+                    val targetType = BinaryJavaAnnotation.computeTargetType(baseType, translatedPath)
+
+                    return BinaryJavaAnnotation.addAnnotation(targetType as JavaPlainType, descriptor, context, signatureParser)
+                }
                 TypeReference.CLASS_TYPE_PARAMETER_BOUND -> {
                     val baseType = computeTypeParameterBound(typeParameters, typeReference)
                     val targetType = BinaryJavaAnnotation.computeTargetType(baseType, translatedPath)

core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt

@@ -208,16 +208,17 @@ class LazyJavaClassDescriptor(
 
             for (javaType in javaTypes) {
                 val kotlinType = c.typeResolver.transformJavaType(javaType, TypeUsage.SUPERTYPE.toAttributes())
-                if (kotlinType.constructor.declarationDescriptor is NotFoundClasses.MockClassDescriptor) {
+                val enhancedKotlinType = c.components.signatureEnhancement.enhanceSuperType(kotlinType, c)
+                if (enhancedKotlinType.constructor.declarationDescriptor is NotFoundClasses.MockClassDescriptor) {
                     incomplete.add(javaType)
                 }
 
-                if (kotlinType.constructor == purelyImplementedSupertype?.constructor) {
+                if (enhancedKotlinType.constructor == purelyImplementedSupertype?.constructor) {
                     continue
                 }
 
-                if (!KotlinBuiltIns.isAnyOrNullableAny(kotlinType)) {
-                    result.add(kotlinType)
+                if (!KotlinBuiltIns.isAnyOrNullableAny(enhancedKotlinType)) {
+                    result.add(enhancedKotlinType)
                 }
             }
 

core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt

@@ -245,6 +245,17 @@ class SignatureEnhancement(
         }
     }
 
+    /*
+     * This method should be only used for type enhancement of base classes' type arguments:
+     *      class A extends B<@NotNull Integer> {}
+     */
+    fun enhanceSuperType(type: KotlinType, context: LazyJavaResolverContext) =
+        SignatureParts(
+            null, type, emptyList(), false, context,
+            AnnotationQualifierApplicabilityType.TYPE_USE,
+            typeParameterBounds = true
+        ).enhance().type
+
     private fun ValueParameterDescriptor.hasDefaultValueInAnnotation(type: KotlinType) =
         when (val defaultValue = getDefaultValueFromAnnotation()) {
             is StringDefaultValue -> type.lexicalCastFrom(defaultValue.value) != null