New J2K: Changed references to symbols.

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

@@ -34,16 +34,30 @@ class JavaToJKTreeBuilder {
 
     private val modifierMapper = ModifierMapper()
 
-    val symbols = mutableMapOf<PsiElement, JKBindableSymbol<*>>()
+    val symbols = mutableMapOf<PsiElement, JKSymbol>()
 
-    fun bindSymbol(psi: PsiElement, element: JKElement) {
+    val symbolsByDeclaration = mutableMapOf<JKDeclaration, JKSymbol>()
-        provideSymbol(psi).bind(element)
+
+    fun provideSymbol(psi: PsiElement): JKSymbol {
+        return symbols.getOrPut(psi) {
+            when (psi) {
+                is PsiClass -> JKMultiverseClassSymbol(psi)
+                is PsiMethod -> JKMultiverseMethodSymbol(psi)
+                is PsiField -> JKMultiverseFieldSymbol(psi)
+                else -> TODO()
+            }
+        }
     }
 
-    fun <T : JKElement> provideSymbol(psi: PsiElement): JKBindableSymbol<T> {
+    fun provideSymbol(psi: JKDeclaration): JKSymbol {
-        return symbols.getOrPut(psi) {
+        return symbolsByDeclaration.getOrPut(psi) {
-            DelayedPsiSymbol<T>(psi)
+            when (psi) {
-        } as JKBindableSymbol<T>
+                is JKClass -> JKUniverseClassSymbol(psi)
+                is JKMethod -> JKUniverseMethodSymbol(psi)
+                is JKField -> JKUniverseFieldSymbol(psi)
+                else -> TODO()
+            }
+        }
     }
 
     private inner class ExpressionTreeMapper {
@@ -127,8 +141,8 @@ class JavaToJKTreeBuilder {
         fun PsiMethodCallExpression.toJK(): JKExpression {
             val method = methodExpression as PsiReferenceExpressionImpl
 
-            val identifier = JKMethodReferenceImpl({ method.reference?.resolve() })
+            val identifier = JKMultiverseMethodSymbol(method.reference?.resolve() as PsiMethod)
-            val call = JKJavaMethodCallExpressionImpl(identifier as JKMethodReference, argumentList.toJK())
+            val call = JKJavaMethodCallExpressionImpl(identifier as JKMethodSymbol, argumentList.toJK())
             return if (method.findChildByRole(ChildRole.DOT) != null) {
                 JKQualifiedExpressionImpl((method.qualifier as PsiExpression).toJK(), JKJavaQualifierImpl.DOT, call)
             } else {
@@ -138,7 +152,7 @@ class JavaToJKTreeBuilder {
 
         fun PsiReferenceExpression.toJK(): JKExpression {
             val impl = this as PsiReferenceExpressionImpl
-            val access = JKJavaFieldAccessExpressionImpl(JKFieldReferenceImpl({ impl.resolve() }))
+            val access = JKJavaFieldAccessExpressionImpl(JKMultiverseFieldSymbol(impl.resolve() as PsiField))
             return if (impl.findChildByRole(ChildRole.DOT) != null) {
                 JKQualifiedExpressionImpl((impl.qualifier as PsiExpression).toJK(), JKJavaQualifierImpl.DOT, access)
             } else {
@@ -169,7 +183,7 @@ class JavaToJKTreeBuilder {
                     return JKJavaNewEmptyArrayImpl(dimensions.map { it?.toJK() })
                 }
             }
-            return JKJavaNewExpressionImpl(provideSymbol(constructorFakeReference.resolve()!!), argumentList.toJK())
+            return JKJavaNewExpressionImpl(provideSymbol(constructorFakeReference.resolve()!!) as JKMethodSymbol, argumentList.toJK())
         }
 
         fun PsiArrayAccessExpression.toJK(): JKExpression {
@@ -190,7 +204,7 @@ class JavaToJKTreeBuilder {
 
         fun PsiType.toJK(): JKType {
             return when (this) {
-                is PsiClassType -> JKClassTypeImpl(resolve()?.let { provideSymbol<JKClass>(it) }, parameters.map { it.toJK() })
+                is PsiClassType -> JKClassTypeImpl(resolve()?.let { provideSymbol(it) as? JKClassSymbol }!!, parameters.map { it.toJK() })
                 is PsiArrayType -> JKJavaArrayTypeImpl(componentType.toJK())
                 is PsiPrimitiveType -> when (presentableText) {
                     "int" -> JKJavaPrimitiveTypeImpl.INT
@@ -205,7 +219,7 @@ class JavaToJKTreeBuilder {
     }
 
     private inner class DeclarationMapper(val expressionTreeMapper: ExpressionTreeMapper) {
-        fun PsiClass.toJK(): JKUniverseClass {
+        fun PsiClass.toJK(): JKClass {
             val classKind: JKClass.ClassKind = when {
                 isAnnotationType -> JKClass.ClassKind.ANNOTATION
                 isEnum -> JKClass.ClassKind.ENUM
@@ -213,16 +227,11 @@ class JavaToJKTreeBuilder {
                 else -> JKClass.ClassKind.CLASS
             }
             val psi = this
-            return JKClassImpl(
+            return JKClassImpl(with(modifierMapper) { modifierList.toJK() }, JKNameIdentifierImpl(name!!), classKind).also {
-                with(modifierMapper) { modifierList.toJK() },
-                JKNameIdentifierImpl(name!!),
-                classKind
-            ).also {
                 it.declarationList = psi.children.mapNotNull {
-                    ElementVisitor(this@DeclarationMapper).apply { it.accept(this) }.resultElement as? JKUniverseDeclaration
+                    ElementVisitor(this@DeclarationMapper).apply { it.accept(this) }.resultElement as? JKDeclaration
                 }
-
+                provideSymbol(it)
-                bindSymbol(this, it)
             }
         }
 
@@ -233,7 +242,7 @@ class JavaToJKTreeBuilder {
                 JKNameIdentifierImpl(this.name),
                 with(expressionTreeMapper) { initializer?.toJK() } ?: TODO()
             ).also {
-                bindSymbol(this, it)
+                provideSymbol(it)
             }
         }
 
@@ -242,7 +251,7 @@ class JavaToJKTreeBuilder {
                 with(modifierMapper) { modifierList.toJK() }, JKNameIdentifierImpl(name),
                 parameterList.parameters.map { it -> it.toJK() }, body?.toJK() ?: TODO()
             ).also {
-                bindSymbol(this, it)
+                provideSymbol(it)
             }
         }
 

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

@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.j2k
 
 import org.jetbrains.kotlin.j2k.tree.JKClass
 import org.jetbrains.kotlin.j2k.tree.JKTreeElement
-import org.jetbrains.kotlin.j2k.tree.JKUniverseClass
 import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor
 import org.jetbrains.kotlin.utils.Printer
 
@@ -37,11 +36,11 @@ class NewCodeBuilder {
 
 
     inner class Visitor : JKVisitor<Unit, Unit> {
-        override fun visitElement(element: JKTreeElement, data: Unit) {
+        override fun visitTreeElement(element: JKTreeElement, data: Unit) {
             printer.print("/* !!! Hit visitElement for element type: ${element::class} !!! */")
         }
 
-        override fun visitUniverseClass(universeClass: JKUniverseClass, data: Unit) {
+        override fun visitClass(universeClass: JKClass, data: Unit) {
             printer.print(classKindString(universeClass.classKind))
             builder.append(" ")
             printer.print(universeClass.name.value)

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

@@ -6,8 +6,6 @@
 package org.jetbrains.kotlin.j2k.conversions
 
 import org.jetbrains.kotlin.j2k.tree.*
-import org.jetbrains.kotlin.j2k.tree.impl.JKBlockImpl
-import org.jetbrains.kotlin.j2k.tree.impl.JKKtPropertyImpl
 import org.jetbrains.kotlin.load.java.JvmAbi
 
 class FieldToPropertyConversion : MatchBasedConversion() {
@@ -32,7 +30,7 @@ class FieldToPropertyConversion : MatchBasedConversion() {
     )
 
     fun applyToElement(element: JKTreeElement): JKTreeElement {
-        if (element !is JKUDeclarationList) return applyRecursive(element, this::applyToElement)
+        /*if (element !is JKUDeclarationList) return applyRecursive(element, this::applyToElement)
 
         val propertyInfos = mutableMapOf<String, PropertyInfo>()
 
@@ -42,7 +40,7 @@ class FieldToPropertyConversion : MatchBasedConversion() {
             }
         }
 
-        val declarations = element.declarations.toMutableList()
+        val declarations= element.declarations.toMutableList()
         declarations.forEach {
             when (it) {
                 is JKJavaField -> propertyInfoFor(it.name.value).field = it
@@ -63,13 +61,13 @@ class FieldToPropertyConversion : MatchBasedConversion() {
                     JKKtPropertyImpl(field.modifierList, field.type, field.name, field.initializer, JKBlockImpl(), JKBlockImpl())
 
                 declarations.remove(field)
-                declarations.remove(info.getter)
+                declarations.remove(info.getter!!)
-                declarations.remove(info.setter)
+                declarations.remove(info.setter!!)
                 declarations.add(property)
             }
         }
 
-        element.declarations = declarations
+        element.declarations = declarations*/
 
         return element
     }

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

@@ -16,23 +16,20 @@
 
 package org.jetbrains.kotlin.j2k.conversions
 
-import org.jetbrains.kotlin.j2k.tree.JKTreeElement
+import org.jetbrains.kotlin.j2k.tree.JKClass
-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.JKTreeElement
-import org.jetbrains.kotlin.j2k.tree.impl.JKBlockImpl
 import org.jetbrains.kotlin.j2k.tree.impl.JKJavaPrimitiveTypeImpl
 import org.jetbrains.kotlin.j2k.tree.impl.JKKtFunctionImpl
-import org.jetbrains.kotlin.j2k.tree.impl.JKKtPropertyImpl
 
 class JavaMethodToKotlinFunctionConversion : TransformerBasedConversion() {
-    override fun visitElement(element: JKTreeElement) {
+    override fun visitTreeElement(element: JKTreeElement) {
         element.acceptChildren(this, null)
     }
 
-    override fun visitUniverseClass(universeClass: JKUniverseClass) {
+    override fun visitClass(klass: JKClass) {
         somethingChanged = true
-        universeClass.declarationList = universeClass.declarationList.map {
+        klass.declarationList = klass.declarationList.map {
             if (it is JKJavaMethod) JKKtFunctionImpl(
                 JKJavaPrimitiveTypeImpl.BOOLEAN,
                 it.name,

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

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.j2k.tree
 
-import org.jetbrains.kotlin.j2k.tree.impl.JKBindableSymbol
 import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitorVoid
 import org.jetbrains.kotlin.utils.Printer
 
@@ -24,7 +23,7 @@ private class DebugTreePrinter : JKVisitorVoid {
     internal val stringBuilder = StringBuilder()
     private val printer = Printer(stringBuilder)
 
-    override fun visitElement(element: JKTreeElement) {
+    override fun visitTreeElement(element: JKTreeElement) {
         printer.println(element.classNameWithoutJK(), " [")
         printer.indented {
             element.acceptChildren(this, null)
@@ -78,12 +77,12 @@ private class DebugTreePrinter : JKVisitorVoid {
         printer.println(type.classNameWithoutJK(), " \"")
         printer.indented {
             if (type is JKClassType) {
-                if ((type.classReference as? JKBindableSymbol)?.isBound == true) {
+                /*if ((type.classReference as? JKBindableSymbol)?.isBound == true) {
                     printer.println(type.classReference?.element?.name?.value)
 
                 } else {
                     printer.println("Unbound")
-                }
+                }*/
             }
         }
         printer.println("\"")

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

@@ -77,26 +77,25 @@ sealed class JKJavaQualifierImpl : JKQualifier, JKElementBase() {
 }
 
 class JKJavaMethodCallExpressionImpl(
-    override var identifier: JKMethodReference, override var arguments: JKExpressionList
+    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) {
-        identifier.accept(visitor, data)
         arguments.accept(visitor, data)
     }
 }
 
-class JKJavaFieldAccessExpressionImpl(override var identifier: JKFieldReference) : JKJavaFieldAccessExpression, JKElementBase() {
+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) {
-        identifier.accept(visitor, data)
+
     }
 }
 
 class JKJavaNewExpressionImpl(
-    override val constructorSymbol: JKSymbol<JKMethod>,
+    override val constructorSymbol: JKMethodSymbol,
     arguments: JKExpressionList
 ) : JKJavaNewExpression, JKBranchElementBase() {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaNewExpression(this, data)

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

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.j2k.tree.impl
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.j2k.ast.Nullability
 import org.jetbrains.kotlin.j2k.tree.*
 import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor
@@ -71,7 +70,7 @@ abstract class JKElementBase : JKTreeElement {
 
     }
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitElement(this, data)
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitTreeElement(this, data)
 
     override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {}
 }
@@ -108,16 +107,16 @@ abstract class JKBranchElementBase : JKElementBase(), JKBranchElement {
 }
 
 class JKClassImpl(modifierList: JKModifierList, name: JKNameIdentifier, override var classKind: JKClass.ClassKind) :
-    JKUniverseClass,
+    JKClass,
     JKBranchElementBase() {
 
     override val name by child(name)
     override var modifierList by child(modifierList)
     override val valid: Boolean = true
 
-    override var declarationList by children<JKUniverseDeclaration>()
+    override var declarationList by children<JKDeclaration>()
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitUniverseClass(this, data)
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitClass(this, data)
 }
 
 
@@ -204,7 +203,7 @@ class JKTypeCastExpressionImpl(override var expression: JKExpression, override v
 }
 
 class JKClassTypeImpl(
-    override val classReference: JKSymbol<JKClass>?,
+    override val classReference: JKClassSymbol,
     override val parameters: List<JKType>,
     override val nullability: Nullability = Nullability.Default
 ) : JKClassType, JKElementBase() {
@@ -214,23 +213,4 @@ class JKClassTypeImpl(
     override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
 
     }
-}
-
-
-abstract class JKReferenceBase<T : JKReferenceTarget>(val resolve: () -> PsiElement?) : JKElementBase(), JKReference {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitReference(this, data)
-
-    override var target: T? = null
-}
-
-class JKFieldReferenceImpl(resolve: () -> PsiElement?) : JKFieldReference, JKReferenceBase<JKField>(resolve) {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitFieldReference(this, data)
-}
-
-class JKClassReferenceImpl(resolve: () -> PsiElement?) : JKClassReference, JKReferenceBase<JKClass>(resolve) {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitClassReference(this, data)
-}
-
-class JKMethodReferenceImpl(resolve: () -> PsiElement?) : JKMethodReference, JKReferenceBase<JKMethod>(resolve) {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitMethodReference(this, data)
 }

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

@@ -59,22 +59,21 @@ sealed class JKKtQualifierImpl : JKQualifier, JKElementBase() {
 }
 
 class JKKtCallExpressionImpl(
-    override val identifier: JKMethodReference,
+    override val identifier: JKMethodSymbol,
     override val arguments: JKExpressionList
 ) : JKKtMethodCallExpression, JKElementBase() {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtMethodCallExpression(this, data)
 
     override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
-        identifier.accept(visitor, data)
         arguments.accept(visitor, data)
     }
 }
 
-class JKKtFieldAccessExpressionImpl(override val identifier: JKFieldReference) : JKKtFieldAccessExpression, JKElementBase() {
+class JKKtFieldAccessExpressionImpl(override val identifier: JKFieldSymbol) : JKKtFieldAccessExpression, JKElementBase() {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtFieldAccessExpression(this, data)
 
     override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
-        identifier.accept(visitor, data)
+
     }
 }
 

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

@@ -5,20 +5,71 @@
 
 package org.jetbrains.kotlin.j2k.tree.impl
 
-import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiClass
-import org.jetbrains.kotlin.j2k.tree.JKElement
+import com.intellij.psi.PsiField
-import org.jetbrains.kotlin.j2k.tree.JKSymbol
+import com.intellij.psi.PsiMethod
+import org.jetbrains.kotlin.j2k.tree.JKClass
+import org.jetbrains.kotlin.j2k.tree.JKField
+import org.jetbrains.kotlin.j2k.tree.JKMethod
 
-
+interface JKSymbol {
-abstract class JKBindableSymbol<E : JKElement> : JKSymbol<E> {
+    val target: Any
-    final override lateinit var element: E
+    val declaredIn: JKSymbol
-        private set
-
-    val isBound get() = ::element.isInitialized
-
-    fun bind(new: E) {
-        element = new
-    }
 }
 
-class DelayedPsiSymbol<E : JKElement>(val psi: PsiElement) : JKBindableSymbol<E>()
+interface JKClassSymbol : JKSymbol {
+    val fqName: String
+}
+
+interface JKMethodSymbol : JKSymbol {
+    val fqName: String
+}
+
+interface JKFieldSymbol : JKSymbol {
+    val fqName: String
+}
+
+class JKUniverseClassSymbol(override val target: JKClass) : JKClassSymbol {
+    override val declaredIn: JKSymbol
+        get() = TODO("not implemented") //To change initializer of created properties use File | Settings | File Templates.
+    override val fqName: String
+        get() = target.name.value
+}
+
+class JKMultiverseClassSymbol(override val target: PsiClass) : JKClassSymbol {
+    override val declaredIn: JKSymbol
+        get() = TODO("not implemented") //To change initializer of created properties use File | Settings | File Templates.
+    override val fqName: String
+        get() = target.name!!
+
+}
+
+class JKUniverseMethodSymbol(override val target: JKMethod) : JKMethodSymbol {
+    override val declaredIn: JKSymbol
+        get() = TODO("not implemented") //To change initializer of created properties use File | Settings | File Templates.
+    override val fqName: String
+        get() = target.name.value
+}
+
+class JKMultiverseMethodSymbol(override val target: PsiMethod) : JKMethodSymbol {
+    override val declaredIn: JKSymbol
+        get() = TODO("not implemented") //To change initializer of created properties use File | Settings | File Templates.
+    override val fqName: String
+        get() = target.name
+
+}
+
+class JKUniverseFieldSymbol(override val target: JKField) : JKFieldSymbol {
+    override val declaredIn: JKSymbol
+        get() = TODO("not implemented") //To change initializer of created properties use File | Settings | File Templates.
+    override val fqName: String
+        get() = target.name.value
+}
+
+class JKMultiverseFieldSymbol(override val target: PsiField) : JKFieldSymbol {
+    override val declaredIn: JKSymbol
+        get() = TODO("not implemented") //To change initializer of created properties use File | Settings | File Templates.
+    override val fqName: String
+        get() = target.name
+
+}

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

@@ -16,11 +16,13 @@
 
 package org.jetbrains.kotlin.j2k.tree
 
-interface JKJavaField : JKUniverseDeclaration, JKField {
+import org.jetbrains.kotlin.j2k.tree.impl.JKMethodSymbol
+
+interface JKJavaField : JKField {
     val initializer: JKExpression
 }
 
-interface JKJavaMethod : JKUniverseDeclaration, JKMethod {
+interface JKJavaMethod : JKMethod {
     val block: JKBlock
 }
 
@@ -44,7 +46,7 @@ interface JKJavaMethodCallExpression : JKMethodCallExpression
 interface JKJavaFieldAccessExpression : JKFieldAccessExpression
 
 interface JKJavaNewExpression : JKExpression {
-    val constructorSymbol: JKSymbol<JKMethod>
+    val constructorSymbol: JKMethodSymbol
     val arguments: JKExpressionList
 }
 

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

@@ -17,9 +17,10 @@
 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
-import kotlin.properties.ReadWriteProperty
-import kotlin.reflect.KProperty
 
 interface JKTreeElement : JKElement {
     fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R
@@ -27,23 +28,32 @@ interface JKTreeElement : JKElement {
     fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D)
 }
 
-interface JKUniverseDeclaration : JKTreeElement, JKDeclaration
+interface JKDeclaration : JKTreeElement, JKReferenceTarget
 
-interface JKDeclarationList : JKElement {
+interface JKClass : JKDeclaration, JKModifierListOwner {
-    val declarations: List<JKDeclaration>
+    val name: JKNameIdentifier
+    var declarationList: List<JKDeclaration>
+    var classKind: ClassKind
+
+    enum class ClassKind {
+        ABSTRACT, ANNOTATION, CLASS, ENUM, INTERFACE
+    }
 }
 
-interface JKUDeclarationList : JKDeclarationList {
+interface JKMethod : JKDeclaration, JKModifierListOwner {
-    override var declarations: List<JKUniverseDeclaration>
+    val name: JKNameIdentifier
+    var valueArguments: List<JKValueArgument>
+    val returnType: JKType
 }
 
-interface JKUniverseClass : JKUniverseDeclaration, JKClass {
+interface JKField : JKDeclaration, JKModifierListOwner {
-    override var declarationList: List<JKUniverseDeclaration>
+    val type: JKType
+    val name: JKNameIdentifier
 }
 
 interface JKModifier : JKTreeElement
 
-interface JKModifierList : JKBranchElement, JKTreeElement {
+interface JKModifierList : JKTreeElement {
     var modifiers: List<JKModifier>
 }
 
@@ -51,27 +61,10 @@ interface JKAccessModifier : JKModifier
 
 interface JKModalityModifier : JKModifier
 
-interface JKReference : JKTreeElement {
-    val target: JKReferenceTarget?
-    val isBound get() = target != null
-}
-
-interface JKMethodReference : JKReference {
-    override val target: JKMethod?
-}
-
-interface JKFieldReference : JKReference {
-    override val target: JKField?
-}
-
-interface JKClassReference : JKReference {
-    override val target: JKClass?
-}
-
 interface JKType : JKTreeElement
 
 interface JKClassType : JKType {
-    val classReference: JKSymbol<JKClass>?
+    val classReference: JKSymbol?
     val nullability: Nullability
     val parameters: List<JKType>
 }
@@ -118,12 +111,12 @@ interface JKQualifiedExpression : JKExpression {
 }
 
 interface JKMethodCallExpression : JKExpression {
-    val identifier: JKMethodReference
+    val identifier: JKMethodSymbol
     val arguments: JKExpressionList
 }
 
 interface JKFieldAccessExpression : JKExpression {
-    val identifier: JKFieldReference
+    val identifier: JKFieldSymbol
 }
 
 interface JKArrayAccessExpression : JKExpression {

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

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

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

@@ -39,30 +39,3 @@ interface JKModifierListOwner {
 interface JKReferenceTarget {
     val valid: Boolean
 }
-
-interface JKDeclaration : JKElement, JKReferenceTarget
-
-interface JKClass : JKDeclaration, JKModifierListOwner {
-    val name: JKNameIdentifier
-    val declarationList: 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 JKSymbol<E : JKElement> {
-    val element: E
-}

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

@@ -3,25 +3,23 @@ package org.jetbrains.kotlin.j2k.tree.visitors
 import org.jetbrains.kotlin.j2k.tree.*
 
 interface JKVisitor<out R, in D> {
-    fun visitElement(element: JKTreeElement, data: D): R
+    fun visitTreeElement(treeElement: JKTreeElement, data: D): R 
-    fun visitUniverseDeclaration(universeDeclaration: JKUniverseDeclaration, data: D): R = visitElement(universeDeclaration, data)
+    fun visitDeclaration(declaration: JKDeclaration, data: D): R = visitTreeElement(declaration, data)
-    fun visitUniverseClass(universeClass: JKUniverseClass, data: D): R = visitUniverseDeclaration(universeClass, data)
+    fun visitClass(klass: JKClass, data: D): R = visitDeclaration(klass, data)
-    fun visitModifier(modifier: JKModifier, data: D): R = visitElement(modifier, data)
+    fun visitMethod(method: JKMethod, data: D): R = visitDeclaration(method, data)
-    fun visitModifierList(modifierList: JKModifierList, data: D): R = visitElement(modifierList, data)
+    fun visitField(field: JKField, data: D): R = visitDeclaration(field, data)
+    fun visitModifier(modifier: JKModifier, data: D): R = visitTreeElement(modifier, data)
+    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 visitReference(reference: JKReference, data: D): R = visitElement(reference, data)
+    fun visitType(type: JKType, data: D): R = visitTreeElement(type, data)
-    fun visitMethodReference(methodReference: JKMethodReference, data: D): R = visitReference(methodReference, data)
-    fun visitFieldReference(fieldReference: JKFieldReference, data: D): R = visitReference(fieldReference, data)
-    fun visitClassReference(classReference: JKClassReference, data: D): R = visitReference(classReference, data)
-    fun visitType(type: JKType, data: D): R = visitElement(type, data)
     fun visitClassType(classType: JKClassType, data: D): R = visitType(classType, data)
-    fun visitStatement(statement: JKStatement, data: D): R = visitElement(statement, 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 = visitElement(block, data)
+    fun visitBlock(block: JKBlock, data: D): R = visitTreeElement(block, data)
-    fun visitIdentifier(identifier: JKIdentifier, data: D): R = visitElement(identifier, data)
+    fun visitIdentifier(identifier: JKIdentifier, data: D): R = visitTreeElement(identifier, data)
     fun visitNameIdentifier(nameIdentifier: JKNameIdentifier, data: D): R = visitIdentifier(nameIdentifier, data)
-    fun visitExpression(expression: JKExpression, data: D): R = visitElement(expression, data)
+    fun visitExpression(expression: JKExpression, data: D): R = visitTreeElement(expression, data)
     fun visitExpressionStatement(expressionStatement: JKExpressionStatement, data: D): R = visitStatement(expressionStatement, data)
     fun visitBinaryExpression(binaryExpression: JKBinaryExpression, data: D): R = visitExpression(binaryExpression, data)
     fun visitUnaryExpression(unaryExpression: JKUnaryExpression, data: D): R = visitExpression(unaryExpression, data)
@@ -33,12 +31,12 @@ interface JKVisitor<out R, in D> {
     fun visitArrayAccessExpression(arrayAccessExpression: JKArrayAccessExpression, data: D): R = visitExpression(arrayAccessExpression, data)
     fun visitParenthesizedExpression(parenthesizedExpression: JKParenthesizedExpression, data: D): R = visitExpression(parenthesizedExpression, data)
     fun visitTypeCastExpression(typeCastExpression: JKTypeCastExpression, data: D): R = visitExpression(typeCastExpression, data)
-    fun visitExpressionList(expressionList: JKExpressionList, data: D): R = visitElement(expressionList, data)
+    fun visitExpressionList(expressionList: JKExpressionList, data: D): R = visitTreeElement(expressionList, data)
     fun visitLiteralExpression(literalExpression: JKLiteralExpression, data: D): R = visitExpression(literalExpression, data)
-    fun visitValueArgument(valueArgument: JKValueArgument, data: D): R = visitElement(valueArgument, data)
+    fun visitValueArgument(valueArgument: JKValueArgument, data: D): R = visitTreeElement(valueArgument, data)
     fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression, data: D): R = visitLiteralExpression(stringLiteralExpression, data)
-    fun visitJavaField(javaField: JKJavaField, data: D): R = visitUniverseDeclaration(javaField, data)
+    fun visitJavaField(javaField: JKJavaField, data: D): R = visitField(javaField, data)
-    fun visitJavaMethod(javaMethod: JKJavaMethod, data: D): R = visitUniverseDeclaration(javaMethod, data)
+    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)
@@ -51,9 +49,10 @@ 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 = visitUniverseDeclaration(ktProperty, data)
+    fun visitReturnStatement(returnStatement: JKReturnStatement, data: D): R = visitStatement(returnStatement, data)
-    fun visitKtFunction(ktFunction: JKKtFunction, data: D): R = visitUniverseDeclaration(ktFunction, data)
+    fun visitKtProperty(ktProperty: JKKtProperty, data: D): R = visitField(ktProperty, data)
-    fun visitKtConstructor(ktConstructor: JKKtConstructor, data: D): R = visitUniverseDeclaration(ktConstructor, data)
+    fun visitKtFunction(ktFunction: JKKtFunction, data: D): R = visitMethod(ktFunction, data)
+    fun visitKtConstructor(ktConstructor: JKKtConstructor, data: D): R = visitDeclaration(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

@@ -3,43 +3,39 @@ package org.jetbrains.kotlin.j2k.tree.visitors
 import org.jetbrains.kotlin.j2k.tree.*
 
 interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
-    fun visitElement(element: JKTreeElement)
+    fun visitTreeElement(treeElement: JKTreeElement) 
-    override fun visitElement(element: JKTreeElement, data: Nothing?) = visitElement(element)
+    override fun visitTreeElement(treeElement: JKTreeElement, data: Nothing?) = visitTreeElement(treeElement)
-    fun visitUniverseDeclaration(universeDeclaration: JKUniverseDeclaration) = visitElement(universeDeclaration, null)
+    fun visitDeclaration(declaration: JKDeclaration) = visitTreeElement(declaration, null)
-    override fun visitUniverseDeclaration(universeDeclaration: JKUniverseDeclaration, data: Nothing?) = visitUniverseDeclaration(universeDeclaration)
+    override fun visitDeclaration(declaration: JKDeclaration, data: Nothing?) = visitDeclaration(declaration)
-    fun visitUniverseClass(universeClass: JKUniverseClass) = visitUniverseDeclaration(universeClass, null)
+    fun visitClass(klass: JKClass) = visitDeclaration(klass, null)
-    override fun visitUniverseClass(universeClass: JKUniverseClass, data: Nothing?) = visitUniverseClass(universeClass)
+    override fun visitClass(klass: JKClass, data: Nothing?) = visitClass(klass)
-    fun visitModifier(modifier: JKModifier) = visitElement(modifier, null)
+    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) = visitTreeElement(modifier, null)
     override fun visitModifier(modifier: JKModifier, data: Nothing?) = visitModifier(modifier)
-    fun visitModifierList(modifierList: JKModifierList) = visitElement(modifierList, null)
+    fun visitModifierList(modifierList: JKModifierList) = visitTreeElement(modifierList, null)
     override fun visitModifierList(modifierList: JKModifierList, data: Nothing?) = visitModifierList(modifierList)
     fun visitAccessModifier(accessModifier: JKAccessModifier) = visitModifier(accessModifier, null)
     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 visitReference(reference: JKReference) = visitElement(reference, null)
+    fun visitType(type: JKType) = visitTreeElement(type, null)
-    override fun visitReference(reference: JKReference, data: Nothing?) = visitReference(reference)
-    fun visitMethodReference(methodReference: JKMethodReference) = visitReference(methodReference, null)
-    override fun visitMethodReference(methodReference: JKMethodReference, data: Nothing?) = visitMethodReference(methodReference)
-    fun visitFieldReference(fieldReference: JKFieldReference) = visitReference(fieldReference, null)
-    override fun visitFieldReference(fieldReference: JKFieldReference, data: Nothing?) = visitFieldReference(fieldReference)
-    fun visitClassReference(classReference: JKClassReference) = visitReference(classReference, null)
-    override fun visitClassReference(classReference: JKClassReference, data: Nothing?) = visitClassReference(classReference)
-    fun visitType(type: JKType) = visitElement(type, null)
     override fun visitType(type: JKType, data: Nothing?) = visitType(type)
     fun visitClassType(classType: JKClassType) = visitType(classType, null)
     override fun visitClassType(classType: JKClassType, data: Nothing?) = visitClassType(classType)
-    fun visitStatement(statement: JKStatement) = visitElement(statement, null)
+    fun visitStatement(statement: JKStatement) = visitTreeElement(statement, null)
     override fun visitStatement(statement: JKStatement, data: Nothing?) = visitStatement(statement)
     fun visitLoop(loop: JKLoop) = visitStatement(loop, null)
     override fun visitLoop(loop: JKLoop, data: Nothing?) = visitLoop(loop)
-    fun visitBlock(block: JKBlock) = visitElement(block, null)
+    fun visitBlock(block: JKBlock) = visitTreeElement(block, null)
     override fun visitBlock(block: JKBlock, data: Nothing?) = visitBlock(block)
-    fun visitIdentifier(identifier: JKIdentifier) = visitElement(identifier, null)
+    fun visitIdentifier(identifier: JKIdentifier) = visitTreeElement(identifier, null)
     override fun visitIdentifier(identifier: JKIdentifier, data: Nothing?) = visitIdentifier(identifier)
     fun visitNameIdentifier(nameIdentifier: JKNameIdentifier) = visitIdentifier(nameIdentifier, null)
     override fun visitNameIdentifier(nameIdentifier: JKNameIdentifier, data: Nothing?) = visitNameIdentifier(nameIdentifier)
-    fun visitExpression(expression: JKExpression) = visitElement(expression, null)
+    fun visitExpression(expression: JKExpression) = visitTreeElement(expression, null)
     override fun visitExpression(expression: JKExpression, data: Nothing?) = visitExpression(expression)
     fun visitExpressionStatement(expressionStatement: JKExpressionStatement) = visitStatement(expressionStatement, null)
     override fun visitExpressionStatement(expressionStatement: JKExpressionStatement, data: Nothing?) = visitExpressionStatement(expressionStatement)
@@ -63,17 +59,17 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitParenthesizedExpression(parenthesizedExpression: JKParenthesizedExpression, data: Nothing?) = visitParenthesizedExpression(parenthesizedExpression)
     fun visitTypeCastExpression(typeCastExpression: JKTypeCastExpression) = visitExpression(typeCastExpression, null)
     override fun visitTypeCastExpression(typeCastExpression: JKTypeCastExpression, data: Nothing?) = visitTypeCastExpression(typeCastExpression)
-    fun visitExpressionList(expressionList: JKExpressionList) = visitElement(expressionList, null)
+    fun visitExpressionList(expressionList: JKExpressionList) = visitTreeElement(expressionList, null)
     override fun visitExpressionList(expressionList: JKExpressionList, data: Nothing?) = visitExpressionList(expressionList)
     fun visitLiteralExpression(literalExpression: JKLiteralExpression) = visitExpression(literalExpression, null)
     override fun visitLiteralExpression(literalExpression: JKLiteralExpression, data: Nothing?) = visitLiteralExpression(literalExpression)
-    fun visitValueArgument(valueArgument: JKValueArgument) = visitElement(valueArgument, null)
+    fun visitValueArgument(valueArgument: JKValueArgument) = visitTreeElement(valueArgument, null)
     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) = visitUniverseDeclaration(javaField, null)
+    fun visitJavaField(javaField: JKJavaField) = visitField(javaField, null)
     override fun visitJavaField(javaField: JKJavaField, data: Nothing?) = visitJavaField(javaField)
-    fun visitJavaMethod(javaMethod: JKJavaMethod) = visitUniverseDeclaration(javaMethod, null)
+    fun visitJavaMethod(javaMethod: JKJavaMethod) = visitMethod(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)
@@ -99,11 +95,13 @@ 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) = visitUniverseDeclaration(ktProperty, null)
+    fun visitReturnStatement(returnStatement: JKReturnStatement) = visitStatement(returnStatement, null)
+    override fun visitReturnStatement(returnStatement: JKReturnStatement, data: Nothing?) = visitReturnStatement(returnStatement)
+    fun visitKtProperty(ktProperty: JKKtProperty) = visitField(ktProperty, null)
     override fun visitKtProperty(ktProperty: JKKtProperty, data: Nothing?) = visitKtProperty(ktProperty)
-    fun visitKtFunction(ktFunction: JKKtFunction) = visitUniverseDeclaration(ktFunction, null)
+    fun visitKtFunction(ktFunction: JKKtFunction) = visitMethod(ktFunction, null)
     override fun visitKtFunction(ktFunction: JKKtFunction, data: Nothing?) = visitKtFunction(ktFunction)
-    fun visitKtConstructor(ktConstructor: JKKtConstructor) = visitUniverseDeclaration(ktConstructor, null)
+    fun visitKtConstructor(ktConstructor: JKKtConstructor) = visitDeclaration(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)