Rename: JetElement#getLazyResolveSession() -> getResolutionFacade

Rename local variables and fields of type ResolutionFacade

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

@@ -24,25 +24,25 @@ import org.jetbrains.jet.lang.psi.JetDeclaration
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
 
-public fun JetElement.getLazyResolveSession(): ResolutionFacade {
+public fun JetElement.getResolutionFacade(): ResolutionFacade {
     return KotlinCacheService.getInstance(getProject()).getResolutionFacade(listOf(this))
 }
 
 public fun JetDeclaration.resolveToDescriptor(): DeclarationDescriptor {
-    return getLazyResolveSession().resolveToDescriptor(this)
+    return getResolutionFacade().resolveToDescriptor(this)
 }
 
 public fun JetElement.analyze(): BindingContext {
-    return getLazyResolveSession().analyze(this)
+    return getResolutionFacade().analyze(this)
 }
 
 public fun JetElement.analyzeAndGetResult(): AnalysisResult {
-    val resolutionFacade = getLazyResolveSession()
+    val resolutionFacade = getResolutionFacade()
     return AnalysisResult.success(resolutionFacade.analyze(this), resolutionFacade.findModuleDescriptor(this))
 }
 
 public fun JetElement.findModuleDescriptor(): ModuleDescriptor {
-    return getLazyResolveSession().findModuleDescriptor(this)
+    return getResolutionFacade().findModuleDescriptor(this)
 }
 
 public fun JetElement.analyzeFully(): BindingContext {

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

@@ -26,7 +26,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
+import org.jetbrains.jet.plugin.caches.resolve.getResolutionFacade
 import org.jetbrains.jet.lang.psi.JetQualifiedExpression
 import java.util.LinkedHashMap
 
@@ -58,7 +58,7 @@ object JetFileReferencesResolver {
     }
 
     private class ResolveAllReferencesVisitor(file: JetFile, val resolveQualifiers: Boolean, val resolveShortNames: Boolean) : JetTreeVisitorVoid() {
-        private val resolveSession = file.getLazyResolveSession()
+        private val resolutionFacade = file.getResolutionFacade()
         private val resolveMap = LinkedHashMap<JetReferenceExpression, BindingContext>()
 
         public val result: Map<JetReferenceExpression, BindingContext> = resolveMap
@@ -71,27 +71,27 @@ object JetFileReferencesResolver {
             if (resolveShortNames || userType.getQualifier() != null) {
                 val referenceExpression = userType.getReferenceExpression()
                 if (referenceExpression != null) {
-                    resolveMap[referenceExpression] = resolveSession.analyze(referenceExpression)
+                    resolveMap[referenceExpression] = resolutionFacade.analyze(referenceExpression)
                 }
             }
         }
 
         override fun visitQualifiedExpression(expression: JetQualifiedExpression) {
             val receiverExpression = expression.getReceiverExpression()
-            if (resolveQualifiers || resolveSession.analyze(expression)[BindingContext.QUALIFIER, receiverExpression] == null) {
+            if (resolveQualifiers || resolutionFacade.analyze(expression)[BindingContext.QUALIFIER, receiverExpression] == null) {
                 receiverExpression.accept(this)
             }
 
             val referenceExpression = expression.getSelectorExpression()?.referenceExpression()
             if (referenceExpression != null) {
-                resolveMap[referenceExpression] = resolveSession.analyze(referenceExpression)
+                resolveMap[referenceExpression] = resolutionFacade.analyze(referenceExpression)
             }
             expression.getSelectorExpression()?.accept(this)
         }
 
         override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
             if (resolveShortNames) {
-                resolveMap[expression] = resolveSession.analyze(expression)
+                resolveMap[expression] = resolutionFacade.analyze(expression)
             }
         }
     }

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

@@ -26,7 +26,7 @@ import java.util.HashSet;
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiDocumentManager
-import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession
+import org.jetbrains.jet.plugin.caches.resolve.getResolutionFacade
 import org.jetbrains.jet.lang.resolve.DescriptorUtils
 import java.util.Collections
 import org.jetbrains.jet.analyzer.analyzeInContext
@@ -153,13 +153,13 @@ public object ShortenReferences {
             val elementFilter: (PsiElement) -> FilterResult,
             val resolveMap: Map<JetReferenceExpression, BindingContext>,
             val importInserter: ImportInserter) : JetVisitorVoid() {
-        protected val resolveSession: ResolutionFacade
+        protected val resolutionFacade: ResolutionFacade
-            get() = file.getLazyResolveSession()
+            get() = file.getResolutionFacade()
 
         protected val elementsToShorten: MutableSet<T> = LinkedHashSet()
 
         protected fun bindingContext(element: JetElement): BindingContext
-                = resolveMap[element] ?: resolveSession.analyze(element)
+                = resolveMap[element] ?: resolutionFacade.analyze(element)
 
         protected abstract fun getShortenedElement(element: T): JetElement?
 
@@ -193,7 +193,7 @@ public object ShortenReferences {
             if (target == null) return false
 
             val typeReference = PsiTreeUtil.getParentOfType(userType, javaClass<JetTypeReference>())!!
-            val scope = resolveSession.analyze(typeReference)[BindingContext.TYPE_RESOLUTION_SCOPE, typeReference]!!
+            val scope = resolutionFacade.analyze(typeReference)[BindingContext.TYPE_RESOLUTION_SCOPE, typeReference]!!
             val name = target.getName()
             val targetByName = scope.getClassifier(name)
             if (targetByName == null) {

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

@@ -39,7 +39,7 @@ import org.jetbrains.jet.plugin.util.extensionsUtils.isExtensionCallable
 
 public class KotlinIndicesHelper(
         private val project: Project,
-        private val resolveSession: ResolutionFacade,
+        private val resolutionFacade: ResolutionFacade,
         private val scope: GlobalSearchScope,
         private val moduleDescriptor: ModuleDescriptor,
         private val visibilityFilter: (DeclarationDescriptor) -> Boolean
@@ -73,7 +73,7 @@ public class KotlinIndicesHelper(
     }
 
     public fun getTopLevelCallablesByName(name: String, context: JetExpression /*TODO: to be dropped*/): Collection<CallableDescriptor> {
-        val jetScope = resolveSession.analyze(context).get(BindingContext.RESOLUTION_SCOPE, context) ?: return listOf()
+        val jetScope = resolutionFacade.analyze(context).get(BindingContext.RESOLUTION_SCOPE, context) ?: return listOf()
 
         val result = HashSet<CallableDescriptor>()
 
@@ -127,7 +127,7 @@ public class KotlinIndicesHelper(
         val sourceNames = JetTopLevelFunctionsFqnNameIndex.getInstance().getAllKeys(project).stream() + JetTopLevelPropertiesFqnNameIndex.getInstance().getAllKeys(project).stream()
         val allFqNames = sourceNames.map { FqName(it) } + JetFromJavaDescriptorHelper.getTopLevelCallableFqNames(project, scope, false).stream()
 
-        val jetScope = resolveSession.analyze(context).get(BindingContext.RESOLUTION_SCOPE, context) ?: return listOf()
+        val jetScope = resolutionFacade.analyze(context).get(BindingContext.RESOLUTION_SCOPE, context) ?: return listOf()
 
         return allFqNames.filter { nameFilter(it.shortName().asString()) }
                 .toSet()
@@ -135,7 +135,7 @@ public class KotlinIndicesHelper(
     }
 
     public fun getCallableExtensions(nameFilter: (String) -> Boolean, expression: JetSimpleNameExpression): Collection<CallableDescriptor> {
-        val bindingContext = resolveSession.analyze(expression)
+        val bindingContext = resolutionFacade.analyze(expression)
         val dataFlowInfo = bindingContext.getDataFlowInfo(expression)
 
         val functionsIndex = JetTopLevelFunctionsFqnNameIndex.getInstance()

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

@@ -109,7 +109,7 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Refere
             }
         }
         catch (e: ProcessCanceledException) {
-            // supposedly session can only be canceled from another thread
+            // supposedly analysis can only be canceled from another thread
             // do not log ProcessCanceledException as it is rethrown by IdeaLogger and code won't be copied
             LOG.error("ProcessCanceledException while analyzing references in ${file.getName()}. References can't be processed.")
             return listOf()

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

@@ -31,11 +31,10 @@ 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: ResolutionFacade,
+                           val resolutionFacade: ResolutionFacade,
                            val moduleDescriptor: ModuleDescriptor,
                            val scope: GlobalSearchScope,
                            val prefixMatcher: PrefixMatcher,
@@ -45,7 +44,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, moduleDescriptor, visibilityFilter)
+        val helper = KotlinIndicesHelper(scope.getProject(), resolutionFacade, scope, moduleDescriptor, visibilityFilter)
         result.addDescriptorElements(helper.getClassDescriptors({ prefixMatcher.prefixMatches(it) }, kindFilter),
                                      suppressAutoInsertion = true)
 

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

@@ -51,9 +51,9 @@ abstract class CompletionSessionBase(protected val configuration: CompletionSess
     protected val position: PsiElement = parameters.getPosition()
     protected val jetReference: JetSimpleNameReference? = position.getParent()?.getReferences()?.filterIsInstance(javaClass<JetSimpleNameReference>())?.firstOrNull()
     private val file = position.getContainingFile() as JetFile
-    protected val resolveSession: ResolutionFacade = file.getLazyResolveSession()
+    protected val resolutionFacade: ResolutionFacade = file.getResolutionFacade()
-    protected val moduleDescriptor: ModuleDescriptor = resolveSession.findModuleDescriptor(file)
+    protected val moduleDescriptor: ModuleDescriptor = resolutionFacade.findModuleDescriptor(file)
-    protected val bindingContext: BindingContext? = jetReference?.let { resolveSession.analyze(it.expression) }
+    protected val bindingContext: BindingContext? = jetReference?.let { resolutionFacade.analyze(it.expression) }
     protected val inDescriptor: DeclarationDescriptor? = jetReference?.let { bindingContext!!.get(BindingContext.RESOLUTION_SCOPE, it.expression)?.getContainingDeclaration() }
 
     // set prefix matcher here to override default one which relies on CompletionUtil.findReferencePrefix()
@@ -82,7 +82,7 @@ abstract class CompletionSessionBase(protected val configuration: CompletionSess
         }
     }
 
-    protected val collector: LookupElementsCollector = LookupElementsCollector(prefixMatcher, parameters, resolveSession, boldImmediateLookupElementFactory)
+    protected val collector: LookupElementsCollector = LookupElementsCollector(prefixMatcher, parameters, resolutionFacade, boldImmediateLookupElementFactory)
 
     protected val project: Project = position.getProject()
 
@@ -92,7 +92,7 @@ abstract class CompletionSessionBase(protected val configuration: CompletionSess
     }
 
     protected val indicesHelper: KotlinIndicesHelper
-            = KotlinIndicesHelper(project, resolveSession, searchScope, moduleDescriptor) { isVisibleDescriptor(it) }
+            = KotlinIndicesHelper(project, resolutionFacade, searchScope, moduleDescriptor) { isVisibleDescriptor(it) }
 
     protected fun isVisibleDescriptor(descriptor: DeclarationDescriptor): Boolean {
         if (configuration.completeNonAccessibleDeclarations) return true
@@ -141,7 +141,7 @@ abstract class CompletionSessionBase(protected val configuration: CompletionSess
 
     protected fun addAllClasses(kindFilter: (ClassKind) -> Boolean) {
         AllClassesCompletion(
-                parameters, resolveSession, moduleDescriptor,
+                parameters, resolutionFacade, moduleDescriptor,
                 searchScope, prefixMatcher, kindFilter, { isVisibleDescriptor(it) }
         ).collect(collector)
     }
@@ -228,7 +228,7 @@ class SmartCompletionSession(configuration: CompletionSessionConfiguration, para
 
     override fun doComplete() {
         if (jetReference != null) {
-            val completion = SmartCompletion(jetReference.expression, resolveSession, { isVisibleDescriptor(it) }, parameters.getOriginalFile() as JetFile, boldImmediateLookupElementFactory)
+            val completion = SmartCompletion(jetReference.expression, resolutionFacade, { isVisibleDescriptor(it) }, parameters.getOriginalFile() as JetFile, boldImmediateLookupElementFactory)
             val result = completion.execute()
             if (result != null) {
                 collector.addElements(result.additionalItems)

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

@@ -27,7 +27,7 @@ import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade
  */
 public class DeclarationDescriptorLookupObject(
         public val descriptor: DeclarationDescriptor,
-        private val analyzer: ResolutionFacade,
+        private val resolutionFacade: ResolutionFacade,
         public val psiElement: PsiElement?
 ) {
     override fun toString(): String {
@@ -44,7 +44,7 @@ public class DeclarationDescriptorLookupObject(
 
         val lookupObject = other as DeclarationDescriptorLookupObject
 
-        if (analyzer != lookupObject.analyzer) {
+        if (resolutionFacade != lookupObject.resolutionFacade) {
             LOG.warn("Descriptors from different resolve sessions")
             return false
         }

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

@@ -87,7 +87,7 @@ class PositionalArgumentExpectedInfo(type: JetType, name: String?, tail: Tail?,
             = function.hashCode()
 }
 
-class ExpectedInfos(val bindingContext: BindingContext, val resolveSession: ResolutionFacade) {
+class ExpectedInfos(val bindingContext: BindingContext, val resolutionFacade: ResolutionFacade) {
     public fun calculate(expressionWithType: JetExpression): Collection<ExpectedInfo>? {
         return calculateForArgument(expressionWithType)
             ?: calculateForFunctionLiteralArgument(expressionWithType)
@@ -174,7 +174,7 @@ class ExpectedInfos(val bindingContext: BindingContext, val resolveSession: Reso
                 false).replaceCollectAllCandidates(true)
         val callResolver = InjectorForMacros(
                 callElement.getProject(),
-                resolveSession.findModuleDescriptor(callElement)
+                resolutionFacade.findModuleDescriptor(callElement)
         ).getCallResolver()
         val results: OverloadResolutionResults<FunctionDescriptor> = callResolver.resolveFunctionCall(callResolutionContext)
 
@@ -295,14 +295,14 @@ class ExpectedInfos(val bindingContext: BindingContext, val resolveSession: Reso
     private fun calculateForInitializer(expressionWithType: JetExpression): Collection<ExpectedInfo>? {
         val property = expressionWithType.getParent() as? JetProperty ?: return null
         if (expressionWithType != property.getInitializer()) return null
-        val propertyDescriptor = resolveSession.resolveToDescriptor(property) as? VariableDescriptor ?: return null
+        val propertyDescriptor = resolutionFacade.resolveToDescriptor(property) as? VariableDescriptor ?: return null
         return listOf(ExpectedInfo(propertyDescriptor.getType(), propertyDescriptor.getName().asString(), null))
     }
 
     private fun calculateForExpressionBody(expressionWithType: JetExpression): Collection<ExpectedInfo>? {
         val declaration = expressionWithType.getParent() as? JetDeclarationWithBody ?: return null
         if (expressionWithType != declaration.getBodyExpression() || declaration.hasBlockBody()) return null
-        val descriptor = resolveSession.resolveToDescriptor(declaration) as? FunctionDescriptor ?: return null
+        val descriptor = resolutionFacade.resolveToDescriptor(declaration) as? FunctionDescriptor ?: return null
         return functionReturnValueExpectedInfo(descriptor).toList()
     }
 

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

@@ -38,12 +38,12 @@ 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: ResolutionFacade, descriptor: DeclarationDescriptor): LookupElement {
+    public open fun createLookupElement(resolutionFacade: ResolutionFacade, descriptor: DeclarationDescriptor): LookupElement {
         val _descriptor = if (descriptor is CallableMemberDescriptor)
             DescriptorUtils.unwrapFakeOverride(descriptor)
         else
             descriptor
-        return createLookupElement(analyzer, _descriptor, DescriptorToSourceUtils.descriptorToDeclaration(_descriptor))
+        return createLookupElement(resolutionFacade, _descriptor, DescriptorToSourceUtils.descriptorToDeclaration(_descriptor))
     }
 
     public fun createLookupElementForJavaClass(psiClass: PsiClass): LookupElement {
@@ -149,8 +149,8 @@ public open class LookupElementFactory protected() {
 }
 
 public class BoldImmediateLookupElementFactory(private val receiverTypes: Collection<JetType>) : LookupElementFactory() {
-    override fun createLookupElement(analyzer: ResolutionFacade, descriptor: DeclarationDescriptor): LookupElement {
+    override fun createLookupElement(resolutionFacade: ResolutionFacade, descriptor: DeclarationDescriptor): LookupElement {
-        val element = super.createLookupElement(analyzer, descriptor)
+        val element = super.createLookupElement(resolutionFacade, descriptor)
 
         if (descriptor !is CallableMemberDescriptor) return element
         val receiverParameter = descriptor.getExtensionReceiverParameter()

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

@@ -34,7 +34,7 @@ import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade
 class LookupElementsCollector(
         private val prefixMatcher: PrefixMatcher,
         private val completionParameters: CompletionParameters,
-        private val resolveSession: ResolutionFacade,
+        private val resolutionFacade: ResolutionFacade,
         private val boldImmediateLookupElementFactory: LookupElementFactory
 ) {
     private val elements = ArrayList<LookupElement>()
@@ -60,7 +60,7 @@ class LookupElementsCollector(
 
     public fun addDescriptorElements(descriptor: DeclarationDescriptor, suppressAutoInsertion: Boolean) {
         run {
-            val lookupElement = boldImmediateLookupElementFactory.createLookupElement(resolveSession, descriptor)
+            val lookupElement = boldImmediateLookupElementFactory.createLookupElement(resolutionFacade, descriptor)
             if (suppressAutoInsertion) {
                 addElementWithAutoInsertionSuppressed(lookupElement)
             }
@@ -77,7 +77,7 @@ class LookupElementsCollector(
                 if (KotlinBuiltIns.getInstance().isFunctionOrExtensionFunctionType(parameterType)) {
                     val parameterCount = KotlinBuiltIns.getInstance().getParameterTypeProjectionsFromFunctionType(parameterType).size()
                     if (parameterCount > 1) {
-                        val lookupElement = boldImmediateLookupElementFactory.createLookupElement(resolveSession, descriptor)
+                        val lookupElement = boldImmediateLookupElementFactory.createLookupElement(resolutionFacade, descriptor)
                         addElement(object : LookupElementDecorator<LookupElement>(lookupElement) {
                             override fun renderElement(presentation: LookupElementPresentation) {
                                 super.renderElement(presentation)

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

@@ -18,10 +18,7 @@ package org.jetbrains.jet.plugin.completion
 
 import com.intellij.codeInsight.completion.*
 import com.intellij.openapi.progress.ProcessCanceledException
-import com.intellij.patterns.ElementPattern
 import com.intellij.patterns.PlatformPatterns
-import com.intellij.psi.PsiElement
-import com.intellij.util.ProcessingContext
 import org.jetbrains.jet.lang.psi.JetFile
 import org.jetbrains.jet.lang.psi.JetPackageDirective
 import org.jetbrains.jet.plugin.caches.resolve.*
@@ -50,12 +47,12 @@ object PackageDirectiveCompletion {
             val prefixMatcher = PlainPrefixMatcher(name.substring(0, prefixLength))
             val result = result.withPrefixMatcher(prefixMatcher)
 
-            val resolveSession = ref.expression.getLazyResolveSession()
+            val resolutionFacade = ref.expression.getResolutionFacade()
-            val bindingContext = resolveSession.analyze(ref.expression)
+            val bindingContext = resolutionFacade.analyze(ref.expression)
 
             val variants = ReferenceVariantsHelper(bindingContext, { true }).getPackageReferenceVariants(ref.expression, prefixMatcher.asNameFilter())
             for (variant in variants) {
-                val lookupElement = LookupElementFactory.DEFAULT.createLookupElement(resolveSession, variant)
+                val lookupElement = LookupElementFactory.DEFAULT.createLookupElement(resolutionFacade, variant)
                 if (!lookupElement.getLookupString().contains(DUMMY_IDENTIFIER)) {
                     result.addElement(lookupElement)
                 }

idea/src/org/jetbrains/jet/plugin/completion/handlers/GenerateLambda.kt

@@ -21,9 +21,7 @@ import com.intellij.codeInsight.completion.InsertionContext
 import com.intellij.codeInsight.template.TemplateManager
 import com.intellij.openapi.util.TextRange
 import com.intellij.codeInsight.template.Template
-import org.jetbrains.jet.plugin.refactoring.JetNameValidator
 import org.jetbrains.jet.plugin.refactoring.JetNameSuggester
-import org.jetbrains.jet.renderer.DescriptorRenderer
 import com.intellij.codeInsight.template.Expression
 import com.intellij.codeInsight.template.ExpressionContext
 import com.intellij.codeInsight.template.TextResult
@@ -38,7 +36,7 @@ import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.jet.lang.psi.JetExpression
 import org.jetbrains.jet.plugin.completion.ExpectedInfos
 import org.jetbrains.jet.lang.psi.JetFile
-import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession
+import org.jetbrains.jet.plugin.caches.resolve.getResolutionFacade
 import org.jetbrains.jet.plugin.util.application.runWriteAction
 import org.jetbrains.jet.plugin.refactoring.EmptyValidator
 import org.jetbrains.jet.plugin.util.IdeDescriptorRenderers
@@ -85,9 +83,9 @@ private fun needExplicitParameterTypes(context: InsertionContext, placeholderRan
     val expression = PsiTreeUtil.findElementOfClassAtRange(file, placeholderRange.getStartOffset(), placeholderRange.getEndOffset(), javaClass<JetExpression>())
     if (expression == null) return false
 
-    val resolveSession = file.getLazyResolveSession()
+    val resolutionFacade = file.getResolutionFacade()
-    val bindingContext = resolveSession.analyze(expression)
+    val bindingContext = resolutionFacade.analyze(expression)
-    val expectedInfos = ExpectedInfos(bindingContext, resolveSession).calculate(expression) ?: return false
+    val expectedInfos = ExpectedInfos(bindingContext, resolutionFacade).calculate(expression) ?: return false
     val functionTypes = expectedInfos.map { it.type }.filter { KotlinBuiltIns.getInstance().isExactFunctionOrExtensionFunctionType(it) }.toSet()
     if (functionTypes.size <= 1) return false
 

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

@@ -36,11 +36,11 @@ import org.jetbrains.jet.plugin.caches.resolve.ResolutionFacade
 import org.jetbrains.jet.plugin.caches.resolve.resolveToDescriptor
 
 class SmartCompletion(val expression: JetSimpleNameExpression,
-                      val resolveSession: ResolutionFacade,
+                      val resolutionFacade: ResolutionFacade,
                       val visibilityFilter: (DeclarationDescriptor) -> Boolean,
                       val originalFile: JetFile,
                       val boldImmediateLookupElementFactory: LookupElementFactory) {
-    private val bindingContext = resolveSession.analyze(expression)
+    private val bindingContext = resolutionFacade.analyze(expression)
     private val project = expression.getProject()
 
     public data class Result(val declarationFilter: ((DeclarationDescriptor) -> Collection<LookupElement>)?,
@@ -117,7 +117,7 @@ class SmartCompletion(val expression: JetSimpleNameExpression,
                         else -> ExpectedInfoClassification.NOT_MATCHES
                     }
                 }
-                result.addLookupElements(expectedInfos, classifier, { boldImmediateLookupElementFactory.createLookupElement(descriptor, resolveSession, bindingContext) })
+                result.addLookupElements(expectedInfos, classifier, { boldImmediateLookupElementFactory.createLookupElement(descriptor, resolutionFacade, bindingContext) })
 
                 if (receiver == null) {
                     toFunctionReferenceLookupElement(descriptor, functionExpectedInfos)?.let { result.add(it) }
@@ -128,9 +128,9 @@ class SmartCompletion(val expression: JetSimpleNameExpression,
 
         val additionalItems = ArrayList<LookupElement>()
         if (receiver == null) {
-            TypeInstantiationItems(resolveSession, bindingContext, visibilityFilter).addToCollection(additionalItems, expectedInfos)
+            TypeInstantiationItems(resolutionFacade, bindingContext, visibilityFilter).addToCollection(additionalItems, expectedInfos)
 
-            StaticMembers(bindingContext, resolveSession).addToCollection(additionalItems, expectedInfos, expression, itemsToSkip)
+            StaticMembers(bindingContext, resolutionFacade).addToCollection(additionalItems, expectedInfos, expression, itemsToSkip)
 
             ThisItems(bindingContext).addToCollection(additionalItems, expressionWithType, expectedInfos)
 
@@ -157,7 +157,7 @@ class SmartCompletion(val expression: JetSimpleNameExpression,
             }
         }
 
-        return ExpectedInfos(bindingContext, resolveSession).calculate(expression)
+        return ExpectedInfos(bindingContext, resolutionFacade).calculate(expression)
     }
 
     private fun implicitlyTypedDeclarationFromInitializer(expression: JetExpression): JetDeclaration? {
@@ -175,7 +175,7 @@ class SmartCompletion(val expression: JetSimpleNameExpression,
             is JetProperty -> {
                 //TODO: this can be filtered out by ordinary completion
                 if (expression == parent.getInitializer()) {
-                    return resolveSession.resolveToDescriptor(parent).toSet()
+                    return resolutionFacade.resolveToDescriptor(parent).toSet()
                 }
             }
 
@@ -185,7 +185,7 @@ class SmartCompletion(val expression: JetSimpleNameExpression,
                     if (operationToken == JetTokens.EQ || operationToken == JetTokens.EQEQ || operationToken == JetTokens.EXCLEQ) {
                         val left = parent.getLeft()
                         if (left is JetReferenceExpression) {
-                            return resolveSession.analyze(left)[BindingContext.REFERENCE_TARGET, left].toSet()
+                            return resolutionFacade.analyze(left)[BindingContext.REFERENCE_TARGET, left].toSet()
                         }
                     }
                 }
@@ -237,7 +237,7 @@ class SmartCompletion(val expression: JetSimpleNameExpression,
             val matchedExpectedInfos = functionExpectedInfos.filter { functionType.isSubtypeOf(it.type) }
             if (matchedExpectedInfos.isEmpty()) return null
 
-            var lookupElement = boldImmediateLookupElementFactory.createLookupElement(descriptor, resolveSession, bindingContext)
+            var lookupElement = boldImmediateLookupElementFactory.createLookupElement(descriptor, resolutionFacade, bindingContext)
             val text = "::" + (if (descriptor is ConstructorDescriptor) descriptor.getContainingDeclaration().getName() else descriptor.getName())
             lookupElement = object: LookupElementDecorator<LookupElement>(lookupElement) {
                 override fun getLookupString() = text
@@ -296,7 +296,7 @@ class SmartCompletion(val expression: JetSimpleNameExpression,
         if (jetType.isError()) return null
         val classifier = jetType.getConstructor().getDeclarationDescriptor() ?: return null
 
-        val lookupElement = LookupElementFactory.DEFAULT.createLookupElement(classifier, resolveSession, bindingContext)
+        val lookupElement = LookupElementFactory.DEFAULT.createLookupElement(classifier, resolutionFacade, bindingContext)
         val lookupString = lookupElement.getLookupString()
 
         val typeArgs = jetType.getArguments()

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

@@ -36,7 +36,7 @@ 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: ResolutionFacade) {
+class StaticMembers(val bindingContext: BindingContext, val resolutionFacade: ResolutionFacade) {
     public fun addToCollection(collection: MutableCollection<LookupElement>,
                                expectedInfos: Collection<ExpectedInfo>,
                                context: JetExpression,
@@ -106,7 +106,7 @@ class StaticMembers(val bindingContext: BindingContext, val resolveSession: Reso
     }
 
     private fun createLookupElement(memberDescriptor: DeclarationDescriptor, classDescriptor: ClassDescriptor): LookupElement {
-        val lookupElement = LookupElementFactory.DEFAULT.createLookupElement(memberDescriptor, resolveSession, bindingContext)
+        val lookupElement = LookupElementFactory.DEFAULT.createLookupElement(memberDescriptor, resolutionFacade, bindingContext)
         val qualifierPresentation = classDescriptor.getName().asString()
         val qualifierText = qualifiedNameForSourceCode(classDescriptor)
 

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

@@ -40,7 +40,7 @@ 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: ResolutionFacade, val bindingContext: BindingContext, val visibilityFilter: (DeclarationDescriptor) -> Boolean) {
+class TypeInstantiationItems(val resolutionFacade: 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) {
@@ -67,7 +67,7 @@ class TypeInstantiationItems(val resolveSession: ResolutionFacade, val bindingCo
         }
         if (allConstructors.isNotEmpty() && visibleConstructors.isEmpty()) return
 
-        var lookupElement = LookupElementFactory.DEFAULT.createLookupElement(classifier, resolveSession, bindingContext)
+        var lookupElement = LookupElementFactory.DEFAULT.createLookupElement(classifier, resolutionFacade, bindingContext)
 
         var lookupString = lookupElement.getLookupString()
         var allLookupStrings = setOf(lookupString)
@@ -164,7 +164,7 @@ class TypeInstantiationItems(val resolveSession: ResolutionFacade, val bindingCo
             val samConstructor = scope.getFunctions(`class`.getName())
                                          .filterIsInstance(javaClass<SamConstructorDescriptor>())
                                          .singleOrNull() ?: return
-            val lookupElement = LookupElementFactory.DEFAULT.createLookupElement(samConstructor, resolveSession, bindingContext)
+            val lookupElement = LookupElementFactory.DEFAULT.createLookupElement(samConstructor, resolutionFacade, bindingContext)
                     .assignSmartCompletionPriority(SmartCompletionItemPriority.INSTANTIATION)
                     .addTail(tail)
             collection.add(lookupElement)

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

@@ -188,10 +188,10 @@ fun functionType(function: FunctionDescriptor): JetType? {
 
 fun LookupElementFactory.createLookupElement(
         descriptor: DeclarationDescriptor,
-        resolveSession: ResolutionFacade,
+        resolutionFacade: ResolutionFacade,
         bindingContext: BindingContext
 ): LookupElement {
-    var element = createLookupElement(resolveSession, descriptor)
+    var element = createLookupElement(resolutionFacade, descriptor)
 
     if (descriptor is FunctionDescriptor && descriptor.getValueParameters().isNotEmpty()) {
         element = element.keepOldArgumentListOnTab()

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

@@ -216,7 +216,7 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith
         JetValueArgumentList argumentList = (JetValueArgumentList) parameterOwner;
 
         FunctionDescriptor functionDescriptor = itemToShow.first;
-        ResolutionFacade resolveSession = itemToShow.second;
+        ResolutionFacade resolutionFacade = itemToShow.second;
 
         List<ValueParameterDescriptor> valueParameters = functionDescriptor.getValueParameters();
         List<JetValueArgument> valueArguments = argumentList.getArguments();
@@ -239,7 +239,7 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith
         StringBuilder builder = new StringBuilder();
 
         PsiElement owner = context.getParameterOwner();
-        BindingContext bindingContext = resolveSession.analyze((JetElement) owner);
+        BindingContext bindingContext = resolutionFacade.analyze((JetElement) owner);
 
         for (int i = 0; i < valueParameters.size(); ++i) {
             if (i != 0) {
@@ -382,8 +382,8 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith
             return null;
         }
 
-        ResolutionFacade resolveSession = ResolvePackage.getLazyResolveSession(callNameExpression.getContainingJetFile());
+        ResolutionFacade resolutionFacade = ResolvePackage.getResolutionFacade(callNameExpression.getContainingJetFile());
-        BindingContext bindingContext = resolveSession.analyze(callNameExpression);
+        BindingContext bindingContext = resolutionFacade.analyze(callNameExpression);
 
         JetScope scope = bindingContext.get(BindingContext.RESOLUTION_SCOPE, callNameExpression);
         final DeclarationDescriptor placeDescriptor;
@@ -409,18 +409,19 @@ 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);
+                callNameExpression, new DescriptorKindFilter(DescriptorKindFilter.FUNCTIONS_MASK | DescriptorKindFilter.CLASSIFIERS_MASK,
+                                                             Collections.<DescriptorKindExclude>emptyList()), nameFilter);
 
         Collection<Pair<? extends DeclarationDescriptor, ResolutionFacade>> itemsToShow = new ArrayList<Pair<? extends DeclarationDescriptor, ResolutionFacade>>();
         for (DeclarationDescriptor variant : variants) {
             if (variant instanceof FunctionDescriptor) {
                 //todo: renamed functions?
-                itemsToShow.add(Pair.create((FunctionDescriptor) variant, resolveSession));
+                itemsToShow.add(Pair.create((FunctionDescriptor) variant, resolutionFacade));
             }
             else if (variant instanceof ClassDescriptor) {
                 //todo: renamed classes?
                 for (ConstructorDescriptor constructorDescriptor : ((ClassDescriptor) variant).getConstructors()) {
-                    itemsToShow.add(Pair.create(constructorDescriptor, resolveSession));
+                    itemsToShow.add(Pair.create(constructorDescriptor, resolutionFacade));
                 }
             }
         }

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

@@ -116,11 +116,11 @@ public class AutoImportFix(element: JetSimpleNameExpression) : JetHintAction<Jet
         }
         if (referenceName.isEmpty()) return listOf()
 
-        val resolveSession = element.getLazyResolveSession()
+        val resolutionFacade = element.getResolutionFacade()
 
         val searchScope = file.getResolveScope()
 
-        val bindingContext = resolveSession.analyze(element)
+        val bindingContext = resolutionFacade.analyze(element)
 
         val diagnostics = bindingContext.getDiagnostics().forElement(element)
         if (!diagnostics.any { it.getFactory() in ERRORS }) return listOf()
@@ -138,8 +138,8 @@ public class AutoImportFix(element: JetSimpleNameExpression) : JetHintAction<Jet
 
         val result = ArrayList<PrioritizedFqName>()
 
-        val moduleDescriptor = resolveSession.findModuleDescriptor(element)
+        val moduleDescriptor = resolutionFacade.findModuleDescriptor(element)
-        val indicesHelper = KotlinIndicesHelper(file.getProject(), resolveSession, searchScope, moduleDescriptor, ::isVisible)
+        val indicesHelper = KotlinIndicesHelper(file.getProject(), resolutionFacade, searchScope, moduleDescriptor, ::isVisible)
 
         if (!element.isImportDirectiveExpression() && !JetPsiUtil.isSelectorInQualified(element)) {
             result.addAll(getClassNames(referenceName, file, searchScope))

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

@@ -261,12 +261,12 @@ public class KotlinInlineValHandler extends InlineActionHandler {
         JetFile containingFile = inlinedExpressions.get(0).getContainingJetFile();
         List<JetFunctionLiteralExpression> functionsToAddParameters = Lists.newArrayList();
 
-        ResolutionFacade resolveSessionForBodies = ResolvePackage.getLazyResolveSession(containingFile);
+        ResolutionFacade resolutionFacade = ResolvePackage.getResolutionFacade(containingFile);
         for (JetExpression inlinedExpression : inlinedExpressions) {
             JetFunctionLiteralExpression functionLiteralExpression = getFunctionLiteralExpression(inlinedExpression);
             assert functionLiteralExpression != null : "can't find function literal expression for " + inlinedExpression.getText();
 
-            if (needToAddParameterTypes(functionLiteralExpression, resolveSessionForBodies)) {
+            if (needToAddParameterTypes(functionLiteralExpression, resolutionFacade)) {
                 functionsToAddParameters.add(functionLiteralExpression);
             }
         }
@@ -301,10 +301,10 @@ public class KotlinInlineValHandler extends InlineActionHandler {
 
     private static boolean needToAddParameterTypes(
             @NotNull JetFunctionLiteralExpression functionLiteralExpression,
-            @NotNull ResolutionFacade resolveSessionForBodies
+            @NotNull ResolutionFacade resolutionFacade
     ) {
         JetFunctionLiteral functionLiteral = functionLiteralExpression.getFunctionLiteral();
-        BindingContext context = resolveSessionForBodies.analyze(functionLiteralExpression);
+        BindingContext context = resolutionFacade.analyze(functionLiteralExpression);
         for (Diagnostic diagnostic : context.getDiagnostics()) {
             DiagnosticFactory<?> factory = diagnostic.getFactory();
             PsiElement element = diagnostic.getPsiElement();
@@ -322,9 +322,9 @@ public class KotlinInlineValHandler extends InlineActionHandler {
         JetFile containingFile = inlinedExpressions.get(0).getContainingJetFile();
         List<JetCallExpression> callsToAddArguments = Lists.newArrayList();
 
-        ResolutionFacade resolveSessionForBodies = ResolvePackage.getLazyResolveSession(containingFile);
+        ResolutionFacade resolutionFacade = ResolvePackage.getResolutionFacade(containingFile);
         for (JetExpression inlinedExpression : inlinedExpressions) {
-            BindingContext context = resolveSessionForBodies.analyze(inlinedExpression);
+            BindingContext context = resolutionFacade.analyze(inlinedExpression);
             Call call = CallUtilPackage.getCallWithAssert(inlinedExpression, context);
 
             JetElement callElement = call.getCallElement();

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

@@ -84,13 +84,13 @@ public class JetRunConfigurationProducer extends RuntimeConfigurationProducer im
         if (!(psiFile instanceof JetFile && ProjectRootsUtil.isInProjectOrLibSource(psiFile))) return null;
 
         JetFile jetFile = (JetFile) psiFile;
-        final ResolutionFacade session = ResolvePackage.getLazyResolveSession(jetFile);
+        final ResolutionFacade resolutionFacade = ResolvePackage.getResolutionFacade(jetFile);
         MainFunctionDetector mainFunctionDetector = new MainFunctionDetector(
                 new NotNullFunction<JetNamedFunction, FunctionDescriptor>() {
                     @NotNull
                     @Override
                     public FunctionDescriptor fun(JetNamedFunction function) {
-                        return (FunctionDescriptor) session.resolveToDescriptor(function);
+                        return (FunctionDescriptor) resolutionFacade.resolveToDescriptor(function);
                     }
                 });