New J2K: Type system refactored, parents from types removed, added JKTypeElement

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

@@ -186,8 +186,8 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) {
             return JKExpressionListImpl(this?.expressions?.map { it.toJK() } ?: emptyList())
         }
 
-        fun PsiTypeElement.toJK(): JKType {
+        fun PsiTypeElement.toJK(): JKTypeElement {
-            return type.toJK().also {
+            return JKTypeElementImpl(type.toJK()).also {
                 backAnnotation[it] = this
             }
         }

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

@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.j2k.tree.JKJavaMethod
 import org.jetbrains.kotlin.j2k.tree.JKTreeElement
 import org.jetbrains.kotlin.j2k.tree.impl.JKJavaPrimitiveTypeImpl
 import org.jetbrains.kotlin.j2k.tree.impl.JKKtFunctionImpl
+import org.jetbrains.kotlin.j2k.tree.impl.JKTypeElementImpl
 
 class JavaMethodToKotlinFunctionConversion : TransformerBasedConversion() {
     override fun visitTreeElement(element: JKTreeElement) {
@@ -31,7 +32,7 @@ class JavaMethodToKotlinFunctionConversion : TransformerBasedConversion() {
         somethingChanged = true
         klass.declarationList = klass.declarationList.map {
             if (it is JKJavaMethod) JKKtFunctionImpl(
-                JKJavaPrimitiveTypeImpl.BOOLEAN,
+                JKTypeElementImpl(JKJavaPrimitiveTypeImpl.BOOLEAN),
                 it.name,
                 it.valueArguments,
                 it.block,

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

@@ -8,12 +8,10 @@ package org.jetbrains.kotlin.j2k.conversions
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.j2k.ConversionContext
 import org.jetbrains.kotlin.j2k.ast.Nullability
-import org.jetbrains.kotlin.j2k.tree.JKClassType
+import org.jetbrains.kotlin.j2k.tree.*
-import org.jetbrains.kotlin.j2k.tree.JKJavaPrimitiveType
-import org.jetbrains.kotlin.j2k.tree.JKTreeElement
-import org.jetbrains.kotlin.j2k.tree.JKType
 import org.jetbrains.kotlin.j2k.tree.impl.JKClassSymbol
 import org.jetbrains.kotlin.j2k.tree.impl.JKClassTypeImpl
+import org.jetbrains.kotlin.j2k.tree.impl.JKTypeElementImpl
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
@@ -40,11 +38,14 @@ class TypeMappingConversion(val context: ConversionContext) : MatchBasedConversi
 
 
     fun applyToElement(element: JKTreeElement): JKTreeElement {
-        return when (element) {
+        return if (element is JKTypeElement) {
-            is JKJavaPrimitiveType -> mapPrimitiveType(element)
+            val type = element.type
-            is JKClassType -> mapClassType(element)
+            when (type) {
-            else -> applyRecursive(element, this::applyToElement)
+                is JKJavaPrimitiveType -> mapPrimitiveType(type, element)
-        }
+                is JKClassType -> mapClassType(type, element)
+                else -> applyRecursive(element, this::applyToElement)
+            }
+        } else applyRecursive(element, this::applyToElement)
     }
 
     private fun resolveFqName(classId: ClassId, element: PsiElement): PsiElement? {
@@ -70,17 +71,20 @@ class TypeMappingConversion(val context: ConversionContext) : MatchBasedConversi
         return JKClassTypeImpl(context.symbolProvider.provideSymbol(newTarget) as JKClassSymbol, parameters, nullability)
     }
 
-    fun mapClassType(type: JKClassType): JKType {
+    fun mapClassType(type: JKClassType, typeElement: JKTypeElement): JKTypeElement {
-        val fqNameStr = (type.classReference as? JKClassSymbol)?.fqName ?: return type
+        val fqNameStr = (type.classReference as? JKClassSymbol)?.fqName ?: return typeElement
 
-        val newFqName = JavaToKotlinClassMap.mapJavaToKotlin(FqName(fqNameStr)) ?: return type
+        val newFqName = JavaToKotlinClassMap.mapJavaToKotlin(FqName(fqNameStr)) ?: return typeElement
 
-        return classTypeByFqName(context.backAnnotator(type), newFqName, type.parameters, type.nullability) ?: type
+        return classTypeByFqName(context.backAnnotator(typeElement), newFqName, type.parameters, type.nullability)?.let {
+            JKTypeElementImpl(it)
+        } ?: typeElement
     }
 
-    fun mapPrimitiveType(type: JKJavaPrimitiveType): JKType {
+    fun mapPrimitiveType(type: JKJavaPrimitiveType, typeElement: JKTypeElement): JKTypeElement {
         val fqName = JvmPrimitiveType.get(type.name).primitiveType.typeFqName
 
-        return classTypeByFqName(context.backAnnotator(type), ClassId.topLevel(fqName), emptyList()) ?: type
+        return classTypeByFqName(context.backAnnotator(typeElement), ClassId.topLevel(fqName), emptyList())?.let { JKTypeElementImpl(it) }
+                ?: typeElement
     }
 }

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

@@ -74,15 +74,13 @@ private class DebugTreePrinter : JKVisitorVoid {
         printer.println("]")
     }
 
-    override fun visitType(type: JKType) {
+    override fun visitTypeElement(typeElement: JKTypeElement) {
+        val type = typeElement.type
         printer.println(type.classNameWithoutJK(), " \"")
         printer.indented {
             if (type is JKClassType) {
                 printer.println((type.classReference as? JKClassSymbol)?.fqName ?: type.classReference?.let { it::class } ?: "Unbound")
             }
-            if (type is JKJavaArrayType) {
-                type.type.accept(this, null)
-            }
             if (type is JKJavaPrimitiveType) {
                 printer.println(type.name)
             }

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

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor
 
 class JKJavaFieldImpl(
     modifierList: JKModifierList,
-    type: JKType,
+    type: JKTypeElement,
     name: JKNameIdentifier,
     initializer: JKExpression
 ) : JKJavaField, JKBranchElementBase() {
@@ -32,9 +32,23 @@ class JKJavaFieldImpl(
 
     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)
-    override var type: JKType by child(type)
+}
 
+class JKJavaMethodImpl(
+    override var modifierList: JKModifierList,
+    override var name: JKNameIdentifier,
+    override var valueArguments: List<JKValueArgument>,
+    override var block: JKBlock
+) : JKJavaMethod, JKElementBase() {
+    override val returnType: JKTypeElement
+        get() = TODO()
+
+    override val valid: Boolean
+        get() = true
+
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaMethod(this, data)
 }
 
 class JKJavaLiteralExpressionImpl(
@@ -52,27 +66,12 @@ class JKJavaModifierImpl(override val type: JKJavaModifier.JavaModifierType) : J
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaModifier(this, data)
 }
 
-class JKJavaMethodImpl(
+sealed class JKJavaOperatorImpl : JKOperator {
-    override var modifierList: JKModifierList,
-    override var name: JKNameIdentifier,
-    override var valueArguments: List<JKValueArgument>,
-    override var block: JKBlock
-) : JKJavaMethod, JKElementBase() {
-    override val returnType: JKType
-        get() = TODO()
-
-    override val valid: Boolean
-        get() = true
-
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaMethod(this, data)
-}
-
-sealed class JKJavaOperatorImpl : JKOperator, JKElementBase() {
     object PLUS : JKJavaOperatorImpl()
     object MINUS : JKJavaOperatorImpl()
 }
 
-sealed class JKJavaQualifierImpl : JKQualifier, JKElementBase() {
+sealed class JKJavaQualifierImpl : JKQualifier {
     object DOT : JKJavaQualifierImpl()
 }
 
@@ -80,18 +79,10 @@ class JKJavaMethodCallExpressionImpl(
     override var identifier: JKMethodSymbol, override var arguments: JKExpressionList
 ) : JKJavaMethodCallExpression, JKElementBase() {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaMethodCallExpression(this, data)
-
-    override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
-        arguments.accept(visitor, data)
-    }
 }
 
 class JKJavaFieldAccessExpressionImpl(override var identifier: JKFieldSymbol) : JKJavaFieldAccessExpression, JKElementBase() {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaFieldAccessExpression(this, data)
-
-    override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
-
-    }
 }
 
 class JKJavaNewExpressionImpl(
@@ -105,37 +96,19 @@ class JKJavaNewExpressionImpl(
 
 class JKJavaNewEmptyArrayImpl(override var initializer: List<JKLiteralExpression?>) : JKJavaNewEmptyArray, JKElementBase() {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaNewEmptyArray(this, data)
-
-    override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
-
-    }
 }
 
 class JKJavaNewArrayImpl(override var initializer: List<JKExpression>) : JKJavaNewArray, JKElementBase() {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaNewArray(this, data)
-
-    override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
-
-    }
 }
 
-sealed class JKJavaPrimitiveTypeImpl(override val name: String) : JKJavaPrimitiveType, JKElementBase() {
+sealed class JKJavaPrimitiveTypeImpl(override val name: String) : JKJavaPrimitiveType {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaPrimitiveType(this, data)
-
-    override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
-
-    }
-
     object BYTE : JKJavaPrimitiveTypeImpl("byte")
     object BOOLEAN : JKJavaPrimitiveTypeImpl("boolean")
     object INT : JKJavaPrimitiveTypeImpl("int")
 }
 
-class JKJavaArrayTypeImpl(type: JKType) : JKJavaArrayType, JKBranchElementBase() {
+class JKJavaArrayTypeImpl(override val type: JKType) : JKJavaArrayType
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaArrayType(this, data)
-
-    override val type: JKType by child(type)
-}
 
 class JKReturnStatementImpl(expression: JKExpression) : JKBranchElementBase(), JKReturnStatement {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitReturnStatement(this, data)

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

@@ -127,7 +127,7 @@ class JKModifierListImpl(modifiers: List<JKModifier> = emptyList()) : JKModifier
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitModifierList(this, data)
 }
 
-class JKValueArgumentImpl(type: JKType, override val name: String) : JKValueArgument, JKBranchElementBase() {
+class JKValueArgumentImpl(type: JKTypeElement, override val name: String) : JKValueArgument, JKBranchElementBase() {
     override var type by child(type)
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitValueArgument(this, data)
 }
@@ -144,8 +144,7 @@ class JKBinaryExpressionImpl(left: JKExpression, right: JKExpression, override v
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitBinaryExpression(this, data)
 }
 
-class JKPrefixExpressionImpl(expression: JKExpression, operator: JKOperator) : JKPrefixExpression, JKBranchElementBase() {
+class JKPrefixExpressionImpl(expression: JKExpression, override var operator: JKOperator) : JKPrefixExpression, JKBranchElementBase() {
-    override var operator by child(operator)
     override var expression by child(expression)
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitPrefixExpression(this, data)
 }
@@ -192,25 +191,18 @@ class JKParenthesizedExpressionImpl(override var expression: JKExpression) : JKP
 
 }
 
-class JKTypeCastExpressionImpl(override var expression: JKExpression, override var type: JKType) : JKTypeCastExpression,
+class JKTypeCastExpressionImpl(override var expression: JKExpression, type: JKTypeElement) : JKTypeCastExpression,
     JKBranchElementBase() {
+    override var type by child(type)
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitTypeCastExpression(this, data)
-
-    override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
-        expression.accept(visitor, data)
-        type.accept(visitor, data)
-    }
 }
 
+class JKTypeElementImpl(override val type: JKType) : JKTypeElement, JKElementBase()
+
 class JKClassTypeImpl(
     override val classReference: JKClassSymbol,
-    parameters: List<JKType>,
+    override var parameters: List<JKType>,
     override val nullability: Nullability = Nullability.Default
-) : JKClassType, JKBranchElementBase() {
+) : JKClassType
-
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitClassType(this, data)
-
-    override var parameters: List<JKType> by children(parameters)
-}
 
 class JKNullLiteral : JKExpression, JKElementBase()

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

@@ -21,19 +21,18 @@ import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor
 
 class JKKtPropertyImpl(
     modifierList: JKModifierList,
-    type: JKType,
+    type: JKTypeElement,
     name: JKNameIdentifier,
     initializer: JKExpression,
     getter: JKBlock,
     setter: JKBlock
 ) : JKBranchElementBase(), JKKtProperty {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtProperty(this, data)
-
     override val valid: Boolean
         get() = true
 
     override var modifierList: JKModifierList by child(modifierList)
-    override var type: JKType by child(type)
+    override var type by child(type)
     override var name: JKNameIdentifier by child(name)
     override val initializer: JKExpression by child(initializer)
     override val getter: JKBlock by child(getter)
@@ -41,7 +40,7 @@ class JKKtPropertyImpl(
 }
 
 class JKKtFunctionImpl(
-    returnType: JKType,
+    returnType: JKTypeElement,
     name: JKNameIdentifier,
     valueArguments: List<JKValueArgument>,
     block: JKBlock,
@@ -50,7 +49,7 @@ class JKKtFunctionImpl(
     override val valid: Boolean
         get() = true
 
-    override var returnType: JKType by child(returnType)
+    override var returnType: JKTypeElement by child(returnType)
     override var name: JKNameIdentifier by child(name)
     override var valueArguments: List<JKValueArgument> by children(valueArguments)
     override var block: JKBlock by child(block)
@@ -58,7 +57,6 @@ class JKKtFunctionImpl(
 }
 
 sealed class JKKtQualifierImpl : JKQualifier, JKElementBase() {
-
     object DOT : JKKtQualifierImpl()
     object SAFE : JKKtQualifierImpl()
 }

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

@@ -33,14 +33,6 @@ interface JKJavaAssignmentExpression : JKExpression {
     var rExpression: JKExpression
 }
 
-interface JKJavaPrimitiveType : JKType {
-    val name: String
-}
-
-interface JKJavaArrayType : JKType {
-    val type: JKType
-}
-
 interface JKJavaMethodCallExpression : JKMethodCallExpression
 
 interface JKJavaFieldAccessExpression : JKFieldAccessExpression

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

@@ -16,10 +16,8 @@
 
 package org.jetbrains.kotlin.j2k.tree
 
-import org.jetbrains.kotlin.j2k.ast.Nullability
 import org.jetbrains.kotlin.j2k.tree.impl.JKFieldSymbol
 import org.jetbrains.kotlin.j2k.tree.impl.JKMethodSymbol
-import org.jetbrains.kotlin.j2k.tree.impl.JKSymbol
 import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor
 
 interface JKTreeElement : JKElement {
@@ -43,11 +41,11 @@ interface JKClass : JKDeclaration, JKModifierListOwner {
 interface JKMethod : JKDeclaration, JKModifierListOwner {
     val name: JKNameIdentifier
     var valueArguments: List<JKValueArgument>
-    val returnType: JKType
+    val returnType: JKTypeElement
 }
 
 interface JKField : JKDeclaration, JKModifierListOwner {
-    val type: JKType
+    val type: JKTypeElement
     val name: JKNameIdentifier
 }
 
@@ -61,12 +59,8 @@ interface JKAccessModifier : JKModifier
 
 interface JKModalityModifier : JKModifier
 
-interface JKType : JKTreeElement
+interface JKTypeElement : JKTreeElement {
-
+    val type: JKType
-interface JKClassType : JKType {
-    val classReference: JKSymbol?
-    val nullability: Nullability
-    val parameters: List<JKType>
 }
 
 interface JKStatement : JKTreeElement
@@ -130,7 +124,7 @@ interface JKParenthesizedExpression : JKExpression {
 
 interface JKTypeCastExpression : JKExpression {
     val expression: JKExpression
-    val type: JKType
+    val type: JKTypeElement
 }
 
 interface JKExpressionList : JKTreeElement {
@@ -147,7 +141,7 @@ interface JKLiteralExpression : JKExpression {
 }
 
 interface JKValueArgument : JKTreeElement {
-    var type: JKType
+    var type: JKTypeElement
     val name: String
 }
 

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

@@ -16,7 +16,10 @@
 
 package org.jetbrains.kotlin.j2k.tree
 
-interface JKOperator : JKTreeElement
+import org.jetbrains.kotlin.j2k.ast.Nullability
+import org.jetbrains.kotlin.j2k.tree.impl.JKSymbol
+
+interface JKOperator
 
 interface JKQualifier
 
@@ -39,3 +42,19 @@ interface JKModifierListOwner {
 interface JKReferenceTarget {
     val valid: Boolean
 }
+
+interface JKType
+
+interface JKClassType : JKType {
+    val classReference: JKSymbol?
+    val nullability: Nullability
+    val parameters: List<JKType>
+}
+
+interface JKJavaPrimitiveType : JKType {
+    val name: String
+}
+
+interface JKJavaArrayType : JKType {
+    val type: JKType
+}

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

@@ -12,8 +12,7 @@ interface JKVisitor<out R, in D> {
     fun visitModifierList(modifierList: JKModifierList, data: D): R = visitTreeElement(modifierList, data)
     fun visitAccessModifier(accessModifier: JKAccessModifier, data: D): R = visitModifier(accessModifier, data)
     fun visitModalityModifier(modalityModifier: JKModalityModifier, data: D): R = visitModifier(modalityModifier, data)
-    fun visitType(type: JKType, data: D): R = visitTreeElement(type, data)
+    fun visitTypeElement(typeElement: JKTypeElement, data: D): R = visitTreeElement(typeElement, data)
-    fun visitClassType(classType: JKClassType, data: D): R = visitType(classType, data)
     fun visitStatement(statement: JKStatement, data: D): R = visitTreeElement(statement, data)
     fun visitLoop(loop: JKLoop, data: D): R = visitStatement(loop, data)
     fun visitBlock(block: JKBlock, data: D): R = visitTreeElement(block, data)
@@ -39,8 +38,6 @@ interface JKVisitor<out R, in D> {
     fun visitJavaMethod(javaMethod: JKJavaMethod, data: D): R = visitMethod(javaMethod, data)
     fun visitJavaForLoop(javaForLoop: JKJavaForLoop, data: D): R = visitLoop(javaForLoop, data)
     fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: D): R = visitExpression(javaAssignmentExpression, data)
-    fun visitJavaPrimitiveType(javaPrimitiveType: JKJavaPrimitiveType, data: D): R = visitType(javaPrimitiveType, data)
-    fun visitJavaArrayType(javaArrayType: JKJavaArrayType, data: D): R = visitType(javaArrayType, data)
     fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression, data: D): R = visitMethodCallExpression(javaMethodCallExpression, data)
     fun visitJavaFieldAccessExpression(javaFieldAccessExpression: JKJavaFieldAccessExpression, data: D): R = visitFieldAccessExpression(javaFieldAccessExpression, data)
     fun visitJavaNewExpression(javaNewExpression: JKJavaNewExpression, data: D): R = visitExpression(javaNewExpression, data)

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

@@ -21,10 +21,8 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitAccessModifier(accessModifier: JKAccessModifier, data: Nothing?) = visitAccessModifier(accessModifier)
     fun visitModalityModifier(modalityModifier: JKModalityModifier) = visitModifier(modalityModifier, null)
     override fun visitModalityModifier(modalityModifier: JKModalityModifier, data: Nothing?) = visitModalityModifier(modalityModifier)
-    fun visitType(type: JKType) = visitTreeElement(type, null)
+    fun visitTypeElement(typeElement: JKTypeElement) = visitTreeElement(typeElement, null)
-    override fun visitType(type: JKType, data: Nothing?) = visitType(type)
+    override fun visitTypeElement(typeElement: JKTypeElement, data: Nothing?) = visitTypeElement(typeElement)
-    fun visitClassType(classType: JKClassType) = visitType(classType, null)
-    override fun visitClassType(classType: JKClassType, data: Nothing?) = visitClassType(classType)
     fun visitStatement(statement: JKStatement) = visitTreeElement(statement, null)
     override fun visitStatement(statement: JKStatement, data: Nothing?) = visitStatement(statement)
     fun visitLoop(loop: JKLoop) = visitStatement(loop, null)
@@ -75,10 +73,6 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitJavaForLoop(javaForLoop: JKJavaForLoop, data: Nothing?) = visitJavaForLoop(javaForLoop)
     fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression) = visitExpression(javaAssignmentExpression, null)
     override fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: Nothing?) = visitJavaAssignmentExpression(javaAssignmentExpression)
-    fun visitJavaPrimitiveType(javaPrimitiveType: JKJavaPrimitiveType) = visitType(javaPrimitiveType, null)
-    override fun visitJavaPrimitiveType(javaPrimitiveType: JKJavaPrimitiveType, data: Nothing?) = visitJavaPrimitiveType(javaPrimitiveType)
-    fun visitJavaArrayType(javaArrayType: JKJavaArrayType) = visitType(javaArrayType, null)
-    override fun visitJavaArrayType(javaArrayType: JKJavaArrayType, data: Nothing?) = visitJavaArrayType(javaArrayType)
     fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression) = visitMethodCallExpression(javaMethodCallExpression, null)
     override fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression, data: Nothing?) = visitJavaMethodCallExpression(javaMethodCallExpression)
     fun visitJavaFieldAccessExpression(javaFieldAccessExpression: JKJavaFieldAccessExpression) = visitFieldAccessExpression(javaFieldAccessExpression, null)