New J2K: Separated multiverse and universe declarations

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

@@ -40,7 +40,8 @@ class JavaToJKTreeBuilder : ReferenceTargetProvider {
 
     override fun resolveClassReference(identifier: String): JKClass {
         return universe[identifier] ?: multiverse[identifier] ?: run {
-            val clazz = JKMultiverseClass(JKNameIdentifierImpl(identifier), mutableListOf(), JKClass.ClassKind.CLASS, JKModifierListImpl())
+            val clazz =
+                JKMultiverseClass(JKNameIdentifierImpl(identifier), mutableListOf(), JKClass.ClassKind.CLASS, JKModifierListImpl())
             multiverse[identifier] = clazz
             clazz
         }
@@ -244,7 +245,7 @@ class JavaToJKTreeBuilder : ReferenceTargetProvider {
     }
 
     private inner class DeclarationMapper(val expressionTreeMapper: ExpressionTreeMapper) {
-        fun PsiClass.toJK(): JKClass {
+        fun PsiClass.toJK(): JKUniverseClass {
             val classKind: JKClass.ClassKind = when {
                 isAnnotationType -> JKClass.ClassKind.ANNOTATION
                 isEnum -> JKClass.ClassKind.ENUM
@@ -253,7 +254,7 @@ class JavaToJKTreeBuilder : ReferenceTargetProvider {
             }
             return JKClassImpl(with(modifierMapper) { modifierList.toJK() }, JKNameIdentifierImpl(name!!), classKind).apply {
                 declarations =
-                        children.mapNotNull { ElementVisitor(this@DeclarationMapper).apply { it.accept(this) }.resultElement as? JKDeclaration }
+                        children.mapNotNull { ElementVisitor(this@DeclarationMapper).apply { it.accept(this) }.resultElement as? JKUniverseDeclaration }
             }
         }
 

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

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.j2k
 
 import org.jetbrains.kotlin.j2k.tree.JKClass
 import org.jetbrains.kotlin.j2k.tree.JKElement
-import org.jetbrains.kotlin.j2k.tree.prettyDebugPrintTree
+import org.jetbrains.kotlin.j2k.tree.JKUniverseClass
 import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor
 import org.jetbrains.kotlin.utils.Printer
 
@@ -41,14 +41,14 @@ class NewCodeBuilder {
             printer.print("/* !!! Hit visitElement for element type: ${element::class} !!! */")
         }
 
-        override fun visitClass(klass: JKClass, data: Unit) {
+        override fun visitUniverseClass(universeClass: JKUniverseClass, data: Unit) {
-            printer.print(classKindString(klass.classKind))
+            printer.print(classKindString(universeClass.classKind))
             builder.append(" ")
-            printer.print(klass.name.name)
+            printer.print(universeClass.name.name)
-            if (klass.declarations.isNotEmpty()) {
+            if (universeClass.declarations.isNotEmpty()) {
                 printer.println("{")
                 printer.pushIndent()
-                klass.declarations.forEach { it.accept(this, data) }
+                universeClass.declarations.forEach { it.accept(this, data) }
                 printer.popIndent()
                 printer.println("}")
             }

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

@@ -24,8 +24,8 @@ import org.jetbrains.kotlin.j2k.tree.JKElement
 import org.jetbrains.kotlin.j2k.tree.prettyDebugPrintTree
 
 class NewJavaToKotlinConverter(
-        private val project: Project,
+    private val project: Project,
-        private val settings: ConverterSettings
+    private val settings: ConverterSettings
 ) {
 
     private fun List<JKElement>.prettyPrintTrees() = buildString {

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

@@ -16,10 +16,10 @@
 
 package org.jetbrains.kotlin.j2k.conversions
 
-import org.jetbrains.kotlin.j2k.tree.JKClass
 import org.jetbrains.kotlin.j2k.tree.JKElement
 import org.jetbrains.kotlin.j2k.tree.JKJavaField
 import org.jetbrains.kotlin.j2k.tree.JKJavaMethod
+import org.jetbrains.kotlin.j2k.tree.JKUniverseClass
 import org.jetbrains.kotlin.j2k.tree.impl.JKBlockImpl
 import org.jetbrains.kotlin.j2k.tree.impl.JKJavaPrimitiveTypeImpl
 import org.jetbrains.kotlin.j2k.tree.impl.JKKtFunctionImpl
@@ -30,9 +30,9 @@ class JavaFieldToKotlinPropertyConversion : TransformerBasedConversion() {
         element.acceptChildren(this, null)
     }
 
-    override fun visitClass(klass: JKClass) {
+    override fun visitUniverseClass(universeClass: JKUniverseClass) {
         somethingChanged = true
-        klass.declarations = klass.declarations.map {
+        universeClass.declarations = universeClass.declarations.map {
             if (it is JKJavaField) JKKtPropertyImpl(
                 it.modifierList,
                 it.type,
@@ -50,9 +50,9 @@ class JavaMethodToKotlinFunctionConversion : TransformerBasedConversion() {
         element.acceptChildren(this, null)
     }
 
-    override fun visitClass(klass: JKClass) {
+    override fun visitUniverseClass(universeClass: JKUniverseClass) {
         somethingChanged = true
-        klass.declarations = klass.declarations.map {
+        universeClass.declarations = universeClass.declarations.map {
             if (it is JKJavaMethod) JKKtFunctionImpl(
                 JKJavaPrimitiveTypeImpl.BOOLEAN,
                 it.name,

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/conveersionCache/Implementations.kt

@@ -17,19 +17,26 @@
 package org.jetbrains.kotlin.j2k.tree.conveersionCache
 
 import org.jetbrains.kotlin.j2k.tree.*
-import org.jetbrains.kotlin.j2k.tree.impl.JKElementBase
 import org.jetbrains.kotlin.j2k.tree.impl.JKJavaPrimitiveTypeImpl
 import org.jetbrains.kotlin.j2k.tree.impl.JKModifierListImpl
 
+abstract class JKMultiverseElementBase : JKTreeElement {
+    override var parent: JKTreeElement? = null
 
-class JKMultiverseField(override var name: JKNameIdentifier) : JKField, JKElementBase() {
+    fun <D : JKElement> D.setParent(p: JKElement): D {
+        parent = p
+        return this
+    }
+}
+
+class JKMultiverseField(override var name: JKNameIdentifier) : JKField, JKMultiverseElementBase() {
     override var modifierList: JKModifierList = JKModifierListImpl()
     override var type: JKType = JKJavaPrimitiveTypeImpl.BOOLEAN //TODO
     override val valid: Boolean
         get() = true
 }
 
-class JKMultiverseMethod(override var name: JKNameIdentifier) : JKMethod, JKElementBase() {
+class JKMultiverseMethod(override var name: JKNameIdentifier) : JKMethod, JKMultiverseElementBase() {
     override val returnType: JKType
         get() = TODO("not implemented")
     override var modifierList: JKModifierList = JKModifierListImpl()
@@ -41,8 +48,7 @@ class JKMultiverseMethod(override var name: JKNameIdentifier) : JKMethod, JKElem
 class JKMultiverseClass(
     override var name: JKNameIdentifier, override var declarations: List<JKDeclaration>,
     override var classKind: JKClass.ClassKind, override var modifierList: JKModifierList
-) : JKClass, JKElementBase() {
+) : JKClass, JKMultiverseElementBase() {
-    override var parent: JKElement? = null
     override val valid: Boolean
         get() = true
 }

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/conveersionCache/ReferenceTargetProvider.kt

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.j2k.tree.JKField
 import org.jetbrains.kotlin.j2k.tree.JKJavaField
 import org.jetbrains.kotlin.j2k.tree.JKMethod
 import org.jetbrains.kotlin.j2k.tree.impl.JKNameIdentifierImpl
+import org.jetbrains.kotlin.utils.addToStdlib.cast
 
 interface ReferenceTargetProvider {
     fun resolveClassReference(identifier: String): JKClass
@@ -32,11 +33,11 @@ interface ReferenceTargetProvider {
     fun putMultiverseClass(clazz: JKMultiverseClass)
     fun resolveMethodReference(clazz: JKClass, method: PsiMethod): JKMethod {
         return clazz.declarations.asSequence().filter { it is JKMethod && it.name.name == method.name }.firstOrNull() as JKMethod?
-                ?: JKMultiverseMethod(JKNameIdentifierImpl(method.name)).also { clazz.declarations += it }
+                ?: JKMultiverseMethod(JKNameIdentifierImpl(method.name)).also { clazz.cast<JKMultiverseClass>().declarations += it }
     }
 
     fun resolveFieldReference(clazz: JKClass, field: PsiField): JKField {
         return clazz.declarations.asSequence().filter { it is JKJavaField && it.name.name == field.name }.firstOrNull() as JKField?
-                ?: JKMultiverseField(JKNameIdentifierImpl(field.name)).also { clazz.declarations += it }
+                ?: JKMultiverseField(JKNameIdentifierImpl(field.name)).also { clazz.cast<JKMultiverseClass>().declarations += it }
     }
 }

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

@@ -20,34 +20,35 @@ import org.jetbrains.kotlin.j2k.ast.Nullability
 import org.jetbrains.kotlin.j2k.tree.*
 import org.jetbrains.kotlin.j2k.tree.JKReference.JKReferenceType
 import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor
+import kotlin.properties.ReadWriteProperty
 import kotlin.reflect.KProperty
 
-class JKChild<T : JKElement>(var value: T) {
+class JKChild<T : JKTreeElement>(var value: T) : ReadWriteProperty<JKTreeElement, T> {
-    operator fun getValue(thisRef: JKElement, property: KProperty<*>): T {
+    override operator fun getValue(thisRef: JKTreeElement, property: KProperty<*>): T {
         return value
     }
 
-    operator fun setValue(thisRef: JKElement, property: KProperty<*>, v: T) {
+    override operator fun setValue(thisRef: JKTreeElement, property: KProperty<*>, value: T) {
-        value.parent = null
+        this.value.parent = null
-        v.parent = thisRef
+        value.parent = thisRef
-        value = v
+        this.value = value
     }
 }
 
-class JKListChild<T : JKElement>(var value: List<T>) {
+class JKListChild<T : JKTreeElement>(var value: List<T>) : ReadWriteProperty<JKTreeElement, List<T>> {
-    operator fun getValue(thisRef: JKElement, property: KProperty<*>): List<T> {
+    override operator fun getValue(thisRef: JKTreeElement, property: KProperty<*>): List<T> {
         return value
     }
 
-    operator fun setValue(thisRef: JKElement, property: KProperty<*>, v: List<T>) {
+    override operator fun setValue(thisRef: JKTreeElement, property: KProperty<*>, value: List<T>) {
-        value.forEach { it.parent = null }
+        this.value.forEach { it.parent = null }
-        v.forEach { it.parent = thisRef }
+        value.forEach { it.parent = thisRef }
-        value = v
+        this.value = value
     }
 }
 
 abstract class JKElementBase : JKElement {
-    override var parent: JKElement? = null
+    override var parent: JKTreeElement? = null
 
     fun <D : JKElement> D.setParent(p: JKElement): D {
         parent = p
@@ -60,14 +61,15 @@ abstract class JKElementBase : JKElement {
 }
 
 
-class JKClassImpl(modifierList: JKModifierList, override val name: JKNameIdentifier, override var classKind: JKClass.ClassKind) : JKClass,
+class JKClassImpl(modifierList: JKModifierList, override val name: JKNameIdentifier, override var classKind: JKClass.ClassKind) :
+    JKUniverseClass,
     JKElementBase() {
     override var modifierList by JKChild(modifierList)
     override val valid: Boolean = true
 
-    override var declarations by JKListChild(emptyList<JKDeclaration>())
+    override var declarations by JKListChild(emptyList<JKUniverseDeclaration>())
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitClass(this, data)
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitUniverseClass(this, data)
 
     override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
         modifierList.accept(visitor, data)
@@ -204,7 +206,8 @@ class JKFieldReferenceImpl(override val target: JKField, override val referenceT
     }
 }
 
-class JKClassReferenceImpl(override val target: JKClass, override val referenceType: JKReferenceType) : JKClassReference, JKElementBase() {
+class JKClassReferenceImpl(override val target: JKClass, override val referenceType: JKReferenceType) : JKClassReference,
+    JKElementBase() {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitClassReference(this, data)
 
     override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {

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

@@ -16,11 +16,11 @@
 
 package org.jetbrains.kotlin.j2k.tree
 
-interface JKJavaField : JKField {
+interface JKJavaField : JKUniverseDeclaration, JKField {
     val initializer: JKExpression
 }
 
-interface JKJavaMethod : JKMethod {
+interface JKJavaMethod : JKUniverseDeclaration, JKMethod {
     val block: JKBlock
 }
 

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

@@ -19,36 +19,16 @@ package org.jetbrains.kotlin.j2k.tree
 import org.jetbrains.kotlin.j2k.ast.Nullability
 import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor
 
-
+interface JKElement : JKTreeElement {
-interface JKElement {
-    var parent: JKElement?
-
     fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R
 
     fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D)
 }
 
-interface JKDeclaration : JKElement, JKReferenceTarget
+interface JKUniverseDeclaration : JKElement, JKDeclaration
 
-interface JKClass : JKDeclaration, JKModifierListOwner {
+interface JKUniverseClass : JKUniverseDeclaration, JKClass {
-    val name: JKNameIdentifier
+    override var declarations: List<JKUniverseDeclaration>
-    var declarations: List<JKDeclaration>
-    var classKind: ClassKind
-
-    enum class ClassKind {
-        ABSTRACT, ANNOTATION, CLASS, ENUM, INTERFACE
-    }
-}
-
-interface JKMethod : JKDeclaration, JKModifierListOwner {
-    val name: JKNameIdentifier
-    var valueArguments: List<JKValueArgument>
-    val returnType: JKType
-}
-
-interface JKField : JKDeclaration, JKModifierListOwner {
-    val type: JKType
-    val name: JKNameIdentifier
 }
 
 interface JKModifier : JKElement

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

@@ -16,17 +16,17 @@
 
 package org.jetbrains.kotlin.j2k.tree
 
-interface JKKtProperty : JKField {
+interface JKKtProperty : JKUniverseDeclaration, JKField {
     val initializer: JKExpression
     val getter: JKBlock
     val setter: JKBlock
 }
 
-interface JKKtFunction : JKMethod {
+interface JKKtFunction : JKUniverseDeclaration, JKMethod {
     val block: JKBlock
 }
 
-interface JKKtConstructor : JKDeclaration
+interface JKKtConstructor : JKUniverseDeclaration
 
 interface JKKtPrimaryConstructor : JKKtConstructor
 

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

@@ -20,10 +20,37 @@ interface JKOperator
 
 interface JKQualifier
 
+interface JKTreeElement {
+    var parent: JKTreeElement?
+}
+
 interface JKModifierListOwner {
     var modifierList: JKModifierList
 }
 
 interface JKReferenceTarget {
     val valid: Boolean
+}
+
+interface JKDeclaration : JKTreeElement, JKReferenceTarget
+
+interface JKClass : JKDeclaration, JKModifierListOwner {
+    val name: JKNameIdentifier
+    val declarations: List<JKDeclaration>
+    var classKind: ClassKind
+
+    enum class ClassKind {
+        ABSTRACT, ANNOTATION, CLASS, ENUM, INTERFACE
+    }
+}
+
+interface JKMethod : JKDeclaration, JKModifierListOwner {
+    val name: JKNameIdentifier
+    var valueArguments: List<JKValueArgument>
+    val returnType: JKType
+}
+
+interface JKField : JKDeclaration, JKModifierListOwner {
+    val type: JKType
+    val name: JKNameIdentifier
 }

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/GenerateJKTreeVisitorAndTransformer.kts

@@ -129,7 +129,7 @@ fun genVisitors(commonData: List<InterfaceData>, uncommonData: List<InterfaceDat
         appendln("}")
     })
 
-    File(JK_OUT_ROOT, "$transformerName.kt").writeText(buildString {
+    /*File(JK_OUT_ROOT, "$transformerName.kt").writeText(buildString {
         appendln(pkg)
         appendln()
         appendln("import org.jetbrains.kotlin.j2k.tree.*")
@@ -179,7 +179,7 @@ fun genVisitors(commonData: List<InterfaceData>, uncommonData: List<InterfaceDat
         }
         appendln()
         appendln("}")
-    })
+    })*/
 }
 
 genVisitors(JK_COMMON_FILE.interfaceNames(), JK_JAVA_FILE.interfaceNames() + JK_KT_FILE.interfaceNames(), "JKVisitor", "JKTransformer")

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

@@ -1,66 +0,0 @@
-package org.jetbrains.kotlin.j2k.tree.visitors
-
-import org.jetbrains.kotlin.j2k.tree.*
-
-interface JKTransformer<in D> : JKVisitor<JKElement, D> {
-    override fun visitElement(element: JKElement, data: D): JKElement 
-    override fun visitDeclaration(declaration: JKDeclaration, data: D): JKDeclaration = visitElement(declaration, data) as JKDeclaration
-    override fun visitClass(klass: JKClass, data: D): JKClass = visitDeclaration(klass, data) as JKClass
-    override fun visitMethod(method: JKMethod, data: D): JKMethod = visitDeclaration(method, data) as JKMethod
-    override fun visitField(field: JKField, data: D): JKField = visitDeclaration(field, data) as JKField
-    override fun visitModifier(modifier: JKModifier, data: D): JKModifier = visitElement(modifier, data) as JKModifier
-    override fun visitModifierList(modifierList: JKModifierList, data: D): JKModifierList = visitElement(modifierList, data) as JKModifierList
-    override fun visitAccessModifier(accessModifier: JKAccessModifier, data: D): JKAccessModifier = visitModifier(accessModifier, data) as JKAccessModifier
-    override fun visitModalityModifier(modalityModifier: JKModalityModifier, data: D): JKModalityModifier = visitModifier(modalityModifier, data) as JKModalityModifier
-    override fun visitReference(reference: JKReference, data: D): JKReference = visitElement(reference, data) as JKReference
-    override fun visitMethodReference(methodReference: JKMethodReference, data: D): JKMethodReference = visitReference(methodReference, data) as JKMethodReference
-    override fun visitFieldReference(fieldReference: JKFieldReference, data: D): JKFieldReference = visitReference(fieldReference, data) as JKFieldReference
-    override fun visitClassReference(classReference: JKClassReference, data: D): JKClassReference = visitReference(classReference, data) as JKClassReference
-    override fun visitType(type: JKType, data: D): JKType = visitElement(type, data) as JKType
-    override fun visitClassType(classType: JKClassType, data: D): JKClassType = visitType(classType, data) as JKClassType
-    override fun visitStatement(statement: JKStatement, data: D): JKStatement = visitElement(statement, data) as JKStatement
-    override fun visitLoop(loop: JKLoop, data: D): JKLoop = visitStatement(loop, data) as JKLoop
-    override fun visitBlock(block: JKBlock, data: D): JKBlock = visitElement(block, data) as JKBlock
-    override fun visitIdentifier(identifier: JKIdentifier, data: D): JKIdentifier = visitElement(identifier, data) as JKIdentifier
-    override fun visitNameIdentifier(nameIdentifier: JKNameIdentifier, data: D): JKNameIdentifier = visitIdentifier(nameIdentifier, data) as JKNameIdentifier
-    override fun visitExpression(expression: JKExpression, data: D): JKExpression = visitElement(expression, data) as JKExpression
-    override fun visitExpressionStatement(expressionStatement: JKExpressionStatement, data: D): JKExpressionStatement = visitStatement(expressionStatement, data) as JKExpressionStatement
-    override fun visitBinaryExpression(binaryExpression: JKBinaryExpression, data: D): JKBinaryExpression = visitExpression(binaryExpression, data) as JKBinaryExpression
-    override fun visitUnaryExpression(unaryExpression: JKUnaryExpression, data: D): JKUnaryExpression = visitExpression(unaryExpression, data) as JKUnaryExpression
-    override fun visitPrefixExpression(prefixExpression: JKPrefixExpression, data: D): JKPrefixExpression = visitUnaryExpression(prefixExpression, data) as JKPrefixExpression
-    override fun visitPostfixExpression(postfixExpression: JKPostfixExpression, data: D): JKPostfixExpression = visitUnaryExpression(postfixExpression, data) as JKPostfixExpression
-    override fun visitQualifiedExpression(qualifiedExpression: JKQualifiedExpression, data: D): JKQualifiedExpression = visitExpression(qualifiedExpression, data) as JKQualifiedExpression
-    override fun visitMethodCallExpression(methodCallExpression: JKMethodCallExpression, data: D): JKMethodCallExpression = visitExpression(methodCallExpression, data) as JKMethodCallExpression
-    override fun visitFieldAccessExpression(fieldAccessExpression: JKFieldAccessExpression, data: D): JKFieldAccessExpression = visitExpression(fieldAccessExpression, data) as JKFieldAccessExpression
-    override fun visitArrayAccessExpression(arrayAccessExpression: JKArrayAccessExpression, data: D): JKArrayAccessExpression = visitExpression(arrayAccessExpression, data) as JKArrayAccessExpression
-    override fun visitParenthesizedExpression(parenthesizedExpression: JKParenthesizedExpression, data: D): JKParenthesizedExpression = visitExpression(parenthesizedExpression, data) as JKParenthesizedExpression
-    override fun visitTypeCastExpression(typeCastExpression: JKTypeCastExpression, data: D): JKTypeCastExpression = visitExpression(typeCastExpression, data) as JKTypeCastExpression
-    override fun visitExpressionList(expressionList: JKExpressionList, data: D): JKExpressionList = visitElement(expressionList, data) as JKExpressionList
-    override fun visitLiteralExpression(literalExpression: JKLiteralExpression, data: D): JKLiteralExpression = visitExpression(literalExpression, data) as JKLiteralExpression
-    override fun visitValueArgument(valueArgument: JKValueArgument, data: D): JKValueArgument = visitElement(valueArgument, data) as JKValueArgument
-    override fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression, data: D): JKStringLiteralExpression = visitLiteralExpression(stringLiteralExpression, data) as JKStringLiteralExpression
-    override fun visitJavaField(javaField: JKJavaField, data: D): JKField = visitField(javaField, data) 
-    override fun visitJavaMethod(javaMethod: JKJavaMethod, data: D): JKMethod = visitMethod(javaMethod, data) 
-    override fun visitJavaForLoop(javaForLoop: JKJavaForLoop, data: D): JKLoop = visitLoop(javaForLoop, data) 
-    override fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: D): JKExpression = visitExpression(javaAssignmentExpression, data) 
-    override fun visitJavaPrimitiveType(javaPrimitiveType: JKJavaPrimitiveType, data: D): JKType = visitType(javaPrimitiveType, data) 
-    override fun visitJavaArrayType(javaArrayType: JKJavaArrayType, data: D): JKType = visitType(javaArrayType, data) 
-    override fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression, data: D): JKMethodCallExpression = visitMethodCallExpression(javaMethodCallExpression, data) 
-    override fun visitJavaFieldAccessExpression(javaFieldAccessExpression: JKJavaFieldAccessExpression, data: D): JKFieldAccessExpression = visitFieldAccessExpression(javaFieldAccessExpression, data) 
-    override fun visitJavaNewExpression(javaNewExpression: JKJavaNewExpression, data: D): JKExpression = visitExpression(javaNewExpression, data) 
-    override fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier, data: D): JKAccessModifier = visitAccessModifier(javaAccessModifier, data) 
-    override fun visitJavaModifier(javaModifier: JKJavaModifier, data: D): JKModifier = visitModifier(javaModifier, data) 
-    override fun visitJavaNewEmptyArray(javaNewEmptyArray: JKJavaNewEmptyArray, data: D): JKExpression = visitExpression(javaNewEmptyArray, data) 
-    override fun visitJavaNewArray(javaNewArray: JKJavaNewArray, data: D): JKExpression = visitExpression(javaNewArray, data) 
-    override fun visitJavaLiteralExpression(javaLiteralExpression: JKJavaLiteralExpression, data: D): JKLiteralExpression = visitLiteralExpression(javaLiteralExpression, data) 
-    override fun visitKtProperty(ktProperty: JKKtProperty, data: D): JKField = visitField(ktProperty, data) 
-    override fun visitKtFunction(ktFunction: JKKtFunction, data: D): JKMethod = visitMethod(ktFunction, data) 
-    override fun visitKtConstructor(ktConstructor: JKKtConstructor, data: D): JKDeclaration = visitDeclaration(ktConstructor, data) 
-    override fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor, data: D): JKDeclaration = visitKtConstructor(ktPrimaryConstructor, data) 
-    override fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement, data: D): JKStatement = visitStatement(ktAssignmentStatement, data) 
-    override fun visitKtCall(ktCall: JKKtCall, data: D): JKMethodCallExpression = visitMethodCallExpression(ktCall, data) 
-    override fun visitKtModifier(ktModifier: JKKtModifier, data: D): JKModifier = visitModifier(ktModifier, data) 
-    override fun visitKtMethodCallExpression(ktMethodCallExpression: JKKtMethodCallExpression, data: D): JKMethodCallExpression = visitMethodCallExpression(ktMethodCallExpression, data) 
-    override fun visitKtFieldAccessExpression(ktFieldAccessExpression: JKKtFieldAccessExpression, data: D): JKFieldAccessExpression = visitFieldAccessExpression(ktFieldAccessExpression, data) 
-    override fun visitKtLiteralExpression(ktLiteralExpression: JKKtLiteralExpression, data: D): JKLiteralExpression = visitLiteralExpression(ktLiteralExpression, data) 
-}

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

@@ -1,126 +0,0 @@
-package org.jetbrains.kotlin.j2k.tree.visitors
-
-import org.jetbrains.kotlin.j2k.tree.*
-
-interface JKTransformerVoid : JKTransformer<Nothing?> {
-    fun visitElement(element: JKElement): JKElement 
-    override fun visitElement(element: JKElement, data: Nothing?): JKElement = visitElement(element)
-    fun visitDeclaration(declaration: JKDeclaration): JKDeclaration = visitElement(declaration) as JKDeclaration
-    override fun visitDeclaration(declaration: JKDeclaration, data: Nothing?): JKDeclaration = visitDeclaration(declaration)
-    fun visitClass(klass: JKClass): JKClass = visitDeclaration(klass) as JKClass
-    override fun visitClass(klass: JKClass, data: Nothing?): JKClass = visitClass(klass)
-    fun visitMethod(method: JKMethod): JKMethod = visitDeclaration(method) as JKMethod
-    override fun visitMethod(method: JKMethod, data: Nothing?): JKMethod = visitMethod(method)
-    fun visitField(field: JKField): JKField = visitDeclaration(field) as JKField
-    override fun visitField(field: JKField, data: Nothing?): JKField = visitField(field)
-    fun visitModifier(modifier: JKModifier): JKModifier = visitElement(modifier) as JKModifier
-    override fun visitModifier(modifier: JKModifier, data: Nothing?): JKModifier = visitModifier(modifier)
-    fun visitModifierList(modifierList: JKModifierList): JKModifierList = visitElement(modifierList) as JKModifierList
-    override fun visitModifierList(modifierList: JKModifierList, data: Nothing?): JKModifierList = visitModifierList(modifierList)
-    fun visitAccessModifier(accessModifier: JKAccessModifier): JKAccessModifier = visitModifier(accessModifier) as JKAccessModifier
-    override fun visitAccessModifier(accessModifier: JKAccessModifier, data: Nothing?): JKAccessModifier = visitAccessModifier(accessModifier)
-    fun visitModalityModifier(modalityModifier: JKModalityModifier): JKModalityModifier = visitModifier(modalityModifier) as JKModalityModifier
-    override fun visitModalityModifier(modalityModifier: JKModalityModifier, data: Nothing?): JKModalityModifier = visitModalityModifier(modalityModifier)
-    fun visitReference(reference: JKReference): JKReference = visitElement(reference) as JKReference
-    override fun visitReference(reference: JKReference, data: Nothing?): JKReference = visitReference(reference)
-    fun visitMethodReference(methodReference: JKMethodReference): JKMethodReference = visitReference(methodReference) as JKMethodReference
-    override fun visitMethodReference(methodReference: JKMethodReference, data: Nothing?): JKMethodReference = visitMethodReference(methodReference)
-    fun visitFieldReference(fieldReference: JKFieldReference): JKFieldReference = visitReference(fieldReference) as JKFieldReference
-    override fun visitFieldReference(fieldReference: JKFieldReference, data: Nothing?): JKFieldReference = visitFieldReference(fieldReference)
-    fun visitClassReference(classReference: JKClassReference): JKClassReference = visitReference(classReference) as JKClassReference
-    override fun visitClassReference(classReference: JKClassReference, data: Nothing?): JKClassReference = visitClassReference(classReference)
-    fun visitType(type: JKType): JKType = visitElement(type) as JKType
-    override fun visitType(type: JKType, data: Nothing?): JKType = visitType(type)
-    fun visitClassType(classType: JKClassType): JKClassType = visitType(classType) as JKClassType
-    override fun visitClassType(classType: JKClassType, data: Nothing?): JKClassType = visitClassType(classType)
-    fun visitStatement(statement: JKStatement): JKStatement = visitElement(statement) as JKStatement
-    override fun visitStatement(statement: JKStatement, data: Nothing?): JKStatement = visitStatement(statement)
-    fun visitLoop(loop: JKLoop): JKLoop = visitStatement(loop) as JKLoop
-    override fun visitLoop(loop: JKLoop, data: Nothing?): JKLoop = visitLoop(loop)
-    fun visitBlock(block: JKBlock): JKBlock = visitElement(block) as JKBlock
-    override fun visitBlock(block: JKBlock, data: Nothing?): JKBlock = visitBlock(block)
-    fun visitIdentifier(identifier: JKIdentifier): JKIdentifier = visitElement(identifier) as JKIdentifier
-    override fun visitIdentifier(identifier: JKIdentifier, data: Nothing?): JKIdentifier = visitIdentifier(identifier)
-    fun visitNameIdentifier(nameIdentifier: JKNameIdentifier): JKNameIdentifier = visitIdentifier(nameIdentifier) as JKNameIdentifier
-    override fun visitNameIdentifier(nameIdentifier: JKNameIdentifier, data: Nothing?): JKNameIdentifier = visitNameIdentifier(nameIdentifier)
-    fun visitExpression(expression: JKExpression): JKExpression = visitElement(expression) as JKExpression
-    override fun visitExpression(expression: JKExpression, data: Nothing?): JKExpression = visitExpression(expression)
-    fun visitExpressionStatement(expressionStatement: JKExpressionStatement): JKExpressionStatement = visitStatement(expressionStatement) as JKExpressionStatement
-    override fun visitExpressionStatement(expressionStatement: JKExpressionStatement, data: Nothing?): JKExpressionStatement = visitExpressionStatement(expressionStatement)
-    fun visitBinaryExpression(binaryExpression: JKBinaryExpression): JKBinaryExpression = visitExpression(binaryExpression) as JKBinaryExpression
-    override fun visitBinaryExpression(binaryExpression: JKBinaryExpression, data: Nothing?): JKBinaryExpression = visitBinaryExpression(binaryExpression)
-    fun visitUnaryExpression(unaryExpression: JKUnaryExpression): JKUnaryExpression = visitExpression(unaryExpression) as JKUnaryExpression
-    override fun visitUnaryExpression(unaryExpression: JKUnaryExpression, data: Nothing?): JKUnaryExpression = visitUnaryExpression(unaryExpression)
-    fun visitPrefixExpression(prefixExpression: JKPrefixExpression): JKPrefixExpression = visitUnaryExpression(prefixExpression) as JKPrefixExpression
-    override fun visitPrefixExpression(prefixExpression: JKPrefixExpression, data: Nothing?): JKPrefixExpression = visitPrefixExpression(prefixExpression)
-    fun visitPostfixExpression(postfixExpression: JKPostfixExpression): JKPostfixExpression = visitUnaryExpression(postfixExpression) as JKPostfixExpression
-    override fun visitPostfixExpression(postfixExpression: JKPostfixExpression, data: Nothing?): JKPostfixExpression = visitPostfixExpression(postfixExpression)
-    fun visitQualifiedExpression(qualifiedExpression: JKQualifiedExpression): JKQualifiedExpression = visitExpression(qualifiedExpression) as JKQualifiedExpression
-    override fun visitQualifiedExpression(qualifiedExpression: JKQualifiedExpression, data: Nothing?): JKQualifiedExpression = visitQualifiedExpression(qualifiedExpression)
-    fun visitMethodCallExpression(methodCallExpression: JKMethodCallExpression): JKMethodCallExpression = visitExpression(methodCallExpression) as JKMethodCallExpression
-    override fun visitMethodCallExpression(methodCallExpression: JKMethodCallExpression, data: Nothing?): JKMethodCallExpression = visitMethodCallExpression(methodCallExpression)
-    fun visitFieldAccessExpression(fieldAccessExpression: JKFieldAccessExpression): JKFieldAccessExpression = visitExpression(fieldAccessExpression) as JKFieldAccessExpression
-    override fun visitFieldAccessExpression(fieldAccessExpression: JKFieldAccessExpression, data: Nothing?): JKFieldAccessExpression = visitFieldAccessExpression(fieldAccessExpression)
-    fun visitArrayAccessExpression(arrayAccessExpression: JKArrayAccessExpression): JKArrayAccessExpression = visitExpression(arrayAccessExpression) as JKArrayAccessExpression
-    override fun visitArrayAccessExpression(arrayAccessExpression: JKArrayAccessExpression, data: Nothing?): JKArrayAccessExpression = visitArrayAccessExpression(arrayAccessExpression)
-    fun visitParenthesizedExpression(parenthesizedExpression: JKParenthesizedExpression): JKParenthesizedExpression = visitExpression(parenthesizedExpression) as JKParenthesizedExpression
-    override fun visitParenthesizedExpression(parenthesizedExpression: JKParenthesizedExpression, data: Nothing?): JKParenthesizedExpression = visitParenthesizedExpression(parenthesizedExpression)
-    fun visitTypeCastExpression(typeCastExpression: JKTypeCastExpression): JKTypeCastExpression = visitExpression(typeCastExpression) as JKTypeCastExpression
-    override fun visitTypeCastExpression(typeCastExpression: JKTypeCastExpression, data: Nothing?): JKTypeCastExpression = visitTypeCastExpression(typeCastExpression)
-    fun visitExpressionList(expressionList: JKExpressionList): JKExpressionList = visitElement(expressionList) as JKExpressionList
-    override fun visitExpressionList(expressionList: JKExpressionList, data: Nothing?): JKExpressionList = visitExpressionList(expressionList)
-    fun visitLiteralExpression(literalExpression: JKLiteralExpression): JKLiteralExpression = visitExpression(literalExpression) as JKLiteralExpression
-    override fun visitLiteralExpression(literalExpression: JKLiteralExpression, data: Nothing?): JKLiteralExpression = visitLiteralExpression(literalExpression)
-    fun visitValueArgument(valueArgument: JKValueArgument): JKValueArgument = visitElement(valueArgument) as JKValueArgument
-    override fun visitValueArgument(valueArgument: JKValueArgument, data: Nothing?): JKValueArgument = visitValueArgument(valueArgument)
-    fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression): JKStringLiteralExpression = visitLiteralExpression(stringLiteralExpression) as JKStringLiteralExpression
-    override fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression, data: Nothing?): JKStringLiteralExpression = visitStringLiteralExpression(stringLiteralExpression)
-    fun visitJavaField(javaField: JKJavaField): JKField = visitField(javaField) 
-    override fun visitJavaField(javaField: JKJavaField, data: Nothing?): JKField = visitJavaField(javaField)
-    fun visitJavaMethod(javaMethod: JKJavaMethod): JKMethod = visitMethod(javaMethod) 
-    override fun visitJavaMethod(javaMethod: JKJavaMethod, data: Nothing?): JKMethod = visitJavaMethod(javaMethod)
-    fun visitJavaForLoop(javaForLoop: JKJavaForLoop): JKLoop = visitLoop(javaForLoop) 
-    override fun visitJavaForLoop(javaForLoop: JKJavaForLoop, data: Nothing?): JKLoop = visitJavaForLoop(javaForLoop)
-    fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression): JKExpression = visitExpression(javaAssignmentExpression) 
-    override fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: Nothing?): JKExpression = visitJavaAssignmentExpression(javaAssignmentExpression)
-    fun visitJavaPrimitiveType(javaPrimitiveType: JKJavaPrimitiveType): JKType = visitType(javaPrimitiveType) 
-    override fun visitJavaPrimitiveType(javaPrimitiveType: JKJavaPrimitiveType, data: Nothing?): JKType = visitJavaPrimitiveType(javaPrimitiveType)
-    fun visitJavaArrayType(javaArrayType: JKJavaArrayType): JKType = visitType(javaArrayType) 
-    override fun visitJavaArrayType(javaArrayType: JKJavaArrayType, data: Nothing?): JKType = visitJavaArrayType(javaArrayType)
-    fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression): JKMethodCallExpression = visitMethodCallExpression(javaMethodCallExpression) 
-    override fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression, data: Nothing?): JKMethodCallExpression = visitJavaMethodCallExpression(javaMethodCallExpression)
-    fun visitJavaFieldAccessExpression(javaFieldAccessExpression: JKJavaFieldAccessExpression): JKFieldAccessExpression = visitFieldAccessExpression(javaFieldAccessExpression) 
-    override fun visitJavaFieldAccessExpression(javaFieldAccessExpression: JKJavaFieldAccessExpression, data: Nothing?): JKFieldAccessExpression = visitJavaFieldAccessExpression(javaFieldAccessExpression)
-    fun visitJavaNewExpression(javaNewExpression: JKJavaNewExpression): JKExpression = visitExpression(javaNewExpression) 
-    override fun visitJavaNewExpression(javaNewExpression: JKJavaNewExpression, data: Nothing?): JKExpression = visitJavaNewExpression(javaNewExpression)
-    fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier): JKAccessModifier = visitAccessModifier(javaAccessModifier) 
-    override fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier, data: Nothing?): JKAccessModifier = visitJavaAccessModifier(javaAccessModifier)
-    fun visitJavaModifier(javaModifier: JKJavaModifier): JKModifier = visitModifier(javaModifier) 
-    override fun visitJavaModifier(javaModifier: JKJavaModifier, data: Nothing?): JKModifier = visitJavaModifier(javaModifier)
-    fun visitJavaNewEmptyArray(javaNewEmptyArray: JKJavaNewEmptyArray): JKExpression = visitExpression(javaNewEmptyArray) 
-    override fun visitJavaNewEmptyArray(javaNewEmptyArray: JKJavaNewEmptyArray, data: Nothing?): JKExpression = visitJavaNewEmptyArray(javaNewEmptyArray)
-    fun visitJavaNewArray(javaNewArray: JKJavaNewArray): JKExpression = visitExpression(javaNewArray) 
-    override fun visitJavaNewArray(javaNewArray: JKJavaNewArray, data: Nothing?): JKExpression = visitJavaNewArray(javaNewArray)
-    fun visitJavaLiteralExpression(javaLiteralExpression: JKJavaLiteralExpression): JKLiteralExpression = visitLiteralExpression(javaLiteralExpression) 
-    override fun visitJavaLiteralExpression(javaLiteralExpression: JKJavaLiteralExpression, data: Nothing?): JKLiteralExpression = visitJavaLiteralExpression(javaLiteralExpression)
-    fun visitKtProperty(ktProperty: JKKtProperty): JKField = visitField(ktProperty) 
-    override fun visitKtProperty(ktProperty: JKKtProperty, data: Nothing?): JKField = visitKtProperty(ktProperty)
-    fun visitKtFunction(ktFunction: JKKtFunction): JKMethod = visitMethod(ktFunction) 
-    override fun visitKtFunction(ktFunction: JKKtFunction, data: Nothing?): JKMethod = visitKtFunction(ktFunction)
-    fun visitKtConstructor(ktConstructor: JKKtConstructor): JKDeclaration = visitDeclaration(ktConstructor) 
-    override fun visitKtConstructor(ktConstructor: JKKtConstructor, data: Nothing?): JKDeclaration = visitKtConstructor(ktConstructor)
-    fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor): JKDeclaration = visitKtConstructor(ktPrimaryConstructor) 
-    override fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor, data: Nothing?): JKDeclaration = visitKtPrimaryConstructor(ktPrimaryConstructor)
-    fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement): JKStatement = visitStatement(ktAssignmentStatement) 
-    override fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement, data: Nothing?): JKStatement = visitKtAssignmentStatement(ktAssignmentStatement)
-    fun visitKtCall(ktCall: JKKtCall): JKMethodCallExpression = visitMethodCallExpression(ktCall) 
-    override fun visitKtCall(ktCall: JKKtCall, data: Nothing?): JKMethodCallExpression = visitKtCall(ktCall)
-    fun visitKtModifier(ktModifier: JKKtModifier): JKModifier = visitModifier(ktModifier) 
-    override fun visitKtModifier(ktModifier: JKKtModifier, data: Nothing?): JKModifier = visitKtModifier(ktModifier)
-    fun visitKtMethodCallExpression(ktMethodCallExpression: JKKtMethodCallExpression): JKMethodCallExpression = visitMethodCallExpression(ktMethodCallExpression) 
-    override fun visitKtMethodCallExpression(ktMethodCallExpression: JKKtMethodCallExpression, data: Nothing?): JKMethodCallExpression = visitKtMethodCallExpression(ktMethodCallExpression)
-    fun visitKtFieldAccessExpression(ktFieldAccessExpression: JKKtFieldAccessExpression): JKFieldAccessExpression = visitFieldAccessExpression(ktFieldAccessExpression) 
-    override fun visitKtFieldAccessExpression(ktFieldAccessExpression: JKKtFieldAccessExpression, data: Nothing?): JKFieldAccessExpression = visitKtFieldAccessExpression(ktFieldAccessExpression)
-    fun visitKtLiteralExpression(ktLiteralExpression: JKKtLiteralExpression): JKLiteralExpression = visitLiteralExpression(ktLiteralExpression) 
-    override fun visitKtLiteralExpression(ktLiteralExpression: JKKtLiteralExpression, data: Nothing?): JKLiteralExpression = visitKtLiteralExpression(ktLiteralExpression)
-}

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

@@ -4,10 +4,8 @@ import org.jetbrains.kotlin.j2k.tree.*
 
 interface JKVisitor<out R, in D> {
     fun visitElement(element: JKElement, data: D): R 
-    fun visitDeclaration(declaration: JKDeclaration, data: D): R = visitElement(declaration, data)
+    fun visitUniverseDeclaration(universeDeclaration: JKUniverseDeclaration, data: D): R = visitElement(universeDeclaration, data)
-    fun visitClass(klass: JKClass, data: D): R = visitDeclaration(klass, data)
+    fun visitUniverseClass(universeClass: JKUniverseClass, data: D): R = visitUniverseDeclaration(universeClass, data)
-    fun visitMethod(method: JKMethod, data: D): R = visitDeclaration(method, data)
-    fun visitField(field: JKField, data: D): R = visitDeclaration(field, data)
     fun visitModifier(modifier: JKModifier, data: D): R = visitElement(modifier, data)
     fun visitModifierList(modifierList: JKModifierList, data: D): R = visitElement(modifierList, data)
     fun visitAccessModifier(accessModifier: JKAccessModifier, data: D): R = visitModifier(accessModifier, data)
@@ -39,8 +37,8 @@ interface JKVisitor<out R, in D> {
     fun visitLiteralExpression(literalExpression: JKLiteralExpression, data: D): R = visitExpression(literalExpression, data)
     fun visitValueArgument(valueArgument: JKValueArgument, data: D): R = visitElement(valueArgument, data)
     fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression, data: D): R = visitLiteralExpression(stringLiteralExpression, data)
-    fun visitJavaField(javaField: JKJavaField, data: D): R = visitField(javaField, data)
+    fun visitJavaField(javaField: JKJavaField, data: D): R = visitUniverseDeclaration(javaField, data)
-    fun visitJavaMethod(javaMethod: JKJavaMethod, data: D): R = visitMethod(javaMethod, data)
+    fun visitJavaMethod(javaMethod: JKJavaMethod, data: D): R = visitUniverseDeclaration(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)
@@ -53,9 +51,9 @@ interface JKVisitor<out R, in D> {
     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)
-    fun visitKtProperty(ktProperty: JKKtProperty, data: D): R = visitField(ktProperty, data)
+    fun visitKtProperty(ktProperty: JKKtProperty, data: D): R = visitUniverseDeclaration(ktProperty, data)
-    fun visitKtFunction(ktFunction: JKKtFunction, data: D): R = visitMethod(ktFunction, data)
+    fun visitKtFunction(ktFunction: JKKtFunction, data: D): R = visitUniverseDeclaration(ktFunction, data)
-    fun visitKtConstructor(ktConstructor: JKKtConstructor, data: D): R = visitDeclaration(ktConstructor, data)
+    fun visitKtConstructor(ktConstructor: JKKtConstructor, data: D): R = visitUniverseDeclaration(ktConstructor, data)
     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)

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

@@ -5,14 +5,10 @@ import org.jetbrains.kotlin.j2k.tree.*
 interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     fun visitElement(element: JKElement) 
     override fun visitElement(element: JKElement, data: Nothing?) = visitElement(element)
-    fun visitDeclaration(declaration: JKDeclaration) = visitElement(declaration, null)
+    fun visitUniverseDeclaration(universeDeclaration: JKUniverseDeclaration) = visitElement(universeDeclaration, null)
-    override fun visitDeclaration(declaration: JKDeclaration, data: Nothing?) = visitDeclaration(declaration)
+    override fun visitUniverseDeclaration(universeDeclaration: JKUniverseDeclaration, data: Nothing?) = visitUniverseDeclaration(universeDeclaration)
-    fun visitClass(klass: JKClass) = visitDeclaration(klass, null)
+    fun visitUniverseClass(universeClass: JKUniverseClass) = visitUniverseDeclaration(universeClass, null)
-    override fun visitClass(klass: JKClass, data: Nothing?) = visitClass(klass)
+    override fun visitUniverseClass(universeClass: JKUniverseClass, data: Nothing?) = visitUniverseClass(universeClass)
-    fun visitMethod(method: JKMethod) = visitDeclaration(method, null)
-    override fun visitMethod(method: JKMethod, data: Nothing?) = visitMethod(method)
-    fun visitField(field: JKField) = visitDeclaration(field, null)
-    override fun visitField(field: JKField, data: Nothing?) = visitField(field)
     fun visitModifier(modifier: JKModifier) = visitElement(modifier, null)
     override fun visitModifier(modifier: JKModifier, data: Nothing?) = visitModifier(modifier)
     fun visitModifierList(modifierList: JKModifierList) = visitElement(modifierList, null)
@@ -75,9 +71,9 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitValueArgument(valueArgument: JKValueArgument, data: Nothing?) = visitValueArgument(valueArgument)
     fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression) = visitLiteralExpression(stringLiteralExpression, null)
     override fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression, data: Nothing?) = visitStringLiteralExpression(stringLiteralExpression)
-    fun visitJavaField(javaField: JKJavaField) = visitField(javaField, null)
+    fun visitJavaField(javaField: JKJavaField) = visitUniverseDeclaration(javaField, null)
     override fun visitJavaField(javaField: JKJavaField, data: Nothing?) = visitJavaField(javaField)
-    fun visitJavaMethod(javaMethod: JKJavaMethod) = visitMethod(javaMethod, null)
+    fun visitJavaMethod(javaMethod: JKJavaMethod) = visitUniverseDeclaration(javaMethod, null)
     override fun visitJavaMethod(javaMethod: JKJavaMethod, data: Nothing?) = visitJavaMethod(javaMethod)
     fun visitJavaForLoop(javaForLoop: JKJavaForLoop) = visitLoop(javaForLoop, null)
     override fun visitJavaForLoop(javaForLoop: JKJavaForLoop, data: Nothing?) = visitJavaForLoop(javaForLoop)
@@ -103,11 +99,11 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitJavaNewArray(javaNewArray: JKJavaNewArray, data: Nothing?) = visitJavaNewArray(javaNewArray)
     fun visitJavaLiteralExpression(javaLiteralExpression: JKJavaLiteralExpression) = visitLiteralExpression(javaLiteralExpression, null)
     override fun visitJavaLiteralExpression(javaLiteralExpression: JKJavaLiteralExpression, data: Nothing?) = visitJavaLiteralExpression(javaLiteralExpression)
-    fun visitKtProperty(ktProperty: JKKtProperty) = visitField(ktProperty, null)
+    fun visitKtProperty(ktProperty: JKKtProperty) = visitUniverseDeclaration(ktProperty, null)
     override fun visitKtProperty(ktProperty: JKKtProperty, data: Nothing?) = visitKtProperty(ktProperty)
-    fun visitKtFunction(ktFunction: JKKtFunction) = visitMethod(ktFunction, null)
+    fun visitKtFunction(ktFunction: JKKtFunction) = visitUniverseDeclaration(ktFunction, null)
     override fun visitKtFunction(ktFunction: JKKtFunction, data: Nothing?) = visitKtFunction(ktFunction)
-    fun visitKtConstructor(ktConstructor: JKKtConstructor) = visitDeclaration(ktConstructor, null)
+    fun visitKtConstructor(ktConstructor: JKKtConstructor) = visitUniverseDeclaration(ktConstructor, null)
     override fun visitKtConstructor(ktConstructor: JKKtConstructor, data: Nothing?) = visitKtConstructor(ktConstructor)
     fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor) = visitKtConstructor(ktPrimaryConstructor, null)
     override fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor, data: Nothing?) = visitKtPrimaryConstructor(ktPrimaryConstructor)