New J2K: pass converter context to postprocessing

idea/idea-jvm/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinCodeFragmentFactory.kt

@@ -44,6 +44,7 @@ import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
 import org.jetbrains.kotlin.idea.debugger.KotlinEditorTextProvider
 import org.jetbrains.kotlin.idea.debugger.evaluate.compilation.DebugLabelPropertyDescriptorProvider
 import org.jetbrains.kotlin.idea.j2k.JavaToKotlinConverterFactory
+import org.jetbrains.kotlin.idea.refactoring.convertToKotlin
 import org.jetbrains.kotlin.idea.refactoring.j2k
 import org.jetbrains.kotlin.idea.refactoring.j2kText
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
@@ -242,7 +243,8 @@ class KotlinCodeFragmentFactory : CodeFragmentFactory() {
                 var convertedFragment: KtExpressionCodeFragment? = null
                 project.executeWriteCommand("Convert java expression to kotlin in Evaluate Expression") {
                     try {
-                        val newText = javaExpression.j2kText()
+                        val (elementResults, _, conversionContext) = javaExpression.convertToKotlin() ?: return@executeWriteCommand
+                        val newText = elementResults.singleOrNull()?.text
                         val newImports = importList?.j2kText()
                         if (newText != null) {
                             convertedFragment = KtExpressionCodeFragment(
@@ -253,7 +255,12 @@ class KotlinCodeFragmentFactory : CodeFragmentFactory() {
                                 kotlinCodeFragment.context
                             )
 
-                            AfterConversionPass(project, JavaToKotlinConverterFactory.createPostProcessor(formatCode = false)).run(convertedFragment!!, range = null)
+                            AfterConversionPass(project, JavaToKotlinConverterFactory.createPostProcessor(formatCode = false))
+                                .run(
+                                    convertedFragment!!,
+                                    conversionContext,
+                                    range = null
+                                )
                         }
                     } catch (e: Throwable) {
                         // ignored because text can be invalid

idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertJavaCopyPasteProcessor.kt

@@ -40,6 +40,7 @@ import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.j2k.AfterConversionPass
+import org.jetbrains.kotlin.j2k.ConverterContext
 import org.jetbrains.kotlin.j2k.ConverterSettings
 import org.jetbrains.kotlin.j2k.ParseContext
 import org.jetbrains.kotlin.lexer.KtTokens
@@ -85,14 +86,19 @@ class ConvertJavaCopyPasteProcessor : CopyPastePostProcessor<TextBlockTransferab
 
         if (isNoConversionPosition(targetFile, bounds.startOffset)) return
 
-        data class Result(val text: String?, val referenceData: Collection<KotlinReferenceData>, val explicitImports: Set<FqName>)
+        data class Result(
+            val text: String?,
+            val referenceData: Collection<KotlinReferenceData>,
+            val explicitImports: Set<FqName>,
+            val converterContext: ConverterContext?
+        )
 
         fun doConversion(): Result {
             val dataForConversion = DataForConversion.prepare(data, project)
             val result = dataForConversion.elementsAndTexts.convertCodeToKotlin(project)
             val referenceData = buildReferenceData(result.text, result.parseContext, dataForConversion.importsAndPackage, targetFile)
             val text = if (result.textChanged) result.text else null
-            return Result(text, referenceData, result.importsToAdd)
+            return Result(text, referenceData, result.importsToAdd, result.converterContext)
         }
 
         fun insertImports(bounds: TextRange, referenceData: Collection<KotlinReferenceData>, explicitImports: Collection<FqName>): TextRange? {
@@ -153,7 +159,12 @@ class ConvertJavaCopyPasteProcessor : CopyPastePostProcessor<TextBlockTransferab
             val newBounds = insertImports(boundsAfterReplace, referenceData, explicitImports)
 
             PsiDocumentManager.getInstance(project).commitAllDocuments()
-            AfterConversionPass(project, JavaToKotlinConverterFactory.createPostProcessor(formatCode = true)).run(targetFile, newBounds)
+            AfterConversionPass(project, JavaToKotlinConverterFactory.createPostProcessor(formatCode = true))
+                .run(
+                    targetFile,
+                    conversionResult?.converterContext,
+                    newBounds
+                )
 
             conversionPerformed = true
         }
@@ -202,7 +213,8 @@ internal class ConversionResult(
         val text: String,
         val parseContext: ParseContext,
         val importsToAdd: Set<FqName>,
-        val textChanged: Boolean
+        val textChanged: Boolean,
+        val converterContext: ConverterContext?
 )
 
 internal fun ElementAndTextList.convertCodeToKotlin(project: Project): ConversionResult {
@@ -214,7 +226,7 @@ internal fun ElementAndTextList.convertCodeToKotlin(project: Project): Conversio
         )
 
     val inputElements = this.toList().filterIsInstance<PsiElement>()
-    val results =
+    val (results, _, converterContext) =
             ProgressManager.getInstance().runProcessWithProgressSynchronously(
                     ThrowableComputable<org.jetbrains.kotlin.j2k.Result, Exception> {
                         runReadAction { converter.elementsToKotlin(inputElements) }
@@ -222,7 +234,7 @@ internal fun ElementAndTextList.convertCodeToKotlin(project: Project): Conversio
                     JavaToKotlinAction.title,
                     false,
                     project
-            ).results
+            )
 
 
     val importsToAdd = LinkedHashSet<FqName>()
@@ -257,7 +269,13 @@ internal fun ElementAndTextList.convertCodeToKotlin(project: Project): Conversio
 
     val convertedCode = convertedCodeBuilder.toString()
     val originalCode = originalCodeBuilder.toString()
-    return ConversionResult(convertedCode, parseContext ?: ParseContext.CODE_BLOCK, importsToAdd, convertedCode != originalCode)
+    return ConversionResult(
+        convertedCode,
+        parseContext ?: ParseContext.CODE_BLOCK,
+        importsToAdd,
+        convertedCode != originalCode,
+        converterContext
+    )
 }
 
 internal fun isNoConversionPosition(file: KtFile, offset: Int): Boolean {

idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertTextJavaCopyPasteProcessor.kt

@@ -109,7 +109,8 @@ class ConvertTextJavaCopyPasteProcessor : CopyPastePostProcessor<TextBlockTransf
         val additionalImports = dataForConversion.tryResolveImports(targetFile)
         var convertedImportsText = additionalImports.convertCodeToKotlin(project).text
 
-        val convertedText = dataForConversion.convertCodeToKotlin(project).text
+        val convertedResult = dataForConversion.convertCodeToKotlin(project)
+        val convertedText = convertedResult.text
 
         val newBounds = runWriteAction {
 
@@ -129,7 +130,12 @@ class ConvertTextJavaCopyPasteProcessor : CopyPastePostProcessor<TextBlockTransf
         }
 
         psiDocumentManager.commitAllDocuments()
-        AfterConversionPass(project, JavaToKotlinConverterFactory.createPostProcessor(formatCode = true)).run(targetFile, newBounds)
+        AfterConversionPass(project, JavaToKotlinConverterFactory.createPostProcessor(formatCode = true))
+            .run(
+                targetFile,
+                convertedResult.converterContext,
+                newBounds
+            )
 
         conversionPerformed = true
     }

idea/src/org/jetbrains/kotlin/idea/j2k/J2kPostProcessor.kt

@@ -32,13 +32,12 @@ import org.jetbrains.kotlin.idea.core.util.EDT
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
+import org.jetbrains.kotlin.j2k.ConverterContext
 import org.jetbrains.kotlin.j2k.PostProcessor
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.psiUtil.elementsInRange
-import org.jetbrains.kotlin.resolve.ImportPath
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
 import java.util.*
 
@@ -58,7 +57,7 @@ class J2kPostProcessor(private val formatCode: Boolean) : PostProcessor {
         PROCESS
     }
 
-    override fun doAdditionalProcessing(file: KtFile, rangeMarker: RangeMarker?) =
+    override fun doAdditionalProcessing(file: KtFile, converterContext: ConverterContext?, rangeMarker: RangeMarker?) =
         runBlocking(EDT.ModalityStateElement(ModalityState.defaultModalityState())) {
             do {
                 var modificationStamp: Long? = file.modificationStamp

idea/src/org/jetbrains/kotlin/idea/j2k/JavaToKotlinConverterFactory.kt

@@ -16,6 +16,6 @@ object JavaToKotlinConverterFactory {
     ): JavaToKotlinConverter =
         J2kConverterExtension.extension.createJavaToKotlinConverter(project, settings, services)
 
-    fun createPostProcessor(formatCode: Boolean, settings: ConverterSettings = ConverterSettings.defaultSettings): PostProcessor =
+    fun createPostProcessor(formatCode: Boolean): PostProcessor =
-        J2kConverterExtension.extension.createPostProcessor(formatCode, settings)
+        J2kConverterExtension.extension.createPostProcessor(formatCode)
 }

idea/src/org/jetbrains/kotlin/idea/j2k/OldJ2kConveterExtension.kt

@@ -13,6 +13,6 @@ class OldJ2kConverterExtension : J2kConverterExtension() {
     ): JavaToKotlinConverter =
         OldJavaToKotlinConverter(project, settings, services)
 
-    override fun createPostProcessor(formatCode: Boolean, settings: ConverterSettings): PostProcessor =
+    override fun createPostProcessor(formatCode: Boolean): PostProcessor =
         J2kPostProcessor(formatCode)
 }

idea/src/org/jetbrains/kotlin/idea/refactoring/kotlinRefactoringUtil.kt

@@ -84,7 +84,6 @@ import org.jetbrains.kotlin.idea.refactoring.rename.canonicalRender
 import org.jetbrains.kotlin.idea.util.*
 import org.jetbrains.kotlin.idea.util.string.collapseSpaces
 import org.jetbrains.kotlin.j2k.ConverterSettings
-import org.jetbrains.kotlin.j2k.JavaToKotlinConverter
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.FqNameUnsafe
@@ -643,7 +642,10 @@ fun createJavaClass(klass: KtClass, targetClass: PsiClass?, forcePlainClass: Boo
     return javaClass
 }
 
-fun PsiElement.j2kText(): String? {
+fun PsiElement.j2kText(): String? =
+    convertToKotlin()?.results?.single()?.text //TODO: insert imports
+
+fun PsiElement.convertToKotlin(): org.jetbrains.kotlin.j2k.Result? {
     if (language != JavaLanguage.INSTANCE) return null
 
     val j2kConverter =
@@ -652,7 +654,7 @@ fun PsiElement.j2kText(): String? {
             ConverterSettings.defaultSettings,
             IdeaJavaToKotlinServices
         )
-    return j2kConverter.elementsToKotlin(listOf(this)).results.single()?.text ?: return null //TODO: insert imports
+    return j2kConverter.elementsToKotlin(listOf(this))
 }
 
 fun PsiExpression.j2k(): KtExpression? {

j2k/src/org/jetbrains/kotlin/j2k/AfterConversionPass.kt

@@ -21,7 +21,7 @@ import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.psi.KtFile
 
 class AfterConversionPass(val project: Project, val postProcessor: PostProcessor) {
-    fun run(kotlinFile: KtFile, range: TextRange?) {
+    fun run(kotlinFile: KtFile, converterContext: ConverterContext?, range: TextRange?) {
         val rangeMarker = if (range != null) {
             val document = kotlinFile.viewProvider.document!!
             val marker = document.createRangeMarker(range.startOffset, range.endOffset)
@@ -32,6 +32,6 @@ class AfterConversionPass(val project: Project, val postProcessor: PostProcessor
             null
         }
 
-        postProcessor.doAdditionalProcessing(kotlinFile, rangeMarker)
+        postProcessor.doAdditionalProcessing(kotlinFile, converterContext, rangeMarker)
     }
 }

j2k/src/org/jetbrains/kotlin/j2k/J2KConverterExtension.kt

@@ -14,7 +14,7 @@ abstract class J2kConverterExtension : AbstractExtensionPointBean() {
         services: JavaToKotlinConverterServices
     ): JavaToKotlinConverter
 
-    abstract fun createPostProcessor(formatCode: Boolean, settings: ConverterSettings = ConverterSettings.defaultSettings): PostProcessor
+    abstract fun createPostProcessor(formatCode: Boolean): PostProcessor
 
 
     companion object {

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

@@ -40,7 +40,7 @@ import java.util.*
 interface PostProcessor {
     fun insertImport(file: KtFile, fqName: FqName)
 
-    fun doAdditionalProcessing(file: KtFile, rangeMarker: RangeMarker?)
+    fun doAdditionalProcessing(file: KtFile, converterContext: ConverterContext?, rangeMarker: RangeMarker?)
 }
 
 enum class ParseContext {
@@ -55,10 +55,15 @@ interface ExternalCodeProcessing {
 
 data class ElementResult(val text: String, val importsToAdd: Set<FqName>, val parseContext: ParseContext)
 
-data class Result(val results: List<ElementResult?>, val externalCodeProcessing: ExternalCodeProcessing?)
+data class Result(
+    val results: List<ElementResult?>,
+    val externalCodeProcessing: ExternalCodeProcessing?,
+    val converterContext: ConverterContext?
+)
 
 data class FilesResult(val results: List<String>, val externalCodeProcessing: ExternalCodeProcessing?)
 
+interface ConverterContext
 
 abstract class JavaToKotlinConverter {
     protected abstract fun elementsToKotlin(inputElements: List<PsiElement>, processor: WithProgressProcessor): Result
@@ -101,7 +106,7 @@ class OldJavaToKotlinConverter(
 
                 result!!.importsToAdd.forEach { postProcessor.insertImport(kotlinFile, it) }
 
-                AfterConversionPass(project, postProcessor).run(kotlinFile, range = null)
+                AfterConversionPass(project, postProcessor).run(kotlinFile, converterContext = null, range = null)
 
                 kotlinFile.text
             } catch (e: ProcessCanceledException) {
@@ -140,7 +145,7 @@ class OldJavaToKotlinConverter(
 
             val externalCodeProcessing = buildExternalCodeProcessing(usageProcessings, ::inConversionScope)
 
-            return Result(results, externalCodeProcessing)
+            return Result(results, externalCodeProcessing, null)
         } catch (e: ElementCreationStackTraceRequiredException) {
             // if we got this exception then we need to turn element creation stack traces on to get better diagnostic
             Element.saveCreationStacktraces = true

nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/J2kPostProcessor.kt

@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.idea.formatter.commitAndUnblockDocument
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
-import org.jetbrains.kotlin.j2k.ConverterSettings
+import org.jetbrains.kotlin.j2k.ConverterContext
 import org.jetbrains.kotlin.j2k.PostProcessor
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.nj2k.nullabilityAnalysis.AnalysisScope
@@ -47,10 +47,7 @@ import org.jetbrains.kotlin.psi.psiUtil.elementsInRange
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
 import java.util.*
 
-class NewJ2kPostProcessor(
+class NewJ2kPostProcessor(private val formatCode: Boolean) : PostProcessor {
-    private val formatCode: Boolean,
-    private val settings: ConverterSettings?
-) : PostProcessor {
     override fun insertImport(file: KtFile, fqName: FqName) {
         ApplicationManager.getApplication().invokeAndWait {
             runWriteAction {
@@ -66,10 +63,14 @@ class NewJ2kPostProcessor(
         PROCESS
     }
 
-    private suspend fun List<NewJ2kPostProcessing>.runProcessings(file: KtFile, rangeMarker: RangeMarker?): Boolean {
+    private suspend fun List<NewJ2kPostProcessing>.runProcessings(
+        file: KtFile,
+        converterContext: NewJ2kConverterContext,
+        rangeMarker: RangeMarker?
+    ): Boolean {
         var modificationStamp: Long? = file.modificationStamp
         val elementToActions = runReadAction {
-            collectAvailableActions(this, file, rangeMarker)
+            collectAvailableActions(this, file, converterContext, rangeMarker)
         }
         withContext(EDT) {
             for ((element, action, _, writeActionNeeded) in elementToActions) {
@@ -100,23 +101,24 @@ class NewJ2kPostProcessor(
     }
 
 
-    private suspend fun Processing.runProcessings(file: KtFile, rangeMarker: RangeMarker?) {
+    private suspend fun Processing.runProcessings(file: KtFile, converterContext: NewJ2kConverterContext, rangeMarker: RangeMarker?) {
         when (this) {
-            is SingleOneTimeProcessing -> listOf(processing).runProcessings(file, rangeMarker)
+            is SingleOneTimeProcessing -> listOf(processing).runProcessings(file, converterContext, rangeMarker)
             is RepeatableProcessingGroup ->
                 do {
-                    val needContinue = processings.runProcessings(file, rangeMarker)
+                    val needContinue = processings.runProcessings(file, converterContext, rangeMarker)
                 } while (needContinue)
             is OneTimeProcessingGroup ->
-                processings.forEach { it.runProcessings(file, rangeMarker) }
+                processings.forEach { it.runProcessings(file, converterContext, rangeMarker) }
         }
     }
 
 
-    override fun doAdditionalProcessing(file: KtFile, rangeMarker: RangeMarker?) {
+    override fun doAdditionalProcessing(file: KtFile, converterContext: ConverterContext?, rangeMarker: RangeMarker?) {
         runBlocking(EDT.ModalityStateElement(ModalityState.defaultModalityState())) {
             withContext(EDT) {
                 NullabilityAnalysisFacade(
+                    converterContext as NewJ2kConverterContext,
                     getTypeElementNullability = ::nullabilityByUndefinedNullabilityComment,
                     prepareTypeElement = ::prepareTypeElementByMakingAllTypesNullableConsideringNullabilityComment,
                     debugPrint = false
@@ -131,7 +133,7 @@ class NewJ2kPostProcessor(
                     }
                 }
             }
-            NewJ2KPostProcessingRegistrar.mainProcessings.runProcessings(file, rangeMarker)
+            NewJ2KPostProcessingRegistrar.mainProcessings.runProcessings(file, converterContext as NewJ2kConverterContext, rangeMarker)
             withContext(EDT) {
                 runWriteAction {
                     file.commitAndUnblockDocument()
@@ -159,6 +161,7 @@ class NewJ2kPostProcessor(
     private fun collectAvailableActions(
         processings: Collection<NewJ2kPostProcessing>,
         file: KtFile,
+        context: NewJ2kConverterContext,
         rangeMarker: RangeMarker?
     ): List<ActionData> {
         val diagnostics = analyzeFileRange(file, rangeMarker)
@@ -174,7 +177,7 @@ class NewJ2kPostProcessor(
 
                 if (rangeResult == RangeFilterResult.PROCESS) {
                     processings.forEach { processing ->
-                        val action = processing.createAction(element, diagnostics, settings)
+                        val action = processing.createAction(element, diagnostics, context.converter.settings)
                         if (action != null) {
                             availableActions.add(
                                 ActionData(

nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/NewJ2kConveterExtension.kt

@@ -13,6 +13,6 @@ class NewJ2kConverterExtension : J2kConverterExtension() {
     ): JavaToKotlinConverter =
         NewJavaToKotlinConverter(project, settings, services)
 
-    override fun createPostProcessor(formatCode: Boolean, settings: ConverterSettings): PostProcessor =
+    override fun createPostProcessor(formatCode: Boolean): PostProcessor =
-        NewJ2kPostProcessor(formatCode, settings)
+        NewJ2kPostProcessor(formatCode)
 }

nj2k/src/org/jetbrains/kotlin/nj2k/ConversionsRunner.kt

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.nj2k.tree.JKTreeRoot
 
 object ConversionsRunner {
 
-    private fun createRootConversion(context: ConversionContext) =
+    private fun createRootConversion(context: NewJ2kConverterContext) =
         batchPipe {
             //Java --> Kotlin conversions
             +NonCodeElementsConversion()
@@ -82,9 +82,10 @@ object ConversionsRunner {
             +ClassToObjectPromotionConversion(context)
             +CollectImportsConversion(context)
             +SortClassMembersConversion()
+            +AddElementsInfoConversion(context)
         }
 
-    fun doApply(trees: List<JKTreeRoot>, context: ConversionContext) {
+    fun doApply(trees: List<JKTreeRoot>, context: NewJ2kConverterContext) {
         val conversion = createRootConversion(context)
         conversion.runConversion(trees, context)
     }

nj2k/src/org/jetbrains/kotlin/nj2k/NewJ2kConverterContext.kt

@@ -5,17 +5,18 @@
 
 package org.jetbrains.kotlin.nj2k
 
+import com.intellij.openapi.command.impl.DummyProject
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.j2k.*
-import org.jetbrains.kotlin.nj2k.tree.JKElement
 
-data class ConversionContext(
+data class NewJ2kConverterContext(
     val symbolProvider: JKSymbolProvider,
     val converter: NewJavaToKotlinConverter,
     val inConversionContext: (PsiElement) -> Boolean,
-    val importStorage: ImportStorage
+    val importStorage: ImportStorage,
-) {
+    val elementsInfoStorage: ElementInfoStorage
+) : ConverterContext {
     val project: Project get() = converter.project
     val typeFlavorCalculator = TypeFlavorCalculator(object : TypeFlavorConverterFacade {
         override val referenceSearcher: ReferenceSearcher
@@ -28,4 +29,20 @@ data class ConversionContext(
         override fun inConversionScope(element: PsiElement): Boolean = inConversionContext(element)
     })
 
-}
+    companion object {
+        val DUMMY =
+            NewJ2kConverterContext(
+                JKSymbolProvider(),
+                NewJavaToKotlinConverter(
+                    DummyProject.getInstance(),
+                    ConverterSettings.defaultSettings,
+                    EmptyJavaToKotlinServices
+                ),
+                { false },
+                ImportStorage(),
+                ElementInfoStorage()
+            )
+    }
+
+}
+

nj2k/src/org/jetbrains/kotlin/nj2k/NewJavaToKotlinConverter.kt

@@ -51,7 +51,7 @@ class NewJavaToKotlinConverter(
         progress: ProgressIndicator
     ): FilesResult {
         val withProgressProcessor = WithProgressProcessor(progress, files)
-        val (results, externalCodeProcessing) = ApplicationManager.getApplication().runReadAction(Computable {
+        val (results, externalCodeProcessing, context) = ApplicationManager.getApplication().runReadAction(Computable {
             elementsToKotlin(files, withProgressProcessor)
         })
 
@@ -73,7 +73,7 @@ class NewJavaToKotlinConverter(
                 }
 
                 CommandProcessor.getInstance().runUndoTransparentAction {
-                    AfterConversionPass(project, postProcessor).run(kotlinFile, range = null)
+                    AfterConversionPass(project, postProcessor).run(kotlinFile, context, range = null)
                 }
 
                 kotlinFile.text
@@ -97,7 +97,7 @@ class NewJavaToKotlinConverter(
             element to treeBuilder.buildTree(element)
         }
 
-        val context = ConversionContext(
+        val context = NewJ2kConverterContext(
             symbolProvider,
             this,
             { it.containingFile in inputElements },
@@ -119,6 +119,6 @@ class NewJavaToKotlinConverter(
             )
         }
 
-        return Result(results, null)
+        return Result(results, null, context)
     }
 }

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AnnotationClassConversion.kt

@@ -6,12 +6,12 @@
 package org.jetbrains.kotlin.nj2k.conversions
 
 import org.jetbrains.kotlin.j2k.ast.Nullability
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.toExpression
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
 
-class AnnotationClassConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class AnnotationClassConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKClass) return recurse(element)
         if (element.classKind != JKClass.ClassKind.ANNOTATION) return recurse(element)

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AnnotationConversion.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.isVarargsArgument
 import org.jetbrains.kotlin.nj2k.toExpression
 import org.jetbrains.kotlin.nj2k.tree.*
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.nj2k.tree.impl.JKAnnotationParameterImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKKtAnnotationArrayInitializerExpressionImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKNameIdentifierImpl
 
-class AnnotationConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class AnnotationConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKAnnotation) return recurse(element)
         fixVarargsInvocation(element)

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ArrayInitializerConversion.kt

@@ -8,14 +8,14 @@ package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.PrimitiveType
 import org.jetbrains.kotlin.j2k.ast.Nullability
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.toArgumentList
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
 import org.jetbrains.kotlin.resolve.CollectionLiteralResolver
 
 
-class ArrayInitializerConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class ArrayInitializerConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         var newElement = element
         if (element is JKJavaNewArray) {

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ArrayOperationsConversion.kt

@@ -10,15 +10,12 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
-import org.jetbrains.kotlin.nj2k.tree.impl.JKExpressionStatementImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKFieldAccessExpressionImpl
-import org.jetbrains.kotlin.nj2k.tree.impl.JKFieldSymbol
-import org.jetbrains.kotlin.nj2k.tree.impl.JKKtThrowExpressionImpl
 
 
-class ArrayOperationsConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class ArrayOperationsConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKQualifiedExpression) return recurse(element)
         val selector = element.selector as? JKFieldAccessExpression ?: return recurse(element)

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AssertStatementConversion.kt

@@ -8,12 +8,10 @@ package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.nj2k.*
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKExpressionStatementImpl
-import org.jetbrains.kotlin.nj2k.tree.impl.JKJavaOperatorImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKLambdaExpressionImpl
-import org.jetbrains.kotlin.nj2k.tree.impl.toKtToken
 
 
-class AssertStatementConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class AssertStatementConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKJavaAssertStatement) return recurse(element)
         val messageExpression =

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AssignmentAsExpressionToAlsoConversion.kt

@@ -5,12 +5,12 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
 import org.jetbrains.kotlin.utils.addToStdlib.cast
 
-class AssignmentAsExpressionToAlsoConversion(val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class AssignmentAsExpressionToAlsoConversion(val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKJavaAssignmentExpression) return recurse(element)
         element.invalidate()

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AssignmentStatementValCreationConversion.kt

@@ -5,11 +5,11 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
 
-class AssignmentStatementValCreationConversion(val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class AssignmentStatementValCreationConversion(val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKKtAlsoCallExpression) return recurse(element)
         val codeBlock = (element.statement as? JKBlockStatement)?.block ?: return recurse(element)

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/BaseConversion.kt

@@ -16,17 +16,17 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
 
 interface BatchBaseConversion {
-    fun runConversion(treeRoots: List<JKTreeElement>, context: ConversionContext): Boolean
+    fun runConversion(treeRoots: List<JKTreeElement>, context: NewJ2kConverterContext): Boolean
 }
 
 interface SequentialBaseConversion : BatchBaseConversion {
-    fun runConversion(treeRoot: JKTreeElement, context: ConversionContext): Boolean
+    fun runConversion(treeRoot: JKTreeElement, context: NewJ2kConverterContext): Boolean
 
-    override fun runConversion(treeRoots: List<JKTreeElement>, context: ConversionContext): Boolean {
+    override fun runConversion(treeRoots: List<JKTreeElement>, context: NewJ2kConverterContext): Boolean {
         return treeRoots.asSequence().map { runConversion(it, context) }.max() ?: false
     }
 }

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/BlockToRunConversion.kt

@@ -5,11 +5,11 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
 
-class BlockToRunConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class BlockToRunConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKBlockStatement) return recurse(element)
 

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/BoxedTypeOperationsConversion.kt

@@ -5,12 +5,12 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKArgumentListImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKKtCallExpressionImpl
 
-class BoxedTypeOperationsConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class BoxedTypeOperationsConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         return recurse(
             when (element) {

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/BuiltinMembersConversion.kt

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.nj2k.tree.impl.*
 import org.jetbrains.kotlin.utils.addToStdlib.cast
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
-class BuiltinMembersConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class BuiltinMembersConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKExpression) return recurse(element)
         return recurse(element.convert() ?: element)

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ClassToObjectPromotionConversion.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.getCompanion
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKAnnotationListImpl
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.nj2k.tree.impl.JKClassImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKModalityModifierElementImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.psi
 
-class ClassToObjectPromotionConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class ClassToObjectPromotionConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element is JKClass && element.classKind == JKClass.ClassKind.CLASS) {
             val companion = element.getCompanion() ?: return recurse(element)

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/CollectImportsConversion.kt

@@ -11,14 +11,14 @@
 package org.jetbrains.kotlin.nj2k.conversions
 
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKSymbol
 import org.jetbrains.kotlin.nj2k.tree.impl.fqNameToImport
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 
-class CollectImportsConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class CollectImportsConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         when (element) {
             is JKClassAccessExpression -> addSymbol(element.identifier)

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/CompositeConversion.kt

@@ -5,31 +5,31 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
 
 class BatchPipelineConversion(val conversions: List<BatchBaseConversion>) : BatchBaseConversion {
-    override fun runConversion(treeRoots: List<JKTreeElement>, context: ConversionContext): Boolean {
+    override fun runConversion(treeRoots: List<JKTreeElement>, context: NewJ2kConverterContext): Boolean {
         return conversions.asSequence().map { it.runConversion(treeRoots, context) }.max() ?: false
     }
 }
 
 class SequentialPipelineConversion(val conversions: List<SequentialBaseConversion>) : SequentialBaseConversion {
-    override fun runConversion(treeRoot: JKTreeElement, context: ConversionContext): Boolean {
+    override fun runConversion(treeRoot: JKTreeElement, context: NewJ2kConverterContext): Boolean {
         return conversions.asSequence().map { it.runConversion(treeRoot, context) }.max() ?: false
     }
 }
 
 class BatchRepeatConversion(val conversion: BatchBaseConversion) : BatchBaseConversion {
 
-    override fun runConversion(treeRoots: List<JKTreeElement>, context: ConversionContext): Boolean {
+    override fun runConversion(treeRoots: List<JKTreeElement>, context: NewJ2kConverterContext): Boolean {
         return true in generateSequence { conversion.runConversion(treeRoots, context) }.takeWhile { it }
     }
 
 }
 
 class SequentialRepeatConversion(val conversion: SequentialBaseConversion) : SequentialBaseConversion {
-    override fun runConversion(treeRoot: JKTreeElement, context: ConversionContext): Boolean {
+    override fun runConversion(treeRoot: JKTreeElement, context: NewJ2kConverterContext): Boolean {
         return true in generateSequence { conversion.runConversion(treeRoot, context) }.takeWhile { it }
     }
 

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ConstructorConversion.kt

@@ -5,12 +5,12 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKKtConstructorImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKStubExpressionImpl
 
-class ConstructorConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class ConstructorConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKJavaMethod) return recurse(element)
         val outerClass = element.parentOfType<JKClass>() ?: return recurse(element)

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/DefaultArgumentsConversion.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.copyTreeAndDetach
 import org.jetbrains.kotlin.nj2k.jvmAnnotation
 import org.jetbrains.kotlin.nj2k.tree.*
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.nj2k.tree.impl.JKUniverseMethodSymbol
 import org.jetbrains.kotlin.nj2k.tree.impl.psi
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
-class DefaultArgumentsConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class DefaultArgumentsConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
 
     private fun JKMethod.canNotBeMerged(): Boolean =
         modality == Modality.ABSTRACT

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/EnumFieldAccessConversion.kt

@@ -6,13 +6,13 @@
 package org.jetbrains.kotlin.nj2k.conversions
 
 import com.intellij.psi.PsiEnumConstant
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
 import org.jetbrains.kotlin.psi.psiUtil.containingClass
 
 
-class EnumFieldAccessConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class EnumFieldAccessConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKFieldAccessExpression) return recurse(element)
         if ((element.parent as? JKQualifiedExpression)?.selector == element) return recurse(element)

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/EqualsOperatorConversion.kt

@@ -5,13 +5,13 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.equalsExpression
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKParenthesizedExpressionImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.deepestFqName
 
-class EqualsOperatorConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class EqualsOperatorConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKQualifiedExpression) return recurse(element)
         if (element.receiver is JKSuperExpression) return recurse(element)

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ForConversion.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.nj2k.tree.impl.*
 import kotlin.math.abs
 
 
-class ForConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class ForConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     private val referenceSearcher: ReferenceSearcher
         get() = context.converter.converterServices.oldServices.referenceSearcher
 

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ImplicitCastsConversion.kt

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.nj2k.tree.impl.*
 import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
-class ImplicitCastsConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class ImplicitCastsConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         when (element) {
             is JKVariable -> convertVariable(element)

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ImplicitInitializerConversion.kt

@@ -5,12 +5,12 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.findUsages
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
 
-class ImplicitInitializerConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class ImplicitInitializerConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
 
     enum class InitializationState {
         INITIALIZED_IN_ALL_CONSTRUCTORS,

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/InsertDefaultPrimaryConstructorConversion.kt

@@ -5,12 +5,12 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
 
 
-class InsertDefaultPrimaryConstructorConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class InsertDefaultPrimaryConstructorConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKClass) return recurse(element)
         if (element.classKind != JKClass.ClassKind.CLASS) return recurse(element)

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/InternalDeclarationConversion.kt

@@ -6,12 +6,12 @@
 package org.jetbrains.kotlin.nj2k.conversions
 
 import com.intellij.psi.PsiMember
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.psi
 import org.jetbrains.kotlin.nj2k.visibility
 
-class InternalDeclarationConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class InternalDeclarationConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKVisibilityOwner || element !is JKModalityOwner) return recurse(element)
         val containingClass = element.parentOfType<JKClass>()

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/JavaAnnotationsConversion.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.copyTreeAndDetach
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKAnnotationParameterImpl
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.nj2k.tree.impl.JKFieldAccessExpressionImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKKtLiteralExpressionImpl
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
-class JavaAnnotationsConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class JavaAnnotationsConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element is JKAnnotationList) {
             for (annotation in element.annotations) {

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/JavaMethodToKotlinFunctionConversion.kt

@@ -17,13 +17,13 @@
 package org.jetbrains.kotlin.nj2k.conversions
 
 import org.jetbrains.kotlin.j2k.ast.Nullability
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.throwAnnotation
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKKtFunctionImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.psi
 
-class JavaMethodToKotlinFunctionConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class JavaMethodToKotlinFunctionConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKJavaMethod) return recurse(element)
 

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/JavaModifiersConversion.kt

@@ -5,12 +5,12 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.annotationByFqName
 import org.jetbrains.kotlin.nj2k.jvmAnnotation
 import org.jetbrains.kotlin.nj2k.tree.*
 
-class JavaModifiersConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class JavaModifiersConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element is JKModalityOwner && element is JKAnnotationListOwner) {
             val overrideAnnotation = element.annotationList.annotationByFqName("java.lang.Override")

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/JavaStandartMethodsConversion.kt

@@ -5,12 +5,12 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.j2k.ast.Nullability
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
 
-class JavaStandartMethodsConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class JavaStandartMethodsConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKClass) return recurse(element)
         for (declaration in element.classBody.declarations) {

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/JetbrainsNullableAnnotationsConverter.kt

@@ -8,12 +8,12 @@ package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.j2k.ast.Nullability
 import org.jetbrains.kotlin.load.java.NOT_NULL_ANNOTATIONS
 import org.jetbrains.kotlin.load.java.NULLABLE_ANNOTATIONS
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKTypeElementImpl
 
 
-class JetbrainsNullableAnnotationsConverter(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class JetbrainsNullableAnnotationsConverter(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKAnnotationListOwner) return recurse(element)
 

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/MainFunctionConversion.kt

@@ -5,15 +5,14 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.j2k.ast.Nullability
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
-import org.jetbrains.kotlin.util.collectionUtils.concatInOrder
 
 
 //TODO temporary
-class MainFunctionConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class MainFunctionConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKMethod) return recurse(element)
         if (element.isMainFunctionDeclaration()) {

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ModalityConversion.kt

@@ -7,11 +7,11 @@ package org.jetbrains.kotlin.nj2k.conversions
 
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiMethod
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.psi
 
-class ModalityConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class ModalityConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         when (element) {
             is JKClass -> processClass(element)

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/OperatorExpressionConversion.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.nj2k.conversions
 
 import com.intellij.psi.JavaTokenType
 import org.jetbrains.kotlin.lexer.KtTokens
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.kotlinBinaryExpression
 import org.jetbrains.kotlin.nj2k.kotlinPostfixExpression
 import org.jetbrains.kotlin.nj2k.kotlinPrefixExpression
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
 
 
-class OperatorExpressionConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class OperatorExpressionConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKOperatorExpression) return recurse(element)
         val operator = element.operator as? JKJavaOperatorImpl ?: return recurse(element)

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ParameterModificationInMethodCallsConversion.kt

@@ -6,13 +6,13 @@
 package org.jetbrains.kotlin.nj2k.conversions
 
 import org.jetbrains.kotlin.j2k.ast.Nullability
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.hasWritableUsages
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
 
 
-class ParameterModificationInMethodCallsConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class ParameterModificationInMethodCallsConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKMethod) return recurse(element)
         val newVariables =

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/PrimaryConstructorDetectConversion.kt

@@ -5,13 +5,13 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.replace
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKKtInitDeclarationImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKKtPrimaryConstructorImpl
 
-class PrimaryConstructorDetectConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class PrimaryConstructorDetectConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element is JKClass &&
             (element.classKind == JKClass.ClassKind.CLASS || element.classKind == JKClass.ClassKind.ENUM)

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/RecursiveApplicableConversionBase.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
 
 abstract class RecursiveApplicableConversionBase : MatchBasedConversion() {
@@ -13,7 +13,7 @@ abstract class RecursiveApplicableConversionBase : MatchBasedConversion() {
         somethingChanged = true
     }
 
-    override fun runConversion(treeRoot: JKTreeElement, context: ConversionContext): Boolean {
+    override fun runConversion(treeRoot: JKTreeElement, context: NewJ2kConverterContext): Boolean {
         val root = applyToElement(treeRoot)
         assert(root === treeRoot)
         return somethingChanged

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/StaticMemberAccessConversion.kt

@@ -10,7 +10,7 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiModifierListOwner
 import com.intellij.psi.util.parentOfType
 import org.jetbrains.kotlin.j2k.getContainingClass
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.asQualifierWithThisAsSelector
 import org.jetbrains.kotlin.nj2k.copyTreeAndDetach
 import org.jetbrains.kotlin.nj2k.tree.*
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.psi.psiUtil.containingClass
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 
-class StaticMemberAccessConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class StaticMemberAccessConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         val symbol =
             when (element) {

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/SwitchStatementConversion.kt

@@ -9,7 +9,7 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.controlFlow.ControlFlowFactory
 import com.intellij.psi.controlFlow.ControlFlowUtil
 import com.intellij.psi.controlFlow.LocalsOrMyInstanceFieldsControlFlowPolicy
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.blockStatement
 import org.jetbrains.kotlin.nj2k.copyTreeAndDetach
 import org.jetbrains.kotlin.nj2k.runExpression
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
 
 
-class SwitchStatementConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class SwitchStatementConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKJavaSwitchStatementImpl) return recurse(element)
         element.invalidate()

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/SynchronizedStatementConversion.kt

@@ -5,14 +5,14 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.JKJavaSynchronizedStatement
 import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
 import org.jetbrains.kotlin.nj2k.tree.impl.*
 import org.jetbrains.kotlin.nj2k.tree.withNonCodeElementsFrom
 
 
-class SynchronizedStatementConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class SynchronizedStatementConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKJavaSynchronizedStatement) return recurse(element)
         element.invalidate()

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/TransformerBasedConversion.kt

@@ -16,14 +16,14 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
 import org.jetbrains.kotlin.nj2k.tree.visitors.JKVisitorVoid
 
 abstract class TransformerBasedConversion : SequentialBaseConversion, JKVisitorVoid {
     protected var somethingChanged = false
 
-    override fun runConversion(treeRoot: JKTreeElement, context: ConversionContext): Boolean {
+    override fun runConversion(treeRoot: JKTreeElement, context: NewJ2kConverterContext): Boolean {
         somethingChanged = false
         treeRoot.accept(this, null)
         return somethingChanged

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/TryStatementConversion.kt

@@ -6,14 +6,14 @@
 package org.jetbrains.kotlin.nj2k.conversions
 
 import org.jetbrains.kotlin.j2k.ast.Nullability
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.copyTreeAndDetach
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
 import org.jetbrains.kotlin.nj2k.useExpression
 
 
-class TryStatementConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class TryStatementConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKJavaTryStatement) return recurse(element)
         return if (element.resourceDeclarations.isEmpty())

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/TypeMappingConversion.kt

@@ -15,12 +15,12 @@ import org.jetbrains.kotlin.j2k.ast.Mutability
 import org.jetbrains.kotlin.j2k.ast.Nullability
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.kotlinTypeByName
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
 
-class TypeMappingConversion(val context: ConversionContext) : RecursiveApplicableConversionBase() {
+class TypeMappingConversion(val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
     private val typeFlavorCalculator = TypeFlavorCalculator(object : TypeFlavorConverterFacade {
         override val referenceSearcher: ReferenceSearcher
             get() = context.converter.converterServices.oldServices.referenceSearcher

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/resolveUtil.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.nj2k.conversions
 
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiPolyVariantReference
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
 import org.jetbrains.kotlin.nj2k.tree.impl.psi
 import org.jetbrains.kotlin.name.ClassId
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.psi.psiUtil.getChildOfType
 import org.jetbrains.kotlin.resolve.ImportPath
 
 
-internal fun resolveFqName(classId: ClassId, contextElement: JKTreeElement, context: ConversionContext): PsiElement? {
+internal fun resolveFqName(classId: ClassId, contextElement: JKTreeElement, context: NewJ2kConverterContext): PsiElement? {
     val element = contextElement.psi ?: return null
     return resolveFqName(classId, element)
 }

nj2k/src/org/jetbrains/kotlin/nj2k/expressions.kt

@@ -220,7 +220,7 @@ fun kotlinPostfixExpression(
 fun untilToExpression(
     from: JKExpression,
     to: JKExpression,
-    conversionContext: ConversionContext
+    conversionContext: NewJ2kConverterContext
 ): JKExpression =
     rangeExpression(
         from,
@@ -232,7 +232,7 @@ fun untilToExpression(
 fun downToExpression(
     from: JKExpression,
     to: JKExpression,
-    conversionContext: ConversionContext
+    conversionContext: NewJ2kConverterContext
 ): JKExpression =
     rangeExpression(
         from,
@@ -254,7 +254,7 @@ fun rangeExpression(
     from: JKExpression,
     to: JKExpression,
     operatorName: String,
-    conversionContext: ConversionContext
+    conversionContext: NewJ2kConverterContext
 ): JKExpression =
     JKBinaryExpressionImpl(
         from,
@@ -331,7 +331,7 @@ fun stringLiteral(content: String, symbolProvider: JKSymbolProvider): JKExpressi
     }
 }
 
-fun JKVariable.findUsages(scope: JKTreeElement, context: ConversionContext): List<JKFieldAccessExpression> {
+fun JKVariable.findUsages(scope: JKTreeElement, context: NewJ2kConverterContext): List<JKFieldAccessExpression> {
     val symbol = context.symbolProvider.provideUniverseSymbol(this)
     val usages = mutableListOf<JKFieldAccessExpression>()
     val searcher = object : RecursiveApplicableConversionBase() {
@@ -369,7 +369,7 @@ fun JKExpression.bangedBangedExpr(symbolProvider: JKSymbolProvider): JKExpressio
         JKKtOperatorImpl(KtTokens.EXCLEXCL, type(symbolProvider)!!)
     )
 
-fun JKVariable.hasWritableUsages(scope: JKTreeElement, context: ConversionContext): Boolean =
+fun JKVariable.hasWritableUsages(scope: JKTreeElement, context: NewJ2kConverterContext): Boolean =
     findUsages(scope, context).any {
         it.asAssignmentFromTarget() != null
                 || it.isInDecrementOrIncrement()

nj2k/src/org/jetbrains/kotlin/nj2k/tree/types.kt

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.util.getJavaClassDescriptor
 import org.jetbrains.kotlin.j2k.ast.Nullability
 import org.jetbrains.kotlin.js.descriptorUtils.getJetTypeFqName
 import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.JKSymbolProvider
 import org.jetbrains.kotlin.nj2k.kotlinTypeByName
 import org.jetbrains.kotlin.nj2k.tree.impl.*
@@ -240,7 +240,7 @@ fun <T : JKType> T.updateNullabilityRecursively(newNullability: Nullability): T
         }
     } as T
 
-fun JKJavaMethod.returnTypeNullability(context: ConversionContext): Nullability =
+fun JKJavaMethod.returnTypeNullability(context: NewJ2kConverterContext): Nullability =
     context.typeFlavorCalculator.methodNullability(psi()!!)
 
 fun JKType.isCollectionType(symbolProvider: JKSymbolProvider): Boolean {