New J2K: store reference to conversionContext & symbolProvider in conversion

2019-09-03 14:17:06 +03:00
parent eb690f451e
commit 047bb07727
62 changed files with 218 additions and 201 deletions
@@ -7,11 +7,15 @@ package org.jetbrains.kotlin.nj2k
 import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
-interface BatchBaseConversion {
+interface Conversion {
    val context: NewJ2kConverterContext
    val symbolProvider
        get() = context.symbolProvider
    fun runConversion(treeRoots: List<JKTreeElement>, context: NewJ2kConverterContext): Boolean
 }
-interface SequentialBaseConversion : BatchBaseConversion {
+interface SequentialBaseConversion : Conversion {
    fun runConversion(treeRoot: JKTreeElement, context: NewJ2kConverterContext): Boolean
    override fun runConversion(treeRoots: List<JKTreeElement>, context: NewJ2kConverterContext): Boolean {
@@ -22,25 +22,25 @@ import org.jetbrains.kotlin.nj2k.tree.JKTreeRoot
 object ConversionsRunner {
    private fun createConversions(context: NewJ2kConverterContext) = listOf(
-        NonCodeElementsConversion(),
+        NonCodeElementsConversion(context),
        JavaModifiersConversion(context),
        JavaAnnotationsConversion(context),
        AnnotationClassConversion(context),
        AnnotationConversion(context),
        ModalityConversion(context),
-        FunctionAsAnonymousObjectToLambdaConversion(),
+        FunctionAsAnonymousObjectToLambdaConversion(context),
-        ReturnStatementInLambdaExpressionConversion(),
+        ReturnStatementInLambdaExpressionConversion(context),
        BoxedTypeOperationsConversion(context),
        AssignmentAsExpressionToAlsoConversion(context),
        AssignmentStatementValCreationConversion(context),
-        AssignmentStatementOperatorConversion(),
+        AssignmentStatementOperatorConversion(context),
-        AssignmentStatementSimplifyValConversion(),
+        AssignmentStatementSimplifyValConversion(context),
-        AssignmentStatementSimplifyAlsoConversion(),
+        AssignmentStatementSimplifyAlsoConversion(context),
-        AssignmentStatementSplitAlsoConversion(),
+        AssignmentStatementSplitAlsoConversion(context),
-        PolyadicExpressionConversion(),
+        PolyadicExpressionConversion(context),
        OperatorExpressionConversion(context),
-        AddParenthesisForLineBreaksInBinaryExpression(),
+        AddParenthesisForLineBreaksInBinaryExpression(context),
-        ThrowStatementConversion(),
+        ThrowStatementConversion(context),
        ArrayInitializerConversion(context),
        TryStatementConversion(context),
        EnumFieldAccessConversion(context),
@@ -49,38 +49,38 @@ object ConversionsRunner {
        JetbrainsNullableAnnotationsConverter(context),
        DefaultArgumentsConversion(context),
        ConstructorConversion(context),
-        StaticInitDeclarationConversion(),
+        StaticInitDeclarationConversion(context),
        ImplicitInitializerConversion(context),
        ParameterModificationInMethodCallsConversion(context),
        BlockToRunConversion(context),
        PrimaryConstructorDetectConversion(context),
        InsertDefaultPrimaryConstructorConversion(context),
-        FieldToPropertyConversion(),
+        FieldToPropertyConversion(context),
        JavaStandardMethodsConversion(context),
        JavaMethodToKotlinFunctionConversion(context),
        MainFunctionConversion(context),
        AssertStatementConversion(context),
        SwitchStatementConversion(context),
-        LiteralConversion(),
+        LiteralConversion(context),
        ForConversion(context),
-        LabeledStatementConversion(),
+        LabeledStatementConversion(context),
        ArrayOperationsConversion(context),
        EqualsOperatorConversion(context),
        TypeMappingConversion(context),
        InternalDeclarationConversion(context),
-        InnerClassConversion(),
+        InnerClassConversion(context),
-        StaticsToCompanionExtractConversion(),
+        StaticsToCompanionExtractConversion(context),
-        InterfaceWithFieldConversion(),
+        InterfaceWithFieldConversion(context),
        ClassToObjectPromotionConversion(context),
-        RemoveWrongExtraModifiersForSingleFunctionsConversion(),
+        RemoveWrongExtraModifiersForSingleFunctionsConversion(context),
        MethodReferenceToLambdaConversion(context),
        BuiltinMembersConversion(context),
        ImplicitCastsConversion(context),
-        LiteralConversion(),
+        LiteralConversion(context),
        CollectImportsConversion(context),
-        FilterImportsConversion(),
+        FilterImportsConversion(context),
-        MoveInitBlocksToTheEndConversion(),
+        MoveInitBlocksToTheEndConversion(context),
        AddElementsInfoConversion(context)
    )
@@ -17,8 +17,6 @@ import org.jetbrains.kotlin.nj2k.symbols.JKUniverseMethodSymbol
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKCapturedType
 import org.jetbrains.kotlin.nj2k.tree.impl.psi
 import org.jetbrains.kotlin.nj2k.types.JKParametrizedType
 import org.jetbrains.kotlin.nj2k.types.JKStarProjectionType
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 class AddElementsInfoConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
@@ -55,8 +53,8 @@ class AddElementsInfoConversion(context: NewJ2kConverterContext) : RecursiveAppl
    private fun JKMethod.superMethods(): Collection<FunctionDescriptor>? {
        val psiMethod = psi<PsiMethod>() ?: return null
-        psiMethod.getJavaMethodDescriptor()?.let {
+        psiMethod.getJavaMethodDescriptor()?.let { descriptor ->
-            return it.overriddenDescriptors
+            return descriptor.overriddenDescriptors
        }
        return psiMethod.findSuperMethods().mapNotNull { superMethod ->
            when (superMethod) {
@@ -5,12 +5,14 @@
 package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKBinaryExpressionImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKParenthesizedExpressionImpl
-class AddParenthesisForLineBreaksInBinaryExpression : RecursiveApplicableConversionBase() {
+class AddParenthesisForLineBreaksInBinaryExpression(override val context: NewJ2kConverterContext) :
    RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKBinaryExpression) return recurse(element)
        if (element.parent is JKBinaryExpression) return recurse(element)
@@ -27,5 +29,4 @@ class AddParenthesisForLineBreaksInBinaryExpression : RecursiveApplicableConvers
        }
        return recurse(element)
    }
 }
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.nj2k.toExpression
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
-class AnnotationClassConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class AnnotationClassConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKClass) return recurse(element)
        if (element.classKind != JKClass.ClassKind.ANNOTATION) return recurse(element)
@@ -36,8 +36,8 @@ class AnnotationClassConversion(private val context: NewJ2kConverterContext) : R
    private fun JKJavaAnnotationMethod.asKotlinAnnotationParameter(): JKParameterImpl {
        val type = returnType.type
            .updateNullabilityRecursively(Nullability.NotNull)
-            .replaceJavaClassWithKotlinClassType(context.symbolProvider)
+            .replaceJavaClassWithKotlinClassType(symbolProvider)
-        val initializer = this::defaultValue.detached().toExpression(context.symbolProvider)
+        val initializer = this::defaultValue.detached().toExpression(symbolProvider)
        val isVarArgs = type is JKJavaArrayType && name.value == "value"
        return JKParameterImpl(
            JKTypeElementImpl(
@@ -17,12 +17,12 @@ 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: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class AnnotationConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKAnnotation) return recurse(element)
        fixVarargsInvocation(element)
        for (parameter in element.arguments) {
-            parameter.value = parameter.value.toExpression(context.symbolProvider)
+            parameter.value = parameter.value.toExpression(symbolProvider)
        }
        return recurse(element)
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.nj2k.tree.impl.*
 import org.jetbrains.kotlin.resolve.CollectionLiteralResolver
-class ArrayInitializerConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class ArrayInitializerConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        var newElement = element
        if (element is JKJavaNewArray) {
@@ -29,7 +29,7 @@ class ArrayInitializerConversion(private val context: NewJ2kConverterContext) :
                if (primitiveArrayType == null) JKTypeArgumentListImpl(listOf(element::type.detached()))
                else JKTypeArgumentListImpl()
            newElement = JKJavaMethodCallExpressionImpl(
-                context.symbolProvider.provideMethodSymbol("kotlin.$arrayConstructorName"),
+                symbolProvider.provideMethodSymbol("kotlin.$arrayConstructorName"),
                element.initializer.also { element.initializer = emptyList() }.toArgumentList(),
                typeArguments
            )
@@ -46,13 +46,13 @@ class ArrayInitializerConversion(private val context: NewJ2kConverterContext) :
        if (dimensions.size == 1) {
            return if (type !is JKJavaPrimitiveType) {
                JKJavaMethodCallExpressionImpl(
-                    context.symbolProvider.provideMethodSymbol("kotlin.arrayOfNulls"),
+                    symbolProvider.provideMethodSymbol("kotlin.arrayOfNulls"),
                    JKArgumentListImpl(dimensions[0]),
                    JKTypeArgumentListImpl(listOf(JKTypeElementImpl(type)))
                )
            } else {
                JKJavaNewExpressionImpl(
-                    context.symbolProvider.provideClassSymbol(type.arrayFqName()),
+                    symbolProvider.provideClassSymbol(type.arrayFqName()),
                    JKArgumentListImpl(dimensions[0]),
                    JKTypeArgumentListImpl(emptyList())
                )
@@ -63,7 +63,7 @@ class ArrayInitializerConversion(private val context: NewJ2kConverterContext) :
                JKJavaArrayTypeImpl(currentType)
            }
            return JKJavaNewExpressionImpl(
-                context.symbolProvider.provideClassSymbol("kotlin.Array"),
+                symbolProvider.provideClassSymbol("kotlin.Array"),
                JKArgumentListImpl(
                    dimensions[0],
                    JKLambdaExpressionImpl(
@@ -75,19 +75,19 @@ class ArrayInitializerConversion(private val context: NewJ2kConverterContext) :
            )
        }
        var resultType = JKClassTypeImpl(
-            context.symbolProvider.provideClassSymbol(type.arrayFqName()),
+            symbolProvider.provideClassSymbol(type.arrayFqName()),
            if (type is JKJavaPrimitiveType) emptyList() else listOf(type),
            Nullability.Default
        )
        for (i in 0 until dimensions.size - 2) {
            resultType = JKClassTypeImpl(
-                context.symbolProvider.provideClassSymbol(KotlinBuiltIns.FQ_NAMES.array.toSafe()),
+                symbolProvider.provideClassSymbol(KotlinBuiltIns.FQ_NAMES.array.toSafe()),
                listOf(resultType),
                Nullability.Default
            )
        }
        return JKJavaMethodCallExpressionImpl(
-            context.symbolProvider.provideMethodSymbol("kotlin.arrayOfNulls"),
+            symbolProvider.provideMethodSymbol("kotlin.arrayOfNulls"),
            JKArgumentListImpl(dimensions[0]),
            JKTypeArgumentListImpl(listOf(JKTypeElementImpl(resultType)))
        )
@@ -17,14 +17,14 @@ import org.jetbrains.kotlin.nj2k.tree.impl.JKFieldAccessExpressionImpl
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
-class ArrayOperationsConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class ArrayOperationsConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKQualifiedExpression) return recurse(element)
        val selector = element.selector as? JKFieldAccessExpression ?: return recurse(element)
        if (element.receiver.isArrayOrVarargTypeParameter() && selector.identifier.name == "length") {
            val sizeCall =
                JKFieldAccessExpressionImpl(
-                    context.symbolProvider.provideFieldSymbol("kotlin.Array.size")
+                    symbolProvider.provideFieldSymbol("kotlin.Array.size")
                )
            element.selector = sizeCall
        }
@@ -32,7 +32,7 @@ class ArrayOperationsConversion(private val context: NewJ2kConverterContext) : R
    }
    private fun JKExpression.isArrayOrVarargTypeParameter(): Boolean {
-        if (type(context.symbolProvider) is JKJavaArrayType) return true
+        if (type(symbolProvider) is JKJavaArrayType) return true
        val parameter =
            safeAs<JKFieldAccessExpression>()
                ?.identifier
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.nj2k.tree.impl.JKExpressionStatementImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKLambdaExpressionImpl
-class AssertStatementConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class AssertStatementConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKJavaAssertStatement) return recurse(element)
        val messageExpression =
@@ -29,7 +29,7 @@ class AssertStatementConversion(private val context: NewJ2kConverterContext) : R
                kotlinAssert(
                    element::condition.detached(),
                    messageExpression,
-                    context.symbolProvider
+                    symbolProvider
                )
            )
        )
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
 import org.jetbrains.kotlin.nj2k.tree.impl.*
 import org.jetbrains.kotlin.utils.addToStdlib.cast
-class AssignmentAsExpressionToAlsoConversion(val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class AssignmentAsExpressionToAlsoConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKJavaAssignmentExpression) return recurse(element)
        element.invalidate()
@@ -21,11 +21,11 @@ class AssignmentAsExpressionToAlsoConversion(val context: NewJ2kConverterContext
        val alsoExpression = JKKtAlsoCallExpressionImpl(
            JKBlockStatementImpl(
                JKBlockImpl(listOf(JKKtAssignmentStatementImpl(element.field, JKStubExpressionImpl(), element.operator)))
-            ), context.symbolProvider.provideMethodSymbol("kotlin.also")
+            ), symbolProvider.provideMethodSymbol("kotlin.also")
        ).also {
            it.statement.cast<JKBlockStatement>().block.statements.first().cast<JKKtAssignmentStatement>().expression =
                JKFieldAccessExpressionImpl(
-                    context.symbolProvider.provideUniverseSymbol(
+                    symbolProvider.provideUniverseSymbol(
                        JKParameterImpl(JKTypeElementImpl(JKContextType), JKNameIdentifierImpl("it"))
                    )
                )//TODO introduce symbol
@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.nj2k.conversions
 import com.intellij.psi.JavaTokenType
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.copyTreeAndDetach
 import org.jetbrains.kotlin.nj2k.tree.JKKtAssignmentStatement
 import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
@@ -13,7 +14,7 @@ import org.jetbrains.kotlin.nj2k.tree.impl.JKBinaryExpressionImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKJavaOperatorImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKJavaOperatorToken
-class AssignmentStatementOperatorConversion : RecursiveApplicableConversionBase() {
+class AssignmentStatementOperatorConversion(context : NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKKtAssignmentStatement) return recurse(element)
        val operator = element.operator as? JKJavaOperatorImpl ?: return recurse(element)
@@ -5,11 +5,12 @@
 package org.jetbrains.kotlin.nj2k.conversions
 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.JKStubExpressionImpl
-class AssignmentStatementSimplifyAlsoConversion : RecursiveApplicableConversionBase() {
+class AssignmentStatementSimplifyAlsoConversion(context : NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKExpressionStatement) return recurse(element)
        val qualifiedExpression = element.expression as? JKQualifiedExpression ?: return recurse(element)
@@ -5,10 +5,11 @@
 package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKStubExpressionImpl
-class AssignmentStatementSimplifyValConversion : RecursiveApplicableConversionBase() {
+class AssignmentStatementSimplifyValConversion(context : NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKKtAlsoCallExpression) return recurse(element)
        val codeBlock = (element.statement as? JKBlockStatement)?.block ?: return recurse(element)
@@ -5,11 +5,12 @@
 package org.jetbrains.kotlin.nj2k.conversions
 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.*
-class AssignmentStatementSplitAlsoConversion : RecursiveApplicableConversionBase() {
+class AssignmentStatementSplitAlsoConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        return recurse(
            when (element) {
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
-class AssignmentStatementValCreationConversion(val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class AssignmentStatementValCreationConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKKtAlsoCallExpression) return recurse(element)
        val codeBlock = (element.statement as? JKBlockStatement)?.block ?: return recurse(element)
@@ -29,7 +29,7 @@ class AssignmentStatementValCreationConversion(val context: NewJ2kConverterConte
                                ex1,
                                JKMutabilityModifierElementImpl(Mutability.IMMUTABLE)
                            ).also {
-                                assignableExpr.expression = JKFieldAccessExpressionImpl(context.symbolProvider.provideUniverseSymbol(it))
+                                assignableExpr.expression = JKFieldAccessExpressionImpl(symbolProvider.provideUniverseSymbol(it))
                            }, JKLocalVariableImpl(
                                JKTypeElementImpl(JKJavaVoidType/*TODO*/),
                                JKNameIdentifierImpl("i"),
@@ -37,7 +37,7 @@ class AssignmentStatementValCreationConversion(val context: NewJ2kConverterConte
                                JKMutabilityModifierElementImpl(Mutability.UNKNOWN)
                            ).also {
                                assignableExpr.indexExpression =
-                                    JKFieldAccessExpressionImpl(context.symbolProvider.provideUniverseSymbol(it))
+                                    JKFieldAccessExpressionImpl(symbolProvider.provideUniverseSymbol(it))
                            }
                        )
                    )
@@ -55,7 +55,7 @@ class AssignmentStatementValCreationConversion(val context: NewJ2kConverterConte
                                ex,
                                JKMutabilityModifierElementImpl(Mutability.UNKNOWN)
                            ).also {
-                                assignableExpr.receiver = JKFieldAccessExpressionImpl(context.symbolProvider.provideUniverseSymbol(it))
+                                assignableExpr.receiver = JKFieldAccessExpressionImpl(symbolProvider.provideUniverseSymbol(it))
                            }
                        )
                    )
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
-class BlockToRunConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class BlockToRunConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKBlockStatement) return recurse(element)
@@ -24,7 +24,7 @@ class BlockToRunConversion(private val context: NewJ2kConverterContext) : Recurs
            emptyList()
        )
        val call = JKKtCallExpressionImpl(
-            context.symbolProvider.provideMethodSymbol("kotlin.run"),
+            symbolProvider.provideMethodSymbol("kotlin.run"),
            JKArgumentListImpl(lambda)
        )
        return recurse(JKExpressionStatementImpl(call).withNonCodeElementsFrom(element))
@@ -10,7 +10,7 @@ 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: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class BoxedTypeOperationsConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        return recurse(
            when (element) {
@@ -39,7 +39,7 @@ class BoxedTypeOperationsConversion(private val context: NewJ2kConverterContext)
        val primitiveTypeName = boxedTypeToPrimitiveType[boxedJavaType] ?: return null
        if (operationType !in primitiveTypeNames) return null
        return JKKtCallExpressionImpl(
-            context.symbolProvider.provideMethodSymbol(
+            symbolProvider.provideMethodSymbol(
                "kotlin.${primitiveTypeName.capitalize()}.to${operationType.capitalize()}"
            ),
            JKArgumentListImpl()
@@ -16,7 +16,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: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class BuiltinMembersConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKExpression) return recurse(element)
        return recurse(element.convert() ?: element)
@@ -89,19 +89,19 @@ class BuiltinMembersConversion(private val context: NewJ2kConverterContext) : Re
            when (from) {
                is JKMethodCallExpression ->
                    JKKtCallExpressionImpl(
-                        context.symbolProvider.provideMethodSymbol(fqName),
+                        symbolProvider.provideMethodSymbol(fqName),
                        argumentsProvider(from::arguments.detached()),
                        from::typeArgumentList.detached()
                    ).withNonCodeElementsFrom(from)
                is JKFieldAccessExpression ->
                    JKKtCallExpressionImpl(
-                        context.symbolProvider.provideMethodSymbol(fqName),
+                        symbolProvider.provideMethodSymbol(fqName),
                        JKArgumentListImpl(),
                        JKTypeArgumentListImpl()
                    ).withNonCodeElementsFrom(from)
                is JKJavaNewExpression ->
                    JKKtCallExpressionImpl(
-                        context.symbolProvider.provideMethodSymbol(fqName),
+                        symbolProvider.provideMethodSymbol(fqName),
                        argumentsProvider(from::arguments.detached()),
                        JKTypeArgumentListImpl()
                    ).withNonCodeElementsFrom(from)
@@ -116,11 +116,11 @@ class BuiltinMembersConversion(private val context: NewJ2kConverterContext) : Re
            when (from) {
                is JKMethodCallExpression ->
                    JKFieldAccessExpressionImpl(
-                        context.symbolProvider.provideFieldSymbol(fqName)
+                        symbolProvider.provideFieldSymbol(fqName)
                    ).withNonCodeElementsFrom(from)
                is JKFieldAccessExpression ->
                    JKFieldAccessExpressionImpl(
-                        context.symbolProvider.provideFieldSymbol(fqName)
+                        symbolProvider.provideFieldSymbol(fqName)
                    ).withNonCodeElementsFrom(from)
                else -> error("Bad conversion")
            }
@@ -137,7 +137,7 @@ class BuiltinMembersConversion(private val context: NewJ2kConverterContext) : Re
                        arguments.first()::value.detached().parenthesizeIfBinaryExpression(),
                        JKKtQualifierImpl.DOT,
                        JKKtCallExpressionImpl(
-                            context.symbolProvider.provideMethodSymbol(fqName),
+                            symbolProvider.provideMethodSymbol(fqName),
                            JKArgumentListImpl(arguments.drop(1)),
                            from::typeArgumentList.detached()
                        )
@@ -267,11 +267,11 @@ class BuiltinMembersConversion(private val context: NewJ2kConverterContext) : Re
            Method("java.lang.String.indexOf") convertTo Method("kotlin.text.indexOf"),
            Method("java.lang.String.lastIndexOf") convertTo Method("kotlin.text.lastIndexOf"),
            Method("java.lang.String.getBytes") convertTo Method("kotlin.text.toByteArray")
-                    withByArgumentsFilter { it.singleOrNull()?.type(context.symbolProvider)?.isStringType() == true }
+                    withByArgumentsFilter { it.singleOrNull()?.type(symbolProvider)?.isStringType() == true }
                    withArgumentsProvider { arguments ->
                val argument = arguments.arguments.single()::value.detached()
                val call = JKKtCallExpressionImpl(
-                    context.symbolProvider.provideMethodSymbol("kotlin.text.charset"),
+                    symbolProvider.provideMethodSymbol("kotlin.text.charset"),
                    JKArgumentListImpl(argument)
                )
                JKArgumentListImpl(call)
@@ -280,7 +280,7 @@ class BuiltinMembersConversion(private val context: NewJ2kConverterContext) : Re
            Method("java.lang.String.valueOf")
                    convertTo ExtensionMethod("kotlin.Any.toString")
                    withReplaceType ReplaceType.REPLACE_WITH_QUALIFIER
-                    withByArgumentsFilter { it.isNotEmpty() && it.first().type(context.symbolProvider)?.isArrayType() == false },
+                    withByArgumentsFilter { it.isNotEmpty() && it.first().type(symbolProvider)?.isArrayType() == false },
            Method("java.lang.String.getChars")
                    convertTo Method("kotlin.text.toCharArray")
@@ -296,12 +296,12 @@ class BuiltinMembersConversion(private val context: NewJ2kConverterContext) : Re
            Method("java.lang.String.valueOf")
                    convertTo Method("kotlin.String")
                    withReplaceType ReplaceType.REPLACE_WITH_QUALIFIER
-                    withByArgumentsFilter { it.isNotEmpty() && it.first().type(context.symbolProvider)?.isArrayType() == true },
+                    withByArgumentsFilter { it.isNotEmpty() && it.first().type(symbolProvider)?.isArrayType() == true },
            Method("java.lang.String.copyValueOf")
                    convertTo Method("kotlin.String")
                    withReplaceType ReplaceType.REPLACE_WITH_QUALIFIER
-                    withByArgumentsFilter { it.isNotEmpty() && it.first().type(context.symbolProvider)?.isArrayType() == true },
+                    withByArgumentsFilter { it.isNotEmpty() && it.first().type(symbolProvider)?.isArrayType() == true },
            Method("java.lang.String.replaceAll")
                    convertTo Method("kotlin.text.replace")
@@ -309,7 +309,7 @@ class BuiltinMembersConversion(private val context: NewJ2kConverterContext) : Re
                val detachedArguments = arguments::arguments.detached()
                val first =
                    detachedArguments.first()::value.detached().callOn(
-                        context.symbolProvider.provideMethodSymbol("kotlin.text.toRegex")
+                        symbolProvider.provideMethodSymbol("kotlin.text.toRegex")
                    )
                JKArgumentListImpl(listOf(JKArgumentImpl(first)) + detachedArguments.drop(1))
            },
@@ -319,7 +319,7 @@ class BuiltinMembersConversion(private val context: NewJ2kConverterContext) : Re
                val detachedArguments = arguments::arguments.detached()
                val first =
                    detachedArguments.first()::value.detached().callOn(
-                        context.symbolProvider.provideMethodSymbol("kotlin.text.toRegex")
+                        symbolProvider.provideMethodSymbol("kotlin.text.toRegex")
                    )
                JKArgumentListImpl(listOf(JKArgumentImpl(first)) + detachedArguments.drop(1))
@@ -370,7 +370,7 @@ class BuiltinMembersConversion(private val context: NewJ2kConverterContext) : Re
                            firstArgument,
                            secondArgument,
                            KtTokens.PLUS,
-                            context.symbolProvider
+                            symbolProvider
                        )
                    } withReplaceType ReplaceType.REPLACE_WITH_QUALIFIER,
@@ -392,14 +392,14 @@ class BuiltinMembersConversion(private val context: NewJ2kConverterContext) : Re
                                arguments.arguments = arguments.arguments.dropLast(1)
                            }.let {
                                it.callOn(
-                                    context.symbolProvider.provideMethodSymbol("kotlin.collections.dropLastWhile"),
+                                    symbolProvider.provideMethodSymbol("kotlin.collections.dropLastWhile"),
                                    JKLambdaExpressionImpl(
                                        JKFieldAccessExpressionImpl(
                                            JKUnresolvedField(//TODO replace with `it` parameter
                                                "it",
-                                                context.symbolProvider
+                                                symbolProvider
                                            )
-                                        ).callOn(context.symbolProvider.provideMethodSymbol("kotlin.text.isEmpty"))
+                                        ).callOn(symbolProvider.provideMethodSymbol("kotlin.text.isEmpty"))
                                            .asStatement(),
                                        emptyList()
                                    )
@@ -409,7 +409,7 @@ class BuiltinMembersConversion(private val context: NewJ2kConverterContext) : Re
                    else -> expression.also {
                        val lastArgument = arguments.arguments.last().value.copyTreeAndDetach()
                            .callOn(
-                                context.symbolProvider.provideMethodSymbol("kotlin.ranges.coerceAtLeast"),
+                                symbolProvider.provideMethodSymbol("kotlin.ranges.coerceAtLeast"),
                                JKKtLiteralExpressionImpl("0", JKLiteralExpression.LiteralType.INT)
                            )
                        arguments.arguments = arguments.arguments.dropLast(1) + JKArgumentImpl(lastArgument)
@@ -432,12 +432,12 @@ class BuiltinMembersConversion(private val context: NewJ2kConverterContext) : Re
                                JKFieldAccessExpressionImpl(
                                    JKUnresolvedField(//TODO replace with `it` parameter
                                        "it",
-                                        context.symbolProvider
+                                        symbolProvider
                                    )
                                ),
                                JKKtLiteralExpressionImpl("' '", JKLiteralExpression.LiteralType.CHAR),
                                KtTokens.LTEQ,
-                                context.symbolProvider
+                                symbolProvider
                            )
                        ),
                        emptyList()
@@ -446,9 +446,9 @@ class BuiltinMembersConversion(private val context: NewJ2kConverterContext) : Re
            },
            Method("java.lang.String.format") convertTo CustomExpression { expression ->
                JKClassAccessExpressionImpl(
-                    context.symbolProvider.provideClassSymbol(KotlinBuiltIns.FQ_NAMES.string)
+                    symbolProvider.provideClassSymbol(KotlinBuiltIns.FQ_NAMES.string)
                ).callOn(
-                    context.symbolProvider.provideMethodSymbol("kotlin.text.String.format"),
+                    symbolProvider.provideMethodSymbol("kotlin.text.String.format"),
                    (expression as JKMethodCallExpression).arguments::arguments.detached()
                )
            } withReplaceType ReplaceType.REPLACE_WITH_QUALIFIER,
@@ -501,5 +501,5 @@ class BuiltinMembersConversion(private val context: NewJ2kConverterContext) : Re
    private fun JKExpression.castToTypedArray() =
-        callOn(context.symbolProvider.provideMethodSymbol("kotlin.collections.toTypedArray"))
+        callOn(symbolProvider.provideMethodSymbol("kotlin.collections.toTypedArray"))
 }
@@ -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: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class ClassToObjectPromotionConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element is JKClass && element.classKind == JKClass.ClassKind.CLASS) {
            val companion = element.getCompanion() ?: return recurse(element)
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
-class CollectImportsConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class CollectImportsConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        when (element) {
            is JKClassAccessExpression -> addSymbol(element.identifier)
@@ -10,7 +10,7 @@ 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: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class ConstructorConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKJavaMethod) return recurse(element)
        val outerClass = element.parentOfType<JKClass>() ?: return recurse(element)
@@ -29,7 +29,7 @@ class ConstructorConversion(private val context: NewJ2kConverterContext) : Recur
            element.visibilityElement,
            element.modalityElement
        ).also {
-            context.symbolProvider.transferSymbol(it, element)
+            symbolProvider.transferSymbol(it, element)
        }.withNonCodeElementsFrom(element)
    }
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.nj2k.tree.impl.JKFieldAccessExpressionImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.psi
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
-class DefaultArgumentsConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class DefaultArgumentsConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    private fun JKMethod.canBeGetterOrSetter() =
        name.value.asGetterName() != null
                || name.value.asSetterName() != null
@@ -97,7 +97,7 @@ class DefaultArgumentsConversion(private val context: NewJ2kConverterContext) :
                        val target = on.identifier.target
                        if (target is JKParameter) {
                            val newSymbol =
-                                context.symbolProvider.provideUniverseSymbol(calledMethod.parameters[method.parameters.indexOf(target)])
+                                symbolProvider.provideUniverseSymbol(calledMethod.parameters[method.parameters.indexOf(target)])
                            return JKFieldAccessExpressionImpl(newSymbol)
                        }
                    }
@@ -115,7 +115,7 @@ class DefaultArgumentsConversion(private val context: NewJ2kConverterContext) :
            if (method.hasParametersWithDefaultValues()
                && (method.visibility == Visibility.PUBLIC || method.visibility == Visibility.INTERNAL)
            ) {
-                method.annotationList.annotations += jvmAnnotation("JvmOverloads", context.symbolProvider)
+                method.annotationList.annotations += jvmAnnotation("JvmOverloads", symbolProvider)
            }
        }
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.nj2k.tree.impl.JKQualifiedExpressionImpl
 import org.jetbrains.kotlin.psi.psiUtil.containingClass
-class EnumFieldAccessConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class EnumFieldAccessConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKFieldAccessExpression) return recurse(element)
        if ((element.parent as? JKQualifiedExpression)?.selector == element) return recurse(element)
@@ -34,11 +34,11 @@ class EnumFieldAccessConversion(private val context: NewJ2kConverterContext) : R
    private fun JKFieldSymbol.enumClassSymbol(): JKClassSymbol? =
        when {
            this is JKMultiverseFieldSymbol && target is PsiEnumConstant ->
-                context.symbolProvider.provideDirectSymbol(target.containingClass!!) as JKClassSymbol
+                symbolProvider.provideDirectSymbol(target.containingClass!!) as JKClassSymbol
            this is JKMultiverseKtEnumEntrySymbol ->
-                context.symbolProvider.provideDirectSymbol(target.containingClass()!!) as JKClassSymbol
+                symbolProvider.provideDirectSymbol(target.containingClass()!!) as JKClassSymbol
            this is JKUniverseFieldSymbol && target is JKEnumConstant ->
-                context.symbolProvider.provideUniverseSymbol(target.parentOfType<JKClass>()!!)
+                symbolProvider.provideUniverseSymbol(target.parentOfType<JKClass>()!!)
            else -> null
        }
 }
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.nj2k.symbols.deepestFqName
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKParenthesizedExpressionImpl
-class EqualsOperatorConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class EqualsOperatorConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKQualifiedExpression) return recurse(element)
        if (element.receiver is JKSuperExpression) return recurse(element)
@@ -23,7 +23,7 @@ class EqualsOperatorConversion(private val context: NewJ2kConverterContext) : Re
                    equalsExpression(
                        element::receiver.detached(),
                        argument::value.detached(),
-                        context.symbolProvider
+                        symbolProvider
                    )
                )
            )
