AnalyzerFacadeWithCache.getLazyResolveSessionForFile() inlined

idea/src/org/jetbrains/jet/plugin/caches/resolve/IDELightClassGenerationSupport.java

@@ -38,7 +38,6 @@ import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.plugin.libraries.JetSourceNavigationHelper;
-import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
 import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.plugin.stubindex.JetAllPackagesIndex;
 import org.jetbrains.jet.plugin.stubindex.JetClassByPackageIndex;
@@ -87,7 +86,7 @@ public class IDELightClassGenerationSupport extends LightClassGenerationSupport
         List<JetFile> sortedFiles = new ArrayList<JetFile>(files);
         Collections.sort(sortedFiles, jetFileComparator);
 
-        ResolveSessionForBodies session = AnalyzerFacadeWithCache.getLazyResolveSessionForFile(sortedFiles.get(0));
+        ResolveSessionForBodies session = ResolvePackage.getLazyResolveSession(sortedFiles.get(0));
         forceResolvePackageDeclarations(files, session);
         return new LightClassConstructionContext(session.getBindingContext(), null);
     }
@@ -95,7 +94,7 @@ public class IDELightClassGenerationSupport extends LightClassGenerationSupport
     @NotNull
     @Override
     public LightClassConstructionContext getContextForClassOrObject(@NotNull JetClassOrObject classOrObject) {
-        ResolveSessionForBodies session = AnalyzerFacadeWithCache.getLazyResolveSessionForFile(classOrObject.getContainingJetFile());
+        ResolveSessionForBodies session = ResolvePackage.getLazyResolveSession(classOrObject.getContainingJetFile());
 
         if (JetPsiUtil.isLocal(classOrObject)) {
             BindingContext bindingContext = session.resolveToElement(classOrObject);

idea/src/org/jetbrains/jet/plugin/codeInsight/JetFileReferencesResolver.kt

@@ -21,7 +21,6 @@ import org.jetbrains.jet.lang.psi.JetElement
 import org.jetbrains.jet.lang.resolve.BindingContext
 import org.jetbrains.jet.lang.psi.JetFile
 import org.jetbrains.jet.lang.psi.JetTreeVisitorVoid
-import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache
 import com.intellij.util.containers.HashMap
 import org.jetbrains.jet.lang.psi.JetUserType
 import org.jetbrains.jet.lang.psi.JetDotQualifiedExpression
@@ -29,6 +28,7 @@ import org.jetbrains.jet.lang.psi.JetExpression
 import org.jetbrains.jet.lang.psi.JetCallExpression
 import org.jetbrains.jet.lang.psi.JetSimpleNameExpression
 import java.util.Collections
+import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession
 
 object JetFileReferencesResolver {
     fun resolve(
@@ -58,7 +58,7 @@ object JetFileReferencesResolver {
     }
 
     private class ResolveAllReferencesVisitor(file: JetFile, val visitReceivers: Boolean, val visitShortNames: Boolean) : JetTreeVisitorVoid() {
-        private val resolveSession = AnalyzerFacadeWithCache.getLazyResolveSessionForFile(file)
+        private val resolveSession = file.getLazyResolveSession()
         private val resolveMap = HashMap<JetReferenceExpression, BindingContext>()
 
         public val result: Map<JetReferenceExpression, BindingContext> = resolveMap

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

@@ -5,7 +5,6 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
-import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
 import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.plugin.quickfix.ImportInsertHelper;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
@@ -19,6 +18,7 @@ import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyPackageFragmentF
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaMethodDescriptor
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.SmartPointerManager
+import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession
 
 public object ShortenReferences {
     public fun process(element: JetElement) {
@@ -83,7 +83,7 @@ public object ShortenReferences {
                                       val elementFilter: (PsiElement) -> FilterResult,
                                       val resolveMap: Map<JetReferenceExpression, BindingContext>) : JetVisitorVoid() {
         private val resolveSession : ResolveSessionForBodies
-            get() = AnalyzerFacadeWithCache.getLazyResolveSessionForFile(file)
+            get() = file.getLazyResolveSession()
 
         private val typesToShorten = ArrayList<JetUserType>()
 
@@ -158,7 +158,7 @@ public object ShortenReferences {
                                                      val elementFilter: (PsiElement) -> FilterResult,
                                                      val resolveMap: Map<JetReferenceExpression, BindingContext>) : JetVisitorVoid() {
         private val resolveSession : ResolveSessionForBodies
-            get() = AnalyzerFacadeWithCache.getLazyResolveSessionForFile(file)
+            get() = file.getLazyResolveSession()
 
         private fun bindingContext(expression: JetReferenceExpression): BindingContext
                 = resolveMap[expression] ?: resolveSession.resolveToElement(expression) // binding context can be absent in the map if some references have been shortened already

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

@@ -38,10 +38,10 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.plugin.caches.JetShortNamesCache;
+import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
 import org.jetbrains.jet.plugin.codeInsight.TipsManager;
 import org.jetbrains.jet.plugin.completion.smart.SmartCompletion;
 import org.jetbrains.jet.plugin.completion.weigher.WeigherPackage;
-import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
 import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.plugin.references.JetSimpleNameReference;
 
@@ -64,7 +64,7 @@ class CompletionSession {
         this.jetReference = jetReference;
 
         ResolveSessionForBodies resolveSession =
-                AnalyzerFacadeWithCache.getLazyResolveSessionForFile((JetFile) position.getContainingFile());
+                ResolvePackage.getLazyResolveSession((JetFile) position.getContainingFile());
         BindingContext expressionBindingContext = resolveSession.resolveToElement(jetReference.getExpression());
         JetScope scope = expressionBindingContext.get(BindingContext.RESOLUTION_SCOPE, jetReference.getExpression());
 

idea/src/org/jetbrains/jet/plugin/completion/JetPackagesContributor.java

@@ -28,8 +28,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetPackageDirective;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
 import org.jetbrains.jet.plugin.codeInsight.TipsManager;
-import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
 import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.plugin.references.JetSimpleNameReference;
 
@@ -71,8 +71,8 @@ public class JetPackagesContributor extends CompletionContributor {
                                int prefixLength = parameters.getOffset() - simpleNameReference.getExpression().getTextOffset();
                                result = result.withPrefixMatcher(new PlainPrefixMatcher(name.substring(0, prefixLength)));
 
-                               ResolveSessionForBodies resolveSession = AnalyzerFacadeWithCache
-                                       .getLazyResolveSessionForFile(simpleNameReference.getExpression().getContainingJetFile());
+                               ResolveSessionForBodies resolveSession =
+                                       ResolvePackage.getLazyResolveSession(simpleNameReference.getExpression().getContainingJetFile());
                                BindingContext bindingContext = resolveSession.resolveToElement(simpleNameReference.getExpression());
 
                                for (LookupElement variant : DescriptorLookupConverter.collectLookupElements(

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

@@ -21,19 +21,16 @@ import org.jetbrains.jet.lang.psi.JetCallExpression
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache
 import org.jetbrains.jet.lang.resolve.BindingContext
 import org.jetbrains.jet.lang.psi.JetPsiFactory
-import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace
 import org.jetbrains.jet.lang.resolve.calls.util.DelegatingCall
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo
 import org.jetbrains.jet.lang.types.TypeUtils
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptor
-import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults
 import org.jetbrains.jet.lang.resolve.scopes.JetScope
 import org.jetbrains.jet.lang.psi.JetTypeProjection
 import org.jetbrains.jet.lang.psi.Call
 import java.util.ArrayList
-import org.jetbrains.jet.lang.psi.JetFile
 import org.jetbrains.jet.di.InjectorForMacros
 import org.jetbrains.jet.lang.resolve.BindingTraceContext
+import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession
 
 public class RemoveExplicitTypeArguments : JetSelfTargetingIntention<JetCallExpression>(
         "remove.explicit.type.arguments", javaClass()) {
@@ -43,7 +40,7 @@ public class RemoveExplicitTypeArguments : JetSelfTargetingIntention<JetCallExpr
         val context = AnalyzerFacadeWithCache.getContextForElement(element)
         if (element.getTypeArguments().isEmpty()) return false
 
-        val resolveSession = AnalyzerFacadeWithCache.getLazyResolveSessionForFile(element.getContainingJetFile())
+        val resolveSession = element.getContainingJetFile().getLazyResolveSession()
         val injector = InjectorForMacros(element.getProject(), resolveSession.getModuleDescriptor())
 
         val scope = context[BindingContext.RESOLUTION_SCOPE, element]

idea/src/org/jetbrains/jet/plugin/intentions/Utils.kt

@@ -2,13 +2,13 @@ package org.jetbrains.jet.plugin.intentions
 
 import org.jetbrains.jet.lang.psi.*
 import org.jetbrains.jet.lang.types.JetType
-import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache
 import org.jetbrains.jet.lang.resolve.BindingContext
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor
 import org.jetbrains.jet.renderer.DescriptorRenderer
 import org.jetbrains.jet.plugin.codeInsight.ShortenReferences
 import org.jetbrains.jet.JetNodeTypes
 import org.jetbrains.jet.lexer.JetTokens
+import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession
 
 fun specifyTypeExplicitly(declaration: JetNamedFunction, typeText: String) {
     specifyTypeExplicitly(declaration, JetPsiFactory.createType(declaration.getProject(), typeText))
@@ -29,13 +29,13 @@ fun specifyTypeExplicitly(declaration: JetNamedFunction, typeReference: JetTypeR
 }
 
 fun expressionType(expression: JetExpression): JetType? {
-    val resolveSession = AnalyzerFacadeWithCache.getLazyResolveSessionForFile(expression.getContainingJetFile())
+    val resolveSession = expression.getContainingJetFile().getLazyResolveSession()
     val bindingContext = resolveSession.resolveToElement(expression)
     return bindingContext.get(BindingContext.EXPRESSION_TYPE, expression)
 }
 
 fun functionReturnType(function: JetNamedFunction): JetType? {
-    val resolveSession = AnalyzerFacadeWithCache.getLazyResolveSessionForFile(function.getContainingJetFile())
+    val resolveSession = function.getContainingJetFile().getLazyResolveSession()
     val bindingContext = resolveSession.resolveToElement(function)
     val descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, function)
     if (descriptor == null) return null

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

@@ -37,8 +37,8 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents;
+import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
 import org.jetbrains.jet.plugin.codeInsight.TipsManager;
-import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
 import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 
 import java.util.ArrayList;
@@ -60,7 +60,7 @@ public abstract class BaseJetVariableMacro extends Macro {
         JetExpression contextExpression = findContextExpression(psiFile, context.getStartOffset());
         if (contextExpression == null) return null;
 
-        ResolveSessionForBodies resolveSession = AnalyzerFacadeWithCache.getLazyResolveSessionForFile((JetFile) psiFile);
+        ResolveSessionForBodies resolveSession = ResolvePackage.getLazyResolveSession((JetFile) psiFile);
 
         BindingContext bc = resolveSession.resolveToElement(contextExpression);
         JetScope scope = bc.get(BindingContext.RESOLUTION_SCOPE, contextExpression);

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

@@ -44,8 +44,8 @@ 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.ResolvePackage;
 import org.jetbrains.jet.plugin.codeInsight.TipsManager;
-import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
 import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
 
@@ -380,7 +380,7 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith
         }
 
         ResolveSessionForBodies resolveSession =
-                AnalyzerFacadeWithCache.getLazyResolveSessionForFile(callNameExpression.getContainingJetFile());
+                ResolvePackage.getLazyResolveSession(callNameExpression.getContainingJetFile());
         BindingContext bindingContext = resolveSession.resolveToElement(callNameExpression);
 
         JetScope scope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, callNameExpression);

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

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

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

@@ -51,7 +51,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.project.AnalyzerFacadeWithCache;
+import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
 import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.plugin.project.ProjectStructureUtil;
 import org.jetbrains.jet.plugin.util.JetPsiHeuristicsUtil;
@@ -93,7 +93,7 @@ public class AutoImportFix extends JetHintAction<JetSimpleNameExpression> implem
         }
 
         ResolveSessionForBodies resolveSessionForBodies =
-                AnalyzerFacadeWithCache.getLazyResolveSessionForFile(element.getContainingJetFile());
+                ResolvePackage.getLazyResolveSession(element.getContainingJetFile());
 
         List<FqName> result = Lists.newArrayList();
         if (!isSuppressedTopLevelImportInPosition(element)) {

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

@@ -33,7 +33,7 @@ import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 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.project.AnalyzerFacadeWithCache;
+import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
 import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 
 import java.util.*;
@@ -60,7 +60,7 @@ public class MakeOverriddenMemberOpenFix extends JetIntentionAction<JetDeclarati
         overriddenNonOverridableMembers.clear();
         containingDeclarationsNames.clear();
 
-        ResolveSessionForBodies resolveSession = AnalyzerFacadeWithCache.getLazyResolveSessionForFile((JetFile) file);
+        ResolveSessionForBodies resolveSession = ResolvePackage.getLazyResolveSession((JetFile) file);
         DeclarationDescriptor descriptor = resolveSession.resolveToDescriptor(element);
         if (!(descriptor instanceof CallableMemberDescriptor)) return false;
 

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

@@ -31,7 +31,6 @@ import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor
 import org.jetbrains.jet.plugin.refactoring.JetRefactoringBundle
 import org.jetbrains.jet.lang.cfg.pseudocode.PseudocodeUtil
-import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache
 import org.jetbrains.jet.plugin.util.MaybeValue
 import org.jetbrains.jet.plugin.util.Maybe
 import org.jetbrains.jet.lang.psi.psiUtil.isInsideOf
@@ -80,18 +79,16 @@ import org.jetbrains.jet.lang.psi.JetQualifiedExpression
 import org.jetbrains.jet.lang.psi.JetCallExpression
 import org.jetbrains.jet.lang.psi.JetTreeVisitorVoid
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker
-import org.jetbrains.jet.lang.resolve.name.FqName
 import org.jetbrains.jet.lang.resolve.DescriptorUtils
 import com.intellij.refactoring.util.RefactoringUIUtil
-import org.jetbrains.jet.plugin.references.JetReference
 import org.jetbrains.jet.lang.psi.psiUtil.replaced
-import org.jetbrains.jet.lang.psi.psiUtil.isAncestor
 import java.util.Collections
 import com.intellij.psi.PsiNamedElement
-import org.jetbrains.jet.lang.diagnostics.Severity
-import org.jetbrains.jet.lang.diagnostics.Errors
 import org.jetbrains.jet.lang.descriptors.impl.LocalVariableDescriptor
 import org.jetbrains.jet.lang.types.ErrorUtils
+import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession
+import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache
+import org.jetbrains.jet.lang.diagnostics.Errors
 
 private val DEFAULT_FUNCTION_NAME = "myFun"
 private val DEFAULT_RETURN_TYPE = KotlinBuiltIns.getInstance().getUnitType()
@@ -425,7 +422,7 @@ fun ExtractionData.performAnalysis(): Maybe<ExtractionDescriptor, String> {
     val enclosingDeclaration = commonParent.getParentByType(javaClass<JetDeclarationWithBody>())
     if (enclosingDeclaration == null) return MaybeError(JetRefactoringBundle.message("cannot.refactor.no.container")!!)
 
-    val resolveSession = AnalyzerFacadeWithCache.getLazyResolveSessionForFile(originalFile)
+    val resolveSession = originalFile.getLazyResolveSession()
     val bindingContext = resolveSession.resolveToElement(enclosingDeclaration.getBodyExpression())
 
     val pseudocode = PseudocodeUtil.generatePseudocode(enclosingDeclaration, bindingContext)

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

@@ -58,6 +58,7 @@ 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.ResolvePackage;
 import org.jetbrains.jet.plugin.codeInsight.ShortenReferences;
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
 import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
@@ -257,7 +258,7 @@ public class KotlinInlineValHandler extends InlineActionHandler {
         JetFile containingFile = inlinedExpressions.get(0).getContainingJetFile();
         List<JetFunctionLiteralExpression> functionsToAddParameters = Lists.newArrayList();
 
-        ResolveSessionForBodies resolveSessionForBodies = AnalyzerFacadeWithCache.getLazyResolveSessionForFile(containingFile);
+        ResolveSessionForBodies resolveSessionForBodies = ResolvePackage.getLazyResolveSession(containingFile);
         for (JetExpression inlinedExpression : inlinedExpressions) {
             JetFunctionLiteralExpression functionLiteralExpression = getFunctionLiteralExpression(inlinedExpression);
             assert functionLiteralExpression != null : "can't find function literal expression for " + inlinedExpression.getText();
@@ -317,7 +318,7 @@ public class KotlinInlineValHandler extends InlineActionHandler {
         JetFile containingFile = inlinedExpressions.get(0).getContainingJetFile();
         List<JetCallExpression> callsToAddArguments = Lists.newArrayList();
 
-        ResolveSessionForBodies resolveSessionForBodies = AnalyzerFacadeWithCache.getLazyResolveSessionForFile(containingFile);
+        ResolveSessionForBodies resolveSessionForBodies = ResolvePackage.getLazyResolveSession(containingFile);
         for (JetExpression inlinedExpression : inlinedExpressions) {
             JetCallExpression callExpression = getCallExpression(inlinedExpression);
             assert callExpression != null : "can't find call expression for " + inlinedExpression.getText();

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

@@ -48,6 +48,7 @@ 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.ResolvePackage;
 import org.jetbrains.jet.plugin.codeInsight.CodeInsightUtils;
 import org.jetbrains.jet.plugin.codeInsight.ShortenReferences;
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
@@ -119,7 +120,7 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
             }
         }
         ResolveSessionForBodies resolveSession =
-                AnalyzerFacadeWithCache.getLazyResolveSessionForFile(expression.getContainingJetFile());
+                ResolvePackage.getLazyResolveSession(expression.getContainingJetFile());
         BindingContext bindingContext = resolveSession.resolveToElement(expression);
         final JetType expressionType = bindingContext.get(BindingContext.EXPRESSION_TYPE, expression); //can be null or error type
         JetScope scope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, expression);

idea/tests/org/jetbrains/jet/plugin/codeInsight/AbstractOverrideImplementTest.java

@@ -41,6 +41,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.plugin.JetLightProjectDescriptor;
+import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
 import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 
@@ -123,7 +124,7 @@ public abstract class AbstractOverrideImplementTest extends LightCodeInsightFixt
         assertNotNull("Caret should be inside class or object", classOrObject);
 
         final JetFile jetFile = classOrObject.getContainingJetFile();
-        final ResolveSessionForBodies resolveSession = AnalyzerFacadeWithCache.getLazyResolveSessionForFile(jetFile);
+        final ResolveSessionForBodies resolveSession = ResolvePackage.getLazyResolveSession(jetFile);
         Set<CallableMemberDescriptor> descriptors =
                 handler.collectMethodsToGenerate(classOrObject, resolveSession.resolveToElement(classOrObject));