New J2K: do not print modifiers which are going to be removed in postprocessing

j2k/src/org/jetbrains/kotlin/j2k/usageProcessing/FieldToPropertyProcessing.kt

@@ -37,11 +37,15 @@ class FieldToPropertyProcessing(
             if (field.name != propertyName || replaceReadWithFieldReference || replaceWriteWithFieldReference) MyConvertedCodeProcessor() else null
 
     override var javaCodeProcessors =
-            when {
+        when {
-                field.hasModifierProperty(PsiModifier.PRIVATE) -> emptyList()
+            field.hasModifierProperty(PsiModifier.PRIVATE) -> emptyList()
-                field.name != propertyName -> listOf(ElementRenamedCodeProcessor(propertyName), UseAccessorsJavaCodeProcessor())
+            field.name != propertyName ->
-                else -> listOf(UseAccessorsJavaCodeProcessor())
+                listOf(
-            }
+                    ElementRenamedCodeProcessor(propertyName),
+                    UseAccessorsJavaCodeProcessor(PsiElementFactory.SERVICE.getInstance(field.project), propertyName)
+                )
+            else -> listOf(UseAccessorsJavaCodeProcessor(PsiElementFactory.SERVICE.getInstance(field.project), propertyName))
+        }
 
     override val kotlinCodeProcessors =
             if (field.name != propertyName)
@@ -77,86 +81,91 @@ class FieldToPropertyProcessing(
             }
         }
     }
+}
 
