Add all interface's class-level annotations to its DefaultImpls class. (#161)

Fixes #155

Author: fzhinkin

src/main/kotlin/api/AsmMetadataLoading.kt

@@ -51,7 +51,9 @@ private const val publishedApiAnnotationName = "kotlin/PublishedApi"
 private fun ClassNode.isPublishedApi() = findAnnotation(publishedApiAnnotationName, includeInvisible = true) != null
 internal fun List<AnnotationNode>.isPublishedApi() = firstOrNull { it.refersToName(publishedApiAnnotationName) } != null
 
-internal fun ClassNode.isDefaultImpls(metadata: KotlinClassMetadata?) = isInner() && name.endsWith("\$DefaultImpls") && metadata.isSyntheticClass()
+internal const val DefaultImplsNameSuffix = "\$DefaultImpls"
+internal fun ClassNode.isDefaultImpls(metadata: KotlinClassMetadata?) =
+    isInner() && name.endsWith(DefaultImplsNameSuffix) && metadata.isSyntheticClass()
 
 internal fun ClassNode.findAnnotation(annotationName: String, includeInvisible: Boolean = false) =
     findAnnotation(annotationName, visibleAnnotations, invisibleAnnotations, includeInvisible)

src/main/kotlin/api/KotlinSignaturesLoading.kt

@@ -63,11 +63,22 @@ public fun Sequence<InputStream>.loadApiFromJvmClasses(visibilityFilter: (String
                 val methodSignatures = methods.map { it.buildMethodSignature(mVisibility, this) }
                     .filter { it.isEffectivelyPublic(classAccess, mVisibility) }
 
+                /**
+                 * For synthetic $DefaultImpls classes copy annotations from the original interface
+                 */
+                val inheritedAnnotations = mutableListOf<AnnotationNode>().apply {
+                    if (classNode.isDefaultImpls(kotlinMetadata)) {
+                        val originalInterface = classNodeMap[classNode.name.dropLast(DefaultImplsNameSuffix.length)]
+                        addAll(originalInterface?.visibleAnnotations.orEmpty())
+                        addAll(originalInterface?.invisibleAnnotations.orEmpty())
+                    }
+                }
+
                 ClassBinarySignature(
                     name, superName, outerClassName, supertypes, fieldSignatures + methodSignatures, classAccess,
                     isEffectivelyPublic(mVisibility),
                     metadata.isFileOrMultipartFacade() || isDefaultImpls(metadata),
-                    annotations(visibleAnnotations, invisibleAnnotations)
+                    annotations(visibleAnnotations, invisibleAnnotations) + inheritedAnnotations
                 )
             }
         }
@@ -182,7 +193,7 @@ public fun List<ClassBinarySignature>.filterOutAnnotated(targetAnnotations: Set<
         }
 
         signature.copy(memberSignatures = notAnnotatedMemberSignatures)
-    }
+    }.filterNot { it.isNotUsedWhenEmpty && it.memberSignatures.isEmpty() }
 }
 
 private fun List<ClassBinarySignature>.filterOutNotAnnotated(

src/test/kotlin/cases/default/default.txt

@@ -15,6 +15,9 @@ public final class cases/default/InterfaceFunctions$DefaultImpls {
 	public static synthetic fun withSomeDefaults$default (Lcases/default/InterfaceFunctions;ILjava/lang/String;ILjava/lang/Object;)V
 }
 
+public abstract interface class cases/default/PublicInterfaceWithAllFunctionsFilteredOut {
+}
+
 public final class cases/default/PublishedApiWithDefaultsKt {
 	public static final fun twoDefaults (ILjava/lang/Object;Ljava/lang/String;)V
 	public static synthetic fun twoDefaults$default (ILjava/lang/Object;Ljava/lang/String;ILjava/lang/Object;)V

src/test/kotlin/cases/default/functions.kt

@@ -21,4 +21,19 @@ interface InterfaceFunctions {
 
     fun withSomeDefaults(par1: Int, par2: String? = null)
 
-}
+}
+
+@PrivateApi
+annotation class PrivateApi
+
+@PrivateApi
+interface PrivateInterfaceWithDefaultMethod {
+    fun foo() {}
+
+    fun bar() {}
+}
+
+interface PublicInterfaceWithAllFunctionsFilteredOut {
+    @PrivateApi
+    fun foo() {}
+}

src/test/kotlin/tests/CasesPublicAPITest.kt

@@ -29,7 +29,7 @@ class CasesPublicAPITest {
 
     @Test fun companions() { snapshotAPIAndCompare(testName.methodName, setOf("cases/companions/PrivateApi")) }
 
-    @Test fun default() { snapshotAPIAndCompare(testName.methodName) }
+    @Test fun default() { snapshotAPIAndCompare(testName.methodName, setOf("cases/default/PrivateApi")) }
 
     @Test fun inline() { snapshotAPIAndCompare(testName.methodName) }