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 {
-    return KotlinCacheService.getInstance(getProject()).getLazyResolveSession(this)
+public fun JetElement.getLazyResolveSession(): ResolutionFacade {
+    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);
     }
 }