New J2K: Split ModifiersList to visibilityModifier, modalityModifier, mutabilityModifier and extraModifiers & introduce JKVariable which may have any subset of modifiers

j2k/newSrc/org/jetbrains/kotlin/j2k/ConversionsRunner.kt

@@ -23,15 +23,17 @@ object ConversionsRunner {
 
     private fun createRootConversion(context: ConversionContext) =
         batchPipe {
+            +JavaModifiersConversion()
+            +InternalClassConversion(context)
+            +ModalityConversion(context)
             +OperatorExpressionConversion(context)
             +ThrowStatementConversion()
             +ArrayInitializerConversion(context)
             +TryStatementConversion(context)
-            +ModalityConversion(context)
             +ImplicitInitializerConversion()
             +DefaultArgumentsConversion(context)
             +TypeMappingConversion(context)
-            +FieldToPropertyConversion()
+            +FieldToPropertyConversion(context)
             +PrintlnConversion(context)
             +BlockToRunConversion(context)
             +AssignmentAsExpressionToAlsoConversion(context)
@@ -43,12 +45,11 @@ object ConversionsRunner {
             +PrimaryConstructorDetectConversion(context)
             +InsertDefaultPrimaryConstructorConversion(context)
             +FieldInitializersInPrimaryFromParamsConversion(context)
-            +JavaMethodToKotlinFunctionConversion()
+            +JavaMethodToKotlinFunctionConversion(context)
-            +MainFunctionConversion()
+            +MainFunctionConversion(context)
             +LiteralConversion()
             +AssertStatementConversion(context)
             +InnerClassConversion()
-            +ModifiersConversion(context)
             +StaticsToCompanionExtractConversion()
             +ClassToObjectPromotionConversion(context)
             +PolyadicExpressionConversion()

j2k/newSrc/org/jetbrains/kotlin/j2k/JKSymbolProvider.kt

@@ -7,10 +7,7 @@ package org.jetbrains.kotlin.j2k
 
 import com.intellij.psi.*
 import org.jetbrains.kotlin.j2k.conversions.resolveFqName
-import org.jetbrains.kotlin.j2k.tree.JKClass
+import org.jetbrains.kotlin.j2k.tree.*
-import org.jetbrains.kotlin.j2k.tree.JKDeclaration
-import org.jetbrains.kotlin.j2k.tree.JKField
-import org.jetbrains.kotlin.j2k.tree.JKMethod
 import org.jetbrains.kotlin.j2k.tree.impl.*
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.psi.KtClassOrObject
@@ -53,7 +50,7 @@ class JKSymbolProvider {
     fun provideUniverseSymbol(psi: PsiElement, jk: JKDeclaration): JKSymbol = provideUniverseSymbol(psi).also {
         when (it) {
             is JKUniverseClassSymbol -> it.target = jk as JKClass
-            is JKUniverseFieldSymbol -> it.target = jk as JKField
+            is JKUniverseFieldSymbol -> it.target = jk as JKVariable
             is JKUniverseMethodSymbol -> it.target = jk as JKMethod
         }
         symbolsByJK[jk] = it
@@ -78,7 +75,7 @@ class JKSymbolProvider {
         JKUniverseClassSymbol().also { it.target = jk }
     } as JKClassSymbol
 
-    fun provideUniverseSymbol(jk: JKField): JKFieldSymbol = symbolsByJK.getOrPut(jk) {
+    fun provideUniverseSymbol(jk: JKVariable): JKFieldSymbol = symbolsByJK.getOrPut(jk) {
         JKUniverseFieldSymbol().also { it.target = jk }
     } as JKFieldSymbol
 

j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt

@@ -21,11 +21,7 @@ import com.intellij.psi.*
 import com.intellij.psi.JavaTokenType.SUPER_KEYWORD
 import com.intellij.psi.JavaTokenType.THIS_KEYWORD
 import com.intellij.psi.impl.source.tree.ChildRole
-import com.intellij.psi.impl.source.tree.java.PsiLabeledStatementImpl
+import com.intellij.psi.impl.source.tree.java.*
-import com.intellij.psi.impl.source.tree.java.PsiLiteralExpressionImpl
-import com.intellij.psi.impl.source.tree.java.PsiNewExpressionImpl
-import com.intellij.psi.impl.source.tree.java.PsiReferenceExpressionImpl
-import org.jetbrains.kotlin.j2k.ast.Mutability
 import org.jetbrains.kotlin.j2k.ast.Nullability
 import org.jetbrains.kotlin.j2k.tree.*
 import org.jetbrains.kotlin.j2k.tree.JKLiteralExpression.LiteralType.*
@@ -39,8 +35,6 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) {
 
     private val declarationMapper = DeclarationMapper(expressionTreeMapper)
 
-    private val modifierMapper = ModifierMapper()
-
     private inner class ExpressionTreeMapper {
         fun PsiExpression?.toJK(): JKExpression {
             return when (this) {
@@ -264,12 +258,14 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) {
             val implTypes = this.implementsList?.mapTypes().orEmpty()
             val extTypes = this.extendsList?.mapTypes().orEmpty()
             return JKClassImpl(
-                with(modifierMapper) { modifierList.toJK() },
                 JKNameIdentifierImpl(name!!),
                 JKInheritanceInfoImpl(extTypes + implTypes),
                 classKind,
                 typeParameterList?.toJK() ?: JKTypeParameterListImpl(),
-                createClassBody()
+                createClassBody(),
+                modifiers(),
+                visibility(),
+                modality()
             ).also { jkClassImpl ->
                 jkClassImpl.psi = this
                 symbolProvider.provideUniverseSymbol(this, jkClassImpl)
@@ -292,12 +288,58 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) {
                 with(modifierMapper) { modifierList.toJK() }
             )
 
+        fun PsiMember.modality() =
+            when {
+                modifierList == null -> Modality.OPEN
+                hasModifierProperty(PsiModifier.FINAL) -> Modality.FINAL
+                hasModifierProperty(PsiModifier.ABSTRACT) -> Modality.ABSTRACT
+                else -> Modality.OPEN
+            }
+
+        fun PsiMember.visibility() =
+            when {
+                modifierList == null -> Visibility.PACKAGE_PRIVATE
+                hasModifierProperty(PsiModifier.PACKAGE_LOCAL) -> Visibility.PACKAGE_PRIVATE
+                hasModifierProperty(PsiModifier.PRIVATE) -> Visibility.PRIVATE
+                hasModifierProperty(PsiModifier.PROTECTED) -> Visibility.PROTECTED
+                hasModifierProperty(PsiModifier.PUBLIC) -> Visibility.PUBLIC
+                else -> Visibility.PACKAGE_PRIVATE
+            }
+
+        fun PsiMember.modifiers() =
+            if (modifierList == null) emptyList()
+            else
+                PsiModifier.MODIFIERS
+                    .filter { this.modifierList!!.hasExplicitModifier(it) }
+                    .mapNotNull {
+                        when (it) {
+                            PsiModifier.NATIVE -> ExtraModifier.NATIVE
+                            PsiModifier.STATIC -> ExtraModifier.STATIC
+                            PsiModifier.STRICTFP -> ExtraModifier.STRICTFP
+                            PsiModifier.SYNCHRONIZED -> ExtraModifier.SYNCHRONIZED
+                            PsiModifier.TRANSIENT -> ExtraModifier.TRANSIENT
+                            PsiModifier.VOLATILE -> ExtraModifier.VOLATILE
+
+                            PsiModifier.PROTECTED -> null
+                            PsiModifier.PUBLIC -> null
+                            PsiModifier.PRIVATE -> null
+                            PsiModifier.FINAL -> null
+                            PsiModifier.ABSTRACT -> null
+
+                            else -> TODO("Not yet supported")
+                        }
+                    }
+
+
         fun PsiField.toJK(): JKJavaField {
             return JKJavaFieldImpl(
-                with(modifierMapper) { modifierList.toJK(finalAsMutability = true) },
                 with(expressionTreeMapper) { typeElement?.toJK() } ?: JKTypeElementImpl(JKNoTypeImpl),
                 JKNameIdentifierImpl(name),
-                with(expressionTreeMapper) { initializer.toJK() }
+                with(expressionTreeMapper) { initializer.toJK() },
+                modifiers(),
+                visibility(),
+                modality(),
+                Mutability.UNKNOWN
             ).also {
                 symbolProvider.provideUniverseSymbol(this, it)
                 it.psi = this
@@ -306,7 +348,6 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) {
 
         fun PsiMethod.toJK(): JKJavaMethod {
             return JKJavaMethodImpl(
-                with(modifierMapper) { modifierList.toJK() },
                 with(expressionTreeMapper) {
                     returnTypeElement?.toJK()
                             ?: JKTypeElementImpl(JKJavaVoidType).takeIf { isConstructor }
@@ -316,7 +357,11 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) {
                 parameterList.parameters.map { it.toJK() },
                 body?.toJK() ?: JKBodyStub,
                 typeParameterList?.toJK() ?: JKTypeParameterListImpl(),
-                JKAnnotationListImpl()//TODO get real annotations
+                JKAnnotationListImpl(),//TODO get real annotations
+                throwsList.referencedTypes.map { JKTypeElementImpl(it.toJK(symbolProvider)) },
+                modifiers(),
+                visibility(),
+                modality()
             ).also {
                 it.psi = this
                 symbolProvider.provideUniverseSymbol(this, it)
@@ -331,9 +376,10 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) {
         }
 
         fun PsiParameter.toJK(): JKParameter {
-            return JKParameterImpl(with(expressionTreeMapper) { typeElement?.toJK() } ?: TODO(),
+            return JKParameterImpl(
-                                   JKNameIdentifierImpl(name!!),
+                with(expressionTreeMapper) { typeElement?.toJK() } ?: TODO(),
-                                   with(modifierMapper) { modifierList.toJK() }).also {
+                JKNameIdentifierImpl(name!!)
+            ).also {
                 symbolProvider.provideUniverseSymbol(this, it)
                 it.psi = this
             }
@@ -353,10 +399,10 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) {
 
         fun PsiLocalVariable.toJK(): JKLocalVariable =
             JKLocalVariableImpl(
-                with(modifierMapper) { modifierList.toJK() },
                 with(expressionTreeMapper) { typeElement.toJK() },
                 JKNameIdentifierImpl(this.name ?: TODO()),
-                with(expressionTreeMapper) { initializer.toJK() }
+                with(expressionTreeMapper) { initializer.toJK() },
+                Mutability.UNKNOWN
             ).also { i ->
                 symbolProvider.provideUniverseSymbol(this, i)
                 i.psi = this
@@ -456,64 +502,7 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) {
         }.last()
 
 
-    private inner class ModifierMapper {
+       private inner class ElementVisitor : JavaElementVisitor() {
-        fun PsiModifierList?.toJK(finalAsMutability: Boolean = false): JKModifierList {
-
-            val modifiers = if (this == null) mutableListOf()
-            else PsiModifier.MODIFIERS.filter { hasExplicitModifier(it) }.mapNotNull { modifierToJK(it, finalAsMutability) }.toMutableList()
-
-            modifiers += extractAccess()
-            modifiers += extractModality()
-
-            return JKModifierListImpl(
-                modifiers
-            )
-        }
-
-        fun PsiModifierList?.extractModality(): JKModalityModifier {
-            val modality = when {
-                this == null -> JKModalityModifier.Modality.OPEN
-                hasModifierProperty(PsiModifier.FINAL) -> JKModalityModifier.Modality.FINAL
-                hasModifierProperty(PsiModifier.ABSTRACT) -> JKModalityModifier.Modality.ABSTRACT
-                else -> JKModalityModifier.Modality.OPEN
-            }
-            return JKModalityModifierImpl(modality)
-        }
-
-
-        fun PsiModifierList?.extractAccess(): JKAccessModifier {
-            val visibility = when {
-                this == null -> JKAccessModifier.Visibility.PACKAGE_PRIVATE
-                hasModifierProperty(PsiModifier.PACKAGE_LOCAL) -> JKAccessModifier.Visibility.PACKAGE_PRIVATE
-                hasModifierProperty(PsiModifier.PRIVATE) -> JKAccessModifier.Visibility.PRIVATE
-                hasModifierProperty(PsiModifier.PROTECTED) -> JKAccessModifier.Visibility.PROTECTED
-                hasModifierProperty(PsiModifier.PUBLIC) -> JKAccessModifier.Visibility.PUBLIC
-                else -> JKAccessModifier.Visibility.PACKAGE_PRIVATE
-            }
-            return JKAccessModifierImpl(visibility)
-        }
-
-        fun modifierToJK(name: String, finalAsMutability: Boolean): JKModifier? = when (name) {
-            PsiModifier.NATIVE -> JKJavaModifierImpl(JKJavaModifier.JavaModifierType.NATIVE)
-            PsiModifier.STATIC -> JKJavaModifierImpl(JKJavaModifier.JavaModifierType.STATIC)
-            PsiModifier.STRICTFP -> JKJavaModifierImpl(JKJavaModifier.JavaModifierType.STRICTFP)
-            PsiModifier.SYNCHRONIZED -> JKJavaModifierImpl(JKJavaModifier.JavaModifierType.SYNCHRONIZED)
-            PsiModifier.TRANSIENT -> JKJavaModifierImpl(JKJavaModifier.JavaModifierType.TRANSIENT)
-            PsiModifier.VOLATILE -> JKJavaModifierImpl(JKJavaModifier.JavaModifierType.VOLATILE)
-
-            PsiModifier.PROTECTED -> null
-            PsiModifier.PUBLIC -> null
-            PsiModifier.PRIVATE -> null
-
-            PsiModifier.FINAL -> if (finalAsMutability) JKMutabilityModifierImpl(Mutability.NonMutable) else null
-            PsiModifier.ABSTRACT -> null
-
-            else -> TODO("Not yet supported")
-        }
-
-    }
-
-    private inner class ElementVisitor : JavaElementVisitor() {
 
         var resultElement: JKTreeElement? = null
 

j2k/newSrc/org/jetbrains/kotlin/j2k/NewCodeBuilder.kt

@@ -149,62 +149,12 @@ class NewCodeBuilder {
             breakWithLabelStatement.label.accept(this)
         }
 
-        override fun visitModifierList(modifierList: JKModifierList) {
+        private fun renderModifiersList(modifiersList: JKModifiersListOwner) {
-            modifierList.modifiers.firstOrNull()?.accept(this)
+            renderList(modifiersList.modifiers(), " ") {
-            for (i in 1..modifierList.modifiers.lastIndex) {
+                printer.printWithNoIndent(it.text)
-                printer.printWithNoIndent(" ")
-                modifierList.modifiers[i].accept(this)
             }
         }
 
-        override fun visitAccessModifier(accessModifier: JKAccessModifier) {
-            printer.printWithNoIndent(
-                when (accessModifier.visibility) {
-                    JKAccessModifier.Visibility.PUBLIC -> "public"
-                    JKAccessModifier.Visibility.INTERNAL -> "internal"
-                    JKAccessModifier.Visibility.PACKAGE_PRIVATE -> ""
-//                    JKAccessModifier.Visibility.PACKAGE_PRIVATE -> "internal /* package_local! */"
-                    JKAccessModifier.Visibility.PROTECTED -> "protected"
-                    JKAccessModifier.Visibility.PRIVATE -> "private"
-                }
-            )
-        }
-
-        override fun visitModalityModifier(modalityModifier: JKModalityModifier) {
-            val containingDeclaration = modalityModifier.parent?.parent
-            //TODO: merge with bottom one
-            if (modalityModifier.modality == JKModalityModifier.Modality.ABSTRACT && containingDeclaration is JKClass) {
-                if (containingDeclaration.classKind != JKClass.ClassKind.CLASS) return
-            }
-
-            printer.printWithNoIndent(
-                when (modalityModifier.modality) {
-                    JKModalityModifier.Modality.OPEN -> "open"
-                    JKModalityModifier.Modality.FINAL -> "final"
-                    JKModalityModifier.Modality.ABSTRACT -> "abstract"
-                    JKModalityModifier.Modality.OVERRIDE -> "override"
-                }
-            )
-        }
-
-        override fun visitMutabilityModifier(mutabilityModifier: JKMutabilityModifier) {
-            if (mutabilityModifier.mutability == Mutability.NonMutable) printer.print("val")
-            else printer.print("var")
-        }
-
-        override fun visitKtModifier(ktModifier: JKKtModifier) {
-            printer.printWithNoIndent(
-                when (ktModifier.type) {
-                    JKKtModifier.KtModifierType.ABSTRACT -> "abstract"
-                    JKKtModifier.KtModifierType.INNER -> "inner"
-                    JKKtModifier.KtModifierType.OPEN -> "open"
-                    JKKtModifier.KtModifierType.PRIVATE -> "private"
-                    JKKtModifier.KtModifierType.PROTECTED -> "protected"
-                    else -> ktModifier.type.toString()
-                }
-            )
-        }
-
         private inline fun <T> renderList(list: List<T>, separator: String = ", ", renderElement: (T) -> Unit) =
             renderList(list, { printer.printWithNoIndent(separator) }, renderElement)
 
@@ -218,7 +168,7 @@ class NewCodeBuilder {
         }
 
         override fun visitClass(klass: JKClass) {
-            klass.modifierList.accept(this)
+            renderModifiersList(klass)
             builder.append(" ")
             printer.print(classKindString(klass.classKind))
             builder.append(" ")
@@ -264,7 +214,7 @@ class NewCodeBuilder {
 
 
         override fun visitKtProperty(ktProperty: JKKtProperty) {
-            ktProperty.modifierList.accept(this)
+            renderModifiersList(ktProperty)
 
             printer.printWithNoIndent(" ")
             ktProperty.name.accept(this)
@@ -310,9 +260,8 @@ class NewCodeBuilder {
             ktIsExpression.type.accept(this)
         }
 
-
         override fun visitParameter(parameter: JKParameter) {
-            parameter.modifierList.accept(this)
+            renderModifiersList(parameter)
             printer.printWithNoIndent(" ")
             parameter.name.accept(this)
             if (parameter.type.present() && parameter.type.type !is JKContextType) {
@@ -325,13 +274,21 @@ class NewCodeBuilder {
             }
         }
 
+        override fun visitForLoopVariable(forLoopVariable: JKForLoopVariable) {
+            forLoopVariable.name.accept(this)
+            if (forLoopVariable.type.present() && forLoopVariable.type.type !is JKContextType) {
+                printer.printWithNoIndent(": ")
+                forLoopVariable.type.accept(this)
+            }
+        }
+
         override fun visitKtFunction(ktFunction: JKKtFunction) {
             printer.printIndent()
             if (ktFunction.annotationList.annotations.isNotEmpty()) {
                 ktFunction.annotationList.accept(this)
                 printer.printlnWithNoIndent(" ")
             }
-            ktFunction.modifierList.accept(this)
+            renderModifiersList(ktFunction)
             printer.printWithNoIndent(" fun ")
             ktFunction.typeParameterList.accept(this)
             ktFunction.name.accept(this)
@@ -391,7 +348,7 @@ class NewCodeBuilder {
 
         override fun visitKtGetterOrSetter(ktGetterOrSetter: JKKtGetterOrSetter) {
             printer.indented {
-                ktGetterOrSetter.modifierList.accept(this)
+                renderModifiersList(ktGetterOrSetter)
                 printer.printWithNoIndent(" ")
                 when (ktGetterOrSetter.kind) {
                     JKKtGetterOrSetter.Kind.GETTER -> printer.printWithNoIndent("get")
@@ -554,14 +511,14 @@ class NewCodeBuilder {
         }
 
         override fun visitLocalVariable(localVariable: JKLocalVariable) {
-            if (localVariable.parent !is JKForInStatement) {
+//            if (localVariable.parent !is JKForInStatement) {
-                if (localVariable.modifierList.modality == JKModalityModifier.Modality.FINAL) {
+//                if (localVariable.modifierList.modality == JKModifierTokens.FINAL) {
-                    printer.print("val")
+//                    printer.print("val")
-                } else {
+//                } else {
-                    printer.print("var")
+//                    printer.print("var")
-                }
+//                }
-            }
+//            }
-
+            renderModifiersList(localVariable)
             printer.printWithNoIndent(" ")
             localVariable.name.accept(this)
             if (localVariable.type.present() && localVariable.type.type != JKContextType) {
@@ -692,7 +649,7 @@ class NewCodeBuilder {
         }
 
         override fun visitKtConstructor(ktConstructor: JKKtConstructor) {
-            ktConstructor.modifierList.accept(this)
+            renderModifiersList(ktConstructor)
             printer.print(" constructor")
             renderParameterList(ktConstructor.parameters)
             if (ktConstructor.delegationCall !is JKStubExpression) {
@@ -707,14 +664,8 @@ class NewCodeBuilder {
         }
 
         override fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor) {
-            val hasInitDeclaration =
+            renderModifiersList(ktPrimaryConstructor)
-                (ktPrimaryConstructor.parent as JKClassBody).declarations.any { it is JKKtInitDeclaration }
+            printer.printWithNoIndent(" constructor ")
-            val hasAccessModifier =
-                ktPrimaryConstructor.modifierList.modifiers.any { it is JKAccessModifier }
-            if (hasAccessModifier && hasInitDeclaration && ktPrimaryConstructor.parameters.isNotEmpty()) {
-                ktPrimaryConstructor.modifierList.accept(this)
-                printer.printWithNoIndent(" constructor ")
-            }
             if (ktPrimaryConstructor.parameters.isNotEmpty()) {
                 renderParameterList(ktPrimaryConstructor.parameters)
             }

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/AssignmentStatementValCreationConversion.kt

@@ -24,17 +24,17 @@ class AssignmentStatementValCreationConversion(val context: ConversionContext) :
                     JKDeclarationStatementImpl(
                         listOf(
                             JKLocalVariableImpl(
-                                JKModifierListImpl(JKModalityModifierImpl(JKModalityModifier.Modality.FINAL)),
                                 JKTypeElementImpl(JKJavaVoidType/*TODO*/),
                                 JKNameIdentifierImpl("arr"),
-                                ex1
+                                ex1,
+                                Mutability.IMMUTABLE
                             ).also {
                                 assignableExpr.expression = JKFieldAccessExpressionImpl(context.symbolProvider.provideUniverseSymbol(it))
                             }, JKLocalVariableImpl(
-                                JKModifierListImpl(JKModalityModifierImpl(JKModalityModifier.Modality.FINAL)),
                                 JKTypeElementImpl(JKJavaVoidType/*TODO*/),
                                 JKNameIdentifierImpl("i"),
-                                ex2
+                                ex2,
+                                Mutability.UNKNOWN
                             ).also {
                                 assignableExpr.indexExpression =
                                         JKFieldAccessExpressionImpl(context.symbolProvider.provideUniverseSymbol(it))
@@ -50,10 +50,10 @@ class AssignmentStatementValCreationConversion(val context: ConversionContext) :
                     JKDeclarationStatementImpl(
                         listOf(
                             JKLocalVariableImpl(
-                                JKModifierListImpl(JKModalityModifierImpl(JKModalityModifier.Modality.FINAL)),
                                 JKTypeElementImpl(JKJavaVoidType/*TODO*/),
                                 JKNameIdentifierImpl("arg"),
-                                ex
+                                ex,
+                                Mutability.UNKNOWN
                             ).also {
                                 assignableExpr.receiver = JKFieldAccessExpressionImpl(context.symbolProvider.provideUniverseSymbol(it))
                             }

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/ClassToObjectPromotionConversion.kt

@@ -6,12 +6,8 @@
 package org.jetbrains.kotlin.j2k.conversions
 
 import org.jetbrains.kotlin.j2k.ConversionContext
-import org.jetbrains.kotlin.j2k.tree.JKClass
+import org.jetbrains.kotlin.j2k.tree.*
-import org.jetbrains.kotlin.j2k.tree.JKKtPrimaryConstructor
+import org.jetbrains.kotlin.j2k.tree.impl.*
-import org.jetbrains.kotlin.j2k.tree.JKTreeElement
-import org.jetbrains.kotlin.j2k.tree.declarationList
-import org.jetbrains.kotlin.j2k.tree.impl.JKClassImpl
-import org.jetbrains.kotlin.j2k.tree.impl.psi
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 
 class ClassToObjectPromotionConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
@@ -35,12 +31,16 @@ class ClassToObjectPromotionConversion(private val context: ConversionContext) :
                 element.invalidate()
                 return recurse(
                     JKClassImpl(
-                        element.modifierList,
                         element.name,
                         element.inheritance,
                         JKClass.ClassKind.OBJECT,
                         element.typeParameterList,
-                        companion.classBody
+                        companion.classBody.also {
+                            it.handleDeclarationsModifiers()
+                        },
+                        element.extraModifiers,
+                        element.visibility,
+                        Modality.FINAL
                     )
                 )
             }
@@ -49,6 +49,16 @@ class ClassToObjectPromotionConversion(private val context: ConversionContext) :
         return recurse(element)
     }
 
+    private fun JKClassBody.handleDeclarationsModifiers() {
+        for (declaration in declarations) {
+            if (declaration !is JKVisibilityOwner) continue
+            if (declaration.visibility == Visibility.PROTECTED) {
+                //in old j2k it is internal. should it be private instead?
+                declaration.visibility = Visibility.INTERNAL
+            }
+        }
+    }
+
     private fun JKClass.hasInheritors() =
         context.converter.converterServices.oldServices.referenceSearcher.hasInheritors(psi()!!)
 }

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/ConstructorConversion.kt

@@ -18,10 +18,17 @@ class ConstructorConversion(private val context: ConversionContext) : RecursiveA
         element.invalidate()
         val delegationCall = lookupDelegationCall(element.block) ?: JKStubExpressionImpl()
 
-        return JKKtConstructorImpl(element.name, element.parameters, element.block, element.modifierList, delegationCall)
+        return JKKtConstructorImpl(
-            .also {
+            element.name,
-                context.symbolProvider.transferSymbol(it, element)
+            element.parameters,
-            }
+            element.block,
+            delegationCall,
+            element.extraModifiers,
+            element.visibility,
+            element.modality
+        ).also {
+            context.symbolProvider.transferSymbol(it, element)
+        }
     }
 
     private fun lookupDelegationCall(block: JKBlock): JKDelegationConstructorCall? {

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/FieldInitializersInPrimaryFromParamsConversion.kt

@@ -40,10 +40,10 @@ class FieldInitializersInPrimaryFromParamsConversion(private val context: Conver
                     (assignmentExpression.expression as? JKFieldAccessExpression)?.identifier?.target as? JKParameter ?: continue
                 if (element.parameters.contains(parameter)) {
                     val fieldDeclaration = containingClass.declarationList.find {
-                        (it as? JKField)?.name?.value == fieldTarget.name.value
+                        (it as? JKVariable)?.name?.value == fieldTarget.name.value
-                    } as? JKField ?: continue
+                    } as? JKVariable ?: continue
                     if (!fieldDeclaration.type.type.equalsByName(parameter.type.type)) continue//TODO better way to compare types??
-                    parameter.modifierList = fieldDeclaration::modifierList.detached()
+//                    parameter.modifierList = fieldDeclaration::modifierList.detached()
                     declarationsToRemove += fieldDeclaration
 
                     if (parameter.name.value != fieldTarget.name.value) {

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/FieldToPropertyConversion.kt

@@ -6,8 +6,6 @@
 package org.jetbrains.kotlin.j2k.conversions
 
 import org.jetbrains.kotlin.j2k.ConversionContext
-import org.jetbrains.kotlin.j2k.ast.Mutability
-import org.jetbrains.kotlin.j2k.copyTreeAndDetach
 import org.jetbrains.kotlin.j2k.tree.*
 import org.jetbrains.kotlin.j2k.tree.impl.*
 import org.jetbrains.kotlin.load.java.JvmAbi
@@ -44,10 +42,13 @@ class FieldToPropertyConversion(private val context: ConversionContext) : Recurs
                 ?.takeIf { propertyNameFromGet(it) != null }
                 ?.let {
                     JKJavaFieldImpl(
-                        JKModifierListImpl(),
                         JKTypeElementImpl(it.returnType.type),
                         JKNameIdentifierImpl(propertyNameFromGet(it)!!),
-                        JKStubExpressionImpl()
+                        JKStubExpressionImpl(),
+                        emptyList(),
+                        Visibility.PRIVATE,
+                        Modality.OPEN,
+                        Mutability.UNKNOWN
                     )
                 }
             ?: return null
@@ -58,13 +59,13 @@ class FieldToPropertyConversion(private val context: ConversionContext) : Recurs
             JKKtGetterOrSetterImpl(
                 JKBlockStatementImpl(block)
                     .renamed(propertyField.name.value, "field", propertyField.type.type, RenameType.RENAME_FIELD_ACCESS),
-                JKModifierListImpl(JKAccessModifierImpl(method.modifierList.visibility)),
+                JKKtGetterOrSetter.Kind.GETTER,
-                JKKtGetterOrSetter.Kind.GETTER
+                method.visibility
             )
         } ?: JKKtGetterOrSetterImpl(
             JKBlockStatementImpl(JKBodyStub),
-            JKModifierListImpl(JKAccessModifierImpl(propertyField.modifierList.visibility)),
+            JKKtGetterOrSetter.Kind.GETTER,
-            JKKtGetterOrSetter.Kind.GETTER
+            propertyField.visibility
         )
 
         val ktSetter = setter?.let {
@@ -79,32 +80,35 @@ class FieldToPropertyConversion(private val context: ConversionContext) : Recurs
                         RenameType.RENAME_PARAMETER_ACCESS
                     )
                     .renamed(propertyField.name.value, "field", propertyField.type.type, RenameType.RENAME_FIELD_ACCESS),
-                JKModifierListImpl(JKAccessModifierImpl(method.modifierList.visibility)),
+                JKKtGetterOrSetter.Kind.SETTER,
-                JKKtGetterOrSetter.Kind.SETTER
+                method.visibility
             )
         } ?: JKKtEmptyGetterOrSetterImpl()
         propertyField.invalidate()
 
+        val mutability =
+            if (propertyField.modality == Modality.FINAL) Mutability.IMMUTABLE
+            else if (propertyField.visibility == Visibility.PRIVATE && ktSetter is JKKtEmptyGetterOrSetter)
+                Mutability.IMMUTABLE
+            else Mutability.MUTABLE
+
+        val visibility =
+            listOf(
+                ktGetter.visibility,
+                ktGetter.visibility
+            ).min() ?: Visibility.PUBLIC
+
         return JKKtPropertyImpl(
-            propertyField.modifierList,
             propertyField.type,
             propertyField.name,
             propertyField.initializer,
             ktGetter,
-            ktSetter
+            ktSetter,
-        ).also {
+            propertyField.extraModifiers,
-            it.modifierList.mutability =
+            visibility,
-                    if (it.modifierList.isFinal()) Mutability.NonMutable
+            propertyField.modality,
-                    else if (it.modifierList.visibilityOrNull() == JKAccessModifier.Visibility.PRIVATE && ktSetter is JKKtEmptyGetterOrSetter)
+            mutability
-                        Mutability.NonMutable
+        )
-                    else Mutability.Mutable
-
-            it.modifierList.visibility =
-                    listOf(
-                        ktGetter.modifierList.visibility,
-                        ktGetter.modifierList.visibility
-                    ).min() ?: JKAccessModifier.Visibility.PUBLIC
-        }
     }
 
     private fun JKJavaMethod.isGetterOrSetter() =

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/ForConversion.kt

@@ -120,8 +120,7 @@ class ForConversion(private val context: ConversionContext) : RecursiveApplicabl
 //                JKJavaPrimitiveTypeImpl.INT
 //            else null
             val loopVarDeclaration =
-                JKLocalVariableImpl(
+                JKForLoopVariableImpl(
-                    JKModifierListImpl(JKModalityModifierImpl(JKModalityModifier.Modality.FINAL)),
                     JKTypeElementImpl(JKNoTypeImpl),
                     loopVar::name.detached(),
                     JKStubExpressionImpl()

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/InnerClassConversion.kt

@@ -6,8 +6,6 @@
 package org.jetbrains.kotlin.j2k.conversions
 
 import org.jetbrains.kotlin.j2k.tree.*
-import org.jetbrains.kotlin.j2k.tree.JKKtModifier.KtModifierType.INNER
-import org.jetbrains.kotlin.j2k.tree.impl.JKKtModifierImpl
 
 class InnerClassConversion : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
@@ -22,13 +20,15 @@ class InnerClassConversion : RecursiveApplicableConversionBase() {
     private fun applyArmed(element: JKTreeElement, outer: JKClass): JKTreeElement {
         if (element !is JKClass) return recurseArmed(element, outer)
 
-        val static = element.modifierList.modifiers.find { it is JKJavaModifier && it.type == JKJavaModifier.JavaModifierType.STATIC }
+        val static = element.extraModifiers.find { it == ExtraModifier.STATIC }
         if (static != null) {
-            element.modifierList.modifiers -= static
+            element.extraModifiers -= static
-        } else if (element.classKind != JKClass.ClassKind.INTERFACE && outer.classKind != JKClass.ClassKind.INTERFACE) {
+        } else if (element.classKind != JKClass.ClassKind.INTERFACE &&
-            element.modifierList.modifiers += JKKtModifierImpl(INNER)
+            outer.classKind != JKClass.ClassKind.INTERFACE &&
+            element.classKind != JKClass.ClassKind.ENUM
+        ) {
+            element.extraModifiers += ExtraModifier.INNER
         }
         return recurseArmed(element, element)
     }
-
 }

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/InsertDefaultPrimaryConstructorConversion.kt

@@ -7,22 +7,24 @@ package org.jetbrains.kotlin.j2k.conversions
 
 import org.jetbrains.kotlin.j2k.ConversionContext
 import org.jetbrains.kotlin.j2k.tree.*
-import org.jetbrains.kotlin.j2k.tree.JKModalityModifier.Modality.*
 import org.jetbrains.kotlin.j2k.tree.impl.*
 
 
 class InsertDefaultPrimaryConstructorConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKClass) return recurse(element)
-        if (element.classKind != JKClass.ClassKind.CLASS && element.declarationList.any { it is JKKtConstructor }) return recurse(element)
+        if (element.classKind != JKClass.ClassKind.CLASS) return recurse(element)
+        if (element.declarationList.any { it is JKKtConstructor }) return recurse(element)
 
         val constructor = JKKtPrimaryConstructorImpl(
-            JKNameIdentifierImpl(element.name.value), emptyList(), JKBodyStub,
+            JKNameIdentifierImpl(element.name.value),
-            JKModifierListImpl().also {
+            emptyList(),
-                it.modality = FINAL
+            JKBodyStub,
-                it.visibility = JKAccessModifier.Visibility.PUBLIC
+            JKStubExpressionImpl(),
-            },
+            emptyList(),
-            JKStubExpressionImpl()
+            Visibility.PUBLIC,
+            Modality.FINAL
+
         )
 
         element.classBody.declarations += constructor

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/InternalClassConversion.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.j2k.conversions
+
+import org.jetbrains.kotlin.j2k.ConversionContext
+import org.jetbrains.kotlin.j2k.tree.*
+
+class InternalClassConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+    override fun applyToElement(element: JKTreeElement): JKTreeElement {
+        if (element !is JKClass) return recurse(element)
+        return recurseArmed(element, element.visibility == Visibility.INTERNAL)
+    }
+
+    private fun recurseArmed(element: JKTreeElement, parentIsInternal: Boolean): JKTreeElement {
+        return applyRecursive(element, parentIsInternal, ::applyArmed)
+    }
+
+    private fun applyArmed(element: JKTreeElement, parentIsInternal: Boolean): JKTreeElement {
+        if (element is JKClass) return recurseArmed(element, parentIsInternal)
+        if (element !is JKVisibilityOwner) return recurseArmed(element, parentIsInternal)
+        val isInternal = element.visibility == Visibility.INTERNAL
+        if (isInternal && parentIsInternal && context.converter.settings.noInternalForMembersOfInternal) {
+            element.visibility = Visibility.PUBLIC
+        }
+        return recurseArmed(element, isInternal)
+    }
+}

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/JavaMethodToKotlinFunctionConversion.kt

@@ -16,33 +16,44 @@
 
 package org.jetbrains.kotlin.j2k.conversions
 
-import org.jetbrains.kotlin.j2k.tree.JKClass
+import org.jetbrains.kotlin.j2k.ConversionContext
-import org.jetbrains.kotlin.j2k.tree.JKClassBody
+import org.jetbrains.kotlin.j2k.throwAnnotation
-import org.jetbrains.kotlin.j2k.tree.JKJavaMethod
+import org.jetbrains.kotlin.j2k.tree.*
-import org.jetbrains.kotlin.j2k.tree.JKTreeElement
 import org.jetbrains.kotlin.j2k.tree.impl.JKKtFunctionImpl
 
-class JavaMethodToKotlinFunctionConversion : TransformerBasedConversion() {
+class JavaMethodToKotlinFunctionConversion(private val context: ConversionContext) : TransformerBasedConversion() {
     override fun visitTreeElement(element: JKTreeElement) {
         element.acceptChildren(this, null)
     }
 
     override fun visitClassBody(classBody: JKClassBody) {
         somethingChanged = true
-        classBody.declarations = classBody.declarations.map {
+
-            if (it is JKJavaMethod) {
+        classBody.declarations = classBody.declarations.map { declaration ->
-                it.invalidate()
+            if (declaration is JKJavaMethod) {
+                declaration.invalidate()
+
                 JKKtFunctionImpl(
-                    it.returnType,
+                    declaration.returnType,
-                    it.name,
+                    declaration.name,
-                    it.parameters,
+                    declaration.parameters,
-                    it.block,
+                    declaration.block,
-                    it.modifierList,
+                    declaration.typeParameterList,
-                    it.typeParameterList,
+                    declaration.annotationList.also {
-                    it.annotationList
+                        if (declaration.throwsList.isNotEmpty()) {
+                            it.annotations +=
+                                    throwAnnotation(
+                                        declaration.throwsList.map { it.type },
+                                        context.symbolProvider
+                                    )
+                        }
+                    },
+                    declaration.extraModifiers,
+                    declaration.visibility,
+                    declaration.modality
                 )
             } else {
-                it
+                declaration
             }
         }
         classBody.acceptChildren(this)

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/JavaModifiersConversion.kt

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.j2k.conversions
+
+import org.jetbrains.kotlin.j2k.tree.*
+
+class JavaModifiersConversion: RecursiveApplicableConversionBase() {
+    override fun applyToElement(element: JKTreeElement): JKTreeElement {
+        if (element is JKVisibilityOwner) {
+            if (element.visibility == Visibility.PACKAGE_PRIVATE) {
+                element.visibility = Visibility.INTERNAL
+            }
+        }
+        return recurse(element)
+    }
+}

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/MainFunctionConversion.kt

@@ -5,16 +5,15 @@
 
 package org.jetbrains.kotlin.j2k.conversions
 
+import org.jetbrains.kotlin.j2k.ConversionContext
 import org.jetbrains.kotlin.j2k.ast.Nullability
 import org.jetbrains.kotlin.j2k.tree.*
-import org.jetbrains.kotlin.j2k.tree.impl.JKAnnotationImpl
+import org.jetbrains.kotlin.j2k.tree.impl.*
-import org.jetbrains.kotlin.j2k.tree.impl.JKClassTypeImpl
+import org.jetbrains.kotlin.util.collectionUtils.concatInOrder
-import org.jetbrains.kotlin.j2k.tree.impl.JKNameIdentifierImpl
-import org.jetbrains.kotlin.j2k.tree.impl.JKTypeElementImpl
 
 
 //TODO temporary
-class MainFunctionConversion : RecursiveApplicableConversionBase() {
+class MainFunctionConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKKtFunction) return recurse(element)
         if (element.isMainFunctionDeclaration()) {
@@ -29,7 +28,11 @@ class MainFunctionConversion : RecursiveApplicableConversionBase() {
                     )
                 type = JKTypeElementImpl(newType)
             }
-            element.annotationList.annotations += JKAnnotationImpl(JKNameIdentifierImpl("JvmStatic"))
+            element.annotationList.annotations +=
+                    JKAnnotationImpl(
+                        context.symbolProvider.provideByFqName("kotlin.jvm.JvmStatic"),
+                        JKExpressionListImpl()
+                    )
         }
         return recurse(element)
     }

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/ModalityConversion.kt

@@ -9,12 +9,9 @@ import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiMethod
 import org.jetbrains.kotlin.j2k.ConversionContext
 import org.jetbrains.kotlin.j2k.tree.*
-import org.jetbrains.kotlin.j2k.tree.impl.modality
 import org.jetbrains.kotlin.j2k.tree.impl.psi
 
 class ModalityConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
-
-
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         when (element) {
             is JKClass -> processClass(element)
@@ -25,16 +22,22 @@ class ModalityConversion(private val context: ConversionContext) : RecursiveAppl
 
     private fun processClass(klass: JKClass) {
         if (klass.classKind != JKClass.ClassKind.CLASS) return
-        if (klass.modifierList.modality != JKModalityModifier.Modality.OPEN) return
+        if (klass.modality != Modality.OPEN) return
         if (context.converter.settings.openByDefault) return
         if (!context.converter.converterServices.oldServices.referenceSearcher.hasInheritors(klass.psi as PsiClass)) {
-            klass.modifierList.modality = JKModalityModifier.Modality.FINAL
+            klass.modality = Modality.FINAL
         }
     }
 
     private fun processMethod(method: JKJavaMethod) {
+        val psi = method.psi<PsiMethod>()!!
+        if (method.modality == Modality.OPEN
+            && !context.converter.converterServices.oldServices.referenceSearcher.hasOverrides(psi)
+        ) {
+            method.modality = Modality.FINAL
+        }
         if ((method.psi!! as PsiMethod).findSuperMethods().isNotEmpty()) {
-            method.modifierList.modality = JKModalityModifier.Modality.OVERRIDE
+            method.modality = Modality.OVERRIDE
         }
     }
 

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/ModifiersConversion.kt

@@ -1,108 +0,0 @@
-/*
- * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
- * that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.j2k.conversions
-
-import org.jetbrains.kotlin.j2k.ConversionContext
-import org.jetbrains.kotlin.j2k.ast.Mutability
-import org.jetbrains.kotlin.j2k.tree.*
-import org.jetbrains.kotlin.j2k.tree.impl.*
-
-class ModifiersConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
-
-    override fun applyToElement(element: JKTreeElement): JKTreeElement {
-        if (element is JKModifierListOwner && element !is JKLocalVariable) {
-            var modifiers = element.modifierList.modifiers
-            if (element !is JKField) {
-                modifiers = mapOtherModifiers(modifiers)
-            }
-            element.modifierList.modifiers = modifiers
-            // Is declared inside some class
-            // TODO: Cleanup
-            if (context.converter.settings.noInternalForMembersOfInternal) {
-                relaxVisibility(element)
-            }
-            if (element is JKParameter) {
-                convertParameterModifiers(element)
-            }
-            if (element is JKKtConstructor) {
-                convertConstructorModifiers(element)
-            }
-            if (element is JKClass) {
-                convertClassModifiers(element)
-            }
-            element.sortModifiers()
-        }
-        return recurse(element)
-    }
-
-    private fun convertClassModifiers(klass: JKClass) {
-        val isPackagePrivate = klass.modifierList.visibility == JKAccessModifier.Visibility.PACKAGE_PRIVATE
-        val parentClassIsInternal =
-            (klass.parent as? JKClass)?.modifierList?.visibility == JKAccessModifier.Visibility.INTERNAL
-        if (isPackagePrivate || parentClassIsInternal) {
-            klass.modifierList.visibility = JKAccessModifier.Visibility.INTERNAL
-        }
-    }
-
-    private fun convertConstructorModifiers(constructor: JKKtConstructor) {
-        constructor.filterModifiers { it !is JKModalityModifier }
-    }
-
-    private fun convertParameterModifiers(jkParameter: JKParameter) {
-        if (jkParameter.modifierList.mutability == Mutability.Default) {
-            jkParameter.modifierList.modifiers = emptyList()
-        }
-    }
-
-
-    private fun relaxVisibility(element: JKTreeElement) {
-        if (element is JKParameter) return
-        element as JKModifierListOwner // TODO: Assert
-        val modifierList = element.modifierList
-        val parent = element.parent as? JKClass
-        if (parent == null
-            || modifierList.visibility != JKAccessModifier.Visibility.PACKAGE_PRIVATE
-            || parent.modifierList.visibility != JKAccessModifier.Visibility.PACKAGE_PRIVATE
-        ) return
-        modifierList.visibility = JKAccessModifier.Visibility.PUBLIC
-    }
-
-    private fun mapOtherModifiers(modifiers: List<JKModifier>): List<JKModifier> {
-        return modifiers.map {
-            when (it) {
-                is JKJavaModifier -> when (it.type) {
-                    JKJavaModifier.JavaModifierType.NATIVE -> JKKtModifierImpl(JKKtModifier.KtModifierType.EXTERNAL)
-                    else -> it
-                }
-                else -> it
-            }
-        }
-    }
-
-    private fun JKModifierListOwner.sortModifiers() {
-        modifierList.modifiers = modifierList.modifiers.sortedBy { it.priority }
-    }
-
-    private val JKModifier.priority: Int
-        get() =
-            when (this) {
-                is JKAccessModifier -> 0
-                is JKModalityModifier ->
-                    when (this.modality) {
-                        JKModalityModifier.Modality.FINAL, JKModalityModifier.Modality.OPEN, JKModalityModifier.Modality.ABSTRACT -> 1
-                        JKModalityModifier.Modality.OVERRIDE -> 2
-                    }
-                is JKJavaModifier -> 3
-                is JKKtModifier -> 4
-                is JKMutabilityModifier -> 5
-                else -> 6
-            }
-
-
-    private fun JKModifierListOwner.filterModifiers(filter: (JKModifier) -> Boolean) {
-        modifierList.modifiers = modifierList.modifiers.filter(filter)
-    }
-}

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/PrimaryConstructorDetectConversion.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.j2k.tree.impl.JKKtPrimaryConstructorImpl
 
 class PrimaryConstructorDetectConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
-        if (element is JKClass) {
+        if (element is JKClass && element.classKind == JKClass.ClassKind.CLASS) {
             processClass(element)
         }
         return recurse(element)
@@ -33,8 +33,10 @@ class PrimaryConstructorDetectConversion(private val context: ConversionContext)
                 primaryConstructorCandidate.name,
                 primaryConstructorCandidate.parameters,
                 primaryConstructorCandidate.block,
-                primaryConstructorCandidate.modifierList,
+                primaryConstructorCandidate.delegationCall,
-                primaryConstructorCandidate.delegationCall
+                primaryConstructorCandidate.extraModifiers,
+                primaryConstructorCandidate.visibility,
+                primaryConstructorCandidate.modality
             )
 
         context.symbolProvider.transferSymbol(primaryConstructor, primaryConstructorCandidate)

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/SortClassMembersConversion.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.j2k.conversions
 
-import org.jetbrains.kotlin.j2k.ast.EnumConstant
 import org.jetbrains.kotlin.j2k.tree.*
 
 //TODO temporary
@@ -13,7 +12,7 @@ class SortClassMembersConversion : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKClass) return recurse(element)
         element.classBody.declarations = element.declarationList
-            .sortedByDescending { it is JKField }
+            .sortedByDescending { it is JKVariable }
         return recurse(element)
     }
 }

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/StaticsToCompanionExtractConversion.kt

@@ -13,8 +13,8 @@ class StaticsToCompanionExtractConversion : RecursiveApplicableConversionBase()
         if (element !is JKClass) return recurse(element)
         if (element.classKind == JKClass.ClassKind.COMPANION || element.classKind == JKClass.ClassKind.OBJECT) return element
         val statics = element.declarationList.filter { declaration ->
-            declaration is JKModifierListOwner &&
+            declaration is JKExtraModifiersOwner &&
-                    declaration.modifierList.modifiers.any { it is JKJavaModifier && it.type == JKJavaModifier.JavaModifierType.STATIC }
+                    declaration.extraModifiers.any { it == ExtraModifier.STATIC }
         }
 
         if (statics.isEmpty()) return recurse(element)
@@ -23,9 +23,8 @@ class StaticsToCompanionExtractConversion : RecursiveApplicableConversionBase()
 
         element.classBody.declarations -= statics
         companion.classBody.declarations += statics.onEach { declaration ->
-            (declaration as JKModifierListOwner)
+            (declaration as JKExtraModifiersOwner)
-            declaration.modifierList.modifiers =
+            declaration.extraModifiers -= ExtraModifier.STATIC
-                    declaration.modifierList.modifiers.filterNot { it is JKJavaModifier && it.type == JKJavaModifier.JavaModifierType.STATIC }
         }
 
         return recurse(element)
@@ -40,17 +39,14 @@ class StaticsToCompanionExtractConversion : RecursiveApplicableConversionBase()
         if (companion != null) return companion
 
         return JKClassImpl(
-            JKModifierListImpl(
-                listOf(
-                    JKAccessModifierImpl(JKAccessModifier.Visibility.PUBLIC),
-                    JKModalityModifierImpl(JKModalityModifier.Modality.FINAL)
-                )
-            ),
             JKNameIdentifierImpl(""),
             JKInheritanceInfoImpl(emptyList()),
             JKClass.ClassKind.COMPANION,
             JKTypeParameterListImpl(),
-            JKClassBodyImpl()
+            JKClassBodyImpl(),
+            emptyList(),
+            Visibility.PUBLIC,
+            Modality.FINAL
         ).also { element.classBody.declarations += it }
     }
 }

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/TryStatementConversion.kt

@@ -5,13 +5,10 @@
 
 package org.jetbrains.kotlin.j2k.conversions
 
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.j2k.*
 import org.jetbrains.kotlin.j2k.ast.Nullability
 import org.jetbrains.kotlin.j2k.tree.*
 import org.jetbrains.kotlin.j2k.tree.impl.*
-import org.jetbrains.kotlin.name.ClassId
-import java.util.*
 
 
 class TryStatementConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
@@ -72,8 +69,7 @@ class TryStatementConversion(private val context: ConversionContext) : Recursive
         }.map {
             val parameter = JKParameterImpl(
                 JKTypeElementImpl(it.updateNullability(Nullability.NotNull)),
-                javaCatchSection.parameter.name.copyTreeAndDetach(),
+                javaCatchSection.parameter.name.copyTreeAndDetach()
-                JKModifierListImpl()
             )
             JKKtTryCatchSectionImpl(
                 parameter,

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/resolveUtil.kt

@@ -24,7 +24,7 @@ internal fun resolveFqName(classId: ClassId, contextElement: JKTreeElement, cont
     return resolveFqName(classId, element)
 }
 
-internal fun resolveFqName(classId: ClassId, element: PsiElement): PsiElement? {
+fun resolveFqName(classId: ClassId, element: PsiElement): PsiElement? {
     return constructImportDirectiveWithContext(classId, element)
         .getChildOfType<KtDotQualifiedExpression>()
         ?.selectorExpression

j2k/newSrc/org/jetbrains/kotlin/j2k/expressions.kt

@@ -157,7 +157,7 @@ fun useExpression(
                 )!!
             ) as JKMethodSymbol
     val lambdaParameter =
-        JKParameterImpl(JKTypeElementImpl(JKNoTypeImpl), variableIdentifier, JKModifierListImpl())
+        JKParameterImpl(JKTypeElementImpl(JKNoTypeImpl), variableIdentifier)
 
     val lambda = JKLambdaExpressionImpl(
         listOf(lambdaParameter),

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/DebugTreePrinter.kt

@@ -36,15 +36,11 @@ private class DebugTreePrinter : JKVisitorVoid {
         printer.println(nameIdentifier.describe(), "(\"", nameIdentifier.value, "\")")
     }
 
-    override fun visitJavaModifier(javaModifier: JKJavaModifier) {
-        printer.println(javaModifier.describe(), "(", javaModifier.type, ")")
-    }
-
     override fun visitJavaMethod(javaMethod: JKJavaMethod) {
+        printer.print(javaMethod.modifiers().joinToString(" ") { it.text })
         printer.println(javaMethod.describe(), " [")
         printer.indented {
             javaMethod.block.accept(this, null)
-            javaMethod.modifierList.accept(this, null)
             javaMethod.parameters.forEach { it.accept(this, null) }
         }
         printer.println("]")

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt

@@ -27,28 +27,35 @@ import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType
 
-class JKJavaFieldImpl(modifierList: JKModifierList, type: JKTypeElement, name: JKNameIdentifier, initializer: JKExpression) : JKJavaField,
+class JKJavaFieldImpl(
+    type: JKTypeElement, name: JKNameIdentifier, initializer: JKExpression,
+    override var extraModifiers: List<ExtraModifier>,
+    override var visibility: Visibility,
+    override var modality: Modality,
+    override var mutability: Mutability
+) : JKJavaField,
     JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaField(this, data)
 
     override var initializer: JKExpression by child(initializer)
-    override var modifierList: JKModifierList by child(modifierList)
     override var type by child(type)
     override var name: JKNameIdentifier by child(name)
 }
 
 class JKJavaMethodImpl(
-    modifierList: JKModifierList,
     returnType: JKTypeElement,
     name: JKNameIdentifier,
     parameters: List<JKParameter>,
     block: JKBlock,
     typeParameterList: JKTypeParameterList,
-    annotationList: JKAnnotationList
+    annotationList: JKAnnotationList,
+    throwsList: List<JKTypeElement>,
+    override var extraModifiers: List<ExtraModifier>,
+    override var visibility: Visibility,
+    override var modality: Modality
 ) : JKJavaMethod, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaMethod(this, data)
 
-    override var modifierList: JKModifierList by child(modifierList)
     override var returnType: JKTypeElement by child(returnType)
     override var name: JKNameIdentifier by child(name)
     override var parameters: List<JKParameter> by children(parameters)
@@ -68,9 +75,6 @@ class JKJavaLiteralExpressionImpl(
     }
 }
 
-class JKJavaModifierImpl(override val type: JKJavaModifier.JavaModifierType) : JKJavaModifier, JKElementBase(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaModifier(this, data)
-}
 
 class JKJavaOperatorToken(val psiToken: IElementType) : JKOperatorToken {
     override val text: String

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt

@@ -19,9 +19,7 @@ package org.jetbrains.kotlin.j2k.tree.impl
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.j2k.ConversionContext
 import org.jetbrains.kotlin.j2k.JKSymbolProvider
-import org.jetbrains.kotlin.j2k.ast.Mutability
 import org.jetbrains.kotlin.j2k.ast.Nullability
 import org.jetbrains.kotlin.j2k.conversions.resolveFqName
 import org.jetbrains.kotlin.j2k.tree.*
@@ -40,17 +38,18 @@ class JKFileImpl : JKFile, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
 }
 
 class JKClassImpl(
-    modifierList: JKModifierList,
     name: JKNameIdentifier,
     inheritance: JKInheritanceInfo,
     override var classKind: JKClass.ClassKind,
     typeParameterList: JKTypeParameterList,
-    classBody: JKClassBody
+    classBody: JKClassBody,
+    override var extraModifiers: List<ExtraModifier>,
+    override var visibility: Visibility,
+    override var modality: Modality
 ) : JKClass, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitClass(this, data)
 
     override var name by child(name)
-    override var modifierList by child(modifierList)
     override val inheritance by child(inheritance)
     override var typeParameterList: JKTypeParameterList by child(typeParameterList)
     override var classBody: JKClassBody by child(classBody)
@@ -60,46 +59,26 @@ class JKNameIdentifierImpl(override val value: String) : JKNameIdentifier, JKEle
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitNameIdentifier(this, data)
 }
 
-class JKModifierListImpl(
+class JKForLoopVariableImpl(
-    modifiers: List<JKModifier> = emptyList()
+    type: JKTypeElement,
-) : JKModifierList, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
+    name: JKNameIdentifier,
-    constructor(vararg modifiers: JKModifier) : this(modifiers.asList())
+    initializer: JKExpression
+) : JKForLoopVariable, JKBranchElementBase() {
+    override var initializer by child(initializer)
+    override var name by child(name)
+    override var type by child(type)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitModifierList(this, data)
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitForLoopVariable(this, data)
-
-    override var modifiers: List<JKModifier> by children(modifiers)
 }
 
 
-var JKModifierList.modality
-    get() = modifiers.filterIsInstance<JKModalityModifier>().first().modality
-    set(value) {
-        modifiers = modifiers.filterNot { it is JKModalityModifier } + JKModalityModifierImpl(value)
-    }
-
-var JKModifierList.visibility
-    get() = modifiers.filterIsInstance<JKAccessModifier>().first().visibility
-    set(value) {
-        modifiers = modifiers.filterNot { it is JKAccessModifier } + JKAccessModifierImpl(value)
-    }
-
-var JKModifierList.mutability
-    get() = modifiers.filterIsInstance<JKMutabilityModifier>().firstOrNull()?.mutability ?: Mutability.Default
-    set(value) {
-        modifiers = modifiers.filterNot { it is JKMutabilityModifier } +
-                listOfNotNull(if (value != Mutability.Default) JKMutabilityModifierImpl(value) else null)
-    }
-
 class JKParameterImpl(
     type: JKTypeElement,
     name: JKNameIdentifier,
-    modifierList: JKModifierList,
     initializer: JKExpression = JKStubExpressionImpl()
-
 ) : JKParameter, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitParameter(this, data)
 
-    override var modifierList by child(modifierList)
     override var initializer by child(initializer)
     override var name by child(name)
     override var type by child(type)
@@ -269,9 +248,12 @@ fun JKLiteralExpression.LiteralType.toJkType(symbolProvider: JKSymbolProvider):
     }
 }
 
-class JKLocalVariableImpl(modifierList: JKModifierList, type: JKTypeElement, name: JKNameIdentifier, initializer: JKExpression) :
+class JKLocalVariableImpl(
-    JKLocalVariable, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
+    type: JKTypeElement,
-    override var modifierList by child(modifierList)
+    name: JKNameIdentifier,
+    initializer: JKExpression,
+    override var mutability: Mutability
+) : JKLocalVariable, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
     override var initializer by child(initializer)
     override var name by child(name)
     override var type by child(type)
@@ -368,21 +350,9 @@ class JKClassAccessExpressionImpl(override var identifier: JKClassSymbol) : JKCl
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitClassAccessExpression(this, data)
 }
 
-class JKModalityModifierImpl(override val modality: JKModalityModifier.Modality) : JKModalityModifier, JKElementBase(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitModalityModifier(this, data)
-}
-
-class JKAccessModifierImpl(override val visibility: JKAccessModifier.Visibility) : JKAccessModifier, JKElementBase(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitAccessModifier(this, data)
-}
-
-class JKMutabilityModifierImpl(override val mutability: Mutability) : JKMutabilityModifier, JKElementBase(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitMutabilityModifier(this, data)
-}
-
 class JKLambdaExpressionImpl(
     parameters: List<JKParameter> = listOf(
-        JKParameterImpl(JKTypeElementImpl(JKJavaVoidType), JKNameIdentifierImpl("it"), JKModifierListImpl())
+        JKParameterImpl(JKTypeElementImpl(JKJavaVoidType), JKNameIdentifierImpl("it"))
     ), statement: JKStatement, returnType: JKTypeElement = JKTypeElementImpl(JKContextType)
 ) : JKLambdaExpression, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
     override var statement by child(statement)
@@ -475,14 +445,13 @@ class JKTypeParameterTypeImpl(
 class JKEnumConstantImpl(
     name: JKNameIdentifier,
     arguments: JKExpressionList,
-    type: JKTypeElement,
+    type: JKTypeElement
-    modifierList: JKModifierList
 ) : JKEnumConstant, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
     override var name: JKNameIdentifier by child(name)
     override val arguments: JKExpressionList by child(arguments)
     override var type: JKTypeElement by child(type)
     override var initializer: JKExpression by child(JKStubExpressionImpl())
-    override var modifierList: JKModifierList by child(modifierList)
+
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitEnumConstant(this, data)
 }
 

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/k.kt

@@ -26,16 +26,18 @@ import org.jetbrains.kotlin.types.expressions.OperatorConventions
 import org.jetbrains.kotlin.utils.addToStdlib.cast
 
 class JKKtPropertyImpl(
-    modifierList: JKModifierList,
     type: JKTypeElement,
     name: JKNameIdentifier,
     initializer: JKExpression,
     getter: JKKtGetterOrSetter,
-    setter: JKKtGetterOrSetter
+    setter: JKKtGetterOrSetter,
+    override var extraModifiers: List<ExtraModifier>,
+    override var visibility: Visibility,
+    override var modality: Modality,
+    override var mutability: Mutability
 ) : JKBranchElementBase(), JKKtProperty {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtProperty(this, data)
 
-    override var modifierList: JKModifierList by child(modifierList)
     override var type by child(type)
     override var name: JKNameIdentifier by child(name)
     override var initializer: JKExpression by child(initializer)
@@ -48,9 +50,11 @@ class JKKtFunctionImpl(
     name: JKNameIdentifier,
     parameters: List<JKParameter>,
     block: JKBlock,
-    modifierList: JKModifierList,
     typeParameterList: JKTypeParameterList,
-    annotationList: JKAnnotationList
+    annotationList: JKAnnotationList,
+    override var extraModifiers: List<ExtraModifier>,
+    override var visibility: Visibility,
+    override var modality: Modality
 ) : JKBranchElementBase(), JKKtFunction {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtFunction(this, data)
 
@@ -58,7 +62,6 @@ class JKKtFunctionImpl(
     override var name: JKNameIdentifier by child(name)
     override var parameters: List<JKParameter> by children(parameters)
     override var block: JKBlock by child(block)
-    override var modifierList: JKModifierList by child(modifierList)
     override var typeParameterList: JKTypeParameterList by child(typeParameterList)
     override var annotationList: JKAnnotationList by child(annotationList)
 }
@@ -110,10 +113,6 @@ class JKKtOperatorImpl(override val token: JKKtOperatorToken, val methodSymbol:
 }
 
 
-class JKKtModifierImpl(override val type: JKKtModifier.KtModifierType) : JKKtModifier, JKElementBase() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtModifier(this, data)
-}
-
 class JKKtAlsoCallExpressionImpl(
     statement: JKStatement,
     override val identifier: JKMethodSymbol,
@@ -135,8 +134,7 @@ class JKKtAlsoCallExpressionImpl(
                     listOf(
                         JKParameterImpl(
                             JKTypeElementImpl(JKJavaVoidType),
-                            JKNameIdentifierImpl(parameterName),
+                            JKNameIdentifierImpl(parameterName)
-                            JKModifierListImpl()
                         )
                     ), statement
                 )
@@ -163,15 +161,16 @@ class JKKtConstructorImpl(
     name: JKNameIdentifier,
     parameters: List<JKParameter>,
     block: JKBlock,
-    modifierList: JKModifierList,
+    delegationCall: JKExpression,
-    delegationCall: JKExpression
+    override var extraModifiers: List<ExtraModifier>,
+    override var visibility: Visibility,
+    override var modality: Modality
 ) : JKBranchElementBase(), JKKtConstructor {
     override val returnType: JKTypeElement get() = TODO("!")
 
     override var name: JKNameIdentifier by child(name)
     override var parameters: List<JKParameter> by children(parameters)
     override var block: JKBlock by child(block)
-    override var modifierList: JKModifierList by child(modifierList)
     override var delegationCall: JKExpression by child(delegationCall)
     override var typeParameterList: JKTypeParameterList by child(JKTypeParameterListImpl())
     override var annotationList: JKAnnotationList by child(JKAnnotationListImpl())
@@ -182,16 +181,16 @@ class JKKtConstructorImpl(
 class JKKtPrimaryConstructorImpl(
     name: JKNameIdentifier,
     parameters: List<JKParameter>,
-    block: JKBlock,
+    delegationCall: JKExpression,
-    modifierList: JKModifierList,
+    override var extraModifiers: List<ExtraModifier>,
-    delegationCall: JKExpression
+    override var visibility: Visibility,
+    override var modality: Modality
 ) : JKBranchElementBase(), JKKtPrimaryConstructor {
     override val returnType: JKTypeElement get() = TODO("!")
 
     override var name: JKNameIdentifier by child(name)
     override var parameters: List<JKParameter> by children(parameters)
     override var block: JKBlock by child(block)
-    override var modifierList: JKModifierList by child(modifierList)
     override var delegationCall: JKExpression by child(delegationCall)
     override var typeParameterList: JKTypeParameterList by child(JKTypeParameterListImpl())
     override var annotationList: JKAnnotationList by child(JKAnnotationListImpl())
@@ -292,18 +291,18 @@ class JKKtTryCatchSectionImpl(
 
 class JKKtGetterOrSetterImpl(
     body: JKStatement,
-    modifierList: JKModifierList,
+    override val kind: JKKtGetterOrSetter.Kind,
-    override val kind: JKKtGetterOrSetter.Kind
+    override var visibility: Visibility
 ) : JKKtGetterOrSetter, JKBranchElementBase() {
     override var body: JKStatement by child(body)
-    override var modifierList: JKModifierList by child(modifierList)
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtGetterOrSetter(this, data)
 }
 
 class JKKtEmptyGetterOrSetterImpl : JKKtEmptyGetterOrSetter, JKBranchElementBase() {
+    override var visibility: Visibility = Visibility.PUBLIC
     override var body: JKStatement by child(JKEmptyStatementImpl())
-    override var modifierList: JKModifierList by child(JKModifierListImpl())
     override val kind: JKKtGetterOrSetter.Kind
         get() = error("Cannot get kind of JKKtEmptyGetterOrSetter")
+
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtEmptyGetterOrSetter(this, data)
 }

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/symbols.kt

@@ -129,12 +129,12 @@ class JKMultiverseFunctionSymbol(override val target: KtNamedFunction, private v
         get() = target.name!! // TODO("Fix this")
 }
 
-class JKUniverseFieldSymbol : JKFieldSymbol, JKUniverseSymbol<JKField> {
+class JKUniverseFieldSymbol : JKFieldSymbol, JKUniverseSymbol<JKVariable> {
     override val fieldType: JKType
         get() = target.type.type
     override val name: String
         get() = target.name.value
-    override lateinit var target: JKField
+    override lateinit var target: JKVariable
     override val declaredIn: JKSymbol
         get() = TODO("not implemented") //To change initializer of created properties use File | Settings | File Templates.
     override val fqName: String

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt

@@ -18,7 +18,8 @@ package org.jetbrains.kotlin.j2k.tree
 
 import org.jetbrains.kotlin.idea.search.usagesSearch.constructor
 import org.jetbrains.kotlin.j2k.tree.impl.*
-import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstance
+
+interface JKField : JKVariable, JKVisibilityOwner, JKMutabilityOwner, JKModalityOwner, JKExtraModifiersOwner
 
 interface JKJavaField : JKField, JKBranchElement
 
@@ -58,13 +59,6 @@ interface JKJavaDefaultNewExpression : JKExpression {
     val classSymbol: JKClassSymbol
 }
 
-interface JKJavaModifier : JKModifier {
-    val type: JavaModifierType
-
-    enum class JavaModifierType {
-        NATIVE, STATIC, STRICTFP, SYNCHRONIZED, TRANSIENT, VOLATILE
-    }
-}
 
 interface JKJavaNewEmptyArray : JKExpression {
     val type: JKTypeElement

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.j2k.tree
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.j2k.ast.Mutability
 import org.jetbrains.kotlin.j2k.tree.impl.JKClassSymbol
 import org.jetbrains.kotlin.j2k.tree.impl.JKFieldSymbol
 import org.jetbrains.kotlin.j2k.tree.impl.JKMethodSymbol
@@ -45,7 +44,7 @@ interface JKFile : JKTreeElement, JKBranchElement {
     var declarationList: List<JKDeclaration>
 }
 
-interface JKClass : JKDeclaration, JKModifierListOwner, JKTypeParameterListOwner, JKBranchElement {
+interface JKClass : JKDeclaration, JKVisibilityOwner, JKExtraModifiersOwner, JKModalityOwner, JKTypeParameterListOwner, JKBranchElement {
     val name: JKNameIdentifier
 
     val inheritance: JKInheritanceInfo
@@ -78,47 +77,105 @@ interface JKAnnotationListOwner : JKTreeElement {
     var annotationList: JKAnnotationList
 }
 
-interface JKMethod : JKDeclaration, JKModifierListOwner, JKTypeParameterListOwner, JKAnnotationListOwner {
+interface JKMethod : JKDeclaration, JKVisibilityOwner, JKModalityOwner, JKExtraModifiersOwner, JKTypeParameterListOwner,
+    JKAnnotationListOwner {
     val name: JKNameIdentifier
     var parameters: List<JKParameter>
     val returnType: JKTypeElement
     var block: JKBlock
 }
 
-interface JKField : JKDeclaration, JKModifierListOwner {
+interface JKVariable : JKDeclaration {
     var type: JKTypeElement
     var name: JKNameIdentifier
     var initializer: JKExpression
 }
 
-interface JKLocalVariable : JKField
+interface JKForLoopVariable : JKVariable
 
-interface JKModifier : JKTreeElement
+interface JKLocalVariable : JKVariable, JKMutabilityOwner
 
-interface JKModifierList : JKTreeElement {
+interface JKExtraModifiersOwner : JKModifiersListOwner {
-    var modifiers: List<JKModifier>
+    var extraModifiers: List<ExtraModifier>
 }
 
-interface JKAccessModifier : JKModifier {
+interface Modifier {
-    enum class Visibility {
+    val text: String
-        PUBLIC, INTERNAL, PACKAGE_PRIVATE, PROTECTED, PRIVATE
-    }
-
-    val visibility: Visibility
 }
 
-interface JKModalityModifier : JKModifier {
+enum class ExtraModifier(override val text: String) : Modifier {
-    enum class Modality {
+    ACTUAL("actual"),
-        OPEN, FINAL, ABSTRACT, OVERRIDE
+    ANNOTATION("annotation"),
-    }
+    COMPANION("companion"),
+    CONST("const"),
+    CROSSINLINE("crossinline"),
+    DATA("data"),
+    EXPECT("expect"),
+    EXTERNAL("external"),
+    INFIX("infix"),
+    INLINE("inline"),
+    INNER("inner"),
+    LATEINIT("lateinit"),
+    NOINLINE("noinline"),
+    OPERATOR("operator"),
+    OUT("out"),
+    REIFIED("reified"),
+    SEALED("sealed"),
+    SUSPEND("suspend"),
+    TAILREC("tailrec"),
+    VARARG("vararg"),
 
-    val modality: Modality
+    NATIVE("native"),
+    STATIC("static"),
+    STRICTFP("strictfp"),
+    SYNCHRONIZED("synchronized"),
+    TRANSIENT("transient"),
+    VOLATILE("volatile")
 }
 
-interface JKMutabilityModifier : JKModifier {
+interface JKVisibilityOwner : JKModifiersListOwner{
-    val mutability: Mutability
+    var visibility: Visibility
 }
 
+enum class Visibility(override val text: String) : Modifier {
+    PUBLIC("public"),
+    INTERNAL("internal"),
+    PACKAGE_PRIVATE(""),
+    PROTECTED("protected"),
+    PRIVATE("private")
+}
+
+interface JKModalityOwner : JKModifiersListOwner {
+    var modality: Modality
+}
+
+
+enum class Modality(override val text: String) : Modifier {
+    OPEN("open"),
+    FINAL("final"),
+    ABSTRACT("abstract"),
+    OVERRIDE("override")
+}
+
+interface JKMutabilityOwner : JKModifiersListOwner {
+    var mutability: Mutability
+}
+
+enum class Mutability(override val text: String) : Modifier {
+    MUTABLE("var"),
+    IMMUTABLE("val"),
+    UNKNOWN("var")//TODO ???
+}
+
+interface JKModifiersListOwner : JKTreeElement
+
+fun JKModifiersListOwner.modifiers(): List<Modifier> =
+    listOfNotNull((this as? JKVisibilityOwner)?.visibility) +
+            (this as? JKExtraModifiersOwner)?.extraModifiers.orEmpty() +
+            listOfNotNull((this as? JKModalityOwner)?.modality) +
+            listOfNotNull((this as? JKMutabilityOwner)?.mutability)
+
+
 interface JKTypeElement : JKTreeElement {
     val type: JKType
 }
@@ -216,9 +273,7 @@ interface JKLiteralExpression : JKExpression {
     }
 }
 
-interface JKParameter : JKField {
+interface JKParameter : JKVariable, JKModifiersListOwner
-
-}
 
 interface JKStringLiteralExpression : JKLiteralExpression {
     val text: String
@@ -315,7 +370,7 @@ interface JKTypeParameterListOwner : JKTreeElement {
     var typeParameterList: JKTypeParameterList
 }
 
-interface JKEnumConstant : JKField {
+interface JKEnumConstant : JKVariable {
     val arguments: JKExpressionList
 }
 

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/k.kt

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.j2k.tree
 
 import org.jetbrains.kotlin.j2k.tree.impl.JKMethodSymbol
 
-interface JKKtGetterOrSetter : JKTreeElement, JKModifierListOwner, JKBranchElement {
+interface JKKtGetterOrSetter : JKTreeElement, JKVisibilityOwner, JKBranchElement {
     var body: JKStatement
     val kind: Kind
 
@@ -34,10 +34,12 @@ interface JKKtProperty : JKField {
     var setter: JKKtGetterOrSetter
 }
 
+
+
 interface JKKtFunction : JKMethod {
 }
 
-interface JKKtConstructor : JKDeclaration, JKModifierListOwner, JKMethod, JKBranchElement {
+interface JKKtConstructor : JKDeclaration, JKExtraModifiersOwner, JKMethod, JKBranchElement {
     override var name: JKNameIdentifier
     override var parameters: List<JKParameter>
     var delegationCall: JKExpression
@@ -53,15 +55,6 @@ interface JKKtAssignmentStatement : JKStatement {
 
 interface JKKtCall : JKMethodCallExpression
 
-interface JKKtModifier : JKModifier {
-    val type: KtModifierType
-
-    enum class KtModifierType {
-        ACTUAL, ABSTRACT, ANNOTATION, COMPANION, CONST, CROSSINLINE, DATA, ENUM, EXPECT, EXTERNAL, FINAL, INFIX, INLINE, INNER,
-        LATEINIT, NOINLINE, OPEN, OPERATOR, OUT, OVERRIDE, REIFIED, SEALED, SUSPEND, TAILREC, VARARG, PRIVATE, PROTECTED
-    }
-}
-
 interface JKKtMethodCallExpression : JKMethodCallExpression
 
 interface JKKtAlsoCallExpression : JKKtMethodCallExpression {

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/markers.kt

@@ -52,10 +52,6 @@ interface JKBranchElement : JKElement {
     fun invalidate()
 }
 
-interface JKModifierListOwner {
-    var modifierList: JKModifierList
-}
-
 interface JKType {
     val nullability: Nullability
 }

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt

@@ -12,13 +12,14 @@ interface JKVisitor<out R, in D> {
     fun visitAnnotation(annotation: JKAnnotation, data: D): R = visitTreeElement(annotation, data)
     fun visitAnnotationListOwner(annotationListOwner: JKAnnotationListOwner, data: D): R = visitTreeElement(annotationListOwner, data)
     fun visitMethod(method: JKMethod, data: D): R = visitDeclaration(method, data)
-    fun visitField(field: JKField, data: D): R = visitDeclaration(field, data)
+    fun visitVariable(variable: JKVariable, data: D): R = visitDeclaration(variable, data)
-    fun visitLocalVariable(localVariable: JKLocalVariable, data: D): R = visitField(localVariable, data)
+    fun visitForLoopVariable(forLoopVariable: JKForLoopVariable, data: D): R = visitVariable(forLoopVariable, data)
-    fun visitModifier(modifier: JKModifier, data: D): R = visitTreeElement(modifier, data)
+    fun visitLocalVariable(localVariable: JKLocalVariable, data: D): R = visitVariable(localVariable, data)
-    fun visitModifierList(modifierList: JKModifierList, data: D): R = visitTreeElement(modifierList, data)
+    fun visitExtraModifiersOwner(extraModifiersOwner: JKExtraModifiersOwner, data: D): R = visitModifiersListOwner(extraModifiersOwner, data)
-    fun visitAccessModifier(accessModifier: JKAccessModifier, data: D): R = visitModifier(accessModifier, data)
+    fun visitVisibilityOwner(visibilityOwner: JKVisibilityOwner, data: D): R = visitModifiersListOwner(visibilityOwner, data)
-    fun visitModalityModifier(modalityModifier: JKModalityModifier, data: D): R = visitModifier(modalityModifier, data)
+    fun visitModalityOwner(modalityOwner: JKModalityOwner, data: D): R = visitModifiersListOwner(modalityOwner, data)
-    fun visitMutabilityModifier(mutabilityModifier: JKMutabilityModifier, data: D): R = visitModifier(mutabilityModifier, data)
+    fun visitMutabilityOwner(mutabilityOwner: JKMutabilityOwner, data: D): R = visitModifiersListOwner(mutabilityOwner, data)
+    fun visitModifiersListOwner(modifiersListOwner: JKModifiersListOwner, data: D): R = visitTreeElement(modifiersListOwner, data)
     fun visitTypeElement(typeElement: JKTypeElement, data: D): R = visitTreeElement(typeElement, data)
     fun visitStatement(statement: JKStatement, data: D): R = visitTreeElement(statement, data)
     fun visitBlock(block: JKBlock, data: D): R = visitTreeElement(block, data)
@@ -43,7 +44,7 @@ interface JKVisitor<out R, in D> {
     fun visitTypeCastExpression(typeCastExpression: JKTypeCastExpression, data: D): R = visitExpression(typeCastExpression, data)
     fun visitExpressionList(expressionList: JKExpressionList, data: D): R = visitTreeElement(expressionList, data)
     fun visitLiteralExpression(literalExpression: JKLiteralExpression, data: D): R = visitExpression(literalExpression, data)
-    fun visitParameter(parameter: JKParameter, data: D): R = visitField(parameter, data)
+    fun visitParameter(parameter: JKParameter, data: D): R = visitVariable(parameter, data)
     fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression, data: D): R = visitLiteralExpression(stringLiteralExpression, data)
     fun visitStubExpression(stubExpression: JKStubExpression, data: D): R = visitExpression(stubExpression, data)
     fun visitLoopStatement(loopStatement: JKLoopStatement, data: D): R = visitStatement(loopStatement, data)
@@ -69,9 +70,11 @@ interface JKVisitor<out R, in D> {
     fun visitTypeParameterList(typeParameterList: JKTypeParameterList, data: D): R = visitTreeElement(typeParameterList, data)
     fun visitTypeParameter(typeParameter: JKTypeParameter, data: D): R = visitTreeElement(typeParameter, data)
     fun visitTypeParameterListOwner(typeParameterListOwner: JKTypeParameterListOwner, data: D): R = visitTreeElement(typeParameterListOwner, data)
-    fun visitEnumConstant(enumConstant: JKEnumConstant, data: D): R = visitField(enumConstant, data)
+    fun visitEnumConstant(enumConstant: JKEnumConstant, data: D): R = visitVariable(enumConstant, data)
     fun visitForInStatement(forInStatement: JKForInStatement, data: D): R = visitStatement(forInStatement, data)
     fun visitPackageDeclaration(packageDeclaration: JKPackageDeclaration, data: D): R = visitDeclaration(packageDeclaration, data)
+    fun visitClassLiteralExpression(classLiteralExpression: JKClassLiteralExpression, data: D): R = visitExpression(classLiteralExpression, data)
+    fun visitField(field: JKField, data: D): R = visitVariable(field, data)
     fun visitJavaField(javaField: JKJavaField, data: D): R = visitField(javaField, data)
     fun visitJavaMethod(javaMethod: JKJavaMethod, data: D): R = visitMethod(javaMethod, data)
     fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression, data: D): R = visitMethodCallExpression(javaMethodCallExpression, data)
@@ -79,7 +82,6 @@ interface JKVisitor<out R, in D> {
     fun visitEmptyClassBody(emptyClassBody: JKEmptyClassBody, data: D): R = visitClassBody(emptyClassBody, data)
     fun visitJavaNewExpression(javaNewExpression: JKJavaNewExpression, data: D): R = visitExpression(javaNewExpression, data)
     fun visitJavaDefaultNewExpression(javaDefaultNewExpression: JKJavaDefaultNewExpression, data: D): R = visitExpression(javaDefaultNewExpression, data)
-    fun visitJavaModifier(javaModifier: JKJavaModifier, data: D): R = visitModifier(javaModifier, data)
     fun visitJavaNewEmptyArray(javaNewEmptyArray: JKJavaNewEmptyArray, data: D): R = visitExpression(javaNewEmptyArray, data)
     fun visitJavaNewArray(javaNewArray: JKJavaNewArray, data: D): R = visitExpression(javaNewArray, data)
     fun visitJavaLiteralExpression(javaLiteralExpression: JKJavaLiteralExpression, data: D): R = visitLiteralExpression(javaLiteralExpression, data)
@@ -105,7 +107,6 @@ interface JKVisitor<out R, in D> {
     fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor, data: D): R = visitKtConstructor(ktPrimaryConstructor, data)
     fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement, data: D): R = visitStatement(ktAssignmentStatement, data)
     fun visitKtCall(ktCall: JKKtCall, data: D): R = visitMethodCallExpression(ktCall, data)
-    fun visitKtModifier(ktModifier: JKKtModifier, data: D): R = visitModifier(ktModifier, data)
     fun visitKtMethodCallExpression(ktMethodCallExpression: JKKtMethodCallExpression, data: D): R = visitMethodCallExpression(ktMethodCallExpression, data)
     fun visitKtAlsoCallExpression(ktAlsoCallExpression: JKKtAlsoCallExpression, data: D): R = visitKtMethodCallExpression(ktAlsoCallExpression, data)
     fun visitKtLiteralExpression(ktLiteralExpression: JKKtLiteralExpression, data: D): R = visitLiteralExpression(ktLiteralExpression, data)

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt

@@ -21,20 +21,22 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitAnnotationListOwner(annotationListOwner: JKAnnotationListOwner, data: Nothing?) = visitAnnotationListOwner(annotationListOwner)
     fun visitMethod(method: JKMethod) = visitDeclaration(method, null)
     override fun visitMethod(method: JKMethod, data: Nothing?) = visitMethod(method)
-    fun visitField(field: JKField) = visitDeclaration(field, null)
+    fun visitVariable(variable: JKVariable) = visitDeclaration(variable, null)
-    override fun visitField(field: JKField, data: Nothing?) = visitField(field)
+    override fun visitVariable(variable: JKVariable, data: Nothing?) = visitVariable(variable)
-    fun visitLocalVariable(localVariable: JKLocalVariable) = visitField(localVariable, null)
+    fun visitForLoopVariable(forLoopVariable: JKForLoopVariable) = visitVariable(forLoopVariable, null)
+    override fun visitForLoopVariable(forLoopVariable: JKForLoopVariable, data: Nothing?) = visitForLoopVariable(forLoopVariable)
+    fun visitLocalVariable(localVariable: JKLocalVariable) = visitVariable(localVariable, null)
     override fun visitLocalVariable(localVariable: JKLocalVariable, data: Nothing?) = visitLocalVariable(localVariable)
-    fun visitModifier(modifier: JKModifier) = visitTreeElement(modifier, null)
+    fun visitExtraModifiersOwner(extraModifiersOwner: JKExtraModifiersOwner) = visitModifiersListOwner(extraModifiersOwner, null)
-    override fun visitModifier(modifier: JKModifier, data: Nothing?) = visitModifier(modifier)
+    override fun visitExtraModifiersOwner(extraModifiersOwner: JKExtraModifiersOwner, data: Nothing?) = visitExtraModifiersOwner(extraModifiersOwner)
-    fun visitModifierList(modifierList: JKModifierList) = visitTreeElement(modifierList, null)
+    fun visitVisibilityOwner(visibilityOwner: JKVisibilityOwner) = visitModifiersListOwner(visibilityOwner, null)
-    override fun visitModifierList(modifierList: JKModifierList, data: Nothing?) = visitModifierList(modifierList)
+    override fun visitVisibilityOwner(visibilityOwner: JKVisibilityOwner, data: Nothing?) = visitVisibilityOwner(visibilityOwner)
-    fun visitAccessModifier(accessModifier: JKAccessModifier) = visitModifier(accessModifier, null)
+    fun visitModalityOwner(modalityOwner: JKModalityOwner) = visitModifiersListOwner(modalityOwner, null)
-    override fun visitAccessModifier(accessModifier: JKAccessModifier, data: Nothing?) = visitAccessModifier(accessModifier)
+    override fun visitModalityOwner(modalityOwner: JKModalityOwner, data: Nothing?) = visitModalityOwner(modalityOwner)
-    fun visitModalityModifier(modalityModifier: JKModalityModifier) = visitModifier(modalityModifier, null)
+    fun visitMutabilityOwner(mutabilityOwner: JKMutabilityOwner) = visitModifiersListOwner(mutabilityOwner, null)
-    override fun visitModalityModifier(modalityModifier: JKModalityModifier, data: Nothing?) = visitModalityModifier(modalityModifier)
+    override fun visitMutabilityOwner(mutabilityOwner: JKMutabilityOwner, data: Nothing?) = visitMutabilityOwner(mutabilityOwner)
-    fun visitMutabilityModifier(mutabilityModifier: JKMutabilityModifier) = visitModifier(mutabilityModifier, null)
+    fun visitModifiersListOwner(modifiersListOwner: JKModifiersListOwner) = visitTreeElement(modifiersListOwner, null)
-    override fun visitMutabilityModifier(mutabilityModifier: JKMutabilityModifier, data: Nothing?) = visitMutabilityModifier(mutabilityModifier)
+    override fun visitModifiersListOwner(modifiersListOwner: JKModifiersListOwner, data: Nothing?) = visitModifiersListOwner(modifiersListOwner)
     fun visitTypeElement(typeElement: JKTypeElement) = visitTreeElement(typeElement, null)
     override fun visitTypeElement(typeElement: JKTypeElement, data: Nothing?) = visitTypeElement(typeElement)
     fun visitStatement(statement: JKStatement) = visitTreeElement(statement, null)
@@ -83,7 +85,7 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitExpressionList(expressionList: JKExpressionList, data: Nothing?) = visitExpressionList(expressionList)
     fun visitLiteralExpression(literalExpression: JKLiteralExpression) = visitExpression(literalExpression, null)
     override fun visitLiteralExpression(literalExpression: JKLiteralExpression, data: Nothing?) = visitLiteralExpression(literalExpression)
-    fun visitParameter(parameter: JKParameter) = visitField(parameter, null)
+    fun visitParameter(parameter: JKParameter) = visitVariable(parameter, null)
     override fun visitParameter(parameter: JKParameter, data: Nothing?) = visitParameter(parameter)
     fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression) = visitLiteralExpression(stringLiteralExpression, null)
     override fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression, data: Nothing?) = visitStringLiteralExpression(stringLiteralExpression)
@@ -135,12 +137,16 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitTypeParameter(typeParameter: JKTypeParameter, data: Nothing?) = visitTypeParameter(typeParameter)
     fun visitTypeParameterListOwner(typeParameterListOwner: JKTypeParameterListOwner) = visitTreeElement(typeParameterListOwner, null)
     override fun visitTypeParameterListOwner(typeParameterListOwner: JKTypeParameterListOwner, data: Nothing?) = visitTypeParameterListOwner(typeParameterListOwner)
-    fun visitEnumConstant(enumConstant: JKEnumConstant) = visitField(enumConstant, null)
+    fun visitEnumConstant(enumConstant: JKEnumConstant) = visitVariable(enumConstant, null)
     override fun visitEnumConstant(enumConstant: JKEnumConstant, data: Nothing?) = visitEnumConstant(enumConstant)
     fun visitForInStatement(forInStatement: JKForInStatement) = visitStatement(forInStatement, null)
     override fun visitForInStatement(forInStatement: JKForInStatement, data: Nothing?) = visitForInStatement(forInStatement)
     fun visitPackageDeclaration(packageDeclaration: JKPackageDeclaration) = visitDeclaration(packageDeclaration, null)
     override fun visitPackageDeclaration(packageDeclaration: JKPackageDeclaration, data: Nothing?) = visitPackageDeclaration(packageDeclaration)
+    fun visitClassLiteralExpression(classLiteralExpression: JKClassLiteralExpression) = visitExpression(classLiteralExpression, null)
+    override fun visitClassLiteralExpression(classLiteralExpression: JKClassLiteralExpression, data: Nothing?) = visitClassLiteralExpression(classLiteralExpression)
+    fun visitField(field: JKField) = visitVariable(field, null)
+    override fun visitField(field: JKField, data: Nothing?) = visitField(field)
     fun visitJavaField(javaField: JKJavaField) = visitField(javaField, null)
     override fun visitJavaField(javaField: JKJavaField, data: Nothing?) = visitJavaField(javaField)
     fun visitJavaMethod(javaMethod: JKJavaMethod) = visitMethod(javaMethod, null)
@@ -155,8 +161,6 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitJavaNewExpression(javaNewExpression: JKJavaNewExpression, data: Nothing?) = visitJavaNewExpression(javaNewExpression)
     fun visitJavaDefaultNewExpression(javaDefaultNewExpression: JKJavaDefaultNewExpression) = visitExpression(javaDefaultNewExpression, null)
     override fun visitJavaDefaultNewExpression(javaDefaultNewExpression: JKJavaDefaultNewExpression, data: Nothing?) = visitJavaDefaultNewExpression(javaDefaultNewExpression)
-    fun visitJavaModifier(javaModifier: JKJavaModifier) = visitModifier(javaModifier, null)
-    override fun visitJavaModifier(javaModifier: JKJavaModifier, data: Nothing?) = visitJavaModifier(javaModifier)
     fun visitJavaNewEmptyArray(javaNewEmptyArray: JKJavaNewEmptyArray) = visitExpression(javaNewEmptyArray, null)
     override fun visitJavaNewEmptyArray(javaNewEmptyArray: JKJavaNewEmptyArray, data: Nothing?) = visitJavaNewEmptyArray(javaNewEmptyArray)
     fun visitJavaNewArray(javaNewArray: JKJavaNewArray) = visitExpression(javaNewArray, null)
@@ -207,8 +211,6 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement, data: Nothing?) = visitKtAssignmentStatement(ktAssignmentStatement)
     fun visitKtCall(ktCall: JKKtCall) = visitMethodCallExpression(ktCall, null)
     override fun visitKtCall(ktCall: JKKtCall, data: Nothing?) = visitKtCall(ktCall)
-    fun visitKtModifier(ktModifier: JKKtModifier) = visitModifier(ktModifier, null)
-    override fun visitKtModifier(ktModifier: JKKtModifier, data: Nothing?) = visitKtModifier(ktModifier)
     fun visitKtMethodCallExpression(ktMethodCallExpression: JKKtMethodCallExpression) = visitMethodCallExpression(ktMethodCallExpression, null)
     override fun visitKtMethodCallExpression(ktMethodCallExpression: JKKtMethodCallExpression, data: Nothing?) = visitKtMethodCallExpression(ktMethodCallExpression)
     fun visitKtAlsoCallExpression(ktAlsoCallExpression: JKKtAlsoCallExpression) = visitKtMethodCallExpression(ktAlsoCallExpression, null)