Introduce ResolutionFacade to be used by plugin code instead of resolve session

Do not expose ResolveSessionForBodies where possible
Define API of ResolutionFacade, similar to what ResolveSessionForBodies has
JetElement#getLazyResolveSession returns ResolutionFacade
Call sites to be updated later

idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheService.kt

@@ -35,11 +35,14 @@ import org.jetbrains.jet.lang.psi.JetCodeFragment
 import org.jetbrains.jet.utils.keysToMap
 import com.intellij.openapi.roots.ProjectRootModificationTracker
 import org.jetbrains.jet.plugin.util.ProjectRootsUtil
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
+import org.jetbrains.jet.lang.psi.JetDeclaration
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
 
 private val LOG = Logger.getInstance(javaClass<KotlinCacheService>())
 
-public fun JetElement.getLazyResolveSession(): ResolveSessionForBodies {
+public fun JetElement.getLazyResolveSession(): ResolutionFacade {
-    return KotlinCacheService.getInstance(getProject()).getLazyResolveSession(this)
+    return KotlinCacheService.getInstance(getProject()).getAnalysisFacade(listOf(this))
 }
 
 public fun JetElement.getAnalysisResults(vararg extraFiles: JetFile): AnalyzeExhaust {
@@ -61,6 +64,23 @@ public class KotlinCacheService(val project: Project) {
         public fun getInstance(project: Project): KotlinCacheService = ServiceManager.getService(project, javaClass<KotlinCacheService>())!!
     }
 
+    public fun getResolutionFacade(elements: List<JetElement>): ResolutionFacade {
+        val cache = getCacheToAnalyzeFiles(elements.map { it.getContainingJetFile() })
+        return object : ResolutionFacade {
+            override fun resolveToElement(element: JetElement): BindingContext {
+                return cache.getLazyResolveSession(element).resolveToElement(element)
+            }
+
+            override fun getModuleDescriptorForElement(element: JetElement): ModuleDescriptor {
+                return cache.getLazyResolveSession(element).getModuleDescriptor()
+            }
+
+            override fun resolveToDescriptor(declaration: JetDeclaration): DeclarationDescriptor {
+                return cache.getLazyResolveSession(declaration).resolveToDescriptor(declaration)
+            }
+        }
+    }
+
     fun globalResolveSessionProvider(
             platform: TargetPlatform,
             dependencies: Collection<Any>,

idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/ResolutionFacade.kt

@@ -0,0 +1,32 @@
+/*
+ * 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.resolve
+
+import org.jetbrains.jet.lang.psi.JetElement
+import org.jetbrains.jet.lang.resolve.BindingContext
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
+import org.jetbrains.jet.lang.psi.JetDeclaration
+
+public trait ResolutionFacade {
+
+    public fun resolveToElement(element: JetElement): BindingContext
+
+    public fun resolveToDescriptor(declaration: JetDeclaration): DeclarationDescriptor
+
+    public fun getModuleDescriptorForElement(element: JetElement): ModuleDescriptor
+}

idea/idea-analysis/src/org/jetbrains/jet/plugin/codeInsight/ShortenReferences.kt

@@ -20,7 +20,6 @@ import com.intellij.psi.PsiElement;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.plugin.quickfix.ImportInsertHelper;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
 import java.util.HashSet;
@@ -35,8 +34,8 @@ import org.jetbrains.jet.lang.resolve.calls.callUtil.getCalleeExpressionIfAny
 import java.util.LinkedHashSet
 import org.jetbrains.jet.lang.resolve.ImportPath
 import org.jetbrains.jet.lang.psi.psiUtil.getQualifiedElement
-import org.jetbrains.jet.lang.types.JetType
 import org.jetbrains.jet.lang.resolve.descriptorUtil.getImportableDescriptor
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade
 
 public object ShortenReferences {
     public fun process(element: JetElement) {
@@ -154,7 +153,7 @@ public object ShortenReferences {
             val elementFilter: (PsiElement) -> FilterResult,
             val resolveMap: Map<JetReferenceExpression, BindingContext>,
             val importInserter: ImportInserter) : JetVisitorVoid() {
-        protected val resolveSession: ResolveSessionForBodies
+        protected val resolveSession: ResolutionFacade
             get() = file.getLazyResolveSession()
 
         protected val elementsToShorten: MutableSet<T> = LinkedHashSet()

idea/idea-analysis/src/org/jetbrains/jet/plugin/intentions/RemoveExplicitTypeArguments.kt

@@ -48,7 +48,7 @@ public class RemoveExplicitTypeArguments : JetSelfTargetingIntention<JetTypeArgu
         if (callExpression.getTypeArguments().isEmpty()) return false
 
         val resolveSession = callExpression.getLazyResolveSession()
-        val injector = InjectorForMacros(callExpression.getProject(), resolveSession.getModuleDescriptor())
+        val injector = InjectorForMacros(callExpression.getProject(), resolveSession.getModuleDescriptorForElement(callExpression))
 
         val scope = context[BindingContext.RESOLUTION_SCOPE, callExpression]
         val originalCall = callExpression.getResolvedCall(context)

idea/idea-analysis/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java

@@ -19,6 +19,7 @@ package org.jetbrains.jet.plugin.project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetElement;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade;
 import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
 
 public final class AnalyzerFacadeWithCache {
@@ -28,7 +29,7 @@ public final class AnalyzerFacadeWithCache {
 
     @NotNull
     public static BindingContext getContextForElement(@NotNull JetElement jetElement) {
-        ResolveSessionForBodies resolveSessionForBodies = ResolvePackage.getLazyResolveSession(jetElement);
+        ResolutionFacade resolveSessionForBodies = ResolvePackage.getLazyResolveSession(jetElement);
         return resolveSessionForBodies.resolveToElement(jetElement);
     }
 }

idea/src/org/jetbrains/jet/plugin/caches/KotlinIndicesHelper.kt

@@ -16,7 +16,6 @@
 
 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.*
 import org.jetbrains.jet.plugin.stubindex.*
@@ -35,14 +34,16 @@ 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
 import com.intellij.psi.stubs.StringStubIndexExtension
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade
 import org.jetbrains.jet.plugin.util.extensionsUtils.isExtensionCallable
 
-public class KotlinIndicesHelper(private val project: Project,
+public class KotlinIndicesHelper(
-                                 private val resolveSession: ResolveSessionForBodies,
+        private val project: Project,
-                                 private val scope: GlobalSearchScope,
+        private val resolveSession: ResolutionFacade,
-                                 private val visibilityFilter: (DeclarationDescriptor) -> Boolean) {
+        private val scope: GlobalSearchScope,
-    private val moduleDescriptor = resolveSession.getModuleDescriptor()
+        private val moduleDescriptor: ModuleDescriptor,
-
+        private val visibilityFilter: (DeclarationDescriptor) -> Boolean
+) {
     public fun getTopLevelObjects(nameFilter: (String) -> Boolean): Collection<ClassDescriptor> {
         val allObjectNames = JetTopLevelObjectShortNameIndex.getInstance().getAllKeys(project).stream() +
                 JetFromJavaDescriptorHelper.getPossiblePackageDeclarationsNames(project, scope).stream()

idea/src/org/jetbrains/jet/plugin/completion/AllClassesCompletion.kt

@@ -27,13 +27,16 @@ 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.project.ProjectStructureUtil
-import org.jetbrains.jet.plugin.project.ResolveSessionForBodies
 import org.jetbrains.jet.plugin.caches.KotlinIndicesHelper
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
 import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade
+import org.jetbrains.jet.lang.psi.JetElement
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
 
 class AllClassesCompletion(val parameters: CompletionParameters,
-                           val resolveSession: ResolveSessionForBodies,
+                           val resolveSession: ResolutionFacade,
+                           val moduleDescriptor: ModuleDescriptor,
                            val scope: GlobalSearchScope,
                            val prefixMatcher: PrefixMatcher,
                            val kindFilter: (ClassKind) -> Boolean,
@@ -42,7 +45,7 @@ class AllClassesCompletion(val parameters: CompletionParameters,
         val builtIns = KotlinBuiltIns.getInstance().getNonPhysicalClasses().filter { kindFilter(it.getKind()) && prefixMatcher.prefixMatches(it.getName().asString()) }
         result.addDescriptorElements(builtIns, suppressAutoInsertion = true)
 
-        val helper = KotlinIndicesHelper(scope.getProject(), resolveSession, scope, visibilityFilter)
+        val helper = KotlinIndicesHelper(scope.getProject(), resolveSession, scope, moduleDescriptor, visibilityFilter)
         result.addDescriptorElements(helper.getClassDescriptors({ prefixMatcher.prefixMatches(it) }, kindFilter),
                                      suppressAutoInsertion = true)
 
@@ -79,7 +82,7 @@ class AllClassesCompletion(val parameters: CompletionParameters,
         if (kindFilter(JetFromJavaDescriptorHelper.getCompiledClassKind(aClass))) {
             val qualifiedName = aClass.getQualifiedName()
             if (qualifiedName != null) {
-                val descriptors = ResolveSessionUtils.getClassDescriptorsByFqName(resolveSession.getModuleDescriptor(), FqName(qualifiedName)).filter(visibilityFilter)
+                val descriptors = ResolveSessionUtils.getClassDescriptorsByFqName(moduleDescriptor, FqName(qualifiedName)).filter(visibilityFilter)
                 collector.addDescriptorElements(descriptors, suppressAutoInsertion = true)
             }
         }

idea/src/org/jetbrains/jet/plugin/completion/CompletionSession.kt

@@ -28,7 +28,6 @@ import org.jetbrains.jet.plugin.caches.resolve.*
 import org.jetbrains.jet.plugin.codeInsight.ReferenceVariantsHelper
 import org.jetbrains.jet.plugin.completion.smart.SmartCompletion
 import org.jetbrains.jet.plugin.references.JetSimpleNameReference
-import org.jetbrains.jet.plugin.project.ResolveSessionForBodies
 import org.jetbrains.jet.plugin.caches.KotlinIndicesHelper
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.DelegatingGlobalSearchScope
@@ -51,7 +50,9 @@ abstract class CompletionSessionBase(protected val configuration: CompletionSess
                                      resultSet: CompletionResultSet) {
     protected val position: PsiElement = parameters.getPosition()
     protected val jetReference: JetSimpleNameReference? = position.getParent()?.getReferences()?.filterIsInstance(javaClass<JetSimpleNameReference>())?.firstOrNull()
-    protected val resolveSession: ResolveSessionForBodies = (position.getContainingFile() as JetFile).getLazyResolveSession()
+    private val file = position.getContainingFile() as JetFile
+    protected val resolveSession: ResolutionFacade = file.getLazyResolveSession()
+    protected val moduleDescriptor: ModuleDescriptor = resolveSession.getModuleDescriptorForElement(file)
     protected val bindingContext: BindingContext? = jetReference?.let { resolveSession.resolveToElement(it.expression) }
     protected val inDescriptor: DeclarationDescriptor? = jetReference?.let { bindingContext!!.get(BindingContext.RESOLUTION_SCOPE, it.expression)?.getContainingDeclaration() }
 
@@ -90,7 +91,8 @@ abstract class CompletionSessionBase(protected val configuration: CompletionSess
         override fun contains(file: VirtualFile) = super.contains(file) && file != parameters.getOriginalFile().getVirtualFile()
     }
 
-    protected val indicesHelper: KotlinIndicesHelper = KotlinIndicesHelper(project, resolveSession, searchScope) { isVisibleDescriptor(it) }
+    protected val indicesHelper: KotlinIndicesHelper
+            = KotlinIndicesHelper(project, resolveSession, searchScope, moduleDescriptor) { isVisibleDescriptor(it) }
 
     protected fun isVisibleDescriptor(descriptor: DeclarationDescriptor): Boolean {
         if (configuration.completeNonAccessibleDeclarations) return true
@@ -138,7 +140,10 @@ abstract class CompletionSessionBase(protected val configuration: CompletionSess
             = indicesHelper.getCallableExtensions({ prefixMatcher.prefixMatches(it) }, jetReference!!.expression)
 
     protected fun addAllClasses(kindFilter: (ClassKind) -> Boolean) {
-        AllClassesCompletion(parameters, resolveSession, searchScope, prefixMatcher, kindFilter, { isVisibleDescriptor(it) }).collect(collector)
+        AllClassesCompletion(
+                parameters, resolveSession, moduleDescriptor,
+                searchScope, prefixMatcher, kindFilter, { isVisibleDescriptor(it) }
+        ).collect(collector)
     }
 }
 

idea/src/org/jetbrains/jet/plugin/completion/DeclarationDescriptorLookupObject.kt

@@ -19,13 +19,17 @@ package org.jetbrains.jet.plugin.completion
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.psi.PsiElement
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
-import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade
 
 /**
  * Stores information about resolved descriptor and position of that descriptor.
  * Position will be used for sorting
  */
-public class DeclarationDescriptorLookupObject(public val descriptor: DeclarationDescriptor, private val analyzer: KotlinCodeAnalyzer, public val psiElement: PsiElement?) {
+public class DeclarationDescriptorLookupObject(
+        public val descriptor: DeclarationDescriptor,
+        private val analyzer: ResolutionFacade,
+        public val psiElement: PsiElement?
+) {
     override fun toString(): String {
         return super.toString() + " " + descriptor
     }

idea/src/org/jetbrains/jet/plugin/completion/ExpectedInfos.kt

@@ -65,11 +65,9 @@ import org.jetbrains.jet.lang.resolve.bindingContextUtil.getTargetFunctionDescri
 import org.jetbrains.jet.plugin.completion.smart.toList
 import org.jetbrains.jet.lang.descriptors.PropertyGetterDescriptor
 import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor
-import org.jetbrains.jet.plugin.project.ResolveSessionForBodies
 import org.jetbrains.jet.lang.descriptors.VariableDescriptor
 import org.jetbrains.jet.lang.resolve.calls.results.ResolutionStatus
-import org.jetbrains.jet.lang.resolve.scopes.receivers.Qualifier
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade
-import org.jetbrains.jet.lang.resolve.scopes.receivers.QualifierReceiver
 
 enum class Tail {
     COMMA
@@ -89,7 +87,7 @@ class PositionalArgumentExpectedInfo(type: JetType, name: String?, tail: Tail?,
             = function.hashCode()
 }
 
-class ExpectedInfos(val bindingContext: BindingContext, val resolveSession: ResolveSessionForBodies) {
+class ExpectedInfos(val bindingContext: BindingContext, val resolveSession: ResolutionFacade) {
     public fun calculate(expressionWithType: JetExpression): Collection<ExpectedInfo>? {
         return calculateForArgument(expressionWithType)
             ?: calculateForFunctionLiteralArgument(expressionWithType)
@@ -174,7 +172,10 @@ class ExpectedInfos(val bindingContext: BindingContext, val resolveSession: Reso
                 CheckValueArgumentsMode.ENABLED,
                 CompositeExtension(listOf()),
                 false).replaceCollectAllCandidates(true)
-        val callResolver = InjectorForMacros(callElement.getProject(), resolveSession.getModuleDescriptor()).getCallResolver()!!
+        val callResolver = InjectorForMacros(
+                callElement.getProject(),
+                resolveSession.getModuleDescriptorForElement(callElement)
+        ).getCallResolver()
         val results: OverloadResolutionResults<FunctionDescriptor> = callResolver.resolveFunctionCall(callResolutionContext)
 
         val expectedInfos = HashSet<ExpectedInfo>()

idea/src/org/jetbrains/jet/plugin/completion/LookupElementFactory.kt

@@ -24,7 +24,6 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.jet.lang.descriptors.*
 import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils
 import org.jetbrains.jet.lang.resolve.DescriptorUtils
-import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
 import org.jetbrains.jet.plugin.JetDescriptorIconProvider
 import org.jetbrains.jet.plugin.completion.handlers.*
@@ -36,9 +35,10 @@ import com.intellij.codeInsight.completion.JavaPsiClassReferenceElement
 import com.intellij.codeInsight.lookup.LookupElementDecorator
 import com.intellij.codeInsight.lookup.LookupElementPresentation
 import org.jetbrains.jet.lang.types.JetType
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade
 
 public open class LookupElementFactory protected() {
-    public open fun createLookupElement(analyzer: KotlinCodeAnalyzer, descriptor: DeclarationDescriptor): LookupElement {
+    public open fun createLookupElement(analyzer: ResolutionFacade, descriptor: DeclarationDescriptor): LookupElement {
         val _descriptor = if (descriptor is CallableMemberDescriptor)
             DescriptorUtils.unwrapFakeOverride(descriptor)
         else
@@ -51,7 +51,7 @@ public open class LookupElementFactory protected() {
     }
 
     private fun createLookupElement(
-            analyzer: KotlinCodeAnalyzer,
+            analyzer: ResolutionFacade,
             descriptor: DeclarationDescriptor,
             declaration: PsiElement?
     ): LookupElement {
@@ -149,7 +149,7 @@ public open class LookupElementFactory protected() {
 }
 
 public class BoldImmediateLookupElementFactory(private val receiverTypes: Collection<JetType>) : LookupElementFactory() {
-    override fun createLookupElement(analyzer: KotlinCodeAnalyzer, descriptor: DeclarationDescriptor): LookupElement {
+    override fun createLookupElement(analyzer: ResolutionFacade, descriptor: DeclarationDescriptor): LookupElement {
         val element = super.createLookupElement(analyzer, descriptor)
 
         if (descriptor !is CallableMemberDescriptor) return element

idea/src/org/jetbrains/jet/plugin/completion/LookupElementsCollector.kt

@@ -23,18 +23,18 @@ import com.intellij.codeInsight.lookup.LookupElementPresentation
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
 import org.jetbrains.jet.plugin.completion.handlers.*
-import org.jetbrains.jet.plugin.project.ResolveSessionForBodies
 import com.intellij.codeInsight.completion.PrefixMatcher
 import java.util.ArrayList
 import com.intellij.codeInsight.completion.CompletionResultSet
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor
 import com.intellij.openapi.util.TextRange
 import com.intellij.codeInsight.completion.CompletionParameters
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade
 
 class LookupElementsCollector(
         private val prefixMatcher: PrefixMatcher,
         private val completionParameters: CompletionParameters,
-        private val resolveSession: ResolveSessionForBodies,
+        private val resolveSession: ResolutionFacade,
         private val boldImmediateLookupElementFactory: LookupElementFactory
 ) {
     private val elements = ArrayList<LookupElement>()

idea/src/org/jetbrains/jet/plugin/completion/smart/SmartCompletion.kt

@@ -20,7 +20,6 @@ import org.jetbrains.jet.lang.descriptors.*
 import org.jetbrains.jet.lang.resolve.*
 import org.jetbrains.jet.lang.psi.*
 import org.jetbrains.jet.lexer.JetTokens
-import org.jetbrains.jet.plugin.project.ResolveSessionForBodies
 import org.jetbrains.jet.lang.types.*
 import com.intellij.codeInsight.lookup.*
 import com.intellij.codeInsight.completion.*
@@ -34,9 +33,10 @@ import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession
 import org.jetbrains.jet.renderer.DescriptorRenderer
 import org.jetbrains.jet.lang.psi.psiUtil.getReceiverExpression
 import org.jetbrains.jet.plugin.util.IdeDescriptorRenderers
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade
 
 class SmartCompletion(val expression: JetSimpleNameExpression,
-                      val resolveSession: ResolveSessionForBodies,
+                      val resolveSession: ResolutionFacade,
                       val visibilityFilter: (DeclarationDescriptor) -> Boolean,
                       val originalFile: JetFile,
                       val boldImmediateLookupElementFactory: LookupElementFactory) {

idea/src/org/jetbrains/jet/plugin/completion/smart/StaticMembers.kt

@@ -25,7 +25,6 @@ import com.intellij.codeInsight.lookup.LookupElementDecorator
 import com.intellij.codeInsight.lookup.LookupElementPresentation
 import org.jetbrains.jet.renderer.DescriptorRenderer
 import com.intellij.codeInsight.completion.InsertionContext
-import org.jetbrains.jet.plugin.project.ResolveSessionForBodies
 import org.jetbrains.jet.lang.resolve.BindingContext
 import org.jetbrains.jet.lang.psi.JetExpression
 import org.jetbrains.jet.plugin.completion.ExpectedInfo
@@ -33,10 +32,11 @@ import org.jetbrains.jet.plugin.util.makeNotNullable
 import org.jetbrains.jet.plugin.completion.qualifiedNameForSourceCode
 import org.jetbrains.jet.lang.resolve.descriptorUtil.isExtension
 import org.jetbrains.jet.plugin.util.IdeDescriptorRenderers
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade
 import org.jetbrains.jet.plugin.completion.LookupElementFactory
 
 // adds java static members, enum members and members from class object
-class StaticMembers(val bindingContext: BindingContext, val resolveSession: ResolveSessionForBodies) {
+class StaticMembers(val bindingContext: BindingContext, val resolveSession: ResolutionFacade) {
     public fun addToCollection(collection: MutableCollection<LookupElement>,
                                expectedInfos: Collection<ExpectedInfo>,
                                context: JetExpression,

idea/src/org/jetbrains/jet/plugin/completion/smart/TypeInstantiationItems.kt

@@ -28,7 +28,6 @@ import org.jetbrains.jet.plugin.codeInsight.ImplementMethodsHandler
 import com.intellij.codeInsight.lookup.LookupElementDecorator
 import com.intellij.codeInsight.lookup.LookupElementPresentation
 import com.intellij.codeInsight.completion.InsertionContext
-import org.jetbrains.jet.plugin.project.ResolveSessionForBodies
 import org.jetbrains.jet.plugin.completion.handlers.KotlinFunctionInsertHandler
 import org.jetbrains.jet.plugin.completion.*
 import org.jetbrains.jet.plugin.completion.handlers.CaretPosition
@@ -39,8 +38,9 @@ import org.jetbrains.jet.plugin.util.IdeDescriptorRenderers
 import org.jetbrains.jet.lang.resolve.BindingContext
 import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor
 import org.jetbrains.jet.lang.resolve.java.descriptor.SamConstructorDescriptor
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade
 
-class TypeInstantiationItems(val resolveSession: ResolveSessionForBodies, val bindingContext: BindingContext, val visibilityFilter: (DeclarationDescriptor) -> Boolean) {
+class TypeInstantiationItems(val resolveSession: ResolutionFacade, val bindingContext: BindingContext, val visibilityFilter: (DeclarationDescriptor) -> Boolean) {
     public fun addToCollection(collection: MutableCollection<LookupElement>, expectedInfos: Collection<ExpectedInfo>) {
         val expectedInfosGrouped: Map<JetType, List<ExpectedInfo>> = expectedInfos.groupBy { it.type.makeNotNullable() }
         for ((jetType, infos) in expectedInfosGrouped) {

idea/src/org/jetbrains/jet/plugin/completion/smart/Utils.kt

@@ -32,13 +32,13 @@ import com.intellij.codeInsight.lookup.LookupElementPresentation
 import java.util.ArrayList
 import org.jetbrains.jet.plugin.completion.*
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
-import org.jetbrains.jet.plugin.project.ResolveSessionForBodies
 import org.jetbrains.jet.plugin.completion.handlers.WithTailInsertHandler
 import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor
 import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor
 import com.intellij.openapi.util.Key
 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor
 import org.jetbrains.jet.lang.resolve.BindingContext
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade
 
 class ArtificialElementInsertHandler(
         val textBeforeCaret: String, val textAfterCaret: String, val shortenRefs: Boolean) : InsertHandler<LookupElement>{
@@ -188,7 +188,7 @@ fun functionType(function: FunctionDescriptor): JetType? {
 
 fun LookupElementFactory.createLookupElement(
         descriptor: DeclarationDescriptor,
-        resolveSession: ResolveSessionForBodies,
+        resolveSession: ResolutionFacade,
         bindingContext: BindingContext
 ): LookupElement {
     var element = createLookupElement(resolveSession, descriptor)

idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java

@@ -16,8 +16,6 @@
 
 package org.jetbrains.jet.plugin.debugger;
 
-import com.google.common.base.Predicate;
-import com.google.common.collect.Collections2;
 import com.intellij.debugger.NoDataException;
 import com.intellij.debugger.PositionManager;
 import com.intellij.debugger.SourcePosition;
@@ -45,7 +43,10 @@ import org.jetbrains.jet.codegen.AsmUtil;
 import org.jetbrains.jet.codegen.ClassBuilderFactories;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.state.JetTypeMapper;
-import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
+import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
+import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.calls.callUtil.CallUtilPackage;
@@ -58,9 +59,9 @@ import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.types.lang.InlineStrategy;
 import org.jetbrains.jet.lang.types.lang.InlineUtil;
 import org.jetbrains.jet.plugin.caches.resolve.IdeaModuleInfo;
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade;
 import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
 import org.jetbrains.jet.plugin.codeInsight.CodeInsightUtils;
-import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.plugin.util.DebuggerUtils;
 import org.jetbrains.org.objectweb.asm.Type;
 
@@ -302,10 +303,10 @@ public class JetPositionManager implements PositionManager {
 
     private static JetTypeMapper createTypeMapperForLibraryFile(@Nullable PsiElement notPositionedElement, @NotNull JetFile file) {
         JetElement element = getElementToCreateTypeMapperForLibraryFile(notPositionedElement);
-        ResolveSessionForBodies resolveSession = ResolvePackage.getLazyResolveSession(element);
+        ResolutionFacade resolveSession = ResolvePackage.getLazyResolveSession(element);
 
         GenerationState state = new GenerationState(file.getProject(), ClassBuilderFactories.THROW_EXCEPTION,
-                                                    resolveSession.getModuleDescriptor(),
+                                                    resolveSession.getModuleDescriptorForElement(element),
                                                     resolveSession.resolveToElement(element),
                                                     Collections.singletonList(file)
         );

idea/src/org/jetbrains/jet/plugin/debugger/PositionManagerLibraryClassFileSearcher.kt

@@ -22,21 +22,17 @@ import org.jetbrains.jet.lang.psi.JetElement
 import org.jetbrains.jet.descriptors.serialization.JavaProtoBuf
 import org.jetbrains.jet.renderer.DescriptorRenderer
 import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession
-import com.intellij.psi.PsiElement
 import com.intellij.openapi.diagnostic.Logger
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
 import com.intellij.openapi.roots.libraries.LibraryUtil
 import com.intellij.openapi.module.impl.scopes.LibraryScope
 import com.intellij.openapi.roots.LibraryOrderEntry
-import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.jet.lang.psi.JetDeclaration
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedCallableMemberDescriptor
 import org.jetbrains.jet.lang.descriptors.PropertyDescriptor
 import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.jet.lang.psi.JetNamedDeclaration
-import org.jetbrains.jet.lang.resolve.BindingContext
 import com.intellij.openapi.module.impl.scopes.JdkScope
 import com.intellij.openapi.roots.JdkOrderEntry
 import org.jetbrains.jet.lang.psi.JetPsiUtil
@@ -68,7 +64,7 @@ fun findPackagePartInternalNameForLibraryFile(elementAt: JetElement): String? {
     if (descriptor !is CallableDescriptor) return null
 
     val packageFqName = topLevelDeclaration.getContainingJetFile().getPackageFqName()
-    val packageDescriptor = resolveSession.getModuleDescriptor().getPackage(packageFqName)
+    val packageDescriptor = resolveSession.getModuleDescriptorForElement(topLevelDeclaration).getPackage(packageFqName)
     if (packageDescriptor == null) {
         reportError(topLevelDeclaration, descriptor)
         return null

idea/src/org/jetbrains/jet/plugin/liveTemplates/macro/BaseJetVariableMacro.java

@@ -39,8 +39,8 @@ import org.jetbrains.jet.lang.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents;
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade;
 import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
-import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.plugin.util.extensionsUtils.ExtensionsUtilsPackage;
 
 import java.util.ArrayList;
@@ -64,7 +64,7 @@ public abstract class BaseJetVariableMacro extends Macro {
         JetExpression contextExpression = findContextExpression(psiFile, context.getStartOffset());
         if (contextExpression == null) return null;
 
-        ResolveSessionForBodies resolveSession = ResolvePackage.getLazyResolveSession((JetFile) psiFile);
+        ResolutionFacade resolveSession = ResolvePackage.getLazyResolveSession((JetFile) psiFile);
 
         BindingContext bindingContext = resolveSession.resolveToElement(contextExpression);
         JetScope scope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, contextExpression);
@@ -73,7 +73,7 @@ public abstract class BaseJetVariableMacro extends Macro {
         }
 
         ExpressionTypingComponents components =
-                new InjectorForMacros(project, resolveSession.getModuleDescriptor()).getExpressionTypingComponents();
+                new InjectorForMacros(project, resolveSession.getModuleDescriptorForElement(contextExpression)).getExpressionTypingComponents();
 
         DataFlowInfo dataFlowInfo = getDataFlowInfo(bindingContext, contextExpression);
 

idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java

@@ -47,9 +47,9 @@ import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.lexer.JetTokens;
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade;
 import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
 import org.jetbrains.jet.plugin.codeInsight.ReferenceVariantsHelper;
-import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
 
 import java.awt.*;
@@ -58,7 +58,7 @@ import java.util.List;
 
 public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWithTabActionSupport<
         JetValueArgumentList,
-        Pair<? extends FunctionDescriptor, ResolveSessionForBodies>,
+        Pair<? extends FunctionDescriptor, ResolutionFacade>,
         JetValueArgument>
 {
     public final static Color GREEN_BACKGROUND = new JBColor(new Color(231, 254, 234), Gray._100);
@@ -112,7 +112,7 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith
 
     @Nullable
     @Override
-    public Object[] getParametersForDocumentation(Pair<? extends FunctionDescriptor, ResolveSessionForBodies> p, ParameterInfoContext context) {
+    public Object[] getParametersForDocumentation(Pair<? extends FunctionDescriptor, ResolutionFacade> p, ParameterInfoContext context) {
         return ArrayUtil.EMPTY_OBJECT_ARRAY; //todo: ?
     }
 
@@ -200,7 +200,7 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith
     }
 
     @Override
-    public void updateUI(Pair<? extends FunctionDescriptor, ResolveSessionForBodies> itemToShow, ParameterInfoUIContext context) {
+    public void updateUI(Pair<? extends FunctionDescriptor, ResolutionFacade> itemToShow, ParameterInfoUIContext context) {
         //todo: when we will have ability to pass Array as vararg, implement such feature here too?
         if (context == null || context.getParameterOwner() == null || !context.getParameterOwner().isValid()) {
             context.setUIComponentEnabled(false);
@@ -216,7 +216,7 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith
         JetValueArgumentList argumentList = (JetValueArgumentList) parameterOwner;
 
         FunctionDescriptor functionDescriptor = itemToShow.first;
-        ResolveSessionForBodies resolveSession = itemToShow.second;
+        ResolutionFacade resolveSession = itemToShow.second;
 
         List<ValueParameterDescriptor> valueParameters = functionDescriptor.getValueParameters();
         List<JetValueArgument> valueArguments = argumentList.getArguments();
@@ -382,8 +382,7 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith
             return null;
         }
 
-        ResolveSessionForBodies resolveSession =
+        ResolutionFacade resolveSession = ResolvePackage.getLazyResolveSession(callNameExpression.getContainingJetFile());
-                ResolvePackage.getLazyResolveSession(callNameExpression.getContainingJetFile());
         BindingContext bindingContext = resolveSession.resolveToElement(callNameExpression);
 
         JetScope scope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, callNameExpression);
@@ -412,7 +411,7 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith
         Collection<DeclarationDescriptor> variants = new ReferenceVariantsHelper(bindingContext, visibilityFilter).getReferenceVariants(
                 callNameExpression, new DescriptorKindFilter(DescriptorKindFilter.FUNCTIONS_MASK | DescriptorKindFilter.CLASSIFIERS_MASK, Collections.<DescriptorKindExclude>emptyList()), nameFilter);
 
-        Collection<Pair<? extends DeclarationDescriptor, ResolveSessionForBodies>> itemsToShow = new ArrayList<Pair<? extends DeclarationDescriptor, ResolveSessionForBodies>>();
+        Collection<Pair<? extends DeclarationDescriptor, ResolutionFacade>> itemsToShow = new ArrayList<Pair<? extends DeclarationDescriptor, ResolutionFacade>>();
         for (DeclarationDescriptor variant : variants) {
             if (variant instanceof FunctionDescriptor) {
                 //todo: renamed functions?

idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.kt

@@ -138,7 +138,8 @@ public class AutoImportFix(element: JetSimpleNameExpression) : JetHintAction<Jet
 
         val result = ArrayList<PrioritizedFqName>()
 
-        val indicesHelper = KotlinIndicesHelper(file.getProject(), resolveSession, searchScope, ::isVisible)
+        val moduleDescriptor = resolveSession.getModuleDescriptorForElement(element)
+        val indicesHelper = KotlinIndicesHelper(file.getProject(), resolveSession, searchScope, moduleDescriptor, ::isVisible)
 
         if (!element.isImportDirectiveExpression() && !JetPsiUtil.isSelectorInQualified(element)) {
             result.addAll(getClassNames(referenceName, file, searchScope))

idea/src/org/jetbrains/jet/plugin/quickfix/MakeOverriddenMemberOpenFix.java

@@ -34,8 +34,8 @@ import org.jetbrains.jet.lang.psi.JetCallableDeclaration;
 import org.jetbrains.jet.lang.psi.JetDeclaration;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.plugin.JetBundle;
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade;
 import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
-import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 
 import java.util.*;
 
@@ -61,7 +61,7 @@ public class MakeOverriddenMemberOpenFix extends JetIntentionAction<JetDeclarati
         overriddenNonOverridableMembers.clear();
         containingDeclarationsNames.clear();
 
-        ResolveSessionForBodies resolveSession = ResolvePackage.getLazyResolveSession((JetFile) file);
+        ResolutionFacade resolveSession = ResolvePackage.getLazyResolveSession((JetFile) file);
         DeclarationDescriptor descriptor = resolveSession.resolveToDescriptor(element);
         if (!(descriptor instanceof CallableMemberDescriptor)) return false;
 

idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/extractableAnalysisUtil.kt

@@ -697,11 +697,12 @@ fun ExtractionData.performAnalysis(): AnalysisResult {
 
     val modifiedVarDescriptorsForControlFlow = HashMap(modifiedVarDescriptorsWithExpressions)
     modifiedVarDescriptorsForControlFlow.keySet().retainAll(localInstructions.getVarDescriptorsAccessedAfterwards(bindingContext))
+    val moduleDescriptor = originalFile.getLazyResolveSession().getModuleDescriptorForElement(originalFile)
     val (controlFlow, controlFlowMessage) =
             analyzeControlFlow(
                     localInstructions,
                     pseudocode,
-                    originalFile.getLazyResolveSession().getModuleDescriptor(),
+                    moduleDescriptor,
                     bindingContext,
                     modifiedVarDescriptorsForControlFlow,
                     options,

idea/src/org/jetbrains/jet/plugin/refactoring/inline/KotlinInlineValHandler.java

@@ -59,10 +59,10 @@ import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.plugin.JetLanguage;
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade;
 import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
 import org.jetbrains.jet.plugin.codeInsight.ShortenReferences;
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
-import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.plugin.util.IdeDescriptorRenderers;
 
 import java.util.List;
@@ -261,7 +261,7 @@ public class KotlinInlineValHandler extends InlineActionHandler {
         JetFile containingFile = inlinedExpressions.get(0).getContainingJetFile();
         List<JetFunctionLiteralExpression> functionsToAddParameters = Lists.newArrayList();
 
-        ResolveSessionForBodies resolveSessionForBodies = ResolvePackage.getLazyResolveSession(containingFile);
+        ResolutionFacade resolveSessionForBodies = ResolvePackage.getLazyResolveSession(containingFile);
         for (JetExpression inlinedExpression : inlinedExpressions) {
             JetFunctionLiteralExpression functionLiteralExpression = getFunctionLiteralExpression(inlinedExpression);
             assert functionLiteralExpression != null : "can't find function literal expression for " + inlinedExpression.getText();
@@ -301,7 +301,7 @@ public class KotlinInlineValHandler extends InlineActionHandler {
 
     private static boolean needToAddParameterTypes(
             @NotNull JetFunctionLiteralExpression functionLiteralExpression,
-            @NotNull ResolveSessionForBodies resolveSessionForBodies
+            @NotNull ResolutionFacade resolveSessionForBodies
     ) {
         JetFunctionLiteral functionLiteral = functionLiteralExpression.getFunctionLiteral();
         BindingContext context = resolveSessionForBodies.resolveToElement(functionLiteralExpression);
@@ -322,7 +322,7 @@ public class KotlinInlineValHandler extends InlineActionHandler {
         JetFile containingFile = inlinedExpressions.get(0).getContainingJetFile();
         List<JetCallExpression> callsToAddArguments = Lists.newArrayList();
 
-        ResolveSessionForBodies resolveSessionForBodies = ResolvePackage.getLazyResolveSession(containingFile);
+        ResolutionFacade resolveSessionForBodies = ResolvePackage.getLazyResolveSession(containingFile);
         for (JetExpression inlinedExpression : inlinedExpressions) {
             BindingContext context = resolveSessionForBodies.resolveToElement(inlinedExpression);
             Call call = CallUtilPackage.getCallWithAssert(inlinedExpression, context);

idea/src/org/jetbrains/jet/plugin/refactoring/introduce/introduceVariable/KotlinIntroduceVariableHandler.java

@@ -35,6 +35,7 @@ import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.analyzer.AnalyzerPackage;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.psi.psiUtil.PsiUtilPackage;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -48,10 +49,10 @@ import org.jetbrains.jet.lang.types.TypeUtils;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.lexer.JetTokens;
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade;
 import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
 import org.jetbrains.jet.plugin.codeInsight.CodeInsightUtils;
 import org.jetbrains.jet.plugin.codeInsight.ShortenReferences;
-import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.plugin.refactoring.JetNameSuggester;
 import org.jetbrains.jet.plugin.refactoring.JetNameValidatorImpl;
 import org.jetbrains.jet.plugin.refactoring.JetRefactoringBundle;
@@ -62,7 +63,6 @@ import org.jetbrains.jet.plugin.util.psi.patternMatching.JetPsiRange;
 import org.jetbrains.jet.plugin.util.psi.patternMatching.JetPsiUnifier;
 import org.jetbrains.jet.plugin.util.psi.patternMatching.PatternMatchingPackage;
 import org.jetbrains.jet.plugin.util.psiModificationUtil.PsiModificationUtilPackage;
-import org.jetbrains.jet.renderer.DescriptorRenderer;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -123,9 +123,10 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
                 return;
             }
         }
-        ResolveSessionForBodies resolveSession =
+
-                ResolvePackage.getLazyResolveSession(expression);
+        ResolutionFacade resolveSession = ResolvePackage.getLazyResolveSession(expression);
         final BindingContext bindingContext = resolveSession.resolveToElement(expression);
+        ModuleDescriptor moduleDescriptorForElement = resolveSession.getModuleDescriptorForElement(expression);
         final JetType expressionType = bindingContext.get(BindingContext.EXPRESSION_TYPE, expression); //can be null or error type
         JetScope scope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, expression);
         if (scope != null) {
@@ -133,7 +134,7 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
 
             ObservableBindingTrace bindingTrace = new ObservableBindingTrace(new BindingTraceContext());
             JetType typeNoExpectedType = AnalyzerPackage.computeTypeInfoInContext(
-                    expression, scope, bindingTrace, dataFlowInfo, TypeUtils.NO_EXPECTED_TYPE, resolveSession.getModuleDescriptor()
+                    expression, scope, bindingTrace, dataFlowInfo, TypeUtils.NO_EXPECTED_TYPE, moduleDescriptorForElement
             ).getType();
             if (expressionType != null && typeNoExpectedType != null && !JetTypeChecker.DEFAULT.equalTypes(expressionType,
                                                                                                            typeNoExpectedType)) {

idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationProducer.java

@@ -35,10 +35,10 @@ import org.jetbrains.jet.lang.psi.JetNamedFunction;
 import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.plugin.MainFunctionDetector;
-import org.jetbrains.jet.plugin.util.ProjectRootsUtil;
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade;
 import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
 import org.jetbrains.jet.plugin.project.ProjectStructureUtil;
-import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
+import org.jetbrains.jet.plugin.util.ProjectRootsUtil;
 
 import java.util.List;
 
@@ -84,7 +84,7 @@ public class JetRunConfigurationProducer extends RuntimeConfigurationProducer im
         if (!(psiFile instanceof JetFile && ProjectRootsUtil.isInProjectOrLibSource(psiFile))) return null;
 
         JetFile jetFile = (JetFile) psiFile;
-        final ResolveSessionForBodies session = ResolvePackage.getLazyResolveSession(jetFile);
+        final ResolutionFacade session = ResolvePackage.getLazyResolveSession(jetFile);
         MainFunctionDetector mainFunctionDetector = new MainFunctionDetector(
                 new NotNullFunction<JetNamedFunction, FunctionDescriptor>() {
                     @NotNull

idea/tests/org/jetbrains/jet/plugin/parameterInfo/AbstractFunctionParameterInfoTest.java

@@ -24,7 +24,7 @@ import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetValueArgumentList;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
-import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade;
 
 public abstract class AbstractFunctionParameterInfoTest extends LightCodeInsightFixtureTestCase {
     @Override
@@ -64,7 +64,7 @@ public abstract class AbstractFunctionParameterInfoTest extends LightCodeInsight
 
         for (Object item : mockCreateParameterInfoContext.getItemsToShow()) {
             //noinspection unchecked
-            parameterInfoHandler.updateUI((Pair<? extends FunctionDescriptor, ResolveSessionForBodies>)item, parameterInfoUIContext);
+            parameterInfoHandler.updateUI((Pair<? extends FunctionDescriptor, ResolutionFacade>)item, parameterInfoUIContext);
         }
         assertEquals(expectedResultText, parameterInfoUIContext.getResultText());
     }

idea/tests/org/jetbrains/jet/plugin/stubs/AbstractLazyResolveByStubTest.java

@@ -31,8 +31,8 @@ import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.plugin.JetWithJdkAndRuntimeLightProjectDescriptor;
 import org.jetbrains.jet.plugin.KotlinCodeInsightTestCase;
-import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheService;
+import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade;
-import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
+import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
 import org.jetbrains.jet.test.util.RecursiveDescriptorComparator;
 import org.junit.Assert;
 
@@ -64,9 +64,9 @@ public abstract class AbstractLazyResolveByStubTest extends KotlinCodeInsightTes
     }
 
     private void performTest(@NotNull String path, boolean checkPrimaryConstructors, boolean checkPropertyAccessors) {
-        ResolveSessionForBodies resolveSession =
+        JetFile file = (JetFile) getFile();
-                KotlinCacheService.OBJECT$.getInstance(getFile().getProject()).getLazyResolveSession((JetFile) getFile());
+        ResolutionFacade resolveSession = ResolvePackage.getLazyResolveSession(file);
-        ModuleDescriptor module = resolveSession.getModuleDescriptor();
+        ModuleDescriptor module = resolveSession.getModuleDescriptorForElement(file);
         PackageViewDescriptor packageViewDescriptor = module.getPackage(new FqName("test"));
         Assert.assertNotNull(packageViewDescriptor);