Rename: CancelableResolveSession -> ResolveSessionForBodies

idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java

@@ -48,7 +48,7 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils;
 import org.jetbrains.jet.plugin.caches.resolve.IDELightClassGenerationSupport;
-import org.jetbrains.jet.plugin.project.CancelableResolveSession;
+import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.plugin.stubindex.*;
 
 import java.util.*;
@@ -181,7 +181,7 @@ public class JetShortNamesCache extends PsiShortNamesCache {
     public Collection<ClassDescriptor> getTopLevelObjectsByName(
             @NotNull String name,
             @NotNull JetSimpleNameExpression expression,
-            @NotNull CancelableResolveSession resolveSession,
+            @NotNull ResolveSessionForBodies resolveSession,
             @NotNull GlobalSearchScope scope
     ) {
         BindingContext context = resolveSession.resolveToElement(expression);
@@ -216,7 +216,7 @@ public class JetShortNamesCache extends PsiShortNamesCache {
     public Collection<FunctionDescriptor> getTopLevelFunctionDescriptorsByName(
             @NotNull String name,
             @NotNull JetSimpleNameExpression expression,
-            @NotNull CancelableResolveSession resolveSession,
+            @NotNull ResolveSessionForBodies resolveSession,
             @NotNull GlobalSearchScope scope
     ) {
         // name parameter can differ from expression.getReferenceName() when expression contains completion suffix
@@ -288,7 +288,7 @@ public class JetShortNamesCache extends PsiShortNamesCache {
     public Collection<DeclarationDescriptor> getJetCallableExtensions(
             @NotNull final Condition<String> acceptedNameCondition,
             @NotNull JetSimpleNameExpression expression,
-            @NotNull CancelableResolveSession resolveSession,
+            @NotNull ResolveSessionForBodies resolveSession,
             @NotNull GlobalSearchScope searchScope
     ) {
         BindingContext context = resolveSession.resolveToElement(expression);

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

@@ -28,13 +28,13 @@ import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.java.JetFilesProvider;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeProvider;
-import org.jetbrains.jet.plugin.project.CancelableResolveSession;
+import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.plugin.project.TargetPlatform;
 
 import java.util.Collection;
 
 public abstract class DeclarationsCacheProvider {
-    private final CachedValue<CancelableResolveSession> lazyResolveCache;
+    private final CachedValue<ResolveSessionForBodies> lazyResolveCache;
 
     protected final TargetPlatform platform;
     protected final Project project;
@@ -50,7 +50,7 @@ public abstract class DeclarationsCacheProvider {
     public abstract KotlinDeclarationsCache getDeclarations(boolean allowIncomplete);
 
     @NotNull
-    public CancelableResolveSession getLazyResolveSession() {
+    public ResolveSessionForBodies getLazyResolveSession() {
         return lazyResolveCache.getValue();
     }
 
@@ -58,7 +58,7 @@ public abstract class DeclarationsCacheProvider {
         return JetFilesProvider.getInstance(project).isFileInScope(jetFile, GlobalSearchScope.allScope(project));
     }
 
-    private static class CancelableResolveSessionValueProvider implements CachedValueProvider<CancelableResolveSession> {
+    private static class CancelableResolveSessionValueProvider implements CachedValueProvider<ResolveSessionForBodies> {
         private final Project project;
         private final TargetPlatform platform;
 
@@ -69,10 +69,10 @@ public abstract class DeclarationsCacheProvider {
 
         @Nullable
         @Override
-        public synchronized Result<CancelableResolveSession> compute() {
+        public synchronized Result<ResolveSessionForBodies> compute() {
             Collection<JetFile> files = JetFilesProvider.getInstance(project).allInScope(GlobalSearchScope.allScope(project));
             ResolveSession resolveSession = AnalyzerFacadeProvider.getAnalyzerFacade(platform).getLazyResolveSession(project, files);
-            return Result.create(new CancelableResolveSession(project, resolveSession), PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT);
+            return Result.create(new ResolveSessionForBodies(project, resolveSession), PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT);
         }
     }
 }

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

@@ -7,7 +7,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
-import org.jetbrains.jet.plugin.project.CancelableResolveSession;
+import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.plugin.quickfix.ImportInsertHelper;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
 
@@ -76,7 +76,7 @@ public object ShortenReferences {
     }
 
     private class ShortenTypesVisitor(val file: JetFile, val resolveMap: Map<JetReferenceExpression, BindingContext>) : JetVisitorVoid() {
-        private val resolveSession : CancelableResolveSession
+        private val resolveSession : ResolveSessionForBodies
             get() = AnalyzerFacadeWithCache.getLazyResolveSessionForFile(file)
 
         private val typesToShorten = ArrayList<JetUserType>()
@@ -142,7 +142,7 @@ public object ShortenReferences {
     }
 
     private class ShortenQualifiedExpressionsVisitor(val file: JetFile, val resolveMap: Map<JetReferenceExpression, BindingContext>) : JetVisitorVoid() {
-        private val resolveSession : CancelableResolveSession
+        private val resolveSession : ResolveSessionForBodies
             get() = AnalyzerFacadeWithCache.getLazyResolveSessionForFile(file)
 
         private fun bindingContext(expression: JetReferenceExpression): BindingContext

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

@@ -40,7 +40,7 @@ import org.jetbrains.jet.plugin.caches.JetShortNamesCache;
 import org.jetbrains.jet.plugin.codeInsight.TipsManager;
 import org.jetbrains.jet.plugin.completion.weigher.WeigherPackage;
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
-import org.jetbrains.jet.plugin.project.CancelableResolveSession;
+import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.plugin.references.JetSimpleNameReference;
 
 import java.util.Collection;
@@ -61,7 +61,7 @@ class CompletionSession {
         this.parameters = parameters;
         this.jetReference = jetReference;
 
-        CancelableResolveSession resolveSession =
+        ResolveSessionForBodies resolveSession =
                 AnalyzerFacadeWithCache.getLazyResolveSessionForFile((JetFile) position.getContainingFile());
         BindingContext expressionBindingContext = resolveSession.resolveToElement(jetReference.getExpression());
         JetScope scope = expressionBindingContext.get(BindingContext.RESOLUTION_SCOPE, jetReference.getExpression());
@@ -274,7 +274,7 @@ class CompletionSession {
         return jetResult.getBindingContext();
     }
 
-    private CancelableResolveSession getResolveSession() {
+    private ResolveSessionForBodies getResolveSession() {
         return jetResult.getResolveSession();
     }
 

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

@@ -23,10 +23,10 @@ import com.intellij.openapi.util.Conditions;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.plugin.project.CancelableResolveSession;
+import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 
 public class JetCompletionResultSet {
-    private final CancelableResolveSession resolveSession;
+    private final ResolveSessionForBodies resolveSession;
     private final BindingContext bindingContext;
     private final Condition<DeclarationDescriptor> descriptorFilter;
     private final CompletionResultSet result;
@@ -34,14 +34,14 @@ public class JetCompletionResultSet {
 
     public JetCompletionResultSet(
             @NotNull CompletionResultSet result,
-            @NotNull CancelableResolveSession resolveSession,
+            @NotNull ResolveSessionForBodies resolveSession,
             @NotNull BindingContext bindingContext) {
         this(result, resolveSession, bindingContext, Conditions.<DeclarationDescriptor>alwaysTrue());
     }
 
     public JetCompletionResultSet(
             @NotNull CompletionResultSet result,
-            @NotNull CancelableResolveSession resolveSession,
+            @NotNull ResolveSessionForBodies resolveSession,
             @NotNull BindingContext bindingContext,
             @NotNull Condition<DeclarationDescriptor> descriptorFilter) {
         this.result = result;
@@ -50,7 +50,7 @@ public class JetCompletionResultSet {
         this.descriptorFilter = descriptorFilter;
     }
 
-    public CancelableResolveSession getResolveSession() {
+    public ResolveSessionForBodies getResolveSession() {
         return resolveSession;
     }
 

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

@@ -30,7 +30,7 @@ import org.jetbrains.jet.lang.psi.JetPackageDirective;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.plugin.codeInsight.TipsManager;
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
-import org.jetbrains.jet.plugin.project.CancelableResolveSession;
+import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.plugin.references.JetSimpleNameReference;
 
 /**
@@ -71,7 +71,7 @@ public class JetPackagesContributor extends CompletionContributor {
                                int prefixLength = parameters.getOffset() - simpleNameReference.getExpression().getTextOffset();
                                result = result.withPrefixMatcher(new PlainPrefixMatcher(name.substring(0, prefixLength)));
 
-                               CancelableResolveSession resolveSession = AnalyzerFacadeWithCache
+                               ResolveSessionForBodies resolveSession = AnalyzerFacadeWithCache
                                        .getLazyResolveSessionForFile((JetFile) simpleNameReference.getExpression().getContainingFile());
                                BindingContext bindingContext = resolveSession.resolveToElement(simpleNameReference.getExpression());
 

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

@@ -4,7 +4,7 @@ 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.CancelableResolveSession
+import org.jetbrains.jet.plugin.project.ResolveSessionForBodies
 import org.jetbrains.jet.lang.types.*
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker
 import com.intellij.codeInsight.lookup.*
@@ -38,7 +38,7 @@ trait SmartCompletionData{
     val additionalElements: Iterable<LookupElement>
 }
 
-fun buildSmartCompletionData(expression: JetSimpleNameExpression, resolveSession: CancelableResolveSession): SmartCompletionData? {
+fun buildSmartCompletionData(expression: JetSimpleNameExpression, resolveSession: ResolveSessionForBodies): SmartCompletionData? {
     val parent = expression.getParent()
     val expressionWithType: JetExpression;
     val receiver: JetExpression?
@@ -102,7 +102,7 @@ fun buildSmartCompletionData(expression: JetSimpleNameExpression, resolveSession
     }
 }
 
-private fun calcItemsToSkip(expression: JetExpression, resolveSession: CancelableResolveSession): Collection<DeclarationDescriptor> {
+private fun calcItemsToSkip(expression: JetExpression, resolveSession: ResolveSessionForBodies): Collection<DeclarationDescriptor> {
     val parent = expression.getParent()
     when(parent) {
         is JetProperty -> {
@@ -124,7 +124,7 @@ private fun calcItemsToSkip(expression: JetExpression, resolveSession: Cancelabl
     return listOf()
 }
 
-private fun typeInstantiationItems(expectedType: JetType, resolveSession: CancelableResolveSession, bindingContext: BindingContext): Iterable<LookupElement> {
+private fun typeInstantiationItems(expectedType: JetType, resolveSession: ResolveSessionForBodies, bindingContext: BindingContext): Iterable<LookupElement> {
     val typeConstructor: TypeConstructor = expectedType.getConstructor()
     val classifier: ClassifierDescriptor? = typeConstructor.getDeclarationDescriptor()
     if (!(classifier is ClassDescriptor)) return listOf()
@@ -299,7 +299,7 @@ private fun processDataFlowInfo(dataFlowInfo: DataFlowInfo?, receiver: JetExpres
 }
 
 // adds java static members, enum members and members from class object
-private fun staticMembers(context: JetExpression, expectedType: JetType, resolveSession: CancelableResolveSession, bindingContext: BindingContext): Iterable<LookupElement> {
+private fun staticMembers(context: JetExpression, expectedType: JetType, resolveSession: ResolveSessionForBodies, bindingContext: BindingContext): Iterable<LookupElement> {
     val classDescriptor = TypeUtils.getClassDescriptor(expectedType)
     if (classDescriptor == null) return listOf()
     if (classDescriptor.getName().isSpecial()) return listOf()

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

@@ -45,7 +45,7 @@ import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.plugin.codeInsight.TipsManager;
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
-import org.jetbrains.jet.plugin.project.CancelableResolveSession;
+import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
 
 import java.awt.*;
@@ -54,7 +54,7 @@ import java.util.List;
 
 public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWithTabActionSupport<
         JetValueArgumentList,
-        Pair<? extends FunctionDescriptor, CancelableResolveSession>,
+        Pair<? extends FunctionDescriptor, ResolveSessionForBodies>,
         JetValueArgument>
 {
     public final static Color GREEN_BACKGROUND = new JBColor(new Color(231, 254, 234), Gray._100);
@@ -108,7 +108,7 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith
 
     @Nullable
     @Override
-    public Object[] getParametersForDocumentation(Pair<? extends FunctionDescriptor, CancelableResolveSession> p, ParameterInfoContext context) {
+    public Object[] getParametersForDocumentation(Pair<? extends FunctionDescriptor, ResolveSessionForBodies> p, ParameterInfoContext context) {
         return ArrayUtil.EMPTY_OBJECT_ARRAY; //todo: ?
     }
 
@@ -196,7 +196,7 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith
     }
 
     @Override
-    public void updateUI(Pair<? extends FunctionDescriptor, CancelableResolveSession> itemToShow, ParameterInfoUIContext context) {
+    public void updateUI(Pair<? extends FunctionDescriptor, ResolveSessionForBodies> 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);
@@ -212,7 +212,7 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith
         JetValueArgumentList argumentList = (JetValueArgumentList) parameterOwner;
 
         FunctionDescriptor functionDescriptor = itemToShow.first;
-        CancelableResolveSession resolveSession = itemToShow.second;
+        ResolveSessionForBodies resolveSession = itemToShow.second;
 
         List<ValueParameterDescriptor> valueParameters = functionDescriptor.getValueParameters();
         List<JetValueArgument> valueArguments = argumentList.getArguments();
@@ -378,7 +378,7 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith
             return null;
         }
 
-        CancelableResolveSession resolveSession =
+        ResolveSessionForBodies resolveSession =
                 AnalyzerFacadeWithCache.getLazyResolveSessionForFile((JetFile) callNameExpression.getContainingFile());
         BindingContext bindingContext = resolveSession.resolveToElement(callNameExpression);
 
@@ -392,7 +392,7 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith
 
         Name refName = callNameExpression.getReferencedNameAsName();
 
-        Collection<Pair<? extends DeclarationDescriptor, CancelableResolveSession>> itemsToShow = new ArrayList<Pair<? extends DeclarationDescriptor, CancelableResolveSession>>();
+        Collection<Pair<? extends DeclarationDescriptor, ResolveSessionForBodies>> itemsToShow = new ArrayList<Pair<? extends DeclarationDescriptor, ResolveSessionForBodies>>();
         for (DeclarationDescriptor variant : variants) {
             if (variant instanceof FunctionDescriptor) {
                 FunctionDescriptor functionDescriptor = (FunctionDescriptor) variant;

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

@@ -81,18 +81,18 @@ public final class AnalyzerFacadeWithCache {
 
     @NotNull
     public static BindingContext getContextForElement(@NotNull JetElement jetElement) {
-        CancelableResolveSession cancelableResolveSession = getLazyResolveSessionForFile((JetFile) jetElement.getContainingFile());
+        ResolveSessionForBodies resolveSessionForBodies = getLazyResolveSessionForFile((JetFile) jetElement.getContainingFile());
-        return cancelableResolveSession.resolveToElement(jetElement);
+        return resolveSessionForBodies.resolveToElement(jetElement);
     }
 
     @NotNull
-    public static CancelableResolveSession getLazyResolveSessionForFile(@NotNull JetFile file) {
+    public static ResolveSessionForBodies getLazyResolveSessionForFile(@NotNull JetFile file) {
         Project project = file.getProject();
         DeclarationsCacheProvider provider = KotlinCacheManager.getInstance(project).getRegisteredProvider(TargetPlatformDetector.getPlatform(file));
 
         if (!provider.areDeclarationsAvailable(file)) {
             // There can be request for temp files (in completion) or non-source (in library) files. Create temp sessions for them.
-            CachedValue<CancelableResolveSession> cachedValue;
+            CachedValue<ResolveSessionForBodies> cachedValue;
 
             synchronized (PER_FILE_SESSION_CACHE) {
                 cachedValue = PER_FILE_SESSION_CACHE.get(file);
@@ -111,17 +111,17 @@ public final class AnalyzerFacadeWithCache {
         return AnalyzeExhaust.error(bindingTraceContext.getBindingContext(), e);
     }
 
-    private static final SLRUCache<JetFile, CachedValue<CancelableResolveSession>> PER_FILE_SESSION_CACHE = new SLRUCache<JetFile, CachedValue<CancelableResolveSession>>(2, 3) {
+    private static final SLRUCache<JetFile, CachedValue<ResolveSessionForBodies>> PER_FILE_SESSION_CACHE = new SLRUCache<JetFile, CachedValue<ResolveSessionForBodies>>(2, 3) {
         @NotNull
         @Override
-        public CachedValue<CancelableResolveSession> createValue(final JetFile file) {
+        public CachedValue<ResolveSessionForBodies> createValue(final JetFile file) {
             final Project fileProject = file.getProject();
             return CachedValuesManager.getManager(fileProject).createCachedValue(
                     // Each value monitors OUT_OF_CODE_BLOCK_MODIFICATION_COUNT and modification tracker of the stored value
-                    new CachedValueProvider<CancelableResolveSession>() {
+                    new CachedValueProvider<ResolveSessionForBodies>() {
                         @Nullable
                         @Override
-                        public Result<CancelableResolveSession> compute() {
+                        public Result<ResolveSessionForBodies> compute() {
                             Project project = file.getProject();
 
 
@@ -138,7 +138,7 @@ public final class AnalyzerFacadeWithCache {
                             }
 
                             ResolveSession resolveSession = AnalyzerFacadeProvider.getAnalyzerFacadeForFile(file).getLazyResolveSession(fileProject, files);
-                            return Result.create(new CancelableResolveSession(file, resolveSession), PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT);
+                            return Result.create(new ResolveSessionForBodies(file, resolveSession), PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT);
                         }
                     },
                     true);

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

@@ -30,20 +30,20 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 
-public class CancelableResolveSession implements KotlinCodeAnalyzer, ModificationTracker {
+public class ResolveSessionForBodies implements KotlinCodeAnalyzer, ModificationTracker {
     private final Object createdForObject;
     private final ResolveSession resolveSession;
     private final ResolveElementCache resolveElementCache;
 
-    public CancelableResolveSession(@NotNull JetFile file, @NotNull ResolveSession resolveSession) {
+    public ResolveSessionForBodies(@NotNull JetFile file, @NotNull ResolveSession resolveSession) {
         this(file, file.getProject(), resolveSession);
     }
 
-    public CancelableResolveSession(@NotNull Project project, @NotNull ResolveSession resolveSession) {
+    public ResolveSessionForBodies(@NotNull Project project, @NotNull ResolveSession resolveSession) {
         this(project, project, resolveSession);
     }
 
-    private CancelableResolveSession(Object createdForObject, Project project, ResolveSession resolveSession) {
+    private ResolveSessionForBodies(Object createdForObject, Project project, ResolveSession resolveSession) {
         this.createdForObject = createdForObject;
         this.resolveSession = resolveSession;
         this.resolveElementCache = new ResolveElementCache(resolveSession, project);
@@ -89,6 +89,6 @@ public class CancelableResolveSession implements KotlinCodeAnalyzer, Modificatio
 
     @Override
     public String toString() {
-        return "CancelableResolveSession: " + getModificationCount() + " " + createdForObject + " " + createdForObject.hashCode();
+        return "ResolveSessionForBodies: " + getModificationCount() + " " + createdForObject + " " + createdForObject.hashCode();
     }
 }

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

@@ -52,7 +52,7 @@ 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.project.CancelableResolveSession;
+import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.plugin.project.ProjectStructureUtil;
 import org.jetbrains.jet.plugin.util.JetPsiHeuristicsUtil;
 
@@ -92,16 +92,16 @@ public class AutoImportFix extends JetHintAction<JetSimpleNameExpression> implem
             return Collections.emptyList();
         }
 
-        CancelableResolveSession cancelableResolveSession =
+        ResolveSessionForBodies resolveSessionForBodies =
                 AnalyzerFacadeWithCache.getLazyResolveSessionForFile((JetFile) element.getContainingFile());
 
         List<FqName> result = Lists.newArrayList();
         if (!isSuppressedTopLevelImportInPosition(element)) {
-            result.addAll(getClassNames(referenceName, (JetFile) file, cancelableResolveSession));
+            result.addAll(getClassNames(referenceName, (JetFile) file, resolveSessionForBodies));
-            result.addAll(getJetTopLevelFunctions(referenceName, element, cancelableResolveSession, file.getProject()));
+            result.addAll(getJetTopLevelFunctions(referenceName, element, resolveSessionForBodies, file.getProject()));
         }
 
-        result.addAll(getJetExtensionFunctions(referenceName, element, cancelableResolveSession, file.getProject()));
+        result.addAll(getJetExtensionFunctions(referenceName, element, resolveSessionForBodies, file.getProject()));
 
         return Collections2.filter(result, new Predicate<FqName>() {
             @Override
@@ -119,7 +119,7 @@ public class AutoImportFix extends JetHintAction<JetSimpleNameExpression> implem
     private static Collection<FqName> getJetTopLevelFunctions(
             @NotNull String referenceName,
             @NotNull JetSimpleNameExpression expression,
-            @NotNull CancelableResolveSession resolveSession,
+            @NotNull ResolveSessionForBodies resolveSession,
             @NotNull Project project
     ) {
         JetShortNamesCache namesCache = JetShortNamesCache.getKotlinInstance(project);
@@ -139,7 +139,7 @@ public class AutoImportFix extends JetHintAction<JetSimpleNameExpression> implem
     private static Collection<FqName> getJetExtensionFunctions(
             @NotNull final String referenceName,
             @NotNull JetSimpleNameExpression expression,
-            @NotNull CancelableResolveSession resolveSession,
+            @NotNull ResolveSessionForBodies resolveSession,
             @NotNull Project project
     ) {
         JetShortNamesCache namesCache = JetShortNamesCache.getKotlinInstance(project);

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

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

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

@@ -61,10 +61,9 @@ import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.plugin.JetLanguage;
 import org.jetbrains.jet.plugin.codeInsight.ShortenReferences;
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
-import org.jetbrains.jet.plugin.project.CancelableResolveSession;
+import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
 
-import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -259,12 +258,12 @@ public class KotlinInlineValHandler extends InlineActionHandler {
         JetFile containingFile = (JetFile) inlinedExpressions.get(0).getContainingFile();
         List<JetFunctionLiteralExpression> functionsToAddParameters = Lists.newArrayList();
 
-        CancelableResolveSession cancelableResolveSession = AnalyzerFacadeWithCache.getLazyResolveSessionForFile(containingFile);
+        ResolveSessionForBodies resolveSessionForBodies = AnalyzerFacadeWithCache.getLazyResolveSessionForFile(containingFile);
         for (JetExpression inlinedExpression : inlinedExpressions) {
             JetFunctionLiteralExpression functionLiteralExpression = getFunctionLiteralExpression(inlinedExpression);
             assert functionLiteralExpression != null : "can't find function literal expression for " + inlinedExpression.getText();
 
-            if (needToAddParameterTypes(functionLiteralExpression, cancelableResolveSession)) {
+            if (needToAddParameterTypes(functionLiteralExpression, resolveSessionForBodies)) {
                 functionsToAddParameters.add(functionLiteralExpression);
             }
         }
@@ -298,10 +297,10 @@ public class KotlinInlineValHandler extends InlineActionHandler {
 
     private static boolean needToAddParameterTypes(
             @NotNull JetFunctionLiteralExpression functionLiteralExpression,
-            @NotNull CancelableResolveSession cancelableResolveSession
+            @NotNull ResolveSessionForBodies resolveSessionForBodies
     ) {
         JetFunctionLiteral functionLiteral = functionLiteralExpression.getFunctionLiteral();
-        BindingContext context = cancelableResolveSession.resolveToElement(functionLiteralExpression);
+        BindingContext context = resolveSessionForBodies.resolveToElement(functionLiteralExpression);
         for (Diagnostic diagnostic : context.getDiagnostics()) {
             DiagnosticFactory factory = diagnostic.getFactory();
             PsiElement element = diagnostic.getPsiElement();
@@ -319,12 +318,12 @@ public class KotlinInlineValHandler extends InlineActionHandler {
         JetFile containingFile = (JetFile) inlinedExpressions.get(0).getContainingFile();
         List<JetCallExpression> callsToAddArguments = Lists.newArrayList();
 
-        CancelableResolveSession cancelableResolveSession = AnalyzerFacadeWithCache.getLazyResolveSessionForFile(containingFile);
+        ResolveSessionForBodies resolveSessionForBodies = AnalyzerFacadeWithCache.getLazyResolveSessionForFile(containingFile);
         for (JetExpression inlinedExpression : inlinedExpressions) {
             JetCallExpression callExpression = getCallExpression(inlinedExpression);
             assert callExpression != null : "can't find call expression for " + inlinedExpression.getText();
 
-            if (hasIncompleteTypeInferenceDiagnostic(callExpression, cancelableResolveSession) && callExpression.getTypeArgumentList() == null) {
+            if (hasIncompleteTypeInferenceDiagnostic(callExpression, resolveSessionForBodies) && callExpression.getTypeArgumentList() == null) {
                 callsToAddArguments.add(callExpression);
             }
         }
@@ -366,10 +365,10 @@ public class KotlinInlineValHandler extends InlineActionHandler {
 
     private static boolean hasIncompleteTypeInferenceDiagnostic(
             @NotNull JetCallExpression callExpression,
-            @NotNull CancelableResolveSession cancelableResolveSession
+            @NotNull ResolveSessionForBodies resolveSessionForBodies
     ) {
         JetExpression callee = callExpression.getCalleeExpression();
-        BindingContext context = cancelableResolveSession.resolveToElement(callExpression);
+        BindingContext context = resolveSessionForBodies.resolveToElement(callExpression);
         for (Diagnostic diagnostic : context.getDiagnostics()) {
             if (diagnostic.getFactory() == Errors.TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER && diagnostic.getPsiElement() == callee) {
                 return true;

idea/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.java

@@ -22,15 +22,9 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
-import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lexer.JetTokens;
-import org.jetbrains.jet.plugin.codeInsight.TipsManager;
-import org.jetbrains.jet.plugin.completion.DescriptorLookupConverter;
-import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
-import org.jetbrains.jet.plugin.project.CancelableResolveSession;
 
 public class JetSimpleNameReference extends JetPsiReference {
 

idea/tests/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoTest.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.CancelableResolveSession;
+import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 
 public class JetFunctionParameterInfoTest extends LightCodeInsightFixtureTestCase {
     public void testInheritedFunctions() {
@@ -120,7 +120,7 @@ public class JetFunctionParameterInfoTest extends LightCodeInsightFixtureTestCas
 
         for (Object item : mockCreateParameterInfoContext.getItemsToShow()) {
             //noinspection unchecked
-            parameterInfoHandler.updateUI((Pair<? extends FunctionDescriptor, CancelableResolveSession>)item, parameterInfoUIContext);
+            parameterInfoHandler.updateUI((Pair<? extends FunctionDescriptor, ResolveSessionForBodies>)item, parameterInfoUIContext);
         }
         assertEquals(expectedResultText, parameterInfoUIContext.getResultText());
     }