Converter: use ide resolve through a dedicated interface

Eliminate direct usages of ResolveSession

idea/src/org/jetbrains/jet/plugin/actions/JavaToKotlinAction.kt

@@ -38,9 +38,9 @@ import org.jetbrains.jet.plugin.j2k.J2kPostProcessor
 import com.intellij.openapi.vfs.CharsetToolkit
 import org.jetbrains.jet.lang.psi.JetFile
 import org.jetbrains.jet.utils.addIfNotNull
-import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession
 import com.intellij.openapi.vfs.VfsUtilCore
 import com.intellij.openapi.vfs.VirtualFileVisitor
+import org.jetbrains.jet.plugin.j2k.IdeaResolverForConverter
 
 public class JavaToKotlinAction : AnAction() {
     override fun actionPerformed(e: AnActionEvent) {
@@ -104,7 +104,7 @@ public class JavaToKotlinAction : AnAction() {
     }
 
     private fun convertFiles(javaFiles: List<PsiJavaFile>, project: Project): List<VirtualFile> {
-        val converter = JavaToKotlinConverter(project, ConverterSettings.defaultSettings, FilesConversionScope(javaFiles), IdeaReferenceSearcher, { it.getLazyResolveSession() })
+        val converter = JavaToKotlinConverter(project, ConverterSettings.defaultSettings, FilesConversionScope(javaFiles), IdeaReferenceSearcher, IdeaResolverForConverter)
 
         val convertedTexts = converter.elementsToKotlin(javaFiles.map { it to J2kPostProcessor(it) })
 

idea/src/org/jetbrains/jet/plugin/conversion/copy/ConvertJavaCopyPastePostProcessor.kt

@@ -34,7 +34,7 @@ import com.intellij.openapi.util.TextRange
 import com.intellij.psi.codeStyle.CodeStyleManager
 import com.intellij.lang.java.JavaLanguage
 import org.jetbrains.jet.plugin.j2k.J2kPostProcessor
-import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession
+import org.jetbrains.jet.plugin.j2k.IdeaResolverForConverter
 
 public class ConvertJavaCopyPastePostProcessor() : CopyPastePostProcessor<TextBlockTransferableData>() {
 
@@ -87,11 +87,13 @@ public class ConvertJavaCopyPastePostProcessor() : CopyPastePostProcessor<TextBl
     }
 
     private fun convertCopiedCodeToKotlin(code: CopiedCode, fileCopiedFrom: PsiJavaFile, fileCopiedTo: JetFile): String {
-        val converter = JavaToKotlinConverter(fileCopiedFrom.getProject(),
+        val converter = JavaToKotlinConverter(
-                                         ConverterSettings.defaultSettings,
+                fileCopiedFrom.getProject(),
-                                         FilesConversionScope(listOf(fileCopiedFrom)),
+                ConverterSettings.defaultSettings,
-                                         IdeaReferenceSearcher,
+                FilesConversionScope(listOf(fileCopiedFrom)),
-                                         { it.getLazyResolveSession() })
+                IdeaReferenceSearcher,
+                IdeaResolverForConverter
+        )
         val startOffsets = code.startOffsets
         val endOffsets = code.endOffsets
         assert(startOffsets.size == endOffsets.size) { "Must have the same size" }

idea/src/org/jetbrains/jet/plugin/j2k/IdeaResolverForConverter.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.plugin.j2k
+
+import org.jetbrains.jet.j2k.ResolverForConverter
+import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession
+import org.jetbrains.jet.lang.psi.JetDeclaration
+
+public object IdeaResolverForConverter: ResolverForConverter {
+    override fun resolveToDescriptor(declaration: JetDeclaration) = declaration.getLazyResolveSession().resolveToDescriptor(declaration)
+}

j2k/src/org/jetbrains/jet/j2k/Converter.kt

@@ -27,14 +27,12 @@ import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.jet.j2k.usageProcessing.UsageProcessing
 import org.jetbrains.jet.j2k.usageProcessing.FieldToPropertyProcessing
 import org.jetbrains.jet.j2k.usageProcessing.UsageProcessingExpressionConverter
-import org.jetbrains.jet.lang.psi.JetElement
-import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer
 
 class Converter private(private val elementToConvert: PsiElement,
                         val settings: ConverterSettings,
                         val conversionScope: ConversionScope,
                         val referenceSearcher: ReferenceSearcher,
-                        val resolveSessionGetter: ((JetElement) -> KotlinCodeAnalyzer)?,
+                        val resolverForConverter: ResolverForConverter,
                         private val postProcessor: PostProcessor?,
                         private val commonState: Converter.CommonState,
                         private val personalState: Converter.PersonalState) {
@@ -56,16 +54,16 @@ class Converter private(private val elementToConvert: PsiElement,
 
     class object {
         public fun create(elementToConvert: PsiElement, settings: ConverterSettings, conversionScope: ConversionScope,
-                          referenceSearcher: ReferenceSearcher, resolveSessionGetter: ((JetElement) -> KotlinCodeAnalyzer)?, postProcessor: PostProcessor?,
+                          referenceSearcher: ReferenceSearcher, resolverForConverter: ResolverForConverter, postProcessor: PostProcessor?,
                           usageProcessingsCollector: (UsageProcessing) -> Unit): Converter {
-            return Converter(elementToConvert, settings, conversionScope, referenceSearcher, resolveSessionGetter, postProcessor, CommonState(usageProcessingsCollector), PersonalState(null))
+            return Converter(elementToConvert, settings, conversionScope, referenceSearcher, resolverForConverter, postProcessor, CommonState(usageProcessingsCollector), PersonalState(null))
         }
     }
 
     public fun withSpecialContext(context: PsiElement): Converter = withState(PersonalState(context))
 
     private fun withState(state: PersonalState): Converter
-            = Converter(elementToConvert, settings, conversionScope, referenceSearcher, resolveSessionGetter, postProcessor, commonState, state)
+            = Converter(elementToConvert, settings, conversionScope, referenceSearcher, resolverForConverter, postProcessor, commonState, state)
 
     private fun createDefaultCodeConverter() = CodeConverter(this, DefaultExpressionConverter(), DefaultStatementConverter(), null)
 

j2k/src/org/jetbrains/jet/j2k/JavaToKotlinConverter.kt

@@ -26,8 +26,6 @@ import org.jetbrains.jet.lang.resolve.BindingContext
 import com.intellij.openapi.diagnostic.Logger
 import java.util.ArrayList
 import org.jetbrains.jet.j2k.usageProcessing.UsageProcessing
-import org.jetbrains.jet.lang.psi.JetElement
-import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer
 import java.util.HashMap
 
 public trait ConversionScope {
@@ -48,7 +46,7 @@ public class JavaToKotlinConverter(private val project: Project,
                                    private val settings: ConverterSettings,
                                    private val conversionScope: ConversionScope /*TODO: drop this parameter*/,
                                    private val referenceSearcher: ReferenceSearcher,
-                                   private val resolveSessionGetter: ((JetElement) -> KotlinCodeAnalyzer)?) {
+                                   private val resolverForConverter: ResolverForConverter) {
     private val LOG = Logger.getInstance("#org.jetbrains.jet.j2k.JavaToKotlinConverter")
 
     public fun elementsToKotlin(psiElementsAndProcessors: List<Pair<PsiElement, PostProcessor?>>): List<String> {
@@ -61,7 +59,7 @@ public class JavaToKotlinConverter(private val project: Project,
                 usageProcessings.put(usageProcessing.targetElement, usageProcessing)
             }
             for ((psiElement, postProcessor) in psiElementsAndProcessors) {
-                val converter = Converter.create(psiElement, settings, conversionScope, referenceSearcher, resolveSessionGetter, postProcessor, usageProcessingCollector)
+                val converter = Converter.create(psiElement, settings, conversionScope, referenceSearcher, resolverForConverter, postProcessor, usageProcessingCollector)
                 val result = converter.convert()
                 intermediateResults.add(result)
             }

j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.kt

@@ -90,7 +90,7 @@ public object JavaToKotlinTranslator {
     fun generateKotlinCode(javaCode: String): String {
         val file = createFile(javaCode)
         if (file is PsiJavaFile) {
-            val converter = JavaToKotlinConverter(file.getProject(), ConverterSettings.defaultSettings, FilesConversionScope(listOf(file)), EmptyReferenceSearcher, null)
+            val converter = JavaToKotlinConverter(file.getProject(), ConverterSettings.defaultSettings, FilesConversionScope(listOf(file)), EmptyReferenceSearcher, EmptyResolverForConverter)
             return prettify(converter.elementsToKotlin(listOf(file to null))[0])
         }
         return ""

j2k/src/org/jetbrains/jet/j2k/ResolverForConverter.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.j2k
+
+import org.jetbrains.jet.lang.psi.JetDeclaration
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
+
+public trait ResolverForConverter {
+    public fun resolveToDescriptor(declaration: JetDeclaration): DeclarationDescriptor?
+}
+
+object EmptyResolverForConverter : ResolverForConverter {
+    override fun resolveToDescriptor(declaration: JetDeclaration) = null
+}

j2k/src/org/jetbrains/jet/j2k/TypeConverter.kt

@@ -33,9 +33,9 @@ import org.jetbrains.jet.j2k.ast.Mutability
 import java.util.HashSet
 import org.jetbrains.jet.asJava.KotlinLightElement
 import org.jetbrains.jet.lang.psi.JetCallableDeclaration
-import org.jetbrains.jet.lang.descriptors.CallableDescriptor
 import org.jetbrains.jet.lang.types.TypeUtils
 import org.jetbrains.jet.lang.resolve.DescriptorUtils
+import org.jetbrains.jet.lang.descriptors.CallableDescriptor
 
 class TypeConverter(val converter: Converter) {
     public fun convertType(type: PsiType?, nullability: Nullability = Nullability.Default, mutability: Mutability = Mutability.Default): Type {
@@ -370,9 +370,7 @@ class TypeConverter(val converter: Converter) {
         override fun fromAnnotations(owner: PsiModifierListOwner): Mutability {
             if (owner is KotlinLightElement<*, *>) {
                 val jetDeclaration = owner.origin as? JetCallableDeclaration ?: return Mutability.Default
-                val codeAnalyzer = converter.resolveSessionGetter?.invoke(jetDeclaration)
+                val descriptor = converter.resolverForConverter.resolveToDescriptor(jetDeclaration) as? CallableDescriptor ?: return Mutability.Default
-                val descriptor = codeAnalyzer?.resolveToDescriptor(jetDeclaration)
-                                         as? CallableDescriptor ?: return Mutability.Default
                 val type = descriptor.getReturnType() ?: return Mutability.Default
                 val classDescriptor = TypeUtils.getClassDescriptor(type) ?: return Mutability.Default
                 return if (DescriptorUtils.getFqName(classDescriptor).asString() in mutableKotlinClasses)

j2k/tests/test/org/jetbrains/jet/j2k/test/AbstractJavaToKotlinConverterMultiFileTest.kt

@@ -32,7 +32,7 @@ import com.intellij.psi.PsiManager
 import java.util.ArrayList
 import org.jetbrains.jet.j2k.ConverterSettings
 import org.jetbrains.jet.lang.psi.JetFile
-import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession
+import org.jetbrains.jet.plugin.j2k.IdeaResolverForConverter
 
 public abstract class AbstractJavaToKotlinConverterMultiFileTest() : AbstractJavaToKotlinConverterTest() {
     public fun doTest(dirPath: String) {
@@ -47,7 +47,7 @@ public abstract class AbstractJavaToKotlinConverterMultiFileTest() : AbstractJav
             psiFiles.add(psiFile)
         }
 
-        val converter = JavaToKotlinConverter(project, ConverterSettings.defaultSettings, FilesConversionScope(psiFiles), IdeaReferenceSearcher, { it.getLazyResolveSession() })
+        val converter = JavaToKotlinConverter(project, ConverterSettings.defaultSettings, FilesConversionScope(psiFiles), IdeaReferenceSearcher, IdeaResolverForConverter)
         val results: List<String> = converter.elementsToKotlin(psiFiles.map { it to J2kPostProcessor(it) })
                 .map { reformat(it, project) }
 

j2k/tests/test/org/jetbrains/jet/j2k/test/AbstractJavaToKotlinConverterSingleFileTest.kt

@@ -33,7 +33,7 @@ import com.intellij.psi.PsiJavaFile
 import org.jetbrains.jet.j2k.IdeaReferenceSearcher
 import org.jetbrains.jet.j2k.JavaToKotlinConverter
 import org.jetbrains.jet.lang.psi.JetFile
-import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession
+import org.jetbrains.jet.plugin.j2k.IdeaResolverForConverter
 
 public abstract class AbstractJavaToKotlinConverterSingleFileTest() : AbstractJavaToKotlinConverterTest() {
     val testHeaderPattern = Pattern.compile("//(element|expression|statement|method|class|file|comp)\n")
@@ -111,14 +111,14 @@ public abstract class AbstractJavaToKotlinConverterSingleFileTest() : AbstractJa
 
     private fun elementToKotlin(text: String, settings: ConverterSettings, project: Project): String {
         val fileWithText = createJavaFile(text)
-        val converter = JavaToKotlinConverter(project, settings, FilesConversionScope(listOf(fileWithText)), IdeaReferenceSearcher, { it.getLazyResolveSession() })
+        val converter = JavaToKotlinConverter(project, settings, FilesConversionScope(listOf(fileWithText)), IdeaReferenceSearcher, IdeaResolverForConverter)
         val element = fileWithText.getFirstChild()!!
         return converter.elementsToKotlin(listOf(element to J2kPostProcessor(fileWithText)))[0]
     }
 
     private fun fileToKotlin(text: String, settings: ConverterSettings, project: Project): String {
         val file = createJavaFile(text)
-        val converter = JavaToKotlinConverter(project, settings, FilesConversionScope(listOf(file)), IdeaReferenceSearcher, { it.getLazyResolveSession() })
+        val converter = JavaToKotlinConverter(project, settings, FilesConversionScope(listOf(file)), IdeaReferenceSearcher, IdeaResolverForConverter)
         return converter.elementsToKotlin(listOf(file to J2kPostProcessor(file)))[0]
     }