-    private inner class UseAccessorsJavaCodeProcessor : ExternalCodeProcessor {
+class UseAccessorsJavaCodeProcessor(private val factory: PsiElementFactory, private val propertyName: String) : ExternalCodeProcessor {
-        private val factory = PsiElementFactory.SERVICE.getInstance(field.project)
+    override fun processUsage(reference: PsiReference): Array<PsiReference>? {
+        val refExpr = reference.element as? PsiReferenceExpression ?: return null
+        val qualifier = refExpr.qualifierExpression
 
-        override fun processUsage(reference: PsiReference): Array<PsiReference>? {
+        when (val parent = refExpr.parent) {
-            val refExpr = reference.element as? PsiReferenceExpression ?: return null
+            is PsiAssignmentExpression -> {
-            val qualifier = refExpr.qualifierExpression
+                if (refExpr == parent.lExpression) {
-
+                    if (parent.operationTokenType == JavaTokenType.EQ) {
-            val parent = refExpr.parent
+                        val callExpr =
-            when (parent) {
+                            parent.replace(generateSetterCall(qualifier, parent.rExpression ?: return null)) as PsiMethodCallExpression
-                is PsiAssignmentExpression -> {
+                        return arrayOf(callExpr.methodExpression)
-                    if (refExpr == parent.lExpression) {
+                    } else {
-                        if (parent.operationTokenType == JavaTokenType.EQ) {
+                        val assignmentOpText = parent.operationSign.text
-                            val callExpr = parent.replace(generateSetterCall(qualifier, parent.rExpression ?: return null)) as PsiMethodCallExpression
+                        assert(assignmentOpText.endsWith("="))
-                            return arrayOf(callExpr.methodExpression)
+                        val opText = assignmentOpText.substring(0, assignmentOpText.length - 1)
-                        }
+                        return parent.replaceWithModificationCalls(qualifier, opText, parent.rExpression ?: return null)
-                        else {
-                            val assignmentOpText = parent.operationSign.text
-                            assert(assignmentOpText.endsWith("="))
-                            val opText = assignmentOpText.substring(0, assignmentOpText.length - 1)
-                            return parent.replaceWithModificationCalls(qualifier, opText, parent.rExpression ?: return null)
-                        }
-                    }
-                }
-
-                is PsiPrefixExpression, is PsiPostfixExpression -> {
-                    //TODO: what if it's used as value?
-                    val operationType = (parent as? PsiPrefixExpression)?.operationTokenType
-                                        ?: (parent as PsiPostfixExpression).operationTokenType
-                    val opText = when (operationType) {
-                        JavaTokenType.PLUSPLUS -> "+"
-                        JavaTokenType.MINUSMINUS -> "-"
-                        else -> null
-                    }
-                    if (opText != null) {
-                        return (parent as PsiExpression).replaceWithModificationCalls(qualifier, opText, factory.createExpressionFromText("1", null))
                     }
                 }
             }
 
-            val callExpr = refExpr.replace(generateGetterCall(qualifier)) as PsiMethodCallExpression
+            is PsiPrefixExpression, is PsiPostfixExpression -> {
-            return arrayOf(callExpr.methodExpression)
+                //TODO: what if it's used as value?
+                val operationType = (parent as? PsiPrefixExpression)?.operationTokenType
+                    ?: (parent as PsiPostfixExpression).operationTokenType
+                val opText = when (operationType) {
+                    JavaTokenType.PLUSPLUS -> "+"
+                    JavaTokenType.MINUSMINUS -> "-"
+                    else -> null
+                }
+                if (opText != null) {
+                    return (parent as PsiExpression).replaceWithModificationCalls(
+                        qualifier,
+                        opText,
+                        factory.createExpressionFromText("1", null)
+                    )
+                }
+            }
         }
 
-        //TODO: what if qualifier has side effects?
+        val callExpr = refExpr.replace(generateGetterCall(qualifier)) as PsiMethodCallExpression
-        private fun PsiExpression.replaceWithModificationCalls(qualifier: PsiExpression?, op: String, value: PsiExpression): Array<PsiReference> {
+        return arrayOf(callExpr.methodExpression)
-            var getCall = generateGetterCall(qualifier)
-
-            var binary = factory.createExpressionFromText("x $op y", null) as PsiBinaryExpression
-            binary.lOperand.replace(getCall)
-            binary.rOperand!!.replace(value)
-
-            var setCall = generateSetterCall(qualifier, binary) as PsiMethodCallExpression
-            setCall = this.replace(setCall) as PsiMethodCallExpression
-
-            binary = setCall.argumentList.expressions.single() as PsiBinaryExpression
-            getCall = binary.lOperand as PsiMethodCallExpression
-
-            return arrayOf(getCall.methodExpression, setCall.methodExpression)
-        }
-
-        private fun generateGetterCall(qualifier: PsiExpression?): PsiMethodCallExpression {
-            val text = accessorName(AccessorKind.GETTER) + "()"
-            val expressionText = if (qualifier != null)
-                "${qualifier.text}.$text"
-            else
-                text
-            return factory.createExpressionFromText(expressionText, null) as PsiMethodCallExpression
-        }
-
-        private fun generateSetterCall(qualifier: PsiExpression?, value: PsiExpression): PsiExpression {
-            val text = accessorName(AccessorKind.SETTER) + "(" + value.text + ")"
-            val expressionText = if (qualifier != null)
-                "${qualifier.text}.$text"
-            else
-                text
-            return factory.createExpressionFromText(expressionText, null)
-        }
     }
 
-    private fun accessorName(kind: AccessorKind)
+    //TODO: what if qualifier has side effects?
-            = (if (kind == AccessorKind.GETTER) "get" else "set") + propertyName.capitalize()
+    private fun PsiExpression.replaceWithModificationCalls(
+        qualifier: PsiExpression?,
+        op: String,
+        value: PsiExpression
+    ): Array<PsiReference> {
+        var getCall = generateGetterCall(qualifier)
+
+        var binary = factory.createExpressionFromText("x $op y", null) as PsiBinaryExpression
+        binary.lOperand.replace(getCall)
+        binary.rOperand!!.replace(value)
+
+        var setCall = generateSetterCall(qualifier, binary) as PsiMethodCallExpression
+        setCall = this.replace(setCall) as PsiMethodCallExpression
+
+        binary = setCall.argumentList.expressions.single() as PsiBinaryExpression
+        getCall = binary.lOperand as PsiMethodCallExpression
+
+        return arrayOf(getCall.methodExpression, setCall.methodExpression)
+    }
+
+    private fun generateGetterCall(qualifier: PsiExpression?): PsiMethodCallExpression {
+        val text = accessorName(AccessorKind.GETTER) + "()"
+        val expressionText = if (qualifier != null)
+            "${qualifier.text}.$text"
+        else
+            text
+        return factory.createExpressionFromText(expressionText, null) as PsiMethodCallExpression
+    }
+
+    private fun generateSetterCall(qualifier: PsiExpression?, value: PsiExpression): PsiExpression {
+        val text = accessorName(AccessorKind.SETTER) + "(" + value.text + ")"
+        val expressionText = if (qualifier != null)
+            "${qualifier.text}.$text"
+        else
+            text
+        return factory.createExpressionFromText(expressionText, null)
+    }
+
+    private fun accessorName(kind: AccessorKind) =
+        (if (kind == AccessorKind.GETTER) "get" else "set") + propertyName.capitalize()
 }

nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/processings/ConvertGettersAndSettersToPropertyProcessing.kt

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
 import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.references.readWriteAccess
 import org.jetbrains.kotlin.idea.util.CommentSaver
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.asGetterName
@@ -170,11 +171,14 @@ class ConvertGettersAndSettersToPropertyProcessing : ElementsBasedPostProcessing
                 factory.createExpression(KtTokens.FIELD_KEYWORD.value),
                 true
             )
+        val modifiers = setter.modifiersText?.takeIf { it.isNotEmpty() }
+            ?: setter.safeAs<RealSetter>()?.function?.visibilityModifierTypeOrDefault()?.value
+            ?: property.visibilityModifierTypeOrDefault().value
 
         val ktSetter = factory.createSetter(
             body,
             setter.parameterName,
-            setter.modifiersText?.takeIf { it.isNotEmpty() } ?: property.visibilityModifierTypeOrDefault().value
+            modifiers
         )
         ktSetter.filterModifiers()
         if (setter is RealSetter) {

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

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.nj2k
 
-import com.intellij.lang.jvm.JvmAnnotatedElement
 import com.intellij.lang.jvm.JvmModifier
 import com.intellij.psi.*
 import com.intellij.psi.JavaTokenType.SUPER_KEYWORD
@@ -532,7 +531,7 @@ class JavaToJKTreeBuilder constructor(
                 typeParameterList?.toJK() ?: JKTypeParameterListImpl(),
                 createClassBody(),
                 annotationList(this),
-                extraModifiers(),
+                otherModifiers(),
                 visibility(),
                 modality()
             ).also { jkClassImpl ->
@@ -600,20 +599,20 @@ class JavaToJKTreeBuilder constructor(
         fun PsiMember.modality() =
             modality({ ast, psi -> ast.assignNonCodeElements(psi) })
 
-        fun PsiMember.extraModifiers() =
+        fun PsiMember.otherModifiers() =
             modifierList?.children?.mapNotNull { child ->
                 if (child !is PsiKeyword) return@mapNotNull null
                 when (child.text) {
-                    PsiModifier.NATIVE -> ExtraModifier.NATIVE
+                    PsiModifier.NATIVE -> OtherModifier.NATIVE
-                    PsiModifier.STATIC -> ExtraModifier.STATIC
+                    PsiModifier.STATIC -> OtherModifier.STATIC
-                    PsiModifier.STRICTFP -> ExtraModifier.STRICTFP
+                    PsiModifier.STRICTFP -> OtherModifier.STRICTFP
-                    PsiModifier.SYNCHRONIZED -> ExtraModifier.SYNCHRONIZED
+                    PsiModifier.SYNCHRONIZED -> OtherModifier.SYNCHRONIZED
-                    PsiModifier.TRANSIENT -> ExtraModifier.TRANSIENT
+                    PsiModifier.TRANSIENT -> OtherModifier.TRANSIENT
-                    PsiModifier.VOLATILE -> ExtraModifier.VOLATILE
+                    PsiModifier.VOLATILE -> OtherModifier.VOLATILE
 
                     else -> null
                 }?.let {
-                    JKExtraModifierElementImpl(it).withAssignedNonCodeElements(child)
+                    JKOtherModifierElementImpl(it).withAssignedNonCodeElements(child)
                 }
             }.orEmpty()
 
@@ -627,7 +626,7 @@ class JavaToJKTreeBuilder constructor(
                 nameIdentifier.toJK(),
                 with(expressionTreeMapper) { initializer.toJK() },
                 annotationList(this),
-                extraModifiers(),
+                otherModifiers(),
                 visibility(),
                 modality(),
                 JKMutabilityModifierElementImpl(Mutability.UNKNOWN)
@@ -718,7 +717,7 @@ class JavaToJKTreeBuilder constructor(
                 typeParameterList?.toJK() ?: JKTypeParameterListImpl(),
                 annotationList(this),
                 throwsList.referencedTypes.map { JKTypeElementImpl(it.toJK(symbolProvider)) },
-                extraModifiers(),
+                otherModifiers(),
                 visibility(),
                 modality()
             ).also { jkMethod ->

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

@@ -93,7 +93,9 @@ class NewCodeBuilder(context: NewJ2kConverterContext) {
         }
 
         override fun visitModifierElementRaw(modifierElement: JKModifierElement) {
-            printer.printWithNoIndent(modifierElement.modifier.text)
+            if (modifierElement.modifier != Modality.FINAL) {
+                printer.printWithNoIndent(modifierElement.modifier.text)
+            }
         }
 
         private fun renderExtraTypeParametersUpperBounds(typeParameterList: JKTypeParameterList) {
@@ -212,8 +214,20 @@ class NewCodeBuilder(context: NewJ2kConverterContext) {
         }
 
         private fun renderModifiersList(modifiersList: JKModifiersListOwner) {
-            renderList(modifiersList.modifierElements(), " ") {
+            val hasOverrideModifier = modifiersList.safeAs<JKOtherModifiersOwner>()
-                it.accept(this)
+                ?.otherModifierElements
+                ?.any { it.otherModifier == OtherModifier.OVERRIDE } == true
+            renderList(modifiersList.modifierElements(), " ") { modifierElement ->
+                if (modifierElement.modifier == Modality.FINAL || modifierElement.modifier == Visibility.PUBLIC) {
+                    if (hasOverrideModifier) {
+                        modifierElement.accept(this)
+                    } else {
+                        printLeftNonCodeElements(modifierElement)
+                        printRightNonCodeElements(modifierElement)
+                    }
+                } else {
+                    modifierElement.accept(this)
+                }
             }
         }
 

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

@@ -50,7 +50,7 @@ class ClassToObjectPromotionConversion(private val context: NewJ2kConverterConte
                             }.map { it.detached(element.classBody) }
                         },
                         JKAnnotationListImpl(),
-                        element.extraModifierElements,
+                        element.otherModifierElements,
                         element.visibilityElement,
                         JKModalityModifierElementImpl(Modality.FINAL)
                     ).withNonCodeElementsFrom(element)

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

@@ -25,7 +25,7 @@ class ConstructorConversion(private val context: NewJ2kConverterContext) : Recur
             element.block,
             delegationCall,
             element.annotationList,
-            element.extraModifierElements,
+            element.otherModifierElements,
             element.visibilityElement,
             element.modalityElement
         ).also {

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

@@ -17,12 +17,11 @@ class DefaultArgumentsConversion(private val context: NewJ2kConverterContext) :
         name.value.asGetterName() != null
                 || name.value.asSetterName() != null
 
-
     private fun JKMethod.canNotBeMerged(): Boolean =
         modality == Modality.ABSTRACT
-                || modality == Modality.OVERRIDE
+                || hasOtherModifier(OtherModifier.OVERRIDE)
-                || hasExtraModifier(ExtraModifier.NATIVE)
+                || hasOtherModifier(OtherModifier.NATIVE)
-                || hasExtraModifier(ExtraModifier.SYNCHRONIZED)
+                || hasOtherModifier(OtherModifier.SYNCHRONIZED)
                 || context.converter.converterServices.oldServices.referenceSearcher.hasOverrides(psi()!!)
                 || annotationList.annotations.isNotEmpty()
                 || canBeGetterOrSetter()

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

@@ -23,7 +23,7 @@ class FieldToPropertyConversion : RecursiveApplicableConversionBase() {
                 JKKtEmptyGetterOrSetterImpl(),
                 JKKtEmptyGetterOrSetterImpl(),
                 element.annotationList,
-                element.extraModifierElements,
+                element.otherModifierElements,
                 element.visibilityElement,
                 JKModalityModifierElementImpl(Modality.FINAL),
                 JKMutabilityModifierElementImpl(mutability).withNonCodeElementsFrom(element.modalityElement)

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

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.tree.ExtraModifier
+import org.jetbrains.kotlin.nj2k.tree.OtherModifier
 import org.jetbrains.kotlin.nj2k.tree.JKClass
 import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
-import org.jetbrains.kotlin.nj2k.tree.impl.JKExtraModifierElementImpl
+import org.jetbrains.kotlin.nj2k.tree.impl.JKOtherModifierElementImpl
 import org.jetbrains.kotlin.nj2k.tree.isLocalClass
 
 class InnerClassConversion : RecursiveApplicableConversionBase() {
@@ -26,14 +26,14 @@ class InnerClassConversion : RecursiveApplicableConversionBase() {
         if (element.classKind == JKClass.ClassKind.COMPANION) return recurseArmed(element, outer)
         if (element.isLocalClass()) return recurseArmed(element, outer)
 
-        val static = element.extraModifierElements.find { it.extraModifier == ExtraModifier.STATIC }
+        val static = element.otherModifierElements.find { it.otherModifier == OtherModifier.STATIC }
         if (static != null) {
-            element.extraModifierElements -= static
+            element.otherModifierElements -= static
         } else if (element.classKind != JKClass.ClassKind.INTERFACE &&
             outer.classKind != JKClass.ClassKind.INTERFACE &&
             element.classKind != JKClass.ClassKind.ENUM
         ) {
-            element.extraModifierElements += JKExtraModifierElementImpl(ExtraModifier.INNER)
+            element.otherModifierElements += JKOtherModifierElementImpl(OtherModifier.INNER)
         }
         return recurseArmed(element, element)
     }

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

@@ -43,7 +43,7 @@ class JavaMethodToKotlinFunctionConversion(private val context: NewJ2kConverterC
                         )
                 }
             },
-            element.extraModifierElements,
+            element.otherModifierElements,
             element.visibilityElement,
             element.modalityElement
         ).also {

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

@@ -19,33 +19,33 @@ class JavaModifiersConversion(private val context: NewJ2kConverterContext) : Rec
                 //TODO change modality to OVERRIDE???
             }
         }
-        if (element is JKExtraModifiersOwner && element is JKAnnotationListOwner) {
+        if (element is JKOtherModifiersOwner && element is JKAnnotationListOwner) {
-            element.elementByModifier(ExtraModifier.VOLATILE)?.also { modifierElement ->
+            element.elementByModifier(OtherModifier.VOLATILE)?.also { modifierElement ->
-                element.extraModifierElements -= modifierElement
+                element.otherModifierElements -= modifierElement
                 element.annotationList.annotations +=
                     jvmAnnotation("Volatile", context.symbolProvider).withNonCodeElementsFrom(modifierElement)
             }
 
-            element.elementByModifier(ExtraModifier.TRANSIENT)?.also { modifierElement ->
+            element.elementByModifier(OtherModifier.TRANSIENT)?.also { modifierElement ->
-                element.extraModifierElements -= modifierElement
+                element.otherModifierElements -= modifierElement
                 element.annotationList.annotations +=
                     jvmAnnotation("Transient", context.symbolProvider).withNonCodeElementsFrom(modifierElement)
             }
 
-            element.elementByModifier(ExtraModifier.STRICTFP)?.also { modifierElement ->
+            element.elementByModifier(OtherModifier.STRICTFP)?.also { modifierElement ->
-                element.extraModifierElements -= modifierElement
+                element.otherModifierElements -= modifierElement
                 element.annotationList.annotations +=
                     jvmAnnotation("Strictfp", context.symbolProvider).withNonCodeElementsFrom(modifierElement)
             }
 
-            element.elementByModifier(ExtraModifier.SYNCHRONIZED)?.also { modifierElement ->
+            element.elementByModifier(OtherModifier.SYNCHRONIZED)?.also { modifierElement ->
-                element.extraModifierElements -= modifierElement
+                element.otherModifierElements -= modifierElement
                 element.annotationList.annotations +=
                     jvmAnnotation("Synchronized", context.symbolProvider).withNonCodeElementsFrom(modifierElement)
             }
 
-            element.elementByModifier(ExtraModifier.NATIVE)?.also { modifierElement ->
+            element.elementByModifier(OtherModifier.NATIVE)?.also { modifierElement ->
-                modifierElement.extraModifier = ExtraModifier.EXTERNAL
+                modifierElement.otherModifier = OtherModifier.EXTERNAL
             }
         }
         return recurse(element)

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

@@ -65,10 +65,11 @@ class JavaStandardMethodsConversion(private val context: NewJ2kConverterContext)
         if (method.name.value != "finalize") return false
         if (method.parameters.isNotEmpty()) return false
         if (method.returnType.type != JKJavaVoidType) return false
-        if (method.modality == Modality.OVERRIDE) {
+        if (method.hasOtherModifier(OtherModifier.OVERRIDE)) {
             method.modality =
                 if (containingClass.modality == Modality.OPEN) Modality.OPEN
                 else Modality.FINAL
+            method.otherModifierElements -= method.otherModifierElements.first { it.otherModifier == OtherModifier.OVERRIDE }
         }
         return true
     }

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

@@ -9,6 +9,7 @@ import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiMethod
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
+import org.jetbrains.kotlin.nj2k.tree.impl.JKOtherModifierElementImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.psi
 
 class ModalityConversion(private val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() {
@@ -38,18 +39,27 @@ class ModalityConversion(private val context: NewJ2kConverterContext) : Recursiv
     private fun processMethod(method: JKJavaMethod) {
         val psi = method.psi<PsiMethod>() ?: return
         val containingClass = method.parentOfType<JKClass>() ?: return
-        method.modality = when {
+        when {
             method.modality != Modality.ABSTRACT
-                    && psi.findSuperMethods().isNotEmpty() -> Modality.OVERRIDE
+                    && psi.findSuperMethods().isNotEmpty() -> {
+                method.modality = Modality.FINAL
+                if (!method.hasOtherModifier(OtherModifier.OVERRIDE)) {
+                    method.otherModifierElements += JKOtherModifierElementImpl(OtherModifier.OVERRIDE)
+                }
+            }
             method.modality == Modality.OPEN
                     && context.converter.settings.openByDefault
                     && containingClass.modality == Modality.OPEN
-                    && method.visibility != Visibility.PRIVATE -> Modality.OPEN
+                    && method.visibility != Visibility.PRIVATE -> {
+                method.modality = Modality.OPEN
+            }
 
             method.modality == Modality.OPEN
                     && containingClass.classKind != JKClass.ClassKind.INTERFACE
-                    && !context.converter.converterServices.oldServices.referenceSearcher.hasOverrides(psi) -> Modality.FINAL
+                    && !context.converter.converterServices.oldServices.referenceSearcher.hasOverrides(psi) -> {
-            else -> method.modality
+                method.modality = Modality.FINAL
+            }
+            else -> method.modality = method.modality
         }
     }
 

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

@@ -49,7 +49,7 @@ class PrimaryConstructorDetectConversion(private val context: NewJ2kConverterCon
                 primaryConstructorCandidate.parameters,
                 primaryConstructorCandidate.delegationCall,
                 primaryConstructorCandidate.annotationList,
-                primaryConstructorCandidate.extraModifierElements,
+                primaryConstructorCandidate.otherModifierElements,
                 primaryConstructorCandidate.visibilityElement,
                 primaryConstructorCandidate.modalityElement
             ).withNonCodeElementsFrom(primaryConstructorCandidate)

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

@@ -9,10 +9,10 @@ import org.jetbrains.kotlin.nj2k.tree.*
 
 class RemoveWrongExtraModifiersForSingleFunctionsConversion : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
-        if (element !is JKExtraModifiersOwner) return recurse(element)
+        if (element !is JKOtherModifiersOwner) return recurse(element)
         if (element.parentOfType<JKClass>() == null) {
-            element.elementByModifier(ExtraModifier.STATIC)?.also { modifierElement ->
+            element.elementByModifier(OtherModifier.STATIC)?.also { modifierElement ->
-                element.extraModifierElements -= modifierElement
+                element.otherModifierElements -= modifierElement
             }
         }
         return recurse(element)

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

@@ -53,7 +53,7 @@ class StaticMemberAccessConversion(private val context: NewJ2kConverterContext)
                 ?.safeAs<KtObjectDeclaration>()
                 ?.isCompanion() == true
             is JKTreeElement ->
-                target.safeAs<JKExtraModifiersOwner>()?.hasExtraModifier(ExtraModifier.STATIC) == true
+                target.safeAs<JKOtherModifiersOwner>()?.hasOtherModifier(OtherModifier.STATIC) == true
                         || target.parentOfType<JKClass>()?.classKind == JKClass.ClassKind.OBJECT
             else -> false
         }

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

@@ -13,15 +13,16 @@ 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 JKExtraModifiersOwner && declaration.hasExtraModifier(ExtraModifier.STATIC)
+            declaration is JKOtherModifiersOwner && declaration.hasOtherModifier(OtherModifier.STATIC)
         }
         if (statics.isEmpty()) return recurse(element)
         val companion = element.getOrCreateCompanionObject()
 
         element.classBody.declarations -= statics
         companion.classBody.declarations += statics.onEach { declaration ->
-            (declaration as JKExtraModifiersOwner)
+            if (declaration is JKOtherModifiersOwner) {
-            declaration.extraModifierElements -= declaration.elementByModifier(ExtraModifier.STATIC)!!
+                declaration.otherModifierElements -= declaration.elementByModifier(OtherModifier.STATIC)!!
+            }
         }
         return recurse(element)
     }

nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/j.kt

@@ -31,7 +31,7 @@ class JKJavaFieldImpl(
     name: JKNameIdentifier,
     initializer: JKExpression,
     annotationList: JKAnnotationList,
-    extraModifierElements: List<JKExtraModifierElement>,
+    otherModifierElements: List<JKOtherModifierElement>,
     visibilityElement: JKVisibilityModifierElement,
     modalityElement: JKModalityModifierElement,
     mutabilityElement: JKMutabilityModifierElement
@@ -43,7 +43,7 @@ class JKJavaFieldImpl(
     override var type by child(type)
     override var name: JKNameIdentifier by child(name)
 
-    override var extraModifierElements by children(extraModifierElements)
+    override var otherModifierElements by children(otherModifierElements)
     override var visibilityElement by child(visibilityElement)
     override var modalityElement by child(modalityElement)
     override var mutabilityElement by child(mutabilityElement)
@@ -57,7 +57,7 @@ class JKJavaMethodImpl(
     typeParameterList: JKTypeParameterList,
     annotationList: JKAnnotationList,
     throwsList: List<JKTypeElement>,
-    extraModifierElements: List<JKExtraModifierElement>,
+    otherModifierElements: List<JKOtherModifierElement>,
     visibilityElement: JKVisibilityModifierElement,
     modalityElement: JKModalityModifierElement
 ) : JKJavaMethod(), PsiOwner by PsiOwnerImpl() {
@@ -71,7 +71,7 @@ class JKJavaMethodImpl(
     override var annotationList: JKAnnotationList by child(annotationList)
     override var throwsList: List<JKTypeElement> by children(throwsList)
 
-    override var extraModifierElements by children(extraModifierElements)
+    override var otherModifierElements by children(otherModifierElements)
     override var visibilityElement by child(visibilityElement)
     override var modalityElement by child(modalityElement)
 }

nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/jk.kt

@@ -54,7 +54,7 @@ class JKClassImpl(
     typeParameterList: JKTypeParameterList,
     classBody: JKClassBody,
     annotationList: JKAnnotationList,
-    extraModifierElements: List<JKExtraModifierElement>,
+    otherModifierElements: List<JKOtherModifierElement>,
     visibilityElement: JKVisibilityModifierElement,
     modalityElement: JKModalityModifierElement
 ) : JKClass(), PsiOwner by PsiOwnerImpl() {
@@ -66,7 +66,7 @@ class JKClassImpl(
     override var classBody: JKClassBody by child(classBody)
     override var annotationList: JKAnnotationList by child(annotationList)
 
-    override var extraModifierElements by children(extraModifierElements)
+    override var otherModifierElements by children(otherModifierElements)
     override var visibilityElement by child(visibilityElement)
     override var modalityElement by child(modalityElement)
 }
@@ -636,7 +636,7 @@ class JKVisibilityModifierElementImpl(override var visibility: Visibility) : JKV
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitVisibilityModifierElement(this, data)
 }
 
-class JKExtraModifierElementImpl(override var extraModifier: ExtraModifier) : JKExtraModifierElement() {
+class JKOtherModifierElementImpl(override var otherModifier: OtherModifier) : JKOtherModifierElement() {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitExtraModifierElement(this, data)
 }
 

nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/k.kt

@@ -30,7 +30,7 @@ class JKKtPropertyImpl(
     getter: JKKtGetterOrSetter,
     setter: JKKtGetterOrSetter,
     annotationList: JKAnnotationList,
-    extraModifierElements: List<JKExtraModifierElement>,
+    otherModifierElements: List<JKOtherModifierElement>,
     visibilityElement: JKVisibilityModifierElement,
     modalityElement: JKModalityModifierElement,
     mutabilityElement: JKMutabilityModifierElement
@@ -44,7 +44,7 @@ class JKKtPropertyImpl(
     override var getter: JKKtGetterOrSetter by child(getter)
     override var setter: JKKtGetterOrSetter by child(setter)
 
-    override var extraModifierElements by children(extraModifierElements)
+    override var otherModifierElements by children(otherModifierElements)
     override var visibilityElement by child(visibilityElement)
     override var modalityElement by child(modalityElement)
     override var mutabilityElement by child(mutabilityElement)
@@ -59,7 +59,7 @@ class JKKtFunctionImpl(
     block: JKBlock,
     typeParameterList: JKTypeParameterList,
     annotationList: JKAnnotationList,
-    extraModifierElements: List<JKExtraModifierElement>,
+    otherModifierElements: List<JKOtherModifierElement>,
     visibilityElement: JKVisibilityModifierElement,
     modalityElement: JKModalityModifierElement
 ) : JKKtFunction(), PsiOwner by PsiOwnerImpl() {
@@ -73,7 +73,7 @@ class JKKtFunctionImpl(
     override var annotationList: JKAnnotationList by child(annotationList)
 
 
-    override var extraModifierElements by children(extraModifierElements)
+    override var otherModifierElements by children(otherModifierElements)
     override var visibilityElement by child(visibilityElement)
     override var modalityElement by child(modalityElement)
 }
@@ -178,7 +178,7 @@ class JKKtConstructorImpl(
     block: JKBlock,
     delegationCall: JKExpression,
     annotationList: JKAnnotationList,
-    extraModifierElements: List<JKExtraModifierElement>,
+    otherModifierElements: List<JKOtherModifierElement>,
     visibilityElement: JKVisibilityModifierElement,
     modalityElement: JKModalityModifierElement
 ) : JKKtConstructor() {
@@ -191,7 +191,7 @@ class JKKtConstructorImpl(
     override var typeParameterList: JKTypeParameterList by child(JKTypeParameterListImpl())
     override var annotationList: JKAnnotationList by child(annotationList)
 
-    override var extraModifierElements by children(extraModifierElements)
+    override var otherModifierElements by children(otherModifierElements)
     override var visibilityElement by child(visibilityElement)
     override var modalityElement by child(modalityElement)
 
@@ -203,7 +203,7 @@ class JKKtPrimaryConstructorImpl(
     parameters: List<JKParameter>,
     delegationCall: JKExpression,
     annotationList: JKAnnotationList,
-    extraModifierElements: List<JKExtraModifierElement>,
+    otherModifierElements: List<JKOtherModifierElement>,
     visibilityElement: JKVisibilityModifierElement,
     modalityElement: JKModalityModifierElement
 ) : JKKtPrimaryConstructor() {
@@ -216,7 +216,7 @@ class JKKtPrimaryConstructorImpl(
     override var typeParameterList: JKTypeParameterList by child(JKTypeParameterListImpl())
     override var annotationList: JKAnnotationList by child(annotationList)
 
-    override var extraModifierElements by children(extraModifierElements)
+    override var otherModifierElements by children(otherModifierElements)
     override var visibilityElement by child(visibilityElement)
     override var modalityElement by child(modalityElement)
 

nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/symbols.kt

@@ -56,7 +56,7 @@ abstract class JKUniverseSymbol<T : JKTreeElement> : JKNamedSymbol {
 fun JKSymbol.getDisplayName(): String {
     if (this !is JKUniverseSymbol<*>) return fqName
     return generateSequence(declaredIn as? JKUniverseClassSymbol) { symbol ->
-        symbol.declaredIn.safeAs<JKUniverseClassSymbol>()?.takeIf { !it.target.hasExtraModifier(ExtraModifier.INNER) }
+        symbol.declaredIn.safeAs<JKUniverseClassSymbol>()?.takeIf { !it.target.hasOtherModifier(OtherModifier.INNER) }
     }.fold(name) { acc, symbol -> "${symbol.name}.$acc" }
 }
 

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

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.nj2k.tree
 
 import org.jetbrains.kotlin.nj2k.tree.impl.*
 
-abstract class JKField : JKVariable(), JKVisibilityOwner, JKMutabilityOwner, JKModalityOwner, JKExtraModifiersOwner, JKAnnotationListOwner
+abstract class JKField : JKVariable(), JKVisibilityOwner, JKMutabilityOwner, JKModalityOwner, JKOtherModifiersOwner, JKAnnotationListOwner
 
 abstract class JKJavaField : JKField()
 
@@ -142,7 +142,7 @@ abstract class JKJavaSynchronizedStatement : JKStatement(), JKBranchElement {
 abstract class JKJavaAnnotationMethod : JKMethod(), JKBranchElement {
     abstract val defaultValue: JKAnnotationMemberValue
 
-    override var extraModifierElements by children<JKExtraModifierElement>()
+    override var otherModifierElements by children<JKOtherModifierElement>()
     override var visibilityElement by child(JKVisibilityModifierElementImpl(Visibility.PUBLIC))
     override var modalityElement by child(JKModalityModifierElementImpl(Modality.FINAL))
 }

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

@@ -58,7 +58,7 @@ interface JKFile : JKTreeElement, JKBranchElement {
     var declarationList: List<JKDeclaration>
 }
 
-abstract class JKClass : JKDeclaration(), JKVisibilityOwner, JKExtraModifiersOwner, JKModalityOwner, JKTypeParameterListOwner,
+abstract class JKClass : JKDeclaration(), JKVisibilityOwner, JKOtherModifiersOwner, JKModalityOwner, JKTypeParameterListOwner,
     JKAnnotationListOwner,
     JKBranchElement {
     abstract val name: JKNameIdentifier
@@ -109,7 +109,7 @@ interface JKAnnotationListOwner : JKTreeElement {
     var annotationList: JKAnnotationList
 }
 
-abstract class JKMethod : JKDeclaration(), JKVisibilityOwner, JKModalityOwner, JKExtraModifiersOwner, JKTypeParameterListOwner,
+abstract class JKMethod : JKDeclaration(), JKVisibilityOwner, JKModalityOwner, JKOtherModifiersOwner, JKTypeParameterListOwner,
     JKAnnotationListOwner {
     abstract val name: JKNameIdentifier
     abstract var parameters: List<JKParameter>
@@ -138,7 +138,7 @@ val JKModifierElement.modifier: Modifier
         is JKMutabilityModifierElement -> mutability
         is JKModalityModifierElement -> modality
         is JKVisibilityModifierElement -> visibility
-        is JKExtraModifierElement -> extraModifier
+        is JKOtherModifierElement -> otherModifier
         else -> error("")
     }
 
@@ -154,25 +154,26 @@ abstract class JKVisibilityModifierElement : JKModifierElement() {
     abstract var visibility: Visibility
 }
 
-abstract class JKExtraModifierElement : JKModifierElement() {
+abstract class JKOtherModifierElement : JKModifierElement() {
-    abstract var extraModifier: ExtraModifier
+    abstract var otherModifier: OtherModifier
 }
 
 interface Modifier {
     val text: String
 }
 
-interface JKExtraModifiersOwner : JKModifiersListOwner {
+interface JKOtherModifiersOwner : JKModifiersListOwner {
-    var extraModifierElements: List<JKExtraModifierElement>
+    var otherModifierElements: List<JKOtherModifierElement>
 }
 
-fun JKExtraModifiersOwner.elementByModifier(modifier: ExtraModifier): JKExtraModifierElement? =
+fun JKOtherModifiersOwner.elementByModifier(modifier: OtherModifier): JKOtherModifierElement? =
-    extraModifierElements.firstOrNull { it.extraModifier == modifier }
+    otherModifierElements.firstOrNull { it.otherModifier == modifier }
 
-fun JKExtraModifiersOwner.hasExtraModifier(modifier: ExtraModifier): Boolean =
+fun JKOtherModifiersOwner.hasOtherModifier(modifier: OtherModifier): Boolean =
-    extraModifierElements.any { it.extraModifier == modifier }
+    otherModifierElements.any { it.otherModifier == modifier }
 
-enum class ExtraModifier(override val text: String) : Modifier {
+enum class OtherModifier(override val text: String) : Modifier {
+    OVERRIDE("override"),
     ACTUAL("actual"),
     ANNOTATION("annotation"),
     COMPANION("companion"),
@@ -228,7 +229,6 @@ enum class Modality(override val text: String) : Modifier {
     OPEN("open"),
     FINAL("final"),
     ABSTRACT("abstract"),
-    OVERRIDE("override")
 }
 
 var JKModalityOwner.modality: Modality
@@ -257,7 +257,7 @@ interface JKModifiersListOwner : JKTreeElement
 
 fun JKModifiersListOwner.modifierElements(): List<JKModifierElement> =
     listOfNotNull((this as? JKVisibilityOwner)?.visibilityElement) +
-            (this as? JKExtraModifiersOwner)?.extraModifierElements.orEmpty() +
+            (this as? JKOtherModifiersOwner)?.otherModifierElements.orEmpty() +
             listOfNotNull((this as? JKModalityOwner)?.modalityElement) +
             listOfNotNull((this as? JKMutabilityOwner)?.mutabilityElement)
 

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

@@ -35,7 +35,7 @@ abstract class JKKtProperty : JKField(), PsiOwner {
 
 abstract class JKKtFunction : JKMethod(), PsiOwner
 
-abstract class JKKtConstructor : JKMethod(), JKExtraModifiersOwner {
+abstract class JKKtConstructor : JKMethod(), JKOtherModifiersOwner {
     abstract var delegationCall: JKExpression
 }
 

nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitor.kt

@@ -32,11 +32,11 @@ interface JKVisitor<out R, in D> {
     fun visitVisibilityModifierElement(visibilityModifierElement: JKVisibilityModifierElement, data: D): R =
         visitModifierElement(visibilityModifierElement, data)
 
-    fun visitExtraModifierElement(extraModifierElement: JKExtraModifierElement, data: D): R =
+    fun visitExtraModifierElement(otherModifierElement: JKOtherModifierElement, data: D): R =
-        visitModifierElement(extraModifierElement, data)
+        visitModifierElement(otherModifierElement, data)
 
-    fun visitExtraModifiersOwner(extraModifiersOwner: JKExtraModifiersOwner, data: D): R =
+    fun visitExtraModifiersOwner(otherModifiersOwner: JKOtherModifiersOwner, data: D): R =
-        visitModifiersListOwner(extraModifiersOwner, data)
+        visitModifiersListOwner(otherModifiersOwner, data)
 
     fun visitVisibilityOwner(visibilityOwner: JKVisibilityOwner, data: D): R = visitModifiersListOwner(visibilityOwner, data)
     fun visitModalityOwner(modalityOwner: JKModalityOwner, data: D): R = visitModifiersListOwner(modalityOwner, data)

nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitorVoid.kt

@@ -65,13 +65,13 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitVisibilityModifierElement(visibilityModifierElement: JKVisibilityModifierElement, data: Nothing?) =
         visitVisibilityModifierElement(visibilityModifierElement)
 
-    fun visitExtraModifierElement(extraModifierElement: JKExtraModifierElement) = visitModifierElement(extraModifierElement, null)
+    fun visitExtraModifierElement(otherModifierElement: JKOtherModifierElement) = visitModifierElement(otherModifierElement, null)
-    override fun visitExtraModifierElement(extraModifierElement: JKExtraModifierElement, data: Nothing?) =
+    override fun visitExtraModifierElement(otherModifierElement: JKOtherModifierElement, data: Nothing?) =
-        visitExtraModifierElement(extraModifierElement)
+        visitExtraModifierElement(otherModifierElement)
 
-    fun visitExtraModifiersOwner(extraModifiersOwner: JKExtraModifiersOwner) = visitModifiersListOwner(extraModifiersOwner, null)
+    fun visitExtraModifiersOwner(otherModifiersOwner: JKOtherModifiersOwner) = visitModifiersListOwner(otherModifiersOwner, null)
-    override fun visitExtraModifiersOwner(extraModifiersOwner: JKExtraModifiersOwner, data: Nothing?) =
+    override fun visitExtraModifiersOwner(otherModifiersOwner: JKOtherModifiersOwner, data: Nothing?) =
-        visitExtraModifiersOwner(extraModifiersOwner)
+        visitExtraModifiersOwner(otherModifiersOwner)
 
     fun visitVisibilityOwner(visibilityOwner: JKVisibilityOwner) = visitModifiersListOwner(visibilityOwner, null)
     override fun visitVisibilityOwner(visibilityOwner: JKVisibilityOwner, data: Nothing?) = visitVisibilityOwner(visibilityOwner)

nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitorWithCommentsPrinting.kt

@@ -178,21 +178,21 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
     fun visitVisibilityModifierElementRaw(visibilityModifierElement: JKVisibilityModifierElement) =
         visitModifierElementRaw(visibilityModifierElement)
 
-    override fun visitExtraModifierElement(extraModifierElement: JKExtraModifierElement) {
+    override fun visitExtraModifierElement(otherModifierElement: JKOtherModifierElement) {
-        printLeftNonCodeElements(extraModifierElement)
+        printLeftNonCodeElements(otherModifierElement)
-        visitExtraModifierElementRaw(extraModifierElement)
+        visitExtraModifierElementRaw(otherModifierElement)
-        printRightNonCodeElements(extraModifierElement)
+        printRightNonCodeElements(otherModifierElement)
     }
 
-    fun visitExtraModifierElementRaw(extraModifierElement: JKExtraModifierElement) = visitModifierElementRaw(extraModifierElement)
+    fun visitExtraModifierElementRaw(otherModifierElement: JKOtherModifierElement) = visitModifierElementRaw(otherModifierElement)
 
-    override fun visitExtraModifiersOwner(extraModifiersOwner: JKExtraModifiersOwner) {
+    override fun visitExtraModifiersOwner(otherModifiersOwner: JKOtherModifiersOwner) {
-        printLeftNonCodeElements(extraModifiersOwner)
+        printLeftNonCodeElements(otherModifiersOwner)
-        visitExtraModifiersOwnerRaw(extraModifiersOwner)
+        visitExtraModifiersOwnerRaw(otherModifiersOwner)
-        printRightNonCodeElements(extraModifiersOwner)
+        printRightNonCodeElements(otherModifiersOwner)
     }
 
-    fun visitExtraModifiersOwnerRaw(extraModifiersOwner: JKExtraModifiersOwner) = visitModifiersListOwnerRaw(extraModifiersOwner)
+    fun visitExtraModifiersOwnerRaw(otherModifiersOwner: JKOtherModifiersOwner) = visitModifiersListOwnerRaw(otherModifiersOwner)
 
     override fun visitVisibilityOwner(visibilityOwner: JKVisibilityOwner) {
         printLeftNonCodeElements(visibilityOwner)

nj2k/testData/newJ2k/comments/comments2.kt

@@ -13,9 +13,9 @@ internal class A {
     fun /* we return int*/ foo(  /*int*/ p: Int/* parameter p */): Int { /* body is empty */
     }
 
-    private/*it's private*/ val field = 0
+    private/*it's private*/  val field = 0
-    /*it's public*/ fun foo(s: String?): Char {}
+    /*it's public*/  fun foo(s: String?): Char {}
-    protected/*it's protected*/ fun foo(c: Char) {}
+    protected/*it's protected*/  fun foo(c: Char) {}
     /**
      * Method description.
      * Multi-line method description.
@@ -29,6 +29,6 @@ internal class A {
     fun foo(param1: String?, param2: String?, param3: String?) {}
 
     companion object {
-        /*it's public*/const /*and static*/ val/*and final*/ C = 1
+        /*it's public*/  /*and static*/ const val/*and final*/ C = 1
     }
 }

nj2k/testData/newJ2k/detectProperties/Comments.kt

@@ -1,7 +1,7 @@
 internal class A(// comment for field2 setter
         // comment for field2 getter
-        // comment for field2
+        var field2 // comment for field2
-        var field2: Int) {
+        : Int) {
     /**
      * Comment for field1 setter
      */

nj2k/testData/newJ2k/function/override.kt

@@ -3,5 +3,5 @@ internal open class A {
 }
 
 internal class B : A() {
-    override fun a() {}
+    public override fun a() {}
 }

nj2k/testData/newJ2k/function/overrideAndOpen.kt

@@ -3,7 +3,7 @@ internal open class A {
 }
 
 internal open class B : A() {
-    override fun foo() {}
+    public override fun foo() {}
 }
 
 internal class C : B() {

nj2k/testData/newJ2k/inheritance/openModifier.kt

@@ -31,9 +31,8 @@ internal abstract class E {
 }
 
 internal class F : E() {
-    override fun f1() {}
+    public override fun f1() {}
-
+    public override fun f2() {
-    override fun f2() {
         super.f2()
     }
 }

nj2k/testData/newJ2k/issues/kt-836.kt

@@ -16,7 +16,7 @@ internal open class Base {
 }
 
 internal class Child : Base() {
-    override fun test() {}
+    public override fun test() {}
     override fun toString(): String {
         return "Child"
     }

nj2k/testData/newJ2k/superExpression/classAextendsB.kt

@@ -5,8 +5,7 @@ internal open class B(i: Int) {
 }
 
 internal class A : B(10) {
-
+    public override fun call(): Int {
-    override fun call(): Int {
         return super.call()
     }
 }