Added ResolutionFacada.resolveImportReference and used it (but not all places replaced yet!!)

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

@@ -33,13 +33,12 @@ import org.jetbrains.kotlin.idea.project.TargetPlatform.JS
 import org.jetbrains.kotlin.idea.project.TargetPlatform.JVM
 import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
-import org.jetbrains.kotlin.psi.JetCodeFragment
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
 import org.jetbrains.kotlin.utils.keysToMap
 import kotlin.platform.platformStatic
 
@@ -73,6 +72,15 @@ public class KotlinCacheService(val project: Project) {
                 return cache.getLazyResolveSession(file).getScopeProvider().getFileScope(file)
             }
 
+            override fun resolveImportReference(file: JetFile, fqName: FqName): Collection<DeclarationDescriptor> {
+                val importDirective = JetPsiFactory(project).createImportDirective(ImportPath(fqName, false))
+                val moduleDescriptor = findModuleDescriptor(file)
+                val scope = JetModuleUtil.getSubpackagesOfRootScope(moduleDescriptor)
+                val resolver = cache.getLazyResolveSession(file).getQualifiedExpressionResolver()
+                return resolver.processImportReference(
+                        importDirective, scope, scope, BindingTraceContext(), QualifiedExpressionResolver.LookupMode.EVERYTHING).getAllDescriptors()
+            }
+
             override fun <T> get(extension: CacheExtension<T>): T {
                 return cache[extension]
             }

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

@@ -16,14 +16,15 @@
 
 package org.jetbrains.kotlin.idea.caches.resolve
 
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.psi.JetDeclaration
 import org.jetbrains.kotlin.analyzer.AnalysisResult
