New J2K: Standardize modality and visibility

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

@@ -11,6 +11,9 @@ import org.jetbrains.kotlin.j2k.tree.JKElement
 
 data class ConversionContext(
     val symbolProvider: JKSymbolProvider,
-    val project: Project,
+    val converter: NewJavaToKotlinConverter,
     val backAnnotator: (JKElement) -> PsiElement?
-)
+) {
+
+    val project: Project get() = converter.project
+}

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

@@ -24,6 +24,7 @@ object ConversionsRunner {
     fun doApply(trees: List<JKTreeElement>, context: ConversionContext) {
 
         trees.forEach {
+            ModalityConversion(context).runConversion(it, context)
             FieldToPropertyConversion().runConversion(it, context)
             TypeMappingConversion(context).runConversion(it, context)
             AssignmentAsExpressionToAlsoConversion(context).runConversion(it, context)

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

@@ -324,18 +324,43 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) {
     }
 
     private inner class ModifierMapper {
-        fun PsiModifierList?.toJK(): JKModifierList = JKModifierListImpl(
+        fun PsiModifierList?.toJK(): JKModifierList {
-            if (this == null) emptyList()
-            else PsiModifier.MODIFIERS.filter { hasExplicitModifier(it) }.map { modifierToJK(it) }.toMutableList()
-        )
 
-        fun modifierToJK(name: String): JKModifier = when (name) {
+            val modifiers = if (this == null) mutableListOf()
-            PsiModifier.PUBLIC -> JKJavaAccessModifierImpl(JKJavaAccessModifier.AccessModifierType.PUBLIC)
+            else PsiModifier.MODIFIERS.filter { hasExplicitModifier(it) }.mapNotNull { modifierToJK(it) }.toMutableList()
-            PsiModifier.PRIVATE -> JKJavaAccessModifierImpl(JKJavaAccessModifier.AccessModifierType.PRIVATE)
-            PsiModifier.PROTECTED -> JKJavaAccessModifierImpl(JKJavaAccessModifier.AccessModifierType.PROTECTED)
 
-            PsiModifier.ABSTRACT -> JKJavaModifierImpl(JKJavaModifier.JavaModifierType.ABSTRACT)
+            modifiers += extractAccess()
-            PsiModifier.FINAL -> JKJavaModifierImpl(JKJavaModifier.JavaModifierType.FINAL)
+            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): JKModifier? = when (name) {
             PsiModifier.NATIVE -> JKJavaModifierImpl(JKJavaModifier.JavaModifierType.NATIVE)
             PsiModifier.STATIC -> JKJavaModifierImpl(JKJavaModifier.JavaModifierType.STATIC)
             PsiModifier.STRICTFP -> JKJavaModifierImpl(JKJavaModifier.JavaModifierType.STRICTFP)
@@ -343,8 +368,16 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) {
             PsiModifier.TRANSIENT -> JKJavaModifierImpl(JKJavaModifier.JavaModifierType.TRANSIENT)
             PsiModifier.VOLATILE -> JKJavaModifierImpl(JKJavaModifier.JavaModifierType.VOLATILE)
 
+            PsiModifier.PROTECTED -> null
+            PsiModifier.PUBLIC -> null
+            PsiModifier.PRIVATE -> null
+
+            PsiModifier.FINAL -> null
+            PsiModifier.ABSTRACT -> null
+
             else -> TODO("Not yet supported")
         }
+
     }
 
     private inner class ElementVisitor : JavaElementVisitor() {

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

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.j2k.ast.Nullability
 import org.jetbrains.kotlin.j2k.tree.*
 import org.jetbrains.kotlin.j2k.tree.impl.JKBodyStub
 import org.jetbrains.kotlin.j2k.tree.impl.JKClassSymbol
+import org.jetbrains.kotlin.j2k.tree.impl.modality
 import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitorVoid
 import org.jetbrains.kotlin.lexer.KtSingleValueToken
 import org.jetbrains.kotlin.name.FqName
@@ -60,6 +61,28 @@ class NewCodeBuilder {
             }
         }
 
+        override fun visitAccessModifier(accessModifier: JKAccessModifier) {
+            printer.printWithNoIndent(
+                when (accessModifier.visibility) {
+                    JKAccessModifier.Visibility.PUBLIC -> "public"
+                    JKAccessModifier.Visibility.PACKAGE_PRIVATE, JKAccessModifier.Visibility.INTERNAL -> "internal"
+//                    JKAccessModifier.Visibility.PACKAGE_PRIVATE -> "internal /* package_local! */"
+                    JKAccessModifier.Visibility.PROTECTED -> "protected"
+                    JKAccessModifier.Visibility.PRIVATE -> "private"
+                }
+            )
+        }
+
+        override fun visitModalityModifier(modalityModifier: JKModalityModifier) {
+            printer.printWithNoIndent(
+                when (modalityModifier.modality) {
+                    JKModalityModifier.Modality.OPEN -> "open"
+                    JKModalityModifier.Modality.FINAL -> "final"
+                    JKModalityModifier.Modality.ABSTRACT -> "abstract"
+                }
+            )
+        }
+
         override fun visitKtModifier(ktModifier: JKKtModifier) {
             printer.printWithNoIndent(
                 when (ktModifier.type) {
@@ -90,8 +113,8 @@ class NewCodeBuilder {
         }
 
         override fun visitKtProperty(ktProperty: JKKtProperty) {
-            // TODO: Fix this
+            // TODO: Fix this, as Modality is not mutability
-            if (ktProperty.modifierList.modifiers.any { (it as? JKJavaModifier)?.type == JKJavaModifier.JavaModifierType.FINAL }) {
+            if (ktProperty.modifierList.modality == JKModalityModifier.Modality.FINAL) {
                 printer.print("val")
             } else {
                 printer.print("var")
@@ -174,7 +197,7 @@ class NewCodeBuilder {
         }
 
         override fun visitLocalVariable(localVariable: JKLocalVariable) {
-            if (localVariable.modifierList.modifiers.any { (it as? JKJavaModifier)?.type == JKJavaModifier.JavaModifierType.FINAL }) {
+            if (localVariable.modifierList.modality == JKModalityModifier.Modality.FINAL) {
                 printer.print("val")
             } else {
                 printer.print("var")

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

@@ -24,8 +24,9 @@ import org.jetbrains.kotlin.j2k.tree.JKTreeElement
 import org.jetbrains.kotlin.j2k.tree.prettyDebugPrintTree
 
 class NewJavaToKotlinConverter(
-    private val project: Project,
+    val project: Project,
-    private val settings: ConverterSettings
+    val settings: ConverterSettings,
+    val converterServices: NewJavaToKotlinServices
 ) {
 
     private fun List<JKTreeElement>.prettyPrintTrees() = buildString {
@@ -46,7 +47,7 @@ class NewJavaToKotlinConverter(
 
         val context = ConversionContext(
             symbolProvider,
-            project
+            this
         ) { treeBuilder.backAnnotation[it] }
 
         ConversionsRunner.doApply(fileTrees, context)

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

@@ -0,0 +1,34 @@
+/*
+ * 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 com.intellij.psi.PsiClass
+import org.jetbrains.kotlin.j2k.ConversionContext
+import org.jetbrains.kotlin.j2k.tree.JKClass
+import org.jetbrains.kotlin.j2k.tree.JKModalityModifier
+import org.jetbrains.kotlin.j2k.tree.JKTreeElement
+import org.jetbrains.kotlin.j2k.tree.impl.modality
+
+class ModalityConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+
+
+    override fun applyToElement(element: JKTreeElement): JKTreeElement {
+        if (element is JKClass) {
+            processClass(element)
+        }
+        return recurse(element)
+    }
+
+    private fun processClass(klass: JKClass) {
+        if (klass.classKind != JKClass.ClassKind.CLASS) return
+        if (klass.modifierList.modality != JKModalityModifier.Modality.OPEN) return
+        if (context.converter.settings.openByDefault) return
+        if (!context.converter.converterServices.oldServices.referenceSearcher.hasInheritors(context.backAnnotator(klass) as PsiClass)) {
+            klass.modifierList.modality = JKModalityModifier.Modality.FINAL
+        }
+    }
+
+}

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

@@ -15,38 +15,16 @@ class ModifiersConversion : RecursiveApplicableConversionBase() {
             element.also {
                 var modifiers = it.modifierList.modifiers
                 if (element !is JKField) {
-                    if (!modifiers.any { it is JKJavaModifier && it.type == JKJavaModifier.JavaModifierType.FINAL }) {
-                        modifiers += JKKtModifierImpl(JKKtModifier.KtModifierType.OPEN)
-                    }
                     modifiers = mapOtherModifiers(modifiers)
                 }
-                if (!modifiers.any { it is JKJavaAccessModifier }) {
+                it.modifierList.modifiers = modifiers
-                    modifiers += JKKtModifierImpl(JKKtModifier.KtModifierType.INTERNAL)
-                }
-                it.modifierList.modifiers = mapAccessModifiers(modifiers)
             } else recurse(element)
     }
 
-    private fun mapAccessModifiers(modifiers: List<JKModifier>): List<JKModifier> {
-        return modifiers.mapNotNull {
-            when (it) {
-                is JKJavaAccessModifier -> when (it.type) {
-                    JKJavaAccessModifier.AccessModifierType.PUBLIC -> null
-                    JKJavaAccessModifier.AccessModifierType.PRIVATE -> JKKtModifierImpl(JKKtModifier.KtModifierType.PRIVATE)
-                    JKJavaAccessModifier.AccessModifierType.PROTECTED -> JKKtModifierImpl(JKKtModifier.KtModifierType.PROTECTED)
-                }
-                else -> it
-            }
-        }
-    }
-
-
     private fun mapOtherModifiers(modifiers: List<JKModifier>): List<JKModifier> {
-        return modifiers.mapNotNull {
+        return modifiers.map {
             when (it) {
                 is JKJavaModifier -> when (it.type) {
-                    JKJavaModifier.JavaModifierType.ABSTRACT -> JKKtModifierImpl(JKKtModifier.KtModifierType.ABSTRACT)
-                    JKJavaModifier.JavaModifierType.FINAL -> null
                     JKJavaModifier.JavaModifierType.NATIVE -> JKKtModifierImpl(JKKtModifier.KtModifierType.EXTERNAL)
                     else -> it
                 }

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

@@ -36,10 +36,6 @@ private class DebugTreePrinter : JKVisitorVoid {
         printer.println(javaModifier.classNameWithoutJK(), "(", javaModifier.type, ")")
     }
 
-    override fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier) {
-        printer.println(javaAccessModifier.classNameWithoutJK(), "(", javaAccessModifier.type, ")")
-    }
-
     override fun visitJavaMethod(javaMethod: JKJavaMethod) {
         printer.println(javaMethod.classNameWithoutJK(), " [")
         printer.indented {

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

@@ -58,10 +58,6 @@ class JKJavaLiteralExpressionImpl(
     }
 }
 
-class JKJavaAccessModifierImpl(override val type: JKJavaAccessModifier.AccessModifierType) : JKJavaAccessModifier, JKElementBase() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaAccessModifier(this, data)
-}
-
 class JKJavaModifierImpl(override val type: JKJavaModifier.JavaModifierType) : JKJavaModifier, JKElementBase() {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaModifier(this, data)
 }

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

@@ -52,6 +52,20 @@ class JKModifierListImpl(
     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)
+    }
+
+
 class JKParameterImpl(
     type: JKTypeElement,
     name: JKNameIdentifier,
@@ -285,4 +299,12 @@ class JKIfElseExpressionImpl(condition: JKExpression, thenBranch: JKExpression,
 
 class JKClassAccessExpressionImpl(override var identifier: JKClassSymbol) : JKClassAccessExpression, JKElementBase() {
     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() {
+    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() {
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitAccessModifier(this, data)
 }

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

@@ -43,19 +43,11 @@ interface JKJavaDefaultNewExpression : JKExpression {
     val classSymbol: JKClassSymbol
 }
 
-interface JKJavaAccessModifier : JKAccessModifier {
-    val type: AccessModifierType
-
-    enum class AccessModifierType {
-        PUBLIC, PROTECTED, PRIVATE
-    }
-}
-
 interface JKJavaModifier : JKModifier {
     val type: JavaModifierType
 
     enum class JavaModifierType {
-        ABSTRACT, FINAL, NATIVE, STATIC, STRICTFP, SYNCHRONIZED, TRANSIENT, VOLATILE
+        NATIVE, STATIC, STRICTFP, SYNCHRONIZED, TRANSIENT, VOLATILE
     }
 }
 

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

@@ -67,9 +67,21 @@ interface JKModifierList : JKTreeElement {
     var modifiers: List<JKModifier>
 }
 
-interface JKAccessModifier : JKModifier
+interface JKAccessModifier : JKModifier {
+    enum class Visibility {
+        PUBLIC, INTERNAL, PACKAGE_PRIVATE, PROTECTED, PRIVATE
+    }
 
-interface JKModalityModifier : JKModifier
+    val visibility: Visibility
+}
+
+interface JKModalityModifier : JKModifier {
+    enum class Modality {
+        OPEN, FINAL, ABSTRACT
+    }
+
+    val modality: Modality
+}
 
 interface JKTypeElement : JKTreeElement {
     val type: JKType

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

@@ -58,7 +58,6 @@ interface JKVisitor<out R, in D> {
     fun visitJavaFieldAccessExpression(javaFieldAccessExpression: JKJavaFieldAccessExpression, data: D): R = visitFieldAccessExpression(javaFieldAccessExpression, data)
     fun visitJavaNewExpression(javaNewExpression: JKJavaNewExpression, data: D): R = visitExpression(javaNewExpression, data)
     fun visitJavaDefaultNewExpression(javaDefaultNewExpression: JKJavaDefaultNewExpression, data: D): R = visitExpression(javaDefaultNewExpression, data)
-    fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier, data: D): R = visitAccessModifier(javaAccessModifier, 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)

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

@@ -113,8 +113,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 visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier) = visitAccessModifier(javaAccessModifier, null)
-    override fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier, data: Nothing?) = visitJavaAccessModifier(javaAccessModifier)
     fun visitJavaModifier(javaModifier: JKJavaModifier) = visitModifier(javaModifier, null)
     override fun visitJavaModifier(javaModifier: JKJavaModifier, data: Nothing?) = visitJavaModifier(javaModifier)
     fun visitJavaNewEmptyArray(javaNewEmptyArray: JKJavaNewEmptyArray) = visitExpression(javaNewEmptyArray, null)