@@ -5,10 +5,11 @@
 package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
-class FieldToPropertyConversion : RecursiveApplicableConversionBase() {
+class FieldToPropertyConversion(context : NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKJavaField) return recurse(element)
        element.invalidate()
@@ -6,11 +6,12 @@
 package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.nj2k.ImportStorage
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.JKImportList
 import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
-class FilterImportsConversion : RecursiveApplicableConversionBase() {
+class FilterImportsConversion(context : NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKImportList) return recurse(element)
        element.imports = element.imports.filter { import ->
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.nj2k.tree.impl.*
 import kotlin.math.abs
-class ForConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class ForConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    private val referenceSearcher: ReferenceSearcher
        get() = context.converter.converterServices.oldServices.referenceSearcher
@@ -53,7 +53,7 @@ class ForConversion(private val context: NewJ2kConverterContext) : RecursiveAppl
                JKExpressionStatementImpl(
                    runExpression(
                        convertedFromForLoopSyntheticWhileStatement,
-                        context.symbolProvider
+                        symbolProvider
                    )
                )
            !notNeedParentBlock -> blockStatement(convertedFromForLoopSyntheticWhileStatement)
@@ -63,7 +63,7 @@ class ForConversion(private val context: NewJ2kConverterContext) : RecursiveAppl
    private fun createWhileBody(loopStatement: JKJavaForLoopStatement): JKStatement {
        if (loopStatement.updaters.singleOrNull() is JKEmptyStatement) return loopStatement::body.detached()
-        val continueStatementConverter = object : RecursiveApplicableConversionBase() {
+        val continueStatementConverter = object : RecursiveApplicableConversionBase(context) {
            override fun applyToElement(element: JKTreeElement): JKTreeElement {
                if (element !is JKContinueStatement) return recurse(element)
                val elementPsi = element.psi<PsiContinueStatement>()!!
@@ -90,7 +90,7 @@ class ForConversion(private val context: NewJ2kConverterContext) : RecursiveAppl
            val statements =
                if (hasNameConflict) {
-                    listOf(JKExpressionStatementImpl(runExpression(body, context.symbolProvider))) + loopStatement::updaters.detached()
+                    listOf(JKExpressionStatementImpl(runExpression(body, symbolProvider))) + loopStatement::updaters.detached()
                } else {
                    body.block::statements.detached() + loopStatement::updaters.detached()
                }
@@ -185,7 +185,7 @@ class ForConversion(private val context: NewJ2kConverterContext) : RecursiveAppl
                start,
                convertBound(bound, if (inclusiveComparison) 0 else -1),
                JKKtSingleValueOperatorToken(KtTokens.RANGE),
-                context.symbolProvider
+                symbolProvider
            )
        }
    }
@@ -203,7 +203,7 @@ class ForConversion(private val context: NewJ2kConverterContext) : RecursiveAppl
            bound,
            JKKtLiteralExpressionImpl(abs(correction).toString(), JKLiteralExpression.LiteralType.INT),
            JKKtSingleValueOperatorToken(sign),
-            context.symbolProvider
+            symbolProvider
        )
    }
@@ -238,7 +238,7 @@ class ForConversion(private val context: NewJ2kConverterContext) : RecursiveAppl
                indices,
                JKKtQualifierImpl.DOT,
                JKJavaMethodCallExpressionImpl(
-                    context.symbolProvider.provideMethodSymbol("kotlin.collections.reversed"),
+                    symbolProvider.provideMethodSymbol("kotlin.collections.reversed"),
                    JKArgumentListImpl()
                )
            )
@@ -255,7 +255,7 @@ class ForConversion(private val context: NewJ2kConverterContext) : RecursiveAppl
    private fun indicesByArrayLength(javaSizeCall: JKQualifiedExpression): JKQualifiedExpression? {
        val methodCall = javaSizeCall.selector as? JKFieldAccessExpression ?: return null
-        val receiverType = javaSizeCall.receiver.type(context.symbolProvider)
+        val receiverType = javaSizeCall.receiver.type(symbolProvider)
        if (methodCall.identifier.name == "length" && receiverType is JKJavaArrayType) {
            return toIndicesCall(javaSizeCall)
        }
@@ -265,7 +265,7 @@ class ForConversion(private val context: NewJ2kConverterContext) : RecursiveAppl
    private fun toIndicesCall(javaSizeCall: JKQualifiedExpression): JKQualifiedExpression? {
        if (javaSizeCall.psi == null) return null
        val selector = JKFieldAccessExpressionImpl(
-            context.symbolProvider.provideFieldSymbol("kotlin.collections.indices")
+            symbolProvider.provideFieldSymbol("kotlin.collections.indices")
        )
        return JKQualifiedExpressionImpl(javaSizeCall::receiver.detached(), javaSizeCall.operator, selector)
    }
@@ -5,13 +5,14 @@
 package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.symbols.JKClassSymbol
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKBlockStatementImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKLambdaExpressionImpl
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
-class FunctionAsAnonymousObjectToLambdaConversion : RecursiveApplicableConversionBase() {
+class FunctionAsAnonymousObjectToLambdaConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKJavaNewExpression) return recurse(element)
        if (element.isAnonymousClass()
@@ -16,7 +16,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: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class ImplicitCastsConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        when (element) {
            is JKVariable -> convertVariable(element)
@@ -30,8 +30,8 @@ class ImplicitCastsConversion(private val context: NewJ2kConverterContext) : Rec
    private fun convertBinaryExpression(binaryExpression: JKBinaryExpression): JKExpression {
        fun JKBinaryExpression.convertBinaryOperationWithChar(): JKBinaryExpression {
-            val leftType = left.type(context.symbolProvider)?.asPrimitiveType() ?: return this
+            val leftType = left.type(symbolProvider)?.asPrimitiveType() ?: return this
-            val rightType = right.type(context.symbolProvider)?.asPrimitiveType() ?: return this
+            val rightType = right.type(symbolProvider)?.asPrimitiveType() ?: return this
            val leftOperandCastedCasted by lazy {
                JKBinaryExpressionImpl(
@@ -72,7 +72,7 @@ class ImplicitCastsConversion(private val context: NewJ2kConverterContext) : Rec
    }
    private fun convertAssignmentStatement(statement: JKKtAssignmentStatement) {
-        val expressionType = statement.field.type(context.symbolProvider) ?: return
+        val expressionType = statement.field.type(symbolProvider) ?: return
        statement.expression.castTo(expressionType)?.also {
            statement.expression = it
        }
@@ -99,13 +99,13 @@ class ImplicitCastsConversion(private val context: NewJ2kConverterContext) : Rec
    private fun JKExpression.castStringToRegex(toType: JKType): JKExpression? {
        if (toType.safeAs<JKClassType>()?.classReference?.fqName != "java.util.regex.Pattern") return null
-        val expressionType = type(context.symbolProvider) ?: return null
+        val expressionType = type(symbolProvider) ?: return null
        if (!expressionType.isStringType()) return null
        return JKQualifiedExpressionImpl(
            copyTreeAndDetach().parenthesizeIfBinaryExpression(),
            JKKtQualifierImpl.DOT,
            JKKtCallExpressionImpl(
-                context.symbolProvider.provideMethodSymbol("kotlin.text.toRegex"),
+                symbolProvider.provideMethodSymbol("kotlin.text.toRegex"),
                JKArgumentListImpl(),
                JKTypeArgumentListImpl()
            )
@@ -120,7 +120,7 @@ class ImplicitCastsConversion(private val context: NewJ2kConverterContext) : Rec
            val casted = expression.castToAsPrimitiveTypes(toType, strict) ?: return null
            return JKPrefixExpressionImpl(casted, operator)
        }
-        val expressionTypeAsPrimitive = type(context.symbolProvider)?.asPrimitiveType() ?: return null
+        val expressionTypeAsPrimitive = type(symbolProvider)?.asPrimitiveType() ?: return null
        val toTypeAsPrimitive = toType.asPrimitiveType() ?: return null
        if (toTypeAsPrimitive == expressionTypeAsPrimitive) return null
@@ -147,7 +147,7 @@ class ImplicitCastsConversion(private val context: NewJ2kConverterContext) : Rec
            this.copyTreeAndDetach(),
            JKKtQualifierImpl.DOT,
            JKJavaMethodCallExpressionImpl(
-                context.symbolProvider.provideMethodSymbol("kotlin.$initialTypeName.$conversionFunctionName"),
+                symbolProvider.provideMethodSymbol("kotlin.$initialTypeName.$conversionFunctionName"),
                JKArgumentListImpl()
            )
        )
@@ -155,7 +155,7 @@ class ImplicitCastsConversion(private val context: NewJ2kConverterContext) : Rec
    private fun JKExpression.castTo(toType: JKType, strict: Boolean = false): JKExpression? {
-        val expressionType = type(context.symbolProvider)
+        val expressionType = type(symbolProvider)
        if (expressionType == toType) return null
        castToAsPrimitiveTypes(toType, strict)?.also { return it }
        castStringToRegex(toType)?.also { return it }
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.nj2k.tree.impl.JKJavaLiteralExpressionImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKJavaPrimitiveTypeImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKNullLiteral
-class ImplicitInitializerConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class ImplicitInitializerConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    enum class InitializationState {
        INITIALIZED_IN_ALL_CONSTRUCTORS,
@@ -48,11 +48,11 @@ class ImplicitInitializerConversion(private val context: NewJ2kConverterContext)
    }
    private fun JKJavaField.initializationState(): InitializationState {
-        val fieldSymbol = context.symbolProvider.provideUniverseSymbol(this)
+        val fieldSymbol = symbolProvider.provideUniverseSymbol(this)
        val containingClass = parentOfType<JKClass>() ?: return InitializationState.NON_INITIALIZED
        val symbolToConstructor = containingClass.declarationList
            .filterIsInstance<JKKtConstructor>()
-            .map { context.symbolProvider.provideUniverseSymbol(it) to it }
+            .map { symbolProvider.provideUniverseSymbol(it) to it }
            .toMap()
        fun JKMethodSymbol.parentConstructor(): JKMethodSymbol? =
@@ -61,7 +61,7 @@ class ImplicitInitializerConversion(private val context: NewJ2kConverterContext)
        val constructors = containingClass.declarationList
            .filterIsInstance<JKKtConstructor>()
-            .map { context.symbolProvider.provideUniverseSymbol(it) to false }
+            .map { symbolProvider.provideUniverseSymbol(it) to false }
            .toMap()
            .toMutableMap()
@@ -87,7 +87,7 @@ class ImplicitInitializerConversion(private val context: NewJ2kConverterContext)
        }
        for (constructor in constructorsWithInitializers) {
-            constructors[context.symbolProvider.provideUniverseSymbol(constructor)] = true
+            constructors[symbolProvider.provideUniverseSymbol(constructor)] = true
        }
        val constructorsToInitialize = mutableListOf<JKMethodSymbol>()
@@ -5,13 +5,14 @@
 package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.OtherModifier
 import org.jetbrains.kotlin.nj2k.tree.JKClass
 import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
 import org.jetbrains.kotlin.nj2k.tree.impl.JKOtherModifierElementImpl
 import org.jetbrains.kotlin.nj2k.tree.isLocalClass
-class InnerClassConversion : RecursiveApplicableConversionBase() {
+class InnerClassConversion(context : NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKClass) return recurse(element)
        return recurseArmed(element, element)
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
-class InsertDefaultPrimaryConstructorConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class InsertDefaultPrimaryConstructorConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKClass) return recurse(element)
        if (element.classKind != JKClass.ClassKind.CLASS) return recurse(element)
@@ -35,7 +35,7 @@ class InsertDefaultPrimaryConstructorConversion(private val context: NewJ2kConve
        if (superClassSymbol is JKUniverseClassSymbol) {
            val superClass = recurse(superClassSymbol.target)
-            val superConstructor = context.symbolProvider.provideUniverseSymbol(
+            val superConstructor = symbolProvider.provideUniverseSymbol(
                superClass.declarationList.singleOrNull { it is JKKtConstructor && it.parameters.isEmpty() } as? JKMethod ?: return recurse(
                    element
                )
@@ -5,11 +5,12 @@
 package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.getOrCreateCompanionObject
 import org.jetbrains.kotlin.nj2k.tree.*
-class InterfaceWithFieldConversion : RecursiveApplicableConversionBase() {
+class InterfaceWithFieldConversion(context : NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKClass) return recurse(element)
        if (element.classKind != JKClass.ClassKind.INTERFACE
@@ -11,7 +11,7 @@ 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: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class InternalDeclarationConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKVisibilityOwner || element !is JKModalityOwner) return recurse(element)
        val containingClass = element.parentOfType<JKClass>()
@@ -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: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class JavaAnnotationsConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element is JKAnnotationList) {
            for (annotation in element.annotations) {
@@ -29,14 +29,14 @@ class JavaAnnotationsConversion(private val context: NewJ2kConverterContext) : R
    private fun processAnnotation(annotation: JKAnnotation) {
        if (annotation.classSymbol.fqName == "java.lang.Deprecated") {
-            annotation.classSymbol = context.symbolProvider.provideClassSymbol("kotlin.Deprecated")
+            annotation.classSymbol = symbolProvider.provideClassSymbol("kotlin.Deprecated")
            if (annotation.arguments.isEmpty()) {
                annotation.arguments +=
                    JKAnnotationParameterImpl(JKKtLiteralExpressionImpl("\"\"", JKLiteralExpression.LiteralType.STRING))
            }
        }
        if (annotation.classSymbol.fqName == "java.lang.annotation.Target") {
-            annotation.classSymbol = context.symbolProvider.provideClassSymbol("kotlin.annotation.Target")
+            annotation.classSymbol = symbolProvider.provideClassSymbol("kotlin.annotation.Target")
            val arguments = annotation.arguments.singleOrNull()?.let { parameter ->
                val value = parameter.value
@@ -51,7 +51,7 @@ class JavaAnnotationsConversion(private val context: NewJ2kConverterContext) : R
                        value.fieldAccessFqName()
                            ?.let { targetMappings[it] }
                            ?.map { fqName ->
-                                JKFieldAccessExpressionImpl(context.symbolProvider.provideFieldSymbol(fqName))
+                                JKFieldAccessExpressionImpl(symbolProvider.provideFieldSymbol(fqName))
                            } ?: listOf(value.copyTreeAndDetach())
                    }
                annotation.arguments = newArguments.map { JKAnnotationParameterImpl(it) }
@@ -23,7 +23,7 @@ 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: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class JavaMethodToKotlinFunctionConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKJavaMethod) return recurse(element)
@@ -39,7 +39,7 @@ class JavaMethodToKotlinFunctionConversion(private val context: NewJ2kConverterC
                    it.annotations +=
                        throwAnnotation(
                            element.throwsList.map { it.type.updateNullabilityRecursively(Nullability.NotNull) },
-                            context.symbolProvider
+                            symbolProvider
                        )
                }
            },
@@ -48,7 +48,7 @@ class JavaMethodToKotlinFunctionConversion(private val context: NewJ2kConverterC
            element.modalityElement
        ).also {
            it.psi = element.psi
-            context.symbolProvider.transferSymbol(it, element)
+            symbolProvider.transferSymbol(it, element)
            it.leftParen.takeNonCodeElementsFrom(element.leftParen)
            it.rightParen.takeNonCodeElementsFrom(element.rightParen)
        }.withNonCodeElementsFrom(element)
@@ -10,38 +10,37 @@ import org.jetbrains.kotlin.nj2k.annotationByFqName
 import org.jetbrains.kotlin.nj2k.jvmAnnotation
 import org.jetbrains.kotlin.nj2k.tree.*
-class JavaModifiersConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class JavaModifiersConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element is JKModalityOwner && element is JKAnnotationListOwner) {
            val overrideAnnotation = element.annotationList.annotationByFqName("java.lang.Override")
            if (overrideAnnotation != null) {
                element.annotationList.annotations -= overrideAnnotation
                //TODO change modality to OVERRIDE???
            }
        }
        if (element is JKOtherModifiersOwner && element is JKAnnotationListOwner) {
            element.elementByModifier(OtherModifier.VOLATILE)?.also { modifierElement ->
                element.otherModifierElements -= modifierElement
                element.annotationList.annotations +=
-                    jvmAnnotation("Volatile", context.symbolProvider).withNonCodeElementsFrom(modifierElement)
+                    jvmAnnotation("Volatile", symbolProvider).withNonCodeElementsFrom(modifierElement)
            }
            element.elementByModifier(OtherModifier.TRANSIENT)?.also { modifierElement ->
                element.otherModifierElements -= modifierElement
                element.annotationList.annotations +=
-                    jvmAnnotation("Transient", context.symbolProvider).withNonCodeElementsFrom(modifierElement)
+                    jvmAnnotation("Transient", symbolProvider).withNonCodeElementsFrom(modifierElement)
            }
            element.elementByModifier(OtherModifier.STRICTFP)?.also { modifierElement ->
                element.otherModifierElements -= modifierElement
                element.annotationList.annotations +=
-                    jvmAnnotation("Strictfp", context.symbolProvider).withNonCodeElementsFrom(modifierElement)
+                    jvmAnnotation("Strictfp", symbolProvider).withNonCodeElementsFrom(modifierElement)
            }
            element.elementByModifier(OtherModifier.SYNCHRONIZED)?.also { modifierElement ->
                element.otherModifierElements -= modifierElement
                element.annotationList.annotations +=
-                    jvmAnnotation("Synchronized", context.symbolProvider).withNonCodeElementsFrom(modifierElement)
+                    jvmAnnotation("Synchronized", symbolProvider).withNonCodeElementsFrom(modifierElement)
            }
            element.elementByModifier(OtherModifier.NATIVE)?.also { modifierElement ->
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.nj2k.symbols.JKUnresolvedClassSymbol
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
-class JavaStandardMethodsConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class JavaStandardMethodsConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKClass) return recurse(element)
        for (declaration in element.classBody.declarations) {
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKTypeElementImpl
-class JetbrainsNullableAnnotationsConverter(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class JetbrainsNullableAnnotationsConverter(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKAnnotationListOwner) return recurse(element)
@@ -5,6 +5,7 @@
 package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.asStatement
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKBlockStatementWithoutBracketsImpl
@@ -13,7 +14,7 @@ import org.jetbrains.kotlin.nj2k.tree.impl.JKLabeledStatementImpl
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
-class LabeledStatementConversion : RecursiveApplicableConversionBase() {
+class LabeledStatementConversion(context : NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKExpressionStatement) return recurse(element)
        val labeledStatement = element.expression  as? JKLabeledStatement ?: return recurse(element)
@@ -5,11 +5,12 @@
 package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKKtLiteralExpressionImpl
 import java.math.BigInteger
-class LiteralConversion : RecursiveApplicableConversionBase() {
+class LiteralConversion(context : NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKJavaLiteralExpression) return recurse(element)
        return element.convertLiteral()
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.nj2k.tree.impl.JKTypeElementImpl
 //TODO temporary
-class MainFunctionConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class MainFunctionConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKMethod) return recurse(element)
        if (element.isMainFunctionDeclaration()) {
@@ -30,7 +30,7 @@ class MainFunctionConversion(private val context: NewJ2kConverterContext) : Recu
            }
            element.annotationList.annotations +=
                JKAnnotationImpl(
-                    context.symbolProvider.provideClassSymbol("kotlin.jvm.JvmStatic"),
+                    symbolProvider.provideClassSymbol("kotlin.jvm.JvmStatic"),
                    emptyList()
                )
        }
@@ -5,11 +5,11 @@
 package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.SequentialBaseConversion
 import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
-abstract class MatchBasedConversion : SequentialBaseConversion {
+abstract class MatchBasedConversion(override val context: NewJ2kConverterContext) : SequentialBaseConversion {
    fun <R : JKTreeElement, T> applyRecursive(element: R, data: T, func: (JKTreeElement, T) -> JKTreeElement): R =
        org.jetbrains.kotlin.nj2k.tree.applyRecursive(element, data, ::onElementChanged, func)
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
-class MethodReferenceToLambdaConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class MethodReferenceToLambdaConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKMethodReferenceExpression) return recurse(element)
        val symbol = element.identifier
@@ -59,7 +59,7 @@ class MethodReferenceToLambdaConversion(private val context: NewJ2kConverterCont
            } else emptyList()
        val arguments = parameters.map { parameter ->
-            val parameterSymbol = context.symbolProvider.provideUniverseSymbol(parameter)
+            val parameterSymbol = symbolProvider.provideUniverseSymbol(parameter)
            JKArgumentImpl(JKFieldAccessExpressionImpl(parameterSymbol))
        }
        val callExpression =
@@ -75,7 +75,7 @@ class MethodReferenceToLambdaConversion(private val context: NewJ2kConverterCont
            }
        val qualifier = when {
            receiverParameter != null ->
-                JKFieldAccessExpressionImpl(context.symbolProvider.provideUniverseSymbol(receiverParameter))
+                JKFieldAccessExpressionImpl(symbolProvider.provideUniverseSymbol(receiverParameter))
            element.isConstructorCall -> element.qualifier.safeAs<JKQualifiedExpression>()?.let { it::receiver.detached() }
            else -> element::qualifier.detached().nullIfStubExpression()
        }
@@ -111,12 +111,12 @@ class MethodReferenceToLambdaConversion(private val context: NewJ2kConverterCont
                .firstOrNull { !it.hasModifier(JvmModifier.STATIC) }
                ?.parameterList
                ?.parameters
-                ?.map { it.type.toJK(context.symbolProvider).substituteTypeParameters(this) }
+                ?.map { it.type.toJK(symbolProvider).substituteTypeParameters(this) }
            is JKMultiverseKtClassSymbol -> reference.target.body
                ?.functions
                ?.singleOrNull()
                ?.valueParameters
-                ?.map { it.typeReference?.toJK(context.symbolProvider)?.substituteTypeParameters(this) ?: return null }
+                ?.map { it.typeReference?.toJK(symbolProvider)?.substituteTypeParameters(this) ?: return null }
            is JKUniverseClassSymbol -> reference.target.classBody.declarations.firstIsInstanceOrNull<JKMethod>()
                ?.parameters
                ?.map { it.type.type.substituteTypeParameters(this) }
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKOtherModifierElementImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.psi
-class ModalityConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class ModalityConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        when (element) {
            is JKClass -> processClass(element)
@@ -5,11 +5,12 @@
 package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.JKClassBody
 import org.jetbrains.kotlin.nj2k.tree.JKKtInitDeclaration
 import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
-class MoveInitBlocksToTheEndConversion : RecursiveApplicableConversionBase() {
+class MoveInitBlocksToTheEndConversion(context : NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKClassBody) return recurse(element)
        element.declarations = element.declarations.sortedBy {
@@ -5,10 +5,11 @@
 package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.JKClass
 import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
-class NonCodeElementsConversion : RecursiveApplicableConversionBase() {
+class NonCodeElementsConversion(context : NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        when (element) {
            is JKClass -> {
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
-class OperatorExpressionConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class OperatorExpressionConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKOperatorExpression) return recurse(element)
        val operator = element.operator as? JKJavaOperatorImpl ?: return recurse(element)
@@ -34,7 +34,7 @@ class OperatorExpressionConversion(private val context: NewJ2kConverterContext)
            is JKPostfixExpression -> {
                val operatorToken = operator.token.toKtToken()
                val operand = applyToElement(element::expression.detached()) as JKExpression
-                recurse(kotlinPostfixExpression(operand, operatorToken, context.symbolProvider))
+                recurse(kotlinPostfixExpression(operand, operatorToken, symbolProvider))
            }
            else -> TODO(element.javaClass.toString())
        }.withNonCodeElementsFrom(element)
@@ -43,13 +43,13 @@ class OperatorExpressionConversion(private val context: NewJ2kConverterContext)
    private fun convertPrefixExpression(operand: JKExpression, javaOperator: JKJavaOperatorImpl) =
        convertTildeExpression(operand, javaOperator)
-            ?: kotlinPrefixExpression(operand, javaOperator.token.toKtToken(), context.symbolProvider)
+            ?: kotlinPrefixExpression(operand, javaOperator.token.toKtToken(), symbolProvider)
    private fun convertTildeExpression(operand: JKExpression, javaOperator: JKJavaOperatorImpl): JKExpression? =
        if (javaOperator.token.psiToken == JavaTokenType.TILDE) {
            val invCall =
                JKKtCallExpressionImpl(
-                    context.symbolProvider.provideMethodSymbol("kotlin.Int.inv"),//TODO check if Long
+                    symbolProvider.provideMethodSymbol("kotlin.Int.inv"),//TODO check if Long
                    JKArgumentListImpl()
                )
            JKQualifiedExpressionImpl(
@@ -61,21 +61,21 @@ class OperatorExpressionConversion(private val context: NewJ2kConverterContext)
    private fun convertBinaryExpression(left: JKExpression, right: JKExpression, token: JKKtOperatorToken): JKBinaryExpression =
        convertStringImplicitConcatenation(left, right, token)
-            ?: kotlinBinaryExpression(left, right, token, context.symbolProvider)
+            ?: kotlinBinaryExpression(left, right, token, symbolProvider)
    private fun convertStringImplicitConcatenation(left: JKExpression, right: JKExpression, token: JKKtOperatorToken): JKBinaryExpression? =
        if (token is JKKtSingleValueOperatorToken
            && token.psiToken == KtTokens.PLUS
-            && right.type(context.symbolProvider)?.isStringType() == true
+            && right.type(symbolProvider)?.isStringType() == true
-            && left.type(context.symbolProvider)?.isStringType() == false
+            && left.type(symbolProvider)?.isStringType() == false
        ) {
            val toStringCall =
                JKKtCallExpressionImpl(
-                    context.symbolProvider.provideMethodSymbol("kotlin.Any.toString"),
+                    symbolProvider.provideMethodSymbol("kotlin.Any.toString"),
                    JKArgumentListImpl()
                )
            val qualifiedCall = JKQualifiedExpressionImpl(left, JKKtQualifierImpl.DOT, toStringCall)
-            kotlinBinaryExpression(qualifiedCall, right, KtTokens.PLUS, context.symbolProvider)
+            kotlinBinaryExpression(qualifiedCall, right, KtTokens.PLUS, symbolProvider)
        } else null
 }
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
-class ParameterModificationInMethodCallsConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class ParameterModificationInMethodCallsConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKMethod) return recurse(element)
        val newVariables =
@@ -21,7 +21,7 @@ class ParameterModificationInMethodCallsConversion(private val context: NewJ2kCo
                    val parameterType =
                        if (parameter.isVarArgs) {
                            JKClassTypeImpl(
-                                context.symbolProvider.provideClassSymbol(parameter.type.type.arrayFqName()),
+                                symbolProvider.provideClassSymbol(parameter.type.type.arrayFqName()),
                                if (parameter.type.type is JKJavaPrimitiveType) emptyList()
                                else listOf(
                                    JKVarianceTypeParameterTypeImpl(
@@ -36,7 +36,7 @@ class ParameterModificationInMethodCallsConversion(private val context: NewJ2kCo
                    JKLocalVariableImpl(
                        JKTypeElementImpl(parameterType),
                        JKNameIdentifierImpl(parameter.name.value),
-                        JKFieldAccessExpressionImpl(context.symbolProvider.provideUniverseSymbol(parameter)),
+                        JKFieldAccessExpressionImpl(symbolProvider.provideUniverseSymbol(parameter)),
                        JKMutabilityModifierElementImpl(Mutability.MUTABLE)
                    )
                } else null
@@ -5,13 +5,14 @@
 package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.parenthesizeIfBinaryExpression
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKBinaryExpressionImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKParenthesizedExpressionImpl
-class PolyadicExpressionConversion : RecursiveApplicableConversionBase() {
+class PolyadicExpressionConversion(context : NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKJavaPolyadicExpression) return recurse(element)
        val needParenthesis = element.operands.any { it.containsNewLine() }
@@ -11,7 +11,7 @@ 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: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class PrimaryConstructorDetectConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element is JKClass &&
            (element.classKind == JKClass.ClassKind.CLASS || element.classKind == JKClass.ClassKind.ENUM)
@@ -54,7 +54,7 @@ class PrimaryConstructorDetectConversion(private val context: NewJ2kConverterCon
                primaryConstructorCandidate.modalityElement
            ).withNonCodeElementsFrom(primaryConstructorCandidate)
-        context.symbolProvider.transferSymbol(primaryConstructor, primaryConstructorCandidate)
+        symbolProvider.transferSymbol(primaryConstructor, primaryConstructorCandidate)
        element.classBody.declarations += primaryConstructor
    }
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
-abstract class RecursiveApplicableConversionBase : MatchBasedConversion() {
+abstract class RecursiveApplicableConversionBase(context: NewJ2kConverterContext) : MatchBasedConversion(context) {
    override fun onElementChanged(new: JKTreeElement, old: JKTreeElement) {
        somethingChanged = true
    }
@@ -5,9 +5,10 @@
 package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
-class RemoveWrongExtraModifiersForSingleFunctionsConversion : RecursiveApplicableConversionBase() {
+class RemoveWrongExtraModifiersForSingleFunctionsConversion(context : NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKOtherModifiersOwner) return recurse(element)
        if (element.parentOfType<JKClass>() == null) {
@@ -5,6 +5,7 @@
 package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.asStatement
 import org.jetbrains.kotlin.nj2k.copyTreeAndDetach
 import org.jetbrains.kotlin.nj2k.tree.*
@@ -13,7 +14,7 @@ import org.jetbrains.kotlin.nj2k.tree.impl.JKLabeledStatementImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKNameIdentifierImpl
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
-class ReturnStatementInLambdaExpressionConversion : RecursiveApplicableConversionBase() {
+class ReturnStatementInLambdaExpressionConversion(context : NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    companion object {
        const val DEFAULT_LABEL_NAME = "label"
    }
@@ -5,13 +5,14 @@
 package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.createCompanion
 import org.jetbrains.kotlin.nj2k.getCompanion
 import org.jetbrains.kotlin.nj2k.replace
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.JKKtInitDeclarationImpl
-class StaticInitDeclarationConversion : RecursiveApplicableConversionBase() {
+class StaticInitDeclarationConversion(context : NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKClass) return recurse(element)
        val staticInitDeclarations =
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
-class StaticMemberAccessConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class StaticMemberAccessConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        val symbol =
            when (element) {
@@ -71,17 +71,17 @@ class StaticMemberAccessConversion(private val context: NewJ2kConverterContext)
                target.getStrictParentOfType<KtClassOrObject>()?.let { klass ->
                    if (klass is KtObjectDeclaration && klass.isCompanion()) klass.containingClass()
                    else klass
-                }?.let { context.symbolProvider.provideDirectSymbol(it) }
+                }?.let { symbolProvider.provideDirectSymbol(it) }
            is PsiElement -> target.getContainingClass()?.let {
-                context.symbolProvider.provideDirectSymbol(it)
+                symbolProvider.provideDirectSymbol(it)
            }
            is JKTreeElement ->
                target.parentOfType<JKClass>()?.let { klass ->
                    if (klass.classKind == JKClass.ClassKind.COMPANION) klass.parentOfType<JKClass>()
                    else klass
-                }?.let { context.symbolProvider.provideUniverseSymbol(it) }
+                }?.let { symbolProvider.provideUniverseSymbol(it) }
            else -> error("bad isStaticMember")
        } as JKClassSymbol?
    }
@@ -5,10 +5,11 @@
 package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.getOrCreateCompanionObject
 import org.jetbrains.kotlin.nj2k.tree.*
-class StaticsToCompanionExtractConversion : RecursiveApplicableConversionBase() {
+class StaticsToCompanionExtractConversion(context : NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKClass) return recurse(element)
        if (element.classKind == JKClass.ClassKind.COMPANION || element.classKind == JKClass.ClassKind.OBJECT) return element
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
-class SwitchStatementConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class SwitchStatementConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKJavaSwitchStatementImpl) return recurse(element)
        element.invalidate()
@@ -86,7 +86,7 @@ class SwitchStatementConversion(private val context: NewJ2kConverterContext) : R
                    when (statement) {
                        is JKBlockStatement ->
                            JKExpressionStatementImpl(
-                                runExpression(statement, context.symbolProvider)
+                                runExpression(statement, symbolProvider)
                            )
                        else -> statement
                    }
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.nj2k.tree.impl.*
 import org.jetbrains.kotlin.nj2k.tree.withNonCodeElementsFrom
-class SynchronizedStatementConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class SynchronizedStatementConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKJavaSynchronizedStatement) return recurse(element)
        element.invalidate()
@@ -22,7 +22,7 @@ class SynchronizedStatementConversion(private val context: NewJ2kConverterContex
        )
        val synchronizedCall =
            JKKtCallExpressionImpl(
-                context.symbolProvider.provideMethodSymbol("kotlin.synchronized"),
+                symbolProvider.provideMethodSymbol("kotlin.synchronized"),
                JKArgumentListImpl(
                    element.lockExpression,
                    lambdaBody
@@ -5,6 +5,7 @@
 package org.jetbrains.kotlin.nj2k.conversions
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.JKJavaThrowStatement
 import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
 import org.jetbrains.kotlin.nj2k.tree.detached
@@ -12,7 +13,7 @@ import org.jetbrains.kotlin.nj2k.tree.impl.JKExpressionStatementImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKKtThrowExpressionImpl
-class ThrowStatementConversion : RecursiveApplicableConversionBase() {
+class ThrowStatementConversion(context : NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKJavaThrowStatement) return recurse(element)
        val throwExpression = JKKtThrowExpressionImpl(element::exception.detached())
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.nj2k.tree.impl.*
 import org.jetbrains.kotlin.nj2k.useExpression
-class TryStatementConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class TryStatementConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        if (element !is JKJavaTryStatement) return recurse(element)
        return if (element.resourceDeclarations.isEmpty())
@@ -59,7 +59,7 @@ class TryStatementConversion(private val context: NewJ2kConverterContext) : Recu
                        receiver = (variable as JKLocalVariable)::initializer.detached(),
                        variableIdentifier = variable::name.detached(),
                        body = inner,
-                        symbolProvider = context.symbolProvider
+                        symbolProvider = symbolProvider
                    )
                )
            }
@@ -5,14 +5,10 @@
 package org.jetbrains.kotlin.nj2k.conversions
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.PsiVariable
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.j2k.*
 import org.jetbrains.kotlin.j2k.ast.Mutability
 import org.jetbrains.kotlin.j2k.ast.Nullability
 import org.jetbrains.kotlin.j2k.toKotlinMutableTypesMap
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.kotlinTypeByName
@@ -21,7 +17,7 @@ import org.jetbrains.kotlin.nj2k.symbols.JKUniverseClassSymbol
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
-class TypeMappingConversion(val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
+class TypeMappingConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
        when (element) {
            is JKTypeElement -> {
@@ -56,7 +52,7 @@ class TypeMappingConversion(val context: NewJ2kConverterContext) : RecursiveAppl
                JKTypeElementImpl(
                    kotlinTypeByName(
                        KotlinBuiltIns.FQ_NAMES.any.toSafe().asString(),
-                        context.symbolProvider,
+                        symbolProvider,
                        Nullability.Nullable
                    )
                )
@@ -86,12 +82,12 @@ class TypeMappingConversion(val context: NewJ2kConverterContext) : RecursiveAppl
            is JKJavaVoidType ->
                kotlinTypeByName(
                    KotlinBuiltIns.FQ_NAMES.unit.toSafe().asString(),
-                    context.symbolProvider,
+                    symbolProvider,
                    Nullability.NotNull
                )
            is JKJavaArrayType ->
                JKClassTypeImpl(
-                    context.symbolProvider.provideClassSymbol(type.arrayFqName()),
+                    symbolProvider.provideClassSymbol(type.arrayFqName()),
                    if (type is JKJavaPrimitiveType) emptyList() else listOf(type.mapType(typeElement)),
                    nullability
                )
@@ -115,7 +111,7 @@ class TypeMappingConversion(val context: NewJ2kConverterContext) : RecursiveAppl
        val newFqName = kotlinCollectionClassName()
            ?: kotlinStandardType()
            ?: fqName
-        return context.symbolProvider.provideClassSymbol(newFqName)
+        return symbolProvider.provideClassSymbol(newFqName)
    }
    private fun JKClassType.mapClassType(typeElement: JKTypeElement?): JKClassType =
@@ -136,7 +132,7 @@ class TypeMappingConversion(val context: NewJ2kConverterContext) : RecursiveAppl
    private fun JKJavaPrimitiveType.mapPrimitiveType(): JKClassType {
        val fqName = jvmPrimitiveType.primitiveType.typeFqName
        return JKClassTypeImpl(
-            context.symbolProvider.provideClassSymbol(fqName),
+            symbolProvider.provideClassSymbol(fqName),
            nullability = Nullability.NotNull
        )
    }