-import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.JetElement
 import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.scopes.JetScope
 
 public trait ResolutionFacade {
@@ -36,6 +37,9 @@ public trait ResolutionFacade {
 
     public fun getFileTopLevelScope(file: JetFile): JetScope
 
+    //TODO: better pass ModuleDescriptor here
+    public fun resolveImportReference(file: JetFile, fqName: FqName): Collection<DeclarationDescriptor>
+
     public fun findModuleDescriptor(element: JetElement): ModuleDescriptor
 
     public fun <T> get(extension: CacheExtension<T>): T

idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveSessionForBodies.java

@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.psiUtil.PsiUtilPackage;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingContextUtils;
+import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode;
 import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
@@ -138,4 +139,9 @@ public class ResolveSessionForBodies implements KotlinCodeAnalyzer {
     public PackageFragmentProvider getPackageFragmentProvider() {
         return resolveSession.getPackageFragmentProvider();
     }
+
+    @NotNull
+    public QualifiedExpressionResolver getQualifiedExpressionResolver() {
+        return resolveSession.getQualifiedExpressionResolver();
+    }
 }

idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinCopyPasteReferenceProcessor.kt

@@ -49,14 +49,8 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.elementsInRange
 import org.jetbrains.kotlin.psi.psiUtil.getReceiverExpression
-import org.jetbrains.kotlin.resolve.BindingTraceContext
-import org.jetbrains.kotlin.resolve.ImportPath
-import org.jetbrains.kotlin.resolve.JetModuleUtil
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver.LookupMode
 import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
 import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
 import org.jetbrains.kotlin.types.ErrorUtils
 import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
@@ -316,14 +310,7 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
             = this == KotlinReferenceData.Kind.EXTENSION_FUNCTION || this == KotlinReferenceData.Kind.EXTENSION_PROPERTY
 
     private fun findImportableDescriptors(fqName: FqName, file: JetFile): Collection<DeclarationDescriptor> {
-        val importDirective = JetPsiFactory(file.getProject()).createImportDirective(ImportPath(fqName, false))
-        val moduleDescriptor = file.getResolutionFacade().findModuleDescriptor(file)
-        val scope = JetModuleUtil.getSubpackagesOfRootScope(moduleDescriptor)
-        val qualifiedExpressionResolver = QualifiedExpressionResolver()
-        qualifiedExpressionResolver.setSymbolUsageValidator(SymbolUsageValidator.Empty)
-        return qualifiedExpressionResolver
-                .processImportReference(importDirective, scope, scope, BindingTraceContext(), LookupMode.EVERYTHING)
-                .getAllDescriptors()
+        return file.getResolutionFacade().resolveImportReference(file, fqName)
     }
 
     private fun findCallableToImport(fqName: FqName, file: JetFile): CallableDescriptor?

idea/tests/org/jetbrains/kotlin/addImport/AbstractAddImportTest.kt

@@ -16,22 +16,16 @@
 
 package org.jetbrains.kotlin.addImport
 
+import com.intellij.psi.PsiDocumentManager
 import org.jetbrains.kotlin.AbstractImportsTest
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.test.InTextDirectivesUtils
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver.LookupMode
-import org.jetbrains.kotlin.resolve.JetModuleUtil
-import org.jetbrains.kotlin.resolve.BindingTraceContext
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.JetFile
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import com.intellij.psi.PsiDocumentManager
-import org.jetbrains.kotlin.di.InjectorForTests
-import org.jetbrains.kotlin.test.JetTestUtils
+import org.jetbrains.kotlin.test.InTextDirectivesUtils
 
 public abstract class AbstractAddImportTest : AbstractImportsTest() {
     override fun doTest(file: JetFile) {
@@ -44,13 +38,7 @@ public abstract class AbstractAddImportTest : AbstractImportsTest() {
             descriptorName = descriptorName.substring("class:".length()).trim()
         }
 
-        val importDirective = JetPsiFactory(getProject()).createImportDirective(descriptorName)
-        val moduleDescriptor = file.getResolutionFacade().findModuleDescriptor(file)
-        val scope = JetModuleUtil.getSubpackagesOfRootScope(moduleDescriptor)
-        val descriptors = InjectorForTests(getProject(), moduleDescriptor).getQualifiedExpressionResolver()
-                .processImportReference(importDirective, scope, scope, BindingTraceContext(), LookupMode.EVERYTHING)
-                .getAllDescriptors()
-                .filter(filter)
+        val descriptors = file.getResolutionFacade().resolveImportReference(file, FqName(descriptorName)).filter(filter)
 
         when {
             descriptors.isEmpty() ->

idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/AbstractEditorForEvaluateExpressionTest.kt

@@ -23,7 +23,6 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
 import org.jetbrains.kotlin.checkers.AbstractJetPsiCheckerTest
-import org.jetbrains.kotlin.di.InjectorForTests
 import org.jetbrains.kotlin.idea.caches.resolve.analyzeFully
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.completion.test.AbstractJvmBasicCompletionTest
@@ -31,12 +30,9 @@ import org.jetbrains.kotlin.idea.completion.test.ExpectedCompletionUtils
 import org.jetbrains.kotlin.idea.completion.test.handlers.AbstractCompletionHandlerTest
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
+import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.BindingTraceContext
-import org.jetbrains.kotlin.resolve.JetModuleUtil
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver.LookupMode
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.JetTestUtils
 import java.io.File
@@ -55,13 +51,8 @@ public abstract class AbstractCodeFragmentHighlightingTest : AbstractJetPsiCheck
             val fileText = FileUtil.loadFile(File(filePath), true)
             val file = myFixture.getFile() as JetFile
             InTextDirectivesUtils.findListWithPrefixes(fileText, "// IMPORT: ").forEach {
-                val importDirective = JetPsiFactory(getProject()).createImportDirective(it)
-                val moduleDescriptor = file.getResolutionFacade().findModuleDescriptor(file)
-                val scope = JetModuleUtil.getSubpackagesOfRootScope(moduleDescriptor)
-                val descriptor = InjectorForTests(getProject(), moduleDescriptor).getQualifiedExpressionResolver()
-                                         .processImportReference(importDirective, scope, scope, BindingTraceContext(), LookupMode.EVERYTHING)
-                                         .getAllDescriptors()
-                                         .singleOrNull() ?: error("Could not resolve descriptor to import: $it")
+                val descriptor = file.getResolutionFacade().resolveImportReference(file, FqName(it)).singleOrNull()
+                                            ?: error("Could not resolve descriptor to import: $it")
                 ImportInsertHelper.getInstance(getProject()).importDescriptor(file, descriptor)
             }
         }