diff --git a/idea/src/org/jetbrains/jet/plugin/caches/KotlinIndicesHelper.kt b/idea/src/org/jetbrains/jet/plugin/caches/KotlinIndicesHelper.kt
index dcc582cebd2..a6841a841b2 100644
--- a/idea/src/org/jetbrains/jet/plugin/caches/KotlinIndicesHelper.kt
+++ b/idea/src/org/jetbrains/jet/plugin/caches/KotlinIndicesHelper.kt
@@ -38,17 +38,19 @@ import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver.LookupMode
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.jet.lang.resolve.calls.smartcasts.DataFlowInfo
 
-public class KotlinIndicesHelper(private val project: Project) {
-    public fun getTopLevelObjects(nameFilter: (String) -> Boolean, resolveSession: ResolveSessionForBodies, scope: GlobalSearchScope): Collection<ClassDescriptor> {
+public class KotlinIndicesHelper(private val project: Project,
+                                 private val resolveSession: ResolveSessionForBodies,
+                                 private val scope: GlobalSearchScope) {
+    public fun getTopLevelObjects(nameFilter: (String) -> Boolean): Collection<ClassDescriptor> {
         val allObjectNames = JetTopLevelObjectShortNameIndex.getInstance().getAllKeys(project).stream() +
                 JetFromJavaDescriptorHelper.getPossiblePackageDeclarationsNames(project, scope).stream()
         return allObjectNames
                 .filter(nameFilter)
                 .toSet()
-                .flatMap { getTopLevelObjectsByName(it, resolveSession, scope) }
+                .flatMap { getTopLevelObjectsByName(it) }
     }
 
-    private fun getTopLevelObjectsByName(name: String, resolveSession: ResolveSessionForBodies, scope: GlobalSearchScope): Collection<ClassDescriptor> {
+    private fun getTopLevelObjectsByName(name: String): Collection<ClassDescriptor> {
         val result = hashSetOf<ClassDescriptor>()
 
         val topObjects = JetTopLevelObjectShortNameIndex.getInstance().get(name, project, scope)
@@ -67,7 +69,7 @@ public class KotlinIndicesHelper(private val project: Project) {
         return result
     }
 
-    public fun getTopLevelCallablesByName(name: String, context: JetExpression /*TODO: to be dropped*/, resolveSession: ResolveSessionForBodies, scope: GlobalSearchScope): Collection<CallableDescriptor> {
+    public fun getTopLevelCallablesByName(name: String, context: JetExpression /*TODO: to be dropped*/): Collection<CallableDescriptor> {
         val jetScope = resolveSession.resolveToElement(context).get(BindingContext.RESOLUTION_SCOPE, context) ?: return listOf()
 
         val result = HashSet<CallableDescriptor>()
@@ -76,17 +78,17 @@ public class KotlinIndicesHelper(private val project: Project) {
         val identifier = Name.identifier(name)
         for (fqName in JetFromJavaDescriptorHelper.getTopLevelCallableFqNames(project, scope, false)) {
             if (fqName.lastSegmentIs(identifier)) {
-                result.addAll(findTopLevelCallables(fqName, context, jetScope, resolveSession))
+                result.addAll(findTopLevelCallables(fqName, context, jetScope))
             }
         }
 
-        result.addSourceTopLevelFunctions(name, resolveSession, scope)
-        result.addSourceTopLevelProperties(name, resolveSession, scope)
+        result.addSourceTopLevelFunctions(name)
+        result.addSourceTopLevelProperties(name)
 
         return result
     }
 
-    private fun MutableCollection<in FunctionDescriptor>.addSourceTopLevelFunctions(name: String, resolveSession: ResolveSessionForBodies, scope: GlobalSearchScope) {
+    private fun MutableCollection<in FunctionDescriptor>.addSourceTopLevelFunctions(name: String) {
         val identifier = Name.identifier(name)
         val affectedPackages = JetTopLevelNonExtensionFunctionShortNameIndex.getInstance().get(name, project, scope)
                 .stream()
@@ -102,7 +104,7 @@ public class KotlinIndicesHelper(private val project: Project) {
         }
     }
 
-    private fun MutableCollection<in PropertyDescriptor>.addSourceTopLevelProperties(name: String, resolveSession: ResolveSessionForBodies, scope: GlobalSearchScope) {
+    private fun MutableCollection<in PropertyDescriptor>.addSourceTopLevelProperties(name: String) {
         val identifier = Name.identifier(name)
         val affectedPackages = JetTopLevelNonExtensionPropertyShortNameIndex.getInstance().get(name, project, scope)
                 .stream()
@@ -118,7 +120,7 @@ public class KotlinIndicesHelper(private val project: Project) {
         }
     }
 
-    public fun getTopLevelCallables(nameFilter: (String) -> Boolean, context: JetExpression /*TODO: to be dropped*/, resolveSession: ResolveSessionForBodies, scope: GlobalSearchScope): Collection<CallableDescriptor> {
+    public fun getTopLevelCallables(nameFilter: (String) -> Boolean, context: JetExpression /*TODO: to be dropped*/): Collection<CallableDescriptor> {
         val sourceNames = JetTopLevelFunctionsFqnNameIndex.getInstance().getAllKeys(project).stream() + JetTopLevelPropertiesFqnNameIndex.getInstance().getAllKeys(project).stream()
         val allFqNames = sourceNames.map { FqName(it) } + JetFromJavaDescriptorHelper.getTopLevelCallableFqNames(project, scope, false).stream()
 
@@ -126,13 +128,10 @@ public class KotlinIndicesHelper(private val project: Project) {
 
         return allFqNames.filter { nameFilter(it.shortName().asString()) }
                 .toSet()
-                .flatMap { findTopLevelCallables(it, context, jetScope, resolveSession) }
+                .flatMap { findTopLevelCallables(it, context, jetScope) }
     }
 
-    public fun getCallableExtensions(nameFilter: (String) -> Boolean,
-                                     expression: JetSimpleNameExpression,
-                                     resolveSession: ResolveSessionForBodies,
-                                     scope: GlobalSearchScope): Collection<CallableDescriptor> {
+    public fun getCallableExtensions(nameFilter: (String) -> Boolean, expression: JetSimpleNameExpression): Collection<CallableDescriptor> {
         val bindingContext = resolveSession.resolveToElement(expression)
         val dataFlowInfo = bindingContext.getDataFlowInfo(expression)
 
@@ -189,15 +188,15 @@ public class KotlinIndicesHelper(private val project: Project) {
                           ExpressionTypingUtils.checkIsExtensionCallable(receiverValue, it, isInfixCall, bindingContext, dataFlowInfo) }
     }
 
-    public fun getClassDescriptors(nameFilter: (String) -> Boolean, analyzer: KotlinCodeAnalyzer, scope: GlobalSearchScope): Collection<ClassDescriptor> {
+    public fun getClassDescriptors(nameFilter: (String) -> Boolean): Collection<ClassDescriptor> {
         return JetFullClassNameIndex.getInstance().getAllKeys(project).stream()
                 .map { FqName(it) }
                 .filter { nameFilter(it.shortName().asString()) }
                 .toList()
-                .flatMap { getClassDescriptorsByFQName(analyzer, it, scope) }
+                .flatMap { getClassDescriptorsByFQName(it) }
     }
 
-    private fun getClassDescriptorsByFQName(analyzer: KotlinCodeAnalyzer, classFQName: FqName, scope: GlobalSearchScope): Collection<ClassDescriptor> {
+    private fun getClassDescriptorsByFQName(classFQName: FqName): Collection<ClassDescriptor> {
         val jetClassOrObjects = JetFullClassNameIndex.getInstance().get(classFQName.asString(), project, scope)
 
         if (jetClassOrObjects.isEmpty()) {
@@ -206,10 +205,10 @@ public class KotlinIndicesHelper(private val project: Project) {
         }
 
         // Note: Can't search with psi element as analyzer could be built over temp files
-        return ResolveSessionUtils.getClassDescriptorsByFqName(analyzer.getModuleDescriptor(), classFQName)
+        return ResolveSessionUtils.getClassDescriptorsByFqName(resolveSession.getModuleDescriptor(), classFQName)
     }
 
-    private fun findTopLevelCallables(fqName: FqName, context: JetExpression, jetScope: JetScope, resolveSession: ResolveSessionForBodies): Collection<CallableDescriptor> {
+    private fun findTopLevelCallables(fqName: FqName, context: JetExpression, jetScope: JetScope): Collection<CallableDescriptor> {
         val importDirective = JetPsiFactory(context.getProject()).createImportDirective(ImportPath(fqName, false))
         val allDescriptors = analyzeImportReference(importDirective, jetScope, BindingTraceContext(), resolveSession.getModuleDescriptor())
         return allDescriptors.filterIsInstance(javaClass<CallableDescriptor>()).filter { it.getExtensionReceiverParameter() == null }
diff --git a/idea/src/org/jetbrains/jet/plugin/completion/CompletionSession.kt b/idea/src/org/jetbrains/jet/plugin/completion/CompletionSession.kt
index 43ae1939169..8a6e30cf3db 100644
--- a/idea/src/org/jetbrains/jet/plugin/completion/CompletionSession.kt
+++ b/idea/src/org/jetbrains/jet/plugin/completion/CompletionSession.kt
@@ -62,8 +62,8 @@ abstract class CompletionSessionBase(protected val configuration: CompletionSess
     protected val collector: LookupElementsCollector = LookupElementsCollector(prefixMatcher, resolveSession, { isVisibleDescriptor(it) })
 
     protected val project: Project = position.getProject()
-    protected val indicesHelper: KotlinIndicesHelper = KotlinIndicesHelper(project)
     protected val searchScope: GlobalSearchScope = searchScopeForSourceElementDependencies(parameters.getOriginalFile()) ?: GlobalSearchScope.EMPTY_SCOPE
+    protected val indicesHelper: KotlinIndicesHelper = KotlinIndicesHelper(project, resolveSession, searchScope)
 
     protected fun isVisibleDescriptor(descriptor: DeclarationDescriptor): Boolean {
         if (configuration.completeNonAccessibleDeclarations) return true
@@ -104,12 +104,13 @@ abstract class CompletionSessionBase(protected val configuration: CompletionSess
 
     protected fun getKotlinTopLevelDeclarations(): Collection<DeclarationDescriptor> {
         val filter = { (name: String) -> prefixMatcher.prefixMatches(name) }
-        return (indicesHelper.getTopLevelCallables(filter, jetReference!!.expression, resolveSession, searchScope) +
-                   indicesHelper.getTopLevelObjects(filter, resolveSession, searchScope)).filter { isVisibleDescriptor(it) }
+        return (indicesHelper.getTopLevelCallables(filter, jetReference!!.expression) + indicesHelper.getTopLevelObjects(filter))
+                .filter { isVisibleDescriptor(it) }
     }
 
     protected fun getKotlinExtensions(): Collection<CallableDescriptor> {
-        return indicesHelper.getCallableExtensions({ prefixMatcher.prefixMatches(it) }, jetReference!!.expression, resolveSession, searchScope).filter { isVisibleDescriptor(it) }
+        return indicesHelper.getCallableExtensions({ prefixMatcher.prefixMatches(it) }, jetReference!!.expression)
+                .filter { isVisibleDescriptor(it) }
     }
 
     protected fun addAllTypes() {
diff --git a/idea/src/org/jetbrains/jet/plugin/completion/TypesCompletion.kt b/idea/src/org/jetbrains/jet/plugin/completion/TypesCompletion.kt
index e4c3e01a39d..83d4fb27798 100644
--- a/idea/src/org/jetbrains/jet/plugin/completion/TypesCompletion.kt
+++ b/idea/src/org/jetbrains/jet/plugin/completion/TypesCompletion.kt
@@ -42,7 +42,7 @@ class TypesCompletion(val parameters: CompletionParameters,
 
         val project = parameters.getOriginalFile().getProject()
         val searchScope = searchScopeForSourceElementDependencies(parameters.getOriginalFile()) ?: return
-        result.addDescriptorElements(KotlinIndicesHelper(project).getClassDescriptors({ prefixMatcher.prefixMatches(it) }, resolveSession, searchScope).filter(visibilityFilter),
+        result.addDescriptorElements(KotlinIndicesHelper(project, resolveSession, searchScope).getClassDescriptors { prefixMatcher.prefixMatches(it) }.filter(visibilityFilter),
                                      suppressAutoInsertion = true)
 
         if (!ProjectStructureUtil.isJsKotlinModule(parameters.getOriginalFile() as JetFile)) {
diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.kt b/idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.kt
index 692b404f587..85f0f1ccad4 100644
--- a/idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.kt
+++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.kt
@@ -134,7 +134,7 @@ public class AutoImportFix(element: JetSimpleNameExpression) : JetHintAction<Jet
             resolveSession: ResolveSessionForBodies,
             project: Project
     ): Collection<PrioritizedFqName>
-            = KotlinIndicesHelper(project).getTopLevelCallablesByName(name, context, resolveSession, searchScope)
+            = KotlinIndicesHelper(project, resolveSession, searchScope).getTopLevelCallablesByName(name, context)
             .map { PrioritizedFqName(it) }
             .toSet()
 
@@ -145,7 +145,7 @@ public class AutoImportFix(element: JetSimpleNameExpression) : JetHintAction<Jet
             resolveSession: ResolveSessionForBodies,
             project: Project
     ): Collection<PrioritizedFqName>
-            = KotlinIndicesHelper(project).getCallableExtensions({ it == name }, expression, resolveSession, searchScope)
+            = KotlinIndicesHelper(project, resolveSession, searchScope).getCallableExtensions({ it == name }, expression)
             .map { PrioritizedFqName(it) }
             .toSet()