azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge ResolutionFacadeImpl and KotlinResolveCache, rewrite JavaResolveExtension

Browse Source
This commit is contained in:
Pavel V. Talanov
2015-08-05 12:34:20 +03:00
parent 94431bc3fa
commit d09f4a4dbb
17 changed files with 194 additions and 283 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/container/src/org/jetbrains/kotlin/container/Dsl.kt
+7 -4
View File
@@ -16,8 +16,6 @@
package org.jetbrains.kotlin.container
import kotlin.properties.ReadOnlyProperty
public fun createContainer(id: String, init: StorageComponentContainer.() -> Unit): StorageComponentContainer {
val c = StorageComponentContainer(id)
c.init()
@@ -30,7 +28,12 @@ public inline fun <reified T> StorageComponentContainer.useImpl() {
}
public inline fun <reified T> ComponentProvider.get(): T {
return resolve(javaClass<T>())!!.getValue() as T
return getService(javaClass<T>())
}
@suppress("UNCHECKED_CAST")
public fun <T> ComponentProvider.getService(request: Class<T>): T {
return resolve(request)!!.getValue() as T
}
public fun StorageComponentContainer.useInstance(instance: Any) {
@@ -38,5 +41,5 @@ public fun StorageComponentContainer.useInstance(instance: Any) {
}
public inline fun <reified T> ComponentProvider.get(thisRef: Any?, desc: PropertyMetadata): T {
return resolve(javaClass<T>())!!.getValue() as T
return getService(javaClass<T>())
}
idea/idea-analysis/src/org/jetbrains/kotlin/idea/analysis/AnalyzerUtil.kt
+2 -2
View File
@@ -17,7 +17,7 @@
package org.jetbrains.kotlin.idea.analysis
import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
import org.jetbrains.kotlin.idea.caches.resolve.getService
import org.jetbrains.kotlin.idea.caches.resolve.frontendService
import org.jetbrains.kotlin.psi.JetExpression
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.BindingTrace
@@ -36,7 +36,7 @@ public fun JetExpression.computeTypeInfoInContext(
dataFlowInfo: DataFlowInfo = DataFlowInfo.EMPTY,
expectedType: JetType = TypeUtils.NO_EXPECTED_TYPE
): JetTypeInfo {
return getResolutionFacade().getService<ExpressionTypingServices>(this).getTypeInfo(scope, this, expectedType, dataFlowInfo, trace)
return getResolutionFacade().frontendService<ExpressionTypingServices>(this).getTypeInfo(scope, this, expectedType, dataFlowInfo, trace)
}
jvmOverloads
idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JavaResolveExtension.kt
+6 -23
View File
@@ -16,41 +16,24 @@
package org.jetbrains.kotlin.idea.caches.resolve
import com.intellij.openapi.project.Project
import com.intellij.psi.*
import org.jetbrains.kotlin.container.get
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.incremental.components.NoLookupLocation
import org.jetbrains.kotlin.load.java.sources.JavaSourceElement
import org.jetbrains.kotlin.load.java.structure.*
import org.jetbrains.kotlin.load.java.structure.impl.*
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.BindingTrace
import org.jetbrains.kotlin.resolve.TargetPlatform
import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
import org.jetbrains.kotlin.resolve.scopes.JetScope
public object JavaResolveExtension : CacheExtension<(PsiElement) -> Pair<JavaDescriptorResolver, BindingContext>> {
override val platform: TargetPlatform = JvmPlatform
override fun getData(resolverProvider: ModuleResolverProvider): (PsiElement) -> Pair<JavaDescriptorResolver, BindingContext> {
return {
val componentProvider = resolverProvider.resolverByModule(it.getModuleInfo()).componentProvider
Pair(componentProvider.get<JavaDescriptorResolver>(), componentProvider.get<BindingTrace>().getBindingContext())
}
}
public fun getResolver(project: Project, element: PsiElement): JavaDescriptorResolver =
KotlinCacheService.getInstance(project)[this](element).first
public fun getContext(project: Project, element: PsiElement): BindingContext =
KotlinCacheService.getInstance(project)[this](element).second
private fun PsiElement.getJavaDescriptorResolver(): JavaDescriptorResolver {
@suppress("DEPRECATED_SYMBOL_WITH_MESSAGE")
return KotlinCacheService.getInstance(getProject()).getGlobalFacade(JvmPlatform).frontendService<JavaDescriptorResolver>(this)
}
fun PsiMethod.getJavaMethodDescriptor(): FunctionDescriptor? {
val method = getOriginalElement() as? PsiMethod ?: return null
val resolver = JavaResolveExtension.getResolver(method.getProject(), method)
val resolver = method.getJavaDescriptorResolver()
return when {
method.isConstructor() -> resolver.resolveConstructor(JavaConstructorImpl(method))
else -> resolver.resolveMethod(JavaMethodImpl(method))
@@ -58,11 +41,11 @@ fun PsiMethod.getJavaMethodDescriptor(): FunctionDescriptor? {
}
fun PsiClass.getJavaClassDescriptor(): ClassDescriptor? {
return JavaResolveExtension.getResolver(getProject(), this).resolveClass(JavaClassImpl(this))
return getJavaDescriptorResolver().resolveClass(JavaClassImpl(this))
}
fun PsiField.getJavaFieldDescriptor(): PropertyDescriptor? {
return JavaResolveExtension.getResolver(getProject(), this).resolveField(JavaFieldImpl(this))
return getJavaDescriptorResolver().resolveField(JavaFieldImpl(this))
}
fun PsiMember.getJavaMemberDescriptor(): DeclarationDescriptor? {
idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheService.kt
+54 -55
View File
@@ -24,21 +24,17 @@ import com.intellij.psi.util.CachedValueProvider
import com.intellij.psi.util.CachedValuesManager
import com.intellij.psi.util.PsiModificationTracker
import com.intellij.util.containers.SLRUCache
import org.jetbrains.kotlin.analyzer.AnalysisResult
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.kotlin.analyzer.EmptyResolverForProject
import org.jetbrains.kotlin.idea.project.AnalyzerFacadeProvider
import org.jetbrains.kotlin.idea.project.ResolveElementCache
import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
import org.jetbrains.kotlin.js.resolve.JsPlatform
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.resolve.*
import org.jetbrains.kotlin.psi.JetCodeFragment
import org.jetbrains.kotlin.psi.JetElement
import org.jetbrains.kotlin.psi.JetFile
import org.jetbrains.kotlin.resolve.TargetPlatform
import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
import org.jetbrains.kotlin.resolve.lazy.ResolveSession
import org.jetbrains.kotlin.resolve.scopes.JetScope
import org.jetbrains.kotlin.utils.keysToMap
import kotlin.platform.platformStatic
@@ -50,37 +46,43 @@ public class KotlinCacheService(val project: Project) {
}
public fun getResolutionFacade(elements: List<JetElement>): ResolutionFacade {
return ResolutionFacadeImpl(
project,
getCacheToAnalyzeFiles(elements.map { it.getContainingJetFile() })
)
return getFacadeToAnalyzeFiles(elements.map { it.getContainingJetFile() })
}
private val globalCachesPerPlatform = listOf(JvmPlatform, JsPlatform).keysToMap { platform -> GlobalCache(platform) }
private val globalFacadesPerPlatform = listOf(JvmPlatform, JsPlatform).keysToMap { platform -> GlobalFacade(platform) }
private inner class GlobalCache(platform: TargetPlatform) {
val librariesCache = KotlinResolveCache(project) {
private inner class GlobalFacade(platform: TargetPlatform) {
val facadeForLibraries = ResolutionFacadeImpl(project) {
globalResolveSessionProvider(
project, platform,
project,
platform,
logProcessCanceled = true,
moduleFilter = { it.isLibraryClasses() },
dependencies = listOf(
LibraryModificationTracker.getInstance(project),
ProjectRootModificationTracker.getInstance(project)))
ProjectRootModificationTracker.getInstance(project)
)
)
}
val modulesCache = KotlinResolveCache(project) {
globalResolveSessionProvider(project, platform,
reuseDataFromCache = librariesCache,
moduleFilter = { !it.isLibraryClasses() },
dependencies = listOf(PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT))
val facadeForModules = ResolutionFacadeImpl(project) {
globalResolveSessionProvider(
project,
platform,
reuseDataFrom = facadeForLibraries,
moduleFilter = { !it.isLibraryClasses() },
dependencies = listOf(PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT))
}
}
private fun getGlobalCache(platform: TargetPlatform) = globalCachesPerPlatform[platform]!!.modulesCache
private fun getGlobalLibrariesCache(platform: TargetPlatform) = globalCachesPerPlatform[platform]!!.librariesCache
deprecated("Use JetElement.getResolutionFacade(), please avoid introducing new usages")
public fun getGlobalFacade(platform: TargetPlatform): ResolutionFacade = globalFacade(platform)
private fun createCacheForSyntheticFiles(files: Set<JetFile>): KotlinResolveCache {
private fun globalFacade(platform: TargetPlatform) = globalFacadesPerPlatform[platform]!!.facadeForModules
private fun librariesFacade(platform: TargetPlatform) = globalFacadesPerPlatform[platform]!!.facadeForLibraries
private fun createFacadeForSyntheticFiles(files: Set<JetFile>): ResolutionFacadeImpl {
// we assume that all files come from the same module
val targetPlatform = files.map { TargetPlatformDetector.getPlatform(it) }.toSet().single()
val syntheticFileModule = files.map { it.getModuleInfo() }.toSet().single()
@@ -91,11 +93,12 @@ public class KotlinCacheService(val project: Project) {
return when {
syntheticFileModule is ModuleSourceInfo -> {
val dependentModules = syntheticFileModule.getDependentModules()
KotlinResolveCache(project) {
ResolutionFacadeImpl(project) {
globalResolveSessionProvider(
project, targetPlatform,
project,
targetPlatform,
syntheticFiles = files,
reuseDataFromCache = getGlobalCache(targetPlatform),
reuseDataFrom = globalFacade(targetPlatform),
moduleFilter = { it in dependentModules },
dependencies = dependenciesForSyntheticFileCache
)
@@ -103,11 +106,12 @@ public class KotlinCacheService(val project: Project) {
}
syntheticFileModule is LibrarySourceInfo || syntheticFileModule is NotUnderContentRootModuleInfo -> {
KotlinResolveCache(project) {
ResolutionFacadeImpl(project) {
globalResolveSessionProvider(
project, targetPlatform,
project,
targetPlatform,
syntheticFiles = files,
reuseDataFromCache = getGlobalLibrariesCache(targetPlatform),
reuseDataFrom = librariesFacade(targetPlatform),
moduleFilter = { it == syntheticFileModule },
dependencies = dependenciesForSyntheticFileCache
)
@@ -119,9 +123,10 @@ public class KotlinCacheService(val project: Project) {
// currently the only known scenario is when we cannot determine that file is a library source
// (file under both classes and sources root)
LOG.warn("Creating cache with synthetic files ($files) in classes of library $syntheticFileModule")
KotlinResolveCache(project) {
ResolutionFacadeImpl(project) {
globalResolveSessionProvider(
project, targetPlatform,
project,
targetPlatform,
syntheticFiles = files,
moduleFilter = { true },
dependencies = dependenciesForSyntheticFileCache
@@ -136,14 +141,14 @@ public class KotlinCacheService(val project: Project) {
private val syntheticFileCachesLock = Any()
private val slruCacheProvider = CachedValueProvider {
CachedValueProvider.Result(object : SLRUCache<Set<JetFile>, KotlinResolveCache>(2, 3) {
override fun createValue(files: Set<JetFile>): KotlinResolveCache {
return createCacheForSyntheticFiles(files)
CachedValueProvider.Result(object : SLRUCache<Set<JetFile>, ResolutionFacadeImpl>(2, 3) {
override fun createValue(files: Set<JetFile>): ResolutionFacadeImpl {
return createFacadeForSyntheticFiles(files)
}
}, LibraryModificationTracker.getInstance(project), ProjectRootModificationTracker.getInstance(project))
}
private fun getCacheForSyntheticFiles(files: Set<JetFile>): KotlinResolveCache {
private fun getFacadeForSyntheticFiles(files: Set<JetFile>): ResolutionFacadeImpl {
return synchronized(syntheticFileCachesLock) {
//NOTE: computations inside createCacheForSyntheticFiles depend on project root structure
// so we additionally drop the whole slru cache on change
@@ -153,13 +158,13 @@ public class KotlinCacheService(val project: Project) {
public fun getLazyResolveSession(element: JetElement): ResolveSession {
val file = element.getContainingJetFile()
return getCacheToAnalyzeFiles(listOf(file)).getLazyResolveSession(file)
return getFacadeToAnalyzeFiles(listOf(file)).getLazyResolveSession(file)
}
private fun getCacheToAnalyzeFiles(files: Collection<JetFile>): KotlinResolveCache {
private fun getFacadeToAnalyzeFiles(files: Collection<JetFile>): ResolutionFacadeImpl {
val syntheticFiles = findSyntheticFiles(files)
return if (syntheticFiles.isNotEmpty()) {
getCacheForSyntheticFiles(syntheticFiles)
getFacadeForSyntheticFiles(syntheticFiles)
}
else {
val firstFile = files.firstOrNull()
@@ -167,7 +172,7 @@ public class KotlinCacheService(val project: Project) {
TargetPlatformDetector.getPlatform(firstFile)
else
TargetPlatformDetector.getDefaultPlatform()
getGlobalCache(targetPlatform)
globalFacade(targetPlatform)
}
}
@@ -183,10 +188,6 @@ public class KotlinCacheService(val project: Project) {
?: throw AssertionError("Analyzing kotlin code fragment of type $javaClass with java context of type ${contextElement.javaClass}")
return if (contextFile is JetCodeFragment) contextFile.getContextFile() else contextFile
}
public fun <T> get(extension: CacheExtension<T>): T {
return getGlobalCache(extension.platform)[extension]
}
}
private fun globalResolveSessionProvider(
@@ -194,23 +195,21 @@ private fun globalResolveSessionProvider(
platform: TargetPlatform,
dependencies: Collection<Any>,
moduleFilter: (IdeaModuleInfo) -> Boolean,
reuseDataFromCache: KotlinResolveCache? = null,
reuseDataFrom: ResolutionFacadeImpl? = null,
syntheticFiles: Collection<JetFile> = listOf(),
logProcessCanceled: Boolean = false
): CachedValueProvider.Result<ModuleResolverProvider> {
val analyzerFacade = AnalyzerFacadeProvider.getAnalyzerFacade(platform)
val delegateResolverProvider = reuseDataFromCache?.moduleResolverProvider ?: EmptyModuleResolverProvider
val globalContext = (delegateResolverProvider as? ModuleResolverProviderImpl)
?.globalContext
val delegateResolverProvider = reuseDataFrom?.moduleResolverProvider
val delegateResolverForProject = delegateResolverProvider?.resolverForProject ?: EmptyResolverForProject()
val globalContext = (delegateResolverProvider as? ModuleResolverProviderImpl)?.globalContext
?.withCompositeExceptionTrackerUnderSameLock()
?: GlobalContext(logProcessCanceled)
val moduleResolverProvider = createModuleResolverProvider(
project, globalContext, analyzerFacade, syntheticFiles, delegateResolverProvider, moduleFilter
project, globalContext,
AnalyzerFacadeProvider.getAnalyzerFacade(platform),
syntheticFiles, delegateResolverForProject, moduleFilter
)
val allDependencies = dependencies + listOf(moduleResolverProvider.exceptionTracker)
return CachedValueProvider.Result.create(moduleResolverProvider, allDependencies)
}
idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt
-73
View File
@@ -49,79 +49,6 @@ public interface CacheExtension<T> {
public fun getData(resolverProvider: ModuleResolverProvider): T
}
private class KotlinResolveCache(
val project: Project,
computeModuleResolverProvider: () -> CachedValueProvider.Result<ModuleResolverProvider>
) {
private val resolverCache = SynchronizedCachedValue(project, computeModuleResolverProvider, trackValue = false)
val moduleResolverProvider: ModuleResolverProvider
get() = resolverCache.getValue()
public fun getLazyResolveSession(element: JetElement): ResolveSession {
return moduleResolverProvider.resolverByModule(element.getModuleInfo()).componentProvider.get<ResolveSession>()
}
public fun <T> getService(element: JetElement, serviceClass: Class<T>): T {
//TODO_R:
return moduleResolverProvider.resolverForProject.resolverForModule(element.getModuleInfo()).componentProvider.resolve(serviceClass)?.getValue() as T
}
public fun <T> getService(moduleDescriptor: ModuleDescriptor, serviceClass: Class<T>): T {
//TODO_R:
return moduleResolverProvider.resolverForProject.resolverForModuleDescriptor(moduleDescriptor).componentProvider.resolve(serviceClass)?.getValue() as T
}
public fun <T> getIdeService(element: JetElement, serviceClass: Class<T>): T {
//TODO_R:
return moduleResolverProvider.resolverForProject.resolverForModule(element.getModuleInfo()).componentProvider.create(serviceClass)
}
public fun <T> getIdeService(moduleDescriptor: ModuleDescriptor, serviceClass: Class<T>): T {
//TODO_R:
return moduleResolverProvider.resolverForProject.resolverForModuleDescriptor(moduleDescriptor).componentProvider.create(serviceClass)
}
public fun getLazyResolveSession(moduleDescriptor: ModuleDescriptor): ResolveSession {
return moduleResolverProvider.resolveSessionForBodiesByDescriptor(moduleDescriptor)
}
public fun <T> get(extension: CacheExtension<T>): T {
return extension.getData(moduleResolverProvider)
}
private val analysisResults = CachedValuesManager.getManager(project).createCachedValue(
{
val resolverProvider = moduleResolverProvider
val results = object : SLRUCache<JetFile, PerFileAnalysisCache>(2, 3) {
override fun createValue(file: JetFile?): PerFileAnalysisCache {
return PerFileAnalysisCache(file!!, resolverProvider.resolverByModule(file.getModuleInfo()).componentProvider)
}
}
CachedValueProvider.Result(results, PsiModificationTracker.MODIFICATION_COUNT, resolverProvider.exceptionTracker)
}, false)
fun getAnalysisResultsForElements(elements: Collection<JetElement>): AnalysisResult {
assert(elements.isNotEmpty(), "elements collection should not be empty")
val slruCache = synchronized(analysisResults) {
analysisResults.getValue()!!
}
val results = elements.map {
val perFileCache = synchronized(slruCache) {
slruCache[it.getContainingJetFile()]
}
perFileCache.getAnalysisResults(it)
}
val withError = results.firstOrNull { it.isError() }
val bindingContext = CompositeBindingContext.create(results.map { it.bindingContext })
return if (withError != null)
AnalysisResult.error(bindingContext, withError.error)
else
//TODO: (module refactoring) several elements are passed here in debugger
AnalysisResult.success(bindingContext, getLazyResolveSession(elements.first()).getModuleDescriptor())
}
}
private class PerFileAnalysisCache(val file: JetFile, val componentProvider: ComponentProvider) {
private val cache = HashMap<PsiElement, AnalysisResult>()
idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ModuleDependencyMapper.kt
+8 -34
View File
@@ -21,17 +21,16 @@ import com.intellij.openapi.project.Project
import com.intellij.openapi.roots.JdkOrderEntry
import com.intellij.openapi.roots.LibraryOrderEntry
import com.intellij.openapi.roots.ModuleRootManager
import org.jetbrains.kotlin.analyzer.*
import org.jetbrains.kotlin.container.get
import org.jetbrains.kotlin.analyzer.AnalyzerFacade
import org.jetbrains.kotlin.analyzer.ModuleContent
import org.jetbrains.kotlin.analyzer.ResolverForProject
import org.jetbrains.kotlin.context.GlobalContextImpl
import org.jetbrains.kotlin.context.withProject
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.kotlin.idea.project.IdeaEnvironment
import org.jetbrains.kotlin.load.java.structure.JavaClass
import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
import org.jetbrains.kotlin.psi.JetFile
import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
import org.jetbrains.kotlin.resolve.lazy.ResolveSession
import org.jetbrains.kotlin.storage.ExceptionTracker
fun createModuleResolverProvider(
@@ -39,7 +38,7 @@ fun createModuleResolverProvider(
globalContext: GlobalContextImpl,
analyzerFacade: AnalyzerFacade<JvmPlatformParameters>,
syntheticFiles: Collection<JetFile>,
delegateProvider: ModuleResolverProvider,
delegateResolver: ResolverForProject<IdeaModuleInfo>,
moduleFilter: (IdeaModuleInfo) -> Boolean
): ModuleResolverProvider {
@@ -64,7 +63,7 @@ fun createModuleResolverProvider(
val resolverForProject = analyzerFacade.setupResolverForProject(
globalContext.withProject(project), modulesToCreateResolversFor, modulesContent,
jvmPlatformParameters, IdeaEnvironment, delegateProvider.resolverForProject
jvmPlatformParameters, IdeaEnvironment, delegateResolver
)
return resolverForProject
}
@@ -73,8 +72,7 @@ fun createModuleResolverProvider(
return ModuleResolverProviderImpl(
resolverForProject,
globalContext,
delegateProvider
globalContext
)
}
@@ -105,36 +103,12 @@ private fun collectAllModuleInfosFromIdeaModel(project: Project): List<IdeaModul
interface ModuleResolverProvider {
val exceptionTracker: ExceptionTracker
fun resolverByModule(module: IdeaModuleInfo): ResolverForModule = resolverForProject.resolverForModule(module)
fun resolveSessionForBodiesByModule(module: IdeaModuleInfo): ResolveSession {
return resolveSessionForBodiesByDescriptor(resolverForProject.descriptorForModule(module))
}
fun resolveSessionForBodiesByDescriptor(descriptor: ModuleDescriptor): ResolveSession
val resolverForProject: ResolverForProject<IdeaModuleInfo>
}
object EmptyModuleResolverProvider: ModuleResolverProvider {
override val exceptionTracker: ExceptionTracker
get() = throw IllegalStateException("Should not be called")
override val resolverForProject: ResolverForProject<IdeaModuleInfo> = EmptyResolverForProject()
override fun resolveSessionForBodiesByDescriptor(descriptor: ModuleDescriptor): ResolveSession {
throw IllegalStateException("Trying to obtain resolve session for $descriptor not present in this resolver")
}
}
class ModuleResolverProviderImpl(
override val resolverForProject: ResolverForProject<IdeaModuleInfo>,
val globalContext: GlobalContextImpl,
val delegateProvider: ModuleResolverProvider = EmptyModuleResolverProvider
): ModuleResolverProvider {
val globalContext: GlobalContextImpl
) : ModuleResolverProvider {
override val exceptionTracker: ExceptionTracker = globalContext.exceptionTracker
override fun resolveSessionForBodiesByDescriptor(descriptor: ModuleDescriptor): ResolveSession {
return resolverForProject.resolverForModuleDescriptor(descriptor).componentProvider.get<ResolveSession>()
}
}
idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ResolutionFacade.kt
+6 -5
View File
@@ -16,6 +16,7 @@
package org.jetbrains.kotlin.idea.caches.resolve
import com.intellij.psi.PsiElement
import com.intellij.psi.search.GlobalSearchScope
import org.jetbrains.kotlin.analyzer.AnalysisResult
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
@@ -44,11 +45,11 @@ public interface ResolutionFacade {
public fun <T> get(extension: CacheExtension<T>): T
public fun <T> getFrontendService(element: JetElement, serviceClass: Class<T>): T
public fun <T> getFrontendService(element: PsiElement, serviceClass: Class<T>): T
public fun <T> getFrontendService(moduleDescriptor: ModuleDescriptor, serviceClass: Class<T>): T
public fun <T> getIdeService(element: JetElement, serviceClass: Class<T>): T
public fun <T> getIdeService(element: PsiElement, serviceClass: Class<T>): T
public fun <T> getIdeService(moduleDescriptor: ModuleDescriptor, serviceClass: Class<T>): T
@@ -65,13 +66,13 @@ public interface ResolutionFacade {
}
}
public inline fun <reified T> ResolutionFacade.getService(element: JetElement): T
public inline fun <reified T> ResolutionFacade.frontendService(element: PsiElement): T
= this.getFrontendService(element, javaClass<T>())
public inline fun <reified T> ResolutionFacade.getService(moduleDescriptor: ModuleDescriptor): T
public inline fun <reified T> ResolutionFacade.frontendService(moduleDescriptor: ModuleDescriptor): T
= this.getFrontendService(moduleDescriptor, javaClass<T>())
public inline fun <reified T> ResolutionFacade.ideService(element: JetElement): T
public inline fun <reified T> ResolutionFacade.ideService(element: PsiElement): T
= this.getIdeService(element, javaClass<T>())
public inline fun <reified T> ResolutionFacade.ideService(moduleDescriptor: ModuleDescriptor): T
idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ResolutionFacadeImpl.kt
+73 -24
View File
@@ -17,7 +17,14 @@
package org.jetbrains.kotlin.idea.caches.resolve
import com.intellij.openapi.project.Project
import com.intellij.psi.PsiElement
import com.intellij.psi.util.CachedValueProvider
import com.intellij.psi.util.CachedValuesManager
import com.intellij.psi.util.PsiModificationTracker
import com.intellij.util.containers.SLRUCache
import org.jetbrains.kotlin.analyzer.AnalysisResult
import org.jetbrains.kotlin.container.get
import org.jetbrains.kotlin.container.getService
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.kotlin.idea.project.ResolveElementCache
@@ -26,59 +33,101 @@ import org.jetbrains.kotlin.psi.JetDeclaration
import org.jetbrains.kotlin.psi.JetElement
import org.jetbrains.kotlin.psi.JetFile
import org.jetbrains.kotlin.psi.JetPsiFactory
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.BindingTraceContext
import org.jetbrains.kotlin.resolve.ImportPath
import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver
import org.jetbrains.kotlin.resolve.*
import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
import org.jetbrains.kotlin.resolve.lazy.ResolveSession
import org.jetbrains.kotlin.resolve.scopes.JetScope
private class ResolutionFacadeImpl(private val project: Project, private val cache: KotlinResolveCache) : ResolutionFacade {
override fun <T> getIdeService(element: JetElement, serviceClass: Class<T>): T {
return cache.getIdeService(element, serviceClass)
private class ResolutionFacadeImpl(
private val project: Project,
computeModuleResolverProvider: () -> CachedValueProvider.Result<ModuleResolverProvider>
) : ResolutionFacade {
override fun <T> get(extension: CacheExtension<T>): T = error("TODO: support")
private val resolverCache = SynchronizedCachedValue(project, computeModuleResolverProvider, trackValue = false)
val moduleResolverProvider: ModuleResolverProvider
get() = resolverCache.getValue()
public fun getLazyResolveSession(element: JetElement): ResolveSession {
return resolverForModuleInfo(element.getModuleInfo()).componentProvider.get<ResolveSession>()
}
private fun resolverForModuleInfo(moduleInfo: IdeaModuleInfo) = moduleResolverProvider.resolverForProject.resolverForModule(moduleInfo)
private fun resolverForDescriptor(moduleDescriptor: ModuleDescriptor) = moduleResolverProvider.resolverForProject.resolverForModuleDescriptor(moduleDescriptor)
override fun <T> getFrontendService(element: PsiElement, serviceClass: Class<T>): T {
return resolverForModuleInfo(element.getModuleInfo()).componentProvider.getService(serviceClass)
}
override fun <T> getFrontendService(moduleDescriptor: ModuleDescriptor, serviceClass: Class<T>): T {
return resolverForDescriptor(moduleDescriptor).componentProvider.getService(serviceClass)
}
override fun <T> getIdeService(element: PsiElement, serviceClass: Class<T>): T {
return resolverForModuleInfo(element.getModuleInfo()).componentProvider.create(serviceClass)
}
override fun <T> getIdeService(moduleDescriptor: ModuleDescriptor, serviceClass: Class<T>): T {
return cache.getIdeService(moduleDescriptor, serviceClass)
return resolverForDescriptor(moduleDescriptor).componentProvider.create(serviceClass)
}
override fun analyze(element: JetElement, bodyResolveMode: BodyResolveMode): BindingContext {
val resolveElementCache = cache.getService(element, javaClass<ResolveElementCache>())
val resolveElementCache = getFrontendService(element, javaClass<ResolveElementCache>())
return resolveElementCache.resolveToElement(element, bodyResolveMode)
}
override fun findModuleDescriptor(element: JetElement): ModuleDescriptor {
return cache.getLazyResolveSession(element).getModuleDescriptor()
return moduleResolverProvider.resolverForProject.descriptorForModule(element.getModuleInfo())
}
override fun resolveToDescriptor(declaration: JetDeclaration): DeclarationDescriptor {
return cache.getLazyResolveSession(declaration).resolveToDescriptor(declaration)
return getLazyResolveSession(declaration).resolveToDescriptor(declaration)
}
override fun analyzeFullyAndGetResult(elements: Collection<JetElement>): AnalysisResult {
return cache.getAnalysisResultsForElements(elements)
return getAnalysisResultsForElements(elements)
}
override fun getFileTopLevelScope(file: JetFile): JetScope {
return cache.getLazyResolveSession(file).getFileScopeProvider().getFileScope(file)
}
override fun <T> getFrontendService(element: JetElement, serviceClass: Class<T>): T {
return cache.getService(element, serviceClass)
}
override fun <T> getFrontendService(moduleDescriptor: ModuleDescriptor, serviceClass: Class<T>): T {
return cache.getService(moduleDescriptor, serviceClass)
return getLazyResolveSession(file).getFileScopeProvider().getFileScope(file)
}
override fun resolveImportReference(moduleDescriptor: ModuleDescriptor, fqName: FqName): Collection<DeclarationDescriptor> {
val importDirective = JetPsiFactory(project).createImportDirective(ImportPath(fqName, false))
val qualifiedExpressionResolver = this.getService<QualifiedExpressionResolver>(moduleDescriptor)
val qualifiedExpressionResolver = this.frontendService<QualifiedExpressionResolver>(moduleDescriptor)
return qualifiedExpressionResolver.processImportReference(
importDirective, moduleDescriptor, BindingTraceContext(), QualifiedExpressionResolver.LookupMode.EVERYTHING).getAllDescriptors()
}
override fun <T> get(extension: CacheExtension<T>): T {
return cache[extension]
private val analysisResults = CachedValuesManager.getManager(project).createCachedValue(
{
val resolverProvider = moduleResolverProvider
val results = object : SLRUCache<JetFile, PerFileAnalysisCache>(2, 3) {
override fun createValue(file: JetFile?): PerFileAnalysisCache {
return PerFileAnalysisCache(file!!, resolverProvider.resolverForProject.resolverForModule(file.getModuleInfo()).componentProvider)
}
}
CachedValueProvider.Result(results, PsiModificationTracker.MODIFICATION_COUNT, resolverProvider.exceptionTracker)
}, false)
fun getAnalysisResultsForElements(elements: Collection<JetElement>): AnalysisResult {
assert(elements.isNotEmpty(), "elements collection should not be empty")
val slruCache = synchronized(analysisResults) {
analysisResults.getValue()!!
}
val results = elements.map {
val perFileCache = synchronized(slruCache) {
slruCache[it.getContainingJetFile()]
}
perFileCache.getAnalysisResults(it)
}
val withError = results.firstOrNull { it.isError() }
val bindingContext = CompositeBindingContext.create(results.map { it.bindingContext })
return if (withError != null)
AnalysisResult.error(bindingContext, withError.error)
else
//TODO: (module refactoring) several elements are passed here in debugger
AnalysisResult.success(bindingContext, getLazyResolveSession(elements.first()).getModuleDescriptor())
}
}
idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionSession.kt
+3 -3
View File
@@ -28,8 +28,8 @@ import com.intellij.psi.search.DelegatingGlobalSearchScope
import com.intellij.psi.search.GlobalSearchScope
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade
import org.jetbrains.kotlin.idea.caches.resolve.frontendService
import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
import org.jetbrains.kotlin.idea.caches.resolve.getService
import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
import org.jetbrains.kotlin.idea.codeInsight.ReferenceVariantsHelper
import org.jetbrains.kotlin.idea.core.KotlinIndicesHelper
@@ -46,8 +46,8 @@ import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
import org.jetbrains.kotlin.psi.psiUtil.prevLeaf
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.bindingContextUtil.getDataFlowInfo
import org.jetbrains.kotlin.resolve.calls.smartcasts.SmartCastManager
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory
import org.jetbrains.kotlin.resolve.calls.smartcasts.SmartCastManager
import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
@@ -147,7 +147,7 @@ abstract class CompletionSession(protected val configuration: CompletionSessionC
var receiverTypes = receiversData.receivers.flatMap { receiverValue ->
val dataFlowValue = DataFlowValueFactory.createDataFlowValue(receiverValue, bindingContext, moduleDescriptor)
if (dataFlowValue.isPredictable) { // we don't include smart cast receiver types for "unpredictable" receiver value to mark members grayed
resolutionFacade.getService<SmartCastManager>(file)
resolutionFacade.frontendService<SmartCastManager>(file)
.getSmartCastVariantsWithLessSpecificExcluded(receiverValue, bindingContext, moduleDescriptor, dataFlowInfo)
}
else {
idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt
+3 -3
View File
@@ -20,11 +20,11 @@ import com.intellij.openapi.util.text.StringUtil
import org.jetbrains.kotlin.builtins.KotlinBuiltIns
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade
import org.jetbrains.kotlin.idea.caches.resolve.getService
import org.jetbrains.kotlin.idea.caches.resolve.frontendService
import org.jetbrains.kotlin.idea.caches.resolve.ideService
import org.jetbrains.kotlin.idea.completion.smart.TypesWithContainsDetector
import org.jetbrains.kotlin.idea.core.IterableTypesDetection
import org.jetbrains.kotlin.idea.core.IterableTypesDetector
import org.jetbrains.kotlin.idea.caches.resolve.ideService
import org.jetbrains.kotlin.idea.core.mapArgumentsToParameters
import org.jetbrains.kotlin.idea.util.FuzzyType
import org.jetbrains.kotlin.idea.util.fuzzyReturnType
@@ -247,7 +247,7 @@ class ExpectedInfos(
ContextDependency.INDEPENDENT, CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS,
CallChecker.DoNothing, false)
val callResolutionContext = context.replaceCollectAllCandidates(true)
val callResolver = resolutionFacade.getService<CallResolver>(moduleDescriptor)
val callResolver = resolutionFacade.frontendService<CallResolver>(moduleDescriptor)
val results: OverloadResolutionResults<FunctionDescriptor> = callResolver.resolveFunctionCall(callResolutionContext)
val expectedInfos = LinkedHashSet<ExpectedInfo>()
idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/HeuristicSignatures.kt
+5 -3
View File
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
import org.jetbrains.kotlin.descriptors.impl.SubpackagesScope
import org.jetbrains.kotlin.frontend.di.createContainerForMacros
import org.jetbrains.kotlin.incremental.components.LookupLocation
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.JetPsiFactory
@@ -31,8 +31,10 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils
import org.jetbrains.kotlin.resolve.TypeResolver
import org.jetbrains.kotlin.resolve.scopes.ChainedScope
import org.jetbrains.kotlin.resolve.scopes.JetScope
import org.jetbrains.kotlin.incremental.components.LookupLocation
import org.jetbrains.kotlin.types.*
import org.jetbrains.kotlin.types.IndexedParametersSubstitution
import org.jetbrains.kotlin.types.JetType
import org.jetbrains.kotlin.types.SubstitutionUtils
import org.jetbrains.kotlin.types.Variance
import java.util.HashMap
public class HeuristicSignatures(
idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinIndicesHelper.kt
+2 -2
View File
@@ -24,7 +24,7 @@ import com.intellij.psi.stubs.StringStubIndexExtension
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade
import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
import org.jetbrains.kotlin.idea.caches.resolve.getService
import org.jetbrains.kotlin.idea.caches.resolve.frontendService
import org.jetbrains.kotlin.idea.codeInsight.ReferenceVariantsHelper
import org.jetbrains.kotlin.idea.imports.importableFqName
import org.jetbrains.kotlin.idea.stubindex.*
@@ -115,7 +115,7 @@ public class KotlinIndicesHelper(
private fun possibleReceiverTypeNames(receiverValues: Collection<ReceiverValue>, dataFlowInfo: DataFlowInfo, bindingContext: BindingContext): Set<String> {
val result = HashSet<String>()
for (receiverValue in receiverValues) {
val smartCastManager = resolutionFacade.getService<SmartCastManager>(moduleDescriptor)
val smartCastManager = resolutionFacade.frontendService<SmartCastManager>(moduleDescriptor)
for (type in smartCastManager.getSmartCastVariants(receiverValue, bindingContext, moduleDescriptor, dataFlowInfo)) {
result.addTypeNames(type)
}
idea/idea-core/src/org/jetbrains/kotlin/idea/core/psiClassToDescriptor.kt
+10 -9
View File
@@ -16,25 +16,26 @@
package org.jetbrains.kotlin.idea.core
import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade
import com.intellij.psi.PsiClass
import org.jetbrains.kotlin.psi.JetClassOrObject
import org.jetbrains.kotlin.asJava.KotlinLightClass
import org.jetbrains.kotlin.idea.caches.resolve.KotlinLightClassForDecompiledDeclaration
import org.jetbrains.kotlin.idea.caches.resolve.JavaResolveExtension
import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
import org.jetbrains.kotlin.idea.caches.resolve.KotlinLightClassForDecompiledDeclaration
import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade
import org.jetbrains.kotlin.idea.caches.resolve.frontendService
import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
import org.jetbrains.kotlin.psi.JetClassOrObject
import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
public fun ResolutionFacade.psiClassToDescriptor(
psiClass: PsiClass,
declarationTranslator: (JetClassOrObject) -> JetClassOrObject? = { it }
): ClassifierDescriptor? {
return if (psiClass is KotlinLightClass && psiClass !is KotlinLightClassForDecompiledDeclaration) {
val origin = psiClass.getOrigin ()?: return null
val origin = psiClass.getOrigin () ?: return null
val declaration = declarationTranslator(origin) ?: return null
resolveToDescriptor(declaration)
} else {
get(JavaResolveExtension)(psiClass).first.resolveClass(JavaClassImpl(psiClass))
}
else {
frontendService<JavaDescriptorResolver>(psiClass).resolveClass(JavaClassImpl(psiClass))
} as? ClassifierDescriptor
}
idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt
+4 -5
View File
@@ -57,8 +57,8 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticSink
import org.jetbrains.kotlin.diagnostics.Severity
import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
import org.jetbrains.kotlin.idea.JetLanguage
import org.jetbrains.kotlin.idea.caches.resolve.JavaResolveExtension
import org.jetbrains.kotlin.idea.caches.resolve.KotlinCacheService
import org.jetbrains.kotlin.idea.caches.resolve.getJavaClassDescriptor
import org.jetbrains.kotlin.idea.debugger.evaluate.KotlinEvaluateExpressionCache.CompiledDataDescriptor
import org.jetbrains.kotlin.idea.debugger.evaluate.KotlinEvaluateExpressionCache.ParametersDescriptor
import org.jetbrains.kotlin.idea.debugger.evaluate.compilingEvaluator.loadClasses
@@ -67,7 +67,6 @@ import org.jetbrains.kotlin.idea.util.DebuggerUtils
import org.jetbrains.kotlin.idea.util.application.runReadAction
import org.jetbrains.kotlin.idea.util.attachment.attachmentByPsiFile
import org.jetbrains.kotlin.idea.util.attachment.mergeAttachments
import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
import org.jetbrains.kotlin.load.kotlin.PackageClassUtils
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
@@ -82,7 +81,8 @@ import org.jetbrains.kotlin.types.Flexibility
import org.jetbrains.org.objectweb.asm.*
import org.jetbrains.org.objectweb.asm.Opcodes.ASM5
import org.jetbrains.org.objectweb.asm.tree.MethodNode
import java.util.*
import java.util.Collections
import java.util.HashMap
private val RECEIVER_NAME = "\$receiver"
private val THIS_NAME = "this"
@@ -540,8 +540,7 @@ fun Type.getClassDescriptor(project: Project): ClassDescriptor? {
val classes = JavaPsiFacade.getInstance(project).findClasses(jvmName.asString(), GlobalSearchScope.allScope(project))
if (classes.isEmpty()) null
else {
val clazz = classes.first()
JavaResolveExtension.getResolver(project, clazz).resolveClass(JavaClassImpl(clazz))
classes.first().getJavaClassDescriptor()
}
}
}
idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeArgumentsIntention.kt
+2 -5
View File
@@ -18,11 +18,8 @@ package org.jetbrains.kotlin.idea.intentions
import com.intellij.codeInspection.ProblemHighlightType
import com.intellij.openapi.editor.Editor
import org.jetbrains.kotlin.frontend.di.createContainerForMacros
import org.jetbrains.kotlin.idea.caches.resolve.analyze
import org.jetbrains.kotlin.idea.caches.resolve.findModuleDescriptor
import org.jetbrains.kotlin.idea.caches.resolve.frontendService
import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
import org.jetbrains.kotlin.idea.caches.resolve.getService
import org.jetbrains.kotlin.idea.inspections.IntentionBasedInspection
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.resolve.BindingContext
@@ -72,7 +69,7 @@ public class RemoveExplicitTypeArgumentsIntention : JetSelfTargetingOffsetIndepe
TypeUtils.NO_EXPECTED_TYPE
}
val dataFlow = context.getDataFlowInfo(callExpression)
val callResolver = resolutionFacade.getService<CallResolver>(callExpression)
val callResolver = resolutionFacade.frontendService<CallResolver>(callExpression)
val resolutionResults = callResolver.resolveFunctionCall(
BindingTraceContext(), scope, untypedCall, expectedType, dataFlow, false)
if (!resolutionResults.isSingleResult()) {
idea/src/org/jetbrains/kotlin/idea/ktSignature/KotlinSignatureAnnotationIntention.java
+1 -2
View File
@@ -40,7 +40,6 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
import org.jetbrains.kotlin.descriptors.VariableDescriptor;
import org.jetbrains.kotlin.idea.JetBundle;
import org.jetbrains.kotlin.idea.JetIcons;
import org.jetbrains.kotlin.idea.caches.resolve.JavaResolveExtension;
import org.jetbrains.kotlin.idea.caches.resolve.ResolvePackage;
import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers;
import org.jetbrains.kotlin.load.java.structure.impl.JavaConstructorImpl;
@@ -160,7 +159,7 @@ public class KotlinSignatureAnnotationIntention extends BaseIntentionAction impl
private static String getDefaultSignature(@NotNull Project project, @NotNull PsiMember element) {
PsiMember analyzableAnnotationOwner = KotlinSignatureUtil.getAnalyzableAnnotationOwner(element);
assert analyzableAnnotationOwner != null;
JavaDescriptorResolver javaDescriptorResolver = JavaResolveExtension.INSTANCE$.getResolver(project, analyzableAnnotationOwner);
JavaDescriptorResolver javaDescriptorResolver = ResolvePackage.getJavaDescriptorResolver(analyzableAnnotationOwner);
if (analyzableAnnotationOwner instanceof PsiMethod) {
PsiMethod psiMethod = (PsiMethod) analyzableAnnotationOwner;
idea/src/org/jetbrains/kotlin/idea/ktSignature/KotlinSignatureInJavaMarkerProvider.java
+8 -31
View File
@@ -39,15 +39,13 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
import org.jetbrains.kotlin.idea.JetIcons;
import org.jetbrains.kotlin.idea.caches.resolve.JavaResolveExtension;
import org.jetbrains.kotlin.idea.caches.resolve.KotlinCacheService;
import org.jetbrains.kotlin.idea.caches.resolve.ResolvePackage;
import org.jetbrains.kotlin.idea.project.ProjectStructureUtil;
import org.jetbrains.kotlin.load.java.JavaBindingContext;
import org.jetbrains.kotlin.load.java.structure.impl.JavaConstructorImpl;
import org.jetbrains.kotlin.load.java.structure.impl.JavaFieldImpl;
import org.jetbrains.kotlin.load.java.structure.impl.JavaMethodImpl;
import org.jetbrains.kotlin.resolve.BindingContext;
import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver;
import org.jetbrains.kotlin.resolve.BindingTrace;
import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
import java.awt.event.MouseEvent;
import java.util.Collection;
@@ -114,18 +112,17 @@ public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider {
private static void markElement(@NotNull PsiElement element, @NotNull Collection<LineMarkerInfo> result) {
Project project = element.getProject();
PsiModifierListOwner annotationOwner = KotlinSignatureUtil.getAnalyzableAnnotationOwner(element);
if (annotationOwner == null) {
if (!(annotationOwner instanceof PsiMember)) {
return;
}
JavaResolveExtension resolveExtension = JavaResolveExtension.INSTANCE$;
BindingContext bindingContext = resolveExtension.getContext(project, annotationOwner);
JavaDescriptorResolver javaDescriptorResolver = resolveExtension.getResolver(project, annotationOwner);
DeclarationDescriptor memberDescriptor = getDescriptorForMember(javaDescriptorResolver, annotationOwner);
DeclarationDescriptor memberDescriptor = ResolvePackage.getJavaMemberDescriptor((PsiMember) annotationOwner);
if (memberDescriptor == null) return;
BindingContext bindingContext = KotlinCacheService.getInstance(project).getGlobalFacade(JvmPlatform.INSTANCE$)
.getFrontendService(annotationOwner, BindingTrace.class).getBindingContext();
List<String> errors = bindingContext.get(JavaBindingContext.LOAD_FROM_JAVA_SIGNATURE_ERRORS, memberDescriptor);
boolean hasSignatureAnnotation = KotlinSignatureUtil.findKotlinSignatureAnnotation(annotationOwner) != null;
@@ -134,26 +131,6 @@ public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider {
}
}
@Nullable
private static DeclarationDescriptor getDescriptorForMember(
@NotNull JavaDescriptorResolver javaDescriptorResolver,
@NotNull PsiModifierListOwner member
) {
if (member instanceof PsiMethod) {
PsiMethod method = (PsiMethod) member;
if (method.isConstructor()) {
return ResolvePackage.resolveConstructor(javaDescriptorResolver, new JavaConstructorImpl(method));
}
else {
return ResolvePackage.resolveMethod(javaDescriptorResolver, new JavaMethodImpl(method));
}
}
else if (member instanceof PsiField) {
return ResolvePackage.resolveField(javaDescriptorResolver, new JavaFieldImpl((PsiField) member));
}
return null;
}
public static boolean isMarkersEnabled(@NotNull Project project) {
return PropertiesComponent.getInstance(project).getBoolean(SHOW_MARKERS_PROPERTY, true);
}