1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
/*
* Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
*/
package kotlinx.coroutines.tools
import org.objectweb.asm.*
import org.objectweb.asm.tree.*
import java.io.*
import java.util.jar.*
fun JarFile.classEntries() = entries().asSequence().filter {
!it.isDirectory && it.name.endsWith(".class") && !it.name.startsWith("META-INF/")
}
fun getBinaryAPI(jar: JarFile, visibilityMap: Map<String, ClassVisibility>): List<ClassBinarySignature> =
getBinaryAPI(jar.classEntries().map { entry -> jar.getInputStream(entry) }, visibilityMap)
fun getBinaryAPI(
classStreams: Sequence<InputStream>,
visibilityMap: Map<String, ClassVisibility>
): List<ClassBinarySignature> =
classStreams.map {
it.use { stream ->
val classNode = ClassNode()
ClassReader(stream).accept(classNode, ClassReader.SKIP_CODE)
classNode
}
}.map {
with(it) {
val classVisibility = visibilityMap[name]
val classAccess = AccessFlags(effectiveAccess and Opcodes.ACC_STATIC.inv())
val supertypes = listOf(superName) - "java/lang/Object" + interfaces.sorted()
val memberSignatures = (
fields.map {
with(it) {
FieldBinarySignature(
name,
desc,
isPublishedApi(),
AccessFlags(access)
)
}
} +
methods.map {
with(it) {
MethodBinarySignature(
name,
desc,
isPublishedApi(),
AccessFlags(access)
)
}
}
).filter {
it.isEffectivelyPublic(classAccess, classVisibility)
}
ClassBinarySignature(
name,
superName,
outerClassName,
supertypes,
memberSignatures,
classAccess,
isEffectivelyPublic(classVisibility),
isFileOrMultipartFacade() || isDefaultImpls()
)
}
}.asIterable().sortedBy { it.name }
fun List<ClassBinarySignature>.filterOutNonPublic(nonPublicPackages: List<String> = emptyList()): List<ClassBinarySignature> {
val nonPublicPaths = nonPublicPackages.map { it.replace('.', '/') + '/' }
val classByName = associateBy { it.name }
fun ClassBinarySignature.isInNonPublicPackage() =
nonPublicPaths.any { name.startsWith(it) }
fun ClassBinarySignature.isPublicAndAccessible(): Boolean =
isEffectivelyPublic &&
(outerName == null || classByName[outerName]?.let { outerClass ->
!(this.access.isProtected && outerClass.access.isFinal)
&& outerClass.isPublicAndAccessible()
} ?: true)
fun supertypes(superName: String) = generateSequence({ classByName[superName] }, { classByName[it.superName] })
fun ClassBinarySignature.flattenNonPublicBases(): ClassBinarySignature {
val nonPublicSupertypes = supertypes(superName).takeWhile { !it.isPublicAndAccessible() }.toList()
if (nonPublicSupertypes.isEmpty())
return this
val inheritedStaticSignatures =
nonPublicSupertypes.flatMap { it.memberSignatures.filter { it.access.isStatic } }
// not covered the case when there is public superclass after chain of private superclasses
return this.copy(
memberSignatures = memberSignatures + inheritedStaticSignatures,
supertypes = supertypes - superName
)
}
return filter { !it.isInNonPublicPackage() && it.isPublicAndAccessible() }
.map { it.flattenNonPublicBases() }
.filterNot { it.isNotUsedWhenEmpty && it.memberSignatures.isEmpty() }
}
fun List<ClassBinarySignature>.dump() = dump(to = System.out)
fun <T : Appendable> List<ClassBinarySignature>.dump(to: T): T = to.apply {
this@dump.forEach {
append(it.signature).appendln(" {")
it.memberSignatures.sortedWith(MEMBER_SORT_ORDER).forEach { append("\t").appendln(it.signature) }
appendln("}\n")
}
}
|
