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
|
// 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.caches.project
import com.intellij.openapi.module.Module
import com.intellij.openapi.module.ModuleManager
import com.intellij.openapi.progress.ProgressManager
import com.intellij.openapi.project.Project
import com.intellij.openapi.projectRoots.Sdk
import com.intellij.openapi.roots.JdkOrderEntry
import com.intellij.openapi.roots.LibraryOrderEntry
import com.intellij.openapi.roots.ModuleRootManager
import com.intellij.openapi.roots.OrderRootType
import com.intellij.openapi.roots.impl.libraries.LibraryEx
import com.intellij.openapi.roots.libraries.Library
import com.intellij.util.containers.MultiMap
import org.jetbrains.kotlin.caches.project.cacheInvalidatingOnRootModifications
import org.jetbrains.kotlin.idea.util.getProjectJdkTableSafe
import org.jetbrains.kotlin.platform.TargetPlatform
import org.jetbrains.kotlin.platform.isCommon
import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus.checkCanceled
import org.jetbrains.kotlin.types.typeUtil.closure
import java.util.concurrent.ConcurrentHashMap
/** null-platform means that we should get all modules */
fun getModuleInfosFromIdeaModel(project: Project, platform: TargetPlatform? = null): List<IdeaModuleInfo> {
val ideaModelInfosCache = getIdeaModelInfosCache(project)
return if (platform != null)
ideaModelInfosCache.forPlatform(platform)
else
ideaModelInfosCache.allModules()
}
fun getIdeaModelInfosCache(project: Project): IdeaModelInfosCache = project.cacheInvalidatingOnRootModifications {
collectModuleInfosFromIdeaModel(project)
}
class IdeaModelInfosCache(
private val moduleSourceInfosByModules: MultiMap<Module, ModuleSourceInfo>,
private val libraryInfosByLibraries: MultiMap<Library, LibraryInfo>,
private val sdkInfosBySdks: Map<Sdk, SdkInfo>,
) {
private val resultByPlatform = ConcurrentHashMap<TargetPlatform, List<IdeaModuleInfo>>()
private val moduleSourceInfos = moduleSourceInfosByModules.values().toList()
private val libraryInfos = libraryInfosByLibraries.values().toList()
private val sdkInfos = sdkInfosBySdks.values.toList()
fun forPlatform(platform: TargetPlatform): List<IdeaModuleInfo> {
return resultByPlatform.getOrPut(platform) {
mergePlatformModules(moduleSourceInfos, platform) + libraryInfos + sdkInfos
}
}
fun allModules(): List<IdeaModuleInfo> = moduleSourceInfos + libraryInfos + sdkInfos
fun getModuleInfosForModule(module: Module): Collection<ModuleSourceInfo> = moduleSourceInfosByModules[module]
fun getLibraryInfosForLibrary(library: Library): Collection<LibraryInfo> = libraryInfosByLibraries[library]
fun getSdkInfoForSdk(sdk: Sdk): SdkInfo? = sdkInfosBySdks[sdk]
}
// Workaround for duplicated libraries, see KT-42607
internal class LibraryWrapper(val library: LibraryEx) {
private val allRootUrls by lazy {
mutableSetOf<String>().apply {
for (orderRootType in OrderRootType.getAllTypes()) {
ProgressManager.checkCanceled()
addAll(library.rootProvider.getUrls(orderRootType))
}
}
}
private val hashCode by lazy {
31 + allRootUrls.hashCode()
}
override fun equals(other: Any?): Boolean {
if (this === other) return true
if (other !is LibraryWrapper) return false
if (allRootUrls != other.allRootUrls) return false
return library.excludedRootUrls.contentEquals(other.library.excludedRootUrls)
}
override fun hashCode(): Int = hashCode
}
internal fun Library.asLibraryEx(): LibraryEx {
require(this is LibraryEx) { "Library '${name}' does not implement LibraryEx which is not expected" }
return this
}
internal fun Library.wrap() = LibraryWrapper(this.asLibraryEx())
private fun collectModuleInfosFromIdeaModel(
project: Project
): IdeaModelInfosCache {
val ideaModules = ModuleManager.getInstance(project).modules.toList()
//TODO: (module refactoring) include libraries that are not among dependencies of any module
val ideaLibraries = ideaModules.flatMap { module ->
ModuleRootManager.getInstance(module).orderEntries.filterIsInstance<LibraryOrderEntry>().map {
it.library?.wrap()
}
}.filterNotNull().toSet()
val sdksFromModulesDependencies = ideaModules.flatMap { module ->
ModuleRootManager.getInstance(module).orderEntries.filterIsInstance<JdkOrderEntry>().map {
it.jdk
}
}
return IdeaModelInfosCache(
moduleSourceInfosByModules = MultiMap.create<Module, ModuleSourceInfo>().also { moduleInfosByModules ->
for (module in ideaModules) {
checkCanceled()
moduleInfosByModules.putValues(module, module.correspondingModuleInfos())
}
},
libraryInfosByLibraries = MultiMap.create<Library, LibraryInfo>().also { libraryInfosByLibraries ->
for (libraryWrapper in ideaLibraries) {
checkCanceled()
libraryInfosByLibraries.putValues(libraryWrapper.library, createLibraryInfo(project, libraryWrapper.library))
}
},
sdkInfosBySdks = (sdksFromModulesDependencies + getAllProjectSdks()).filterNotNull().toSet().associateWith { SdkInfo(project, it) }
)
}
private fun mergePlatformModules(
allModules: List<ModuleSourceInfo>,
platform: TargetPlatform
): List<IdeaModuleInfo> {
if (platform.isCommon()) return allModules
val knownCommonModules = mutableSetOf<ModuleSourceInfo>()
val platformModules = allModules.mapNotNull { module ->
if (module.platform != platform || module.expectedBy.isEmpty() || module in knownCommonModules)
return@mapNotNull null
val commonModules = module.expectedBy
.onEach { commonModule -> knownCommonModules.add(commonModule) }
.closure { it.expectedBy.onEach { commonModule -> knownCommonModules.add(commonModule) } }
.toList()
PlatformModuleInfo(module, commonModules)
}.filter { it.platformModule !in knownCommonModules }
val rest = allModules - platformModules.flatMapTo(mutableSetOf()) { it.containedModules }
return rest + platformModules
}
fun getAllProjectSdks(): Array<Sdk> = getProjectJdkTableSafe().allJdks
|
