diff --git a/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.kt b/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.kt index b942a0c9c7d..5adc82f4cc6 100644 --- a/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.kt +++ b/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.kt @@ -122,131 +122,6 @@ public class JetShortNamesCache(private val project: Project) : PsiShortNamesCac destination.addAll(Arrays.asList(*getAllClassNames())) } - public fun getTopLevelObjects(nameFilter: (String) -> Boolean, resolveSession: ResolveSessionForBodies, scope: GlobalSearchScope): Collection { - val allObjectNames = JetTopLevelObjectShortNameIndex.getInstance().getAllKeys(project).stream() + - JetFromJavaDescriptorHelper.getPossiblePackageDeclarationsNames(project, GlobalSearchScope.allScope(project)).stream() - return allObjectNames - .filter(nameFilter) - .toSet() - .flatMap { getTopLevelObjectsByName(it, resolveSession, scope) } - } - - private fun getTopLevelObjectsByName(name: String, resolveSession: ResolveSessionForBodies, scope: GlobalSearchScope): Collection { - val result = hashSetOf() - - val topObjects = JetTopLevelObjectShortNameIndex.getInstance().get(name, project, scope) - for (objectDeclaration in topObjects) { - val fqName = objectDeclaration.getFqName() ?: error("Local object declaration in JetTopLevelShortObjectNameIndex:${objectDeclaration.getText()}") - result.addAll(ResolveSessionUtils.getClassOrObjectDescriptorsByFqName(resolveSession, fqName, ResolveSessionUtils.SINGLETON_FILTER)) - } - - for (psiClass in JetFromJavaDescriptorHelper.getCompiledClassesForTopLevelObjects(project, GlobalSearchScope.allScope(project))) { - val qualifiedName = psiClass.getQualifiedName() - if (qualifiedName != null) { - result.addAll(ResolveSessionUtils.getClassOrObjectDescriptorsByFqName(resolveSession, FqName(qualifiedName), ResolveSessionUtils.SINGLETON_FILTER)) - } - } - - return result - } - - public fun getTopLevelFunctionDescriptorsByName(name: String, context: JetExpression /*TODO: to be dropped*/, resolveSession: ResolveSessionForBodies, scope: GlobalSearchScope): Collection { - - val jetScope = resolveSession.resolveToElement(context).get(BindingContext.RESOLUTION_SCOPE, context) ?: return listOf() - - val result = hashSetOf() - - //TODO: this code is temporary and is to be dropped when compiled top level functions are indexed - val identifier = Name.identifier(name) - for (fqName in JetFromJavaDescriptorHelper.getTopLevelCallableFqNames(project, scope, false)) { - if (fqName.lastSegmentIs(identifier)) { - findTopLevelCallables(fqName, context, jetScope, resolveSession).filterIsInstanceTo(result, javaClass()) - } - } - - result.addSourceTopLevelFunctions(name, resolveSession, scope) - - return result - } - - private fun MutableCollection.addSourceTopLevelFunctions(name: String, resolveSession: ResolveSessionForBodies, scope: GlobalSearchScope) { - val identifier = Name.identifier(name) - val affectedPackages = JetTopLevelNonExtensionFunctionShortNameIndex.getInstance().get(name, project, scope) - .map { it.getContainingFile() } - .filterIsInstance(javaClass()) - .map { it.getPackageFqName() } - .toSet() - - for (affectedPackage in affectedPackages) { - val packageDescriptor = resolveSession.getModuleDescriptor().getPackage(affectedPackage) - ?: error("There's a function in stub index with invalid package: $affectedPackage") - addAll(packageDescriptor.getMemberScope().getFunctions(identifier)) - } - } - - public fun getTopLevelCallables(nameFilter: (String) -> Boolean, context: JetExpression /*TODO: to be dropped*/, resolveSession: ResolveSessionForBodies, scope: GlobalSearchScope): Collection { - val result = ArrayList() - - val sourceNames = JetTopLevelFunctionsFqnNameIndex.getInstance().getAllKeys(project).stream() + JetTopLevelPropertiesFqnNameIndex.getInstance().getAllKeys(project).stream() - val allFqNames = sourceNames.map { FqName(it) } + JetFromJavaDescriptorHelper.getTopLevelCallableFqNames(project, scope, false).stream() - - val jetScope = resolveSession.resolveToElement(context).get(BindingContext.RESOLUTION_SCOPE, context) ?: return listOf() - allFqNames.filter { nameFilter(it.shortName().asString()) } - .toSet() - .flatMapTo(result) { findTopLevelCallables(it, context, jetScope, resolveSession) } - - return result - } - - public fun getCallableExtensions(nameFilter: (String) -> Boolean, - expression: JetSimpleNameExpression, - resolveSession: ResolveSessionForBodies, - scope: GlobalSearchScope): Collection { - val context = resolveSession.resolveToElement(expression) - val receiverExpression = expression.getReceiverExpression() ?: return listOf() - val expressionType = context.get(BindingContext.EXPRESSION_TYPE, receiverExpression) - val jetScope = context.get(BindingContext.RESOLUTION_SCOPE, receiverExpression) - - if (expressionType == null || jetScope == null || expressionType.isError()) { - return listOf() - } - - val sourceNames = JetTopLevelFunctionsFqnNameIndex.getInstance().getAllKeys(project).stream() + JetTopLevelPropertiesFqnNameIndex.getInstance().getAllKeys(project).stream() - val allFqNames = sourceNames.map { FqName(it) } + JetFromJavaDescriptorHelper.getTopLevelCallableFqNames(project, scope, true).stream() - - // Iterate through the function with attempt to resolve found functions - return allFqNames - .filter { nameFilter(it.shortName().asString()) } - .toSet() - .flatMap { ExpressionTypingUtils.canFindSuitableCall(it, receiverExpression, expressionType, jetScope, resolveSession.getModuleDescriptor()) } - } - - public fun getClassDescriptors(nameFilter: (String) -> Boolean, analyzer: KotlinCodeAnalyzer, scope: GlobalSearchScope): Collection { - return JetFullClassNameIndex.getInstance().getAllKeys(project).stream() - .map { FqName(it) } - .filter { nameFilter(it.shortName().asString()) } - .toList() - .flatMap { getClassDescriptorsByFQName(analyzer, it, scope) } - } - - private fun getClassDescriptorsByFQName(analyzer: KotlinCodeAnalyzer, classFQName: FqName, scope: GlobalSearchScope): Collection { - val jetClassOrObjects = JetFullClassNameIndex.getInstance().get(classFQName.asString(), project, scope) - - if (jetClassOrObjects.isEmpty()) { - // This fqn is absent in caches, dead or not in scope - return listOf() - } - - // Note: Can't search with psi element as analyzer could be built over temp files - return ResolveSessionUtils.getClassDescriptorsByFqName(analyzer, classFQName) - } - - private fun findTopLevelCallables(fqName: FqName, context: JetExpression, jetScope: JetScope, resolveSession: ResolveSessionForBodies): Collection { - val importDirective = JetPsiFactory(context.getProject()).createImportDirective(ImportPath(fqName, false)) - val allDescriptors = QualifiedExpressionResolver().analyseImportReference(importDirective, jetScope, BindingTraceContext(), resolveSession.getModuleDescriptor()) - return allDescriptors.filterIsInstance(javaClass()).filter { it.getReceiverParameter() == null } - } - override fun getMethodsByName(NonNls name: String, scope: GlobalSearchScope): Array = array() diff --git a/idea/src/org/jetbrains/jet/plugin/caches/KotlinIndicesHelper.kt b/idea/src/org/jetbrains/jet/plugin/caches/KotlinIndicesHelper.kt new file mode 100644 index 00000000000..2d4a5fb6451 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/caches/KotlinIndicesHelper.kt @@ -0,0 +1,174 @@ +/* + * Copyright 2010-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.plugin.caches + +import org.jetbrains.jet.plugin.project.ResolveSessionForBodies +import com.intellij.psi.search.GlobalSearchScope +import org.jetbrains.jet.lang.descriptors.ClassDescriptor +import org.jetbrains.jet.plugin.stubindex.JetTopLevelObjectShortNameIndex +import org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils +import org.jetbrains.jet.lang.resolve.name.FqName +import org.jetbrains.jet.lang.psi.JetExpression +import org.jetbrains.jet.lang.descriptors.FunctionDescriptor +import org.jetbrains.jet.lang.resolve.BindingContext +import org.jetbrains.jet.lang.resolve.name.Name +import org.jetbrains.jet.plugin.stubindex.JetTopLevelNonExtensionFunctionShortNameIndex +import org.jetbrains.jet.lang.psi.JetFile +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor +import java.util.ArrayList +import org.jetbrains.jet.plugin.stubindex.JetTopLevelFunctionsFqnNameIndex +import org.jetbrains.jet.plugin.stubindex.JetTopLevelPropertiesFqnNameIndex +import org.jetbrains.jet.lang.psi.JetSimpleNameExpression +import org.jetbrains.jet.lang.psi.psiUtil.getReceiverExpression +import org.jetbrains.jet.lang.types.JetType +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils +import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer +import org.jetbrains.jet.plugin.stubindex.JetFullClassNameIndex +import org.jetbrains.jet.lang.resolve.scopes.JetScope +import org.jetbrains.jet.lang.psi.JetPsiFactory +import org.jetbrains.jet.lang.resolve.ImportPath +import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver +import org.jetbrains.jet.lang.resolve.BindingTraceContext +import org.jetbrains.jet.lang.descriptors.CallableDescriptor +import com.intellij.openapi.project.Project + +public class KotlinIndicesHelper(private val project: Project) { + public fun getTopLevelObjects(nameFilter: (String) -> Boolean, resolveSession: ResolveSessionForBodies, scope: GlobalSearchScope): Collection { + val allObjectNames = JetTopLevelObjectShortNameIndex.getInstance().getAllKeys(project).stream() + + JetFromJavaDescriptorHelper.getPossiblePackageDeclarationsNames(project, GlobalSearchScope.allScope(project)).stream() + return allObjectNames + .filter(nameFilter) + .toSet() + .flatMap { getTopLevelObjectsByName(it, resolveSession, scope) } + } + + private fun getTopLevelObjectsByName(name: String, resolveSession: ResolveSessionForBodies, scope: GlobalSearchScope): Collection { + val result = hashSetOf() + + val topObjects = JetTopLevelObjectShortNameIndex.getInstance().get(name, project, scope) + for (objectDeclaration in topObjects) { + val fqName = objectDeclaration.getFqName() ?: error("Local object declaration in JetTopLevelShortObjectNameIndex:${objectDeclaration.getText()}") + result.addAll(ResolveSessionUtils.getClassOrObjectDescriptorsByFqName(resolveSession, fqName, ResolveSessionUtils.SINGLETON_FILTER)) + } + + for (psiClass in JetFromJavaDescriptorHelper.getCompiledClassesForTopLevelObjects(project, GlobalSearchScope.allScope(project))) { + val qualifiedName = psiClass.getQualifiedName() + if (qualifiedName != null) { + result.addAll(ResolveSessionUtils.getClassOrObjectDescriptorsByFqName(resolveSession, FqName(qualifiedName), ResolveSessionUtils.SINGLETON_FILTER)) + } + } + + return result + } + + public fun getTopLevelFunctionDescriptorsByName(name: String, context: JetExpression /*TODO: to be dropped*/, resolveSession: ResolveSessionForBodies, scope: GlobalSearchScope): Collection { + + val jetScope = resolveSession.resolveToElement(context).get(BindingContext.RESOLUTION_SCOPE, context) ?: return listOf() + + val result = hashSetOf() + + //TODO: this code is temporary and is to be dropped when compiled top level functions are indexed + val identifier = Name.identifier(name) + for (fqName in JetFromJavaDescriptorHelper.getTopLevelCallableFqNames(project, scope, false)) { + if (fqName.lastSegmentIs(identifier)) { + findTopLevelCallables(fqName, context, jetScope, resolveSession).filterIsInstanceTo(result, javaClass()) + } + } + + result.addSourceTopLevelFunctions(name, resolveSession, scope) + + return result + } + + private fun MutableCollection.addSourceTopLevelFunctions(name: String, resolveSession: ResolveSessionForBodies, scope: GlobalSearchScope) { + val identifier = Name.identifier(name) + val affectedPackages = JetTopLevelNonExtensionFunctionShortNameIndex.getInstance().get(name, project, scope) + .map { it.getContainingFile() } + .filterIsInstance(javaClass()) + .map { it.getPackageFqName() } + .toSet() + + for (affectedPackage in affectedPackages) { + val packageDescriptor = resolveSession.getModuleDescriptor().getPackage(affectedPackage) + ?: error("There's a function in stub index with invalid package: $affectedPackage") + addAll(packageDescriptor.getMemberScope().getFunctions(identifier)) + } + } + + public fun getTopLevelCallables(nameFilter: (String) -> Boolean, context: JetExpression /*TODO: to be dropped*/, resolveSession: ResolveSessionForBodies, scope: GlobalSearchScope): Collection { + val result = ArrayList() + + val sourceNames = JetTopLevelFunctionsFqnNameIndex.getInstance().getAllKeys(project).stream() + JetTopLevelPropertiesFqnNameIndex.getInstance().getAllKeys(project).stream() + val allFqNames = sourceNames.map { FqName(it) } + JetFromJavaDescriptorHelper.getTopLevelCallableFqNames(project, scope, false).stream() + + val jetScope = resolveSession.resolveToElement(context).get(BindingContext.RESOLUTION_SCOPE, context) ?: return listOf() + allFqNames.filter { nameFilter(it.shortName().asString()) } + .toSet() + .flatMapTo(result) { findTopLevelCallables(it, context, jetScope, resolveSession) } + + return result + } + + public fun getCallableExtensions(nameFilter: (String) -> Boolean, + expression: JetSimpleNameExpression, + resolveSession: ResolveSessionForBodies, + scope: GlobalSearchScope): Collection { + val context = resolveSession.resolveToElement(expression) + val receiverExpression = expression.getReceiverExpression() ?: return listOf() + val expressionType = context.get(BindingContext.EXPRESSION_TYPE, receiverExpression) + val jetScope = context.get(BindingContext.RESOLUTION_SCOPE, receiverExpression) + + if (expressionType == null || jetScope == null || expressionType.isError()) { + return listOf() + } + + val sourceNames = JetTopLevelFunctionsFqnNameIndex.getInstance().getAllKeys(project).stream() + JetTopLevelPropertiesFqnNameIndex.getInstance().getAllKeys(project).stream() + val allFqNames = sourceNames.map { FqName(it) } + JetFromJavaDescriptorHelper.getTopLevelCallableFqNames(project, scope, true).stream() + + // Iterate through the function with attempt to resolve found functions + return allFqNames + .filter { nameFilter(it.shortName().asString()) } + .toSet() + .flatMap { ExpressionTypingUtils.canFindSuitableCall(it, receiverExpression, expressionType, jetScope, resolveSession.getModuleDescriptor()) } + } + + public fun getClassDescriptors(nameFilter: (String) -> Boolean, analyzer: KotlinCodeAnalyzer, scope: GlobalSearchScope): Collection { + return JetFullClassNameIndex.getInstance().getAllKeys(project).stream() + .map { FqName(it) } + .filter { nameFilter(it.shortName().asString()) } + .toList() + .flatMap { getClassDescriptorsByFQName(analyzer, it, scope) } + } + + private fun getClassDescriptorsByFQName(analyzer: KotlinCodeAnalyzer, classFQName: FqName, scope: GlobalSearchScope): Collection { + val jetClassOrObjects = JetFullClassNameIndex.getInstance().get(classFQName.asString(), project, scope) + + if (jetClassOrObjects.isEmpty()) { + // This fqn is absent in caches, dead or not in scope + return listOf() + } + + // Note: Can't search with psi element as analyzer could be built over temp files + return ResolveSessionUtils.getClassDescriptorsByFqName(analyzer, classFQName) + } + + private fun findTopLevelCallables(fqName: FqName, context: JetExpression, jetScope: JetScope, resolveSession: ResolveSessionForBodies): Collection { + val importDirective = JetPsiFactory(context.getProject()).createImportDirective(ImportPath(fqName, false)) + val allDescriptors = QualifiedExpressionResolver().analyseImportReference(importDirective, jetScope, BindingTraceContext(), resolveSession.getModuleDescriptor()) + return allDescriptors.filterIsInstance(javaClass()).filter { it.getReceiverParameter() == null } + } +} \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/completion/CompletionSession.kt b/idea/src/org/jetbrains/jet/plugin/completion/CompletionSession.kt index 756db940281..6b7ef9ff347 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/CompletionSession.kt +++ b/idea/src/org/jetbrains/jet/plugin/completion/CompletionSession.kt @@ -25,13 +25,13 @@ import org.jetbrains.jet.lang.psi.* import org.jetbrains.jet.lang.resolve.BindingContext import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns import org.jetbrains.jet.lexer.JetTokens -import org.jetbrains.jet.plugin.caches.JetShortNamesCache import org.jetbrains.jet.plugin.caches.resolve.* import org.jetbrains.jet.plugin.codeInsight.TipsManager import org.jetbrains.jet.plugin.completion.smart.SmartCompletion import org.jetbrains.jet.plugin.references.JetSimpleNameReference import org.jetbrains.jet.plugin.project.ResolveSessionForBodies import com.intellij.openapi.module.ModuleUtilCore +import org.jetbrains.jet.plugin.caches.KotlinIndicesHelper class CompletionSessionConfiguration( val completeNonImportedDeclarations: Boolean, @@ -78,7 +78,7 @@ class BasicCompletionSession(configuration: CompletionSessionConfiguration, private val collector: LookupElementsCollector = LookupElementsCollector(prefixMatcher, resolveSession, { isVisibleDescriptor(it) }) private val project = position.getProject() - private val shortNamesCache = JetShortNamesCache.getKotlinInstance(project) + private val indicesHelper = KotlinIndicesHelper(project) private val module = ModuleUtilCore.findModuleForPsiElement(parameters.getOriginalFile()) private val searchScope = if (module != null) GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module) else GlobalSearchScope.EMPTY_SCOPE @@ -156,12 +156,12 @@ class BasicCompletionSession(configuration: CompletionSessionConfiguration, private fun addKotlinTopLevelDeclarations() { val filter = { (name: String) -> prefixMatcher.prefixMatches(name) } - collector.addDescriptorElements(shortNamesCache.getTopLevelCallables(filter, jetReference!!.expression, resolveSession, searchScope) + - shortNamesCache.getTopLevelObjects(filter, resolveSession, searchScope)) + collector.addDescriptorElements(indicesHelper.getTopLevelCallables(filter, jetReference!!.expression, resolveSession, searchScope) + + indicesHelper.getTopLevelObjects(filter, resolveSession, searchScope)) } private fun addKotlinExtensions() { - collector.addDescriptorElements(shortNamesCache.getCallableExtensions({ prefixMatcher.prefixMatches(it) }, jetReference!!.expression, resolveSession, searchScope)) + collector.addDescriptorElements(indicesHelper.getCallableExtensions({ prefixMatcher.prefixMatches(it) }, jetReference!!.expression, resolveSession, searchScope)) } private fun shouldRunOnlyTypeCompletion(): Boolean { diff --git a/idea/src/org/jetbrains/jet/plugin/completion/TypesCompletion.kt b/idea/src/org/jetbrains/jet/plugin/completion/TypesCompletion.kt index 3eced2fadd3..38c95b417c6 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/TypesCompletion.kt +++ b/idea/src/org/jetbrains/jet/plugin/completion/TypesCompletion.kt @@ -30,21 +30,20 @@ import org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils import org.jetbrains.jet.lang.resolve.name.FqName import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns import org.jetbrains.jet.plugin.caches.JetFromJavaDescriptorHelper -import org.jetbrains.jet.plugin.caches.JetShortNamesCache import org.jetbrains.jet.plugin.completion.handlers.JetJavaClassInsertHandler import org.jetbrains.jet.plugin.project.ProjectStructureUtil import org.jetbrains.jet.plugin.project.ResolveSessionForBodies import com.intellij.openapi.module.ModuleUtilCore +import org.jetbrains.jet.plugin.caches.KotlinIndicesHelper class TypesCompletion(val parameters: CompletionParameters, val resolveSession: ResolveSessionForBodies, val prefixMatcher: PrefixMatcher) { fun addAllTypes(result: LookupElementsCollector) { result.addDescriptorElements(KotlinBuiltIns.getInstance().getNonPhysicalClasses()) val project = parameters.getOriginalFile().getProject() - val namesCache = JetShortNamesCache.getKotlinInstance(project) val module = ModuleUtilCore.findModuleForPsiElement(parameters.getOriginalFile()) ?: return val searchScope = GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module) - result.addDescriptorElements(namesCache.getClassDescriptors({ prefixMatcher.prefixMatches(it) }, resolveSession, searchScope)) + result.addDescriptorElements(KotlinIndicesHelper(project).getClassDescriptors({ prefixMatcher.prefixMatches(it) }, resolveSession, searchScope)) if (!ProjectStructureUtil.isJsKotlinModule(parameters.getOriginalFile() as JetFile)) { addAdaptedJavaCompletion(result) diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.java index c6146e1662c..1ce41bcad4d 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.java @@ -55,6 +55,7 @@ import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.plugin.JetBundle; import org.jetbrains.jet.plugin.actions.JetAddImportAction; import org.jetbrains.jet.plugin.caches.JetShortNamesCache; +import org.jetbrains.jet.plugin.caches.KotlinIndicesHelper; import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage; import org.jetbrains.jet.plugin.project.ProjectStructureUtil; import org.jetbrains.jet.plugin.project.ResolveSessionForBodies; @@ -130,9 +131,7 @@ public class AutoImportFix extends JetHintAction implem @NotNull ResolveSessionForBodies resolveSession, @NotNull Project project ) { - JetShortNamesCache namesCache = JetShortNamesCache.OBJECT$.getKotlinInstance(project); - - Collection topLevelFunctions = namesCache.getTopLevelFunctionDescriptorsByName( + Collection topLevelFunctions = new KotlinIndicesHelper(project).getTopLevelFunctionDescriptorsByName( referenceName, context, resolveSession, searchScope); return Sets.newHashSet(Collections2.transform(topLevelFunctions, new Function() { @@ -151,8 +150,7 @@ public class AutoImportFix extends JetHintAction implem @NotNull ResolveSessionForBodies resolveSession, @NotNull Project project ) { - JetShortNamesCache namesCache = JetShortNamesCache.OBJECT$.getKotlinInstance(project); - Collection jetCallableExtensions = namesCache.getCallableExtensions( + Collection jetCallableExtensions = new KotlinIndicesHelper(project).getCallableExtensions( new Function1() { @Override public Boolean invoke(String callableExtensionName) { @@ -223,8 +221,7 @@ public class AutoImportFix extends JetHintAction implem } private static Collection getJetClasses(@NotNull final String typeName, @NotNull GlobalSearchScope searchScope, @NotNull Project project, @NotNull KotlinCodeAnalyzer resolveSession) { - JetShortNamesCache cache = JetShortNamesCache.OBJECT$.getKotlinInstance(project); - Collection descriptors = cache.getClassDescriptors(new Function1() { + Collection descriptors = new KotlinIndicesHelper(project).getClassDescriptors(new Function1() { @Override public Boolean invoke(String s) { return typeName.equals(s);