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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
// Copyright 2000-2021 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.jetbrains.kotlin.idea.vfilefinder
import com.intellij.ide.highlighter.JavaClassFileType
import com.intellij.openapi.diagnostic.Logger
import com.intellij.openapi.progress.ProcessCanceledException
import com.intellij.psi.search.GlobalSearchScope
import com.intellij.util.indexing.*
import com.intellij.util.io.IOUtil
import com.intellij.util.io.KeyDescriptor
import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInsPackageFragmentProvider
import org.jetbrains.kotlin.idea.caches.IDEKotlinBinaryClassCache
import org.jetbrains.kotlin.idea.decompiler.builtIns.BuiltInDefinitionFile
import org.jetbrains.kotlin.idea.decompiler.builtIns.KotlinBuiltInFileType
import org.jetbrains.kotlin.idea.decompiler.js.KotlinJavaScriptMetaFileType
import org.jetbrains.kotlin.idea.klib.KlibLoadingMetadataCache
import org.jetbrains.kotlin.idea.klib.KlibMetaFileType
import org.jetbrains.kotlin.library.metadata.KlibMetadataProtoBuf
import org.jetbrains.kotlin.metadata.js.JsProtoBuf
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.serialization.deserialization.MetadataPackageFragment
import org.jetbrains.kotlin.serialization.deserialization.getClassId
import org.jetbrains.kotlin.utils.JsMetadataVersion
import org.jetbrains.lang.manifest.ManifestFileType
import java.io.ByteArrayInputStream
import java.io.DataInput
import java.io.DataOutput
import java.util.*
import java.util.jar.Manifest
abstract class KotlinFileIndexBase<T>(classOfIndex: Class<T>) : ScalarIndexExtension<FqName>() {
val KEY: ID<FqName, Void> = ID.create(classOfIndex.canonicalName)
private val KEY_DESCRIPTOR: KeyDescriptor<FqName> = object : KeyDescriptor<FqName> {
override fun save(output: DataOutput, value: FqName) = IOUtil.writeUTF(output, value.asString())
override fun read(input: DataInput) = FqName(IOUtil.readUTF(input))
override fun getHashCode(value: FqName) = value.asString().hashCode()
override fun isEqual(val1: FqName?, val2: FqName?) = val1 == val2
}
private val LOG = Logger.getInstance(classOfIndex)
override fun getName() = KEY
override fun dependsOnFileContent() = true
override fun getKeyDescriptor() = KEY_DESCRIPTOR
protected fun indexer(f: (FileContent) -> FqName?): DataIndexer<FqName, Void, FileContent> =
DataIndexer {
try {
val fqName = f(it)
if (fqName != null) {
Collections.singletonMap<FqName, Void>(fqName, null)
} else {
emptyMap()
}
} catch (e: ProcessCanceledException) {
throw e
} catch (e: Throwable) {
LOG.warn("Error while indexing file " + it.fileName, e)
emptyMap()
}
}
}
fun <T> KotlinFileIndexBase<T>.hasSomethingInPackage(fqName: FqName, scope: GlobalSearchScope): Boolean =
!FileBasedIndex.getInstance().processValues(name, fqName, null, { _, _ -> false }, scope)
object KotlinClassFileIndex : KotlinFileIndexBase<KotlinClassFileIndex>(KotlinClassFileIndex::class.java) {
override fun getIndexer() = INDEXER
override fun getInputFilter() = DefaultFileTypeSpecificInputFilter(JavaClassFileType.INSTANCE)
override fun getVersion() = VERSION
private const val VERSION = 3
private val INDEXER = indexer { fileContent ->
val headerInfo = IDEKotlinBinaryClassCache.getInstance().getKotlinBinaryClassHeaderData(fileContent.file, fileContent.content)
if (headerInfo != null && headerInfo.metadataVersion.isCompatible()) headerInfo.classId.asSingleFqName() else null
}
}
object KotlinJavaScriptMetaFileIndex : KotlinFileIndexBase<KotlinJavaScriptMetaFileIndex>(KotlinJavaScriptMetaFileIndex::class.java) {
override fun getIndexer() = INDEXER
override fun getInputFilter() = DefaultFileTypeSpecificInputFilter(KotlinJavaScriptMetaFileType)
override fun getVersion() = VERSION
private const val VERSION = 4
private val INDEXER = indexer { fileContent ->
val stream = ByteArrayInputStream(fileContent.content)
if (JsMetadataVersion.readFrom(stream).isCompatible()) {
FqName(JsProtoBuf.Header.parseDelimitedFrom(stream).packageFqName)
} else null
}
}
open class KotlinMetadataFileIndexBase<T>(classOfIndex: Class<T>, indexFunction: (ClassId) -> FqName) :
KotlinFileIndexBase<T>(classOfIndex) {
override fun getIndexer() = INDEXER
override fun getInputFilter() = DefaultFileTypeSpecificInputFilter(KotlinBuiltInFileType)
override fun getVersion() = VERSION
private val VERSION = 1
private val INDEXER = indexer { fileContent ->
if (fileContent.fileType == KotlinBuiltInFileType &&
fileContent.fileName.endsWith(MetadataPackageFragment.DOT_METADATA_FILE_EXTENSION)
) {
val builtins = BuiltInDefinitionFile.read(fileContent.content, fileContent.file)
(builtins as? BuiltInDefinitionFile)?.let { builtinDefFile ->
val proto = builtinDefFile.proto
proto.class_List.singleOrNull()?.let { cls ->
indexFunction(builtinDefFile.nameResolver.getClassId(cls.fqName))
} ?: indexFunction(
ClassId(
builtinDefFile.packageFqName,
Name.identifier(fileContent.fileName.substringBeforeLast(MetadataPackageFragment.DOT_METADATA_FILE_EXTENSION))
)
)
}
} else null
}
}
object KotlinMetadataFileIndex : KotlinMetadataFileIndexBase<KotlinMetadataFileIndex>(
KotlinMetadataFileIndex::class.java, ClassId::asSingleFqName
)
object KotlinMetadataFilePackageIndex : KotlinMetadataFileIndexBase<KotlinMetadataFilePackageIndex>(
KotlinMetadataFilePackageIndex::class.java, ClassId::getPackageFqName
)
object KotlinBuiltInsMetadataIndex : KotlinFileIndexBase<KotlinBuiltInsMetadataIndex>(KotlinBuiltInsMetadataIndex::class.java) {
override fun getIndexer() = INDEXER
override fun getInputFilter() = FileBasedIndex.InputFilter { file -> file.fileType == KotlinBuiltInFileType }
override fun getVersion() = VERSION
private val VERSION = 1
private val INDEXER = indexer { fileContent ->
if (fileContent.fileType == KotlinBuiltInFileType &&
fileContent.fileName.endsWith(JvmBuiltInsPackageFragmentProvider.DOT_BUILTINS_METADATA_FILE_EXTENSION)) {
val builtins = BuiltInDefinitionFile.read(fileContent.content, fileContent.file.parent)
(builtins as? BuiltInDefinitionFile)?.packageFqName
} else null
}
}
object KotlinStdlibIndex : KotlinFileIndexBase<KotlinStdlibIndex>(KotlinStdlibIndex::class.java) {
private const val LIBRARY_NAME_MANIFEST_ATTRIBUTE = "Implementation-Title"
private const val STDLIB_TAG_MANIFEST_ATTRIBUTE = "Kotlin-Runtime-Component"
val KOTLIN_STDLIB_NAME = FqName("kotlin-stdlib")
val KOTLIN_STDLIB_COMMON_NAME = FqName("kotlin-stdlib-common")
val STANDARD_LIBRARY_DEPENDENCY_NAMES = setOf(
KOTLIN_STDLIB_COMMON_NAME,
)
override fun getIndexer() = INDEXER
override fun getInputFilter() = FileBasedIndex.InputFilter { file -> file.fileType is ManifestFileType }
override fun getVersion() = VERSION
private val VERSION = 1
// TODO: refactor [KotlinFileIndexBase] and get rid of FqName here, it's never a proper fully qualified name, just a String wrapper
private val INDEXER = indexer { fileContent ->
if (fileContent.fileType is ManifestFileType) {
val manifest = Manifest(ByteArrayInputStream(fileContent.content))
val attributes = manifest.mainAttributes
attributes.getValue(STDLIB_TAG_MANIFEST_ATTRIBUTE) ?: return@indexer null
val libraryName = attributes.getValue(LIBRARY_NAME_MANIFEST_ATTRIBUTE) ?: return@indexer null
FqName(libraryName)
} else null
}
}
object KlibMetaFileIndex : KotlinFileIndexBase<KlibMetaFileIndex>(KlibMetaFileIndex::class.java) {
override fun getIndexer() = INDEXER
override fun getInputFilter() = DefaultFileTypeSpecificInputFilter(KlibMetaFileType)
override fun getVersion() = VERSION
// This is to express intention to index all Kotlin/Native metadata files irrespectively to file size:
override fun getFileTypesWithSizeLimitNotApplicable() = listOf(KlibMetaFileType)
private const val VERSION = 4
/*todo: check version?!*/
private val INDEXER = indexer { fileContent ->
val fragment = KlibLoadingMetadataCache
.getInstance().getCachedPackageFragment(fileContent.file)
if (fragment != null)
FqName(fragment.getExtension(KlibMetadataProtoBuf.fqName))
else
null
}
}
|
