From f64c32fd71e3cbd049bc613e315b155ae851dc3b Mon Sep 17 00:00:00 2001 From: Dimach Date: Sat, 19 May 2018 16:20:20 +0300 Subject: [PATCH] New J2K: Changed references to symbols. --- .../kotlin/j2k/JavaToJKTreeBuilder.kt | 55 +++++++------ .../jetbrains/kotlin/j2k/NewCodeBuilder.kt | 5 +- .../conversions/FieldToPropertyConversion.kt | 12 ++- .../JavaMethodToKotlinFunctionConversion.kt | 13 ++- .../kotlin/j2k/tree/DebugTreePrinter.kt | 7 +- .../org/jetbrains/kotlin/j2k/tree/impl/j.kt | 9 +-- .../org/jetbrains/kotlin/j2k/tree/impl/jk.kt | 30 ++----- .../org/jetbrains/kotlin/j2k/tree/impl/k.kt | 7 +- .../jetbrains/kotlin/j2k/tree/impl/symbols.kt | 79 +++++++++++++++---- j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt | 8 +- .../org/jetbrains/kotlin/j2k/tree/jk.kt | 53 ++++++------- j2k/newSrc/org/jetbrains/kotlin/j2k/tree/k.kt | 6 +- .../org/jetbrains/kotlin/j2k/tree/markers.kt | 27 ------- .../kotlin/j2k/tree/visitors/JKVisitor.kt | 41 +++++----- .../kotlin/j2k/tree/visitors/JKVisitorVoid.kt | 54 ++++++------- 15 files changed, 201 insertions(+), 205 deletions(-) diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt index 61f61f080fb..8014f3f9439 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt @@ -34,16 +34,30 @@ class JavaToJKTreeBuilder { private val modifierMapper = ModifierMapper() - val symbols = mutableMapOf>() + val symbols = mutableMapOf() - fun bindSymbol(psi: PsiElement, element: JKElement) { - provideSymbol(psi).bind(element) + val symbolsByDeclaration = mutableMapOf() + + 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 provideSymbol(psi: PsiElement): JKBindableSymbol { - return symbols.getOrPut(psi) { - DelayedPsiSymbol(psi) - } as JKBindableSymbol + fun provideSymbol(psi: JKDeclaration): JKSymbol { + return symbolsByDeclaration.getOrPut(psi) { + when (psi) { + 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 call = JKJavaMethodCallExpressionImpl(identifier as JKMethodReference, argumentList.toJK()) + val identifier = JKMultiverseMethodSymbol(method.reference?.resolve() as PsiMethod) + 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(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( - with(modifierMapper) { modifierList.toJK() }, - JKNameIdentifierImpl(name!!), - classKind - ).also { + return JKClassImpl(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 } - - bindSymbol(this, it) + provideSymbol(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) } } diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/NewCodeBuilder.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/NewCodeBuilder.kt index 2434fed3743..822436904c8 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/NewCodeBuilder.kt +++ b/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 { - 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) diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/FieldToPropertyConversion.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/FieldToPropertyConversion.kt index 0a4c75a551b..e68caf250d1 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/FieldToPropertyConversion.kt +++ b/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() @@ -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.setter) + declarations.remove(info.getter!!) + declarations.remove(info.setter!!) declarations.add(property) } } - element.declarations = declarations + element.declarations = declarations*/ return element } diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/JavaMethodToKotlinFunctionConversion.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/JavaMethodToKotlinFunctionConversion.kt index 13a4d859e33..ce70621c7ee 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/JavaMethodToKotlinFunctionConversion.kt +++ b/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.JKJavaField +import org.jetbrains.kotlin.j2k.tree.JKClass 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.JKTreeElement 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, diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/DebugTreePrinter.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/DebugTreePrinter.kt index 0b7a9caa1db..79cc36f9c42 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/DebugTreePrinter.kt +++ b/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("\"") diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt index df527d0d0d3..56890ecdd0c 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt +++ b/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 accept(visitor: JKVisitor, data: D): R = visitor.visitJavaMethodCallExpression(this, data) override fun acceptChildren(visitor: JKVisitor, 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 accept(visitor: JKVisitor, data: D): R = visitor.visitJavaFieldAccessExpression(this, data) override fun acceptChildren(visitor: JKVisitor, data: D) { - identifier.accept(visitor, data) + } } class JKJavaNewExpressionImpl( - override val constructorSymbol: JKSymbol, + override val constructorSymbol: JKMethodSymbol, arguments: JKExpressionList ) : JKJavaNewExpression, JKBranchElementBase() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaNewExpression(this, data) diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt index de1e27e2919..a418895dabe 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt +++ b/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 accept(visitor: JKVisitor, data: D): R = visitor.visitElement(this, data) + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitTreeElement(this, data) override fun acceptChildren(visitor: JKVisitor, 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() + override var declarationList by children() - override fun accept(visitor: JKVisitor, data: D): R = visitor.visitUniverseClass(this, data) + override fun accept(visitor: JKVisitor, 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?, + override val classReference: JKClassSymbol, override val parameters: List, override val nullability: Nullability = Nullability.Default ) : JKClassType, JKElementBase() { @@ -214,23 +213,4 @@ class JKClassTypeImpl( override fun acceptChildren(visitor: JKVisitor, data: D) { } -} - - -abstract class JKReferenceBase(val resolve: () -> PsiElement?) : JKElementBase(), JKReference { - override fun accept(visitor: JKVisitor, data: D): R = visitor.visitReference(this, data) - - override var target: T? = null -} - -class JKFieldReferenceImpl(resolve: () -> PsiElement?) : JKFieldReference, JKReferenceBase(resolve) { - override fun accept(visitor: JKVisitor, data: D): R = visitor.visitFieldReference(this, data) -} - -class JKClassReferenceImpl(resolve: () -> PsiElement?) : JKClassReference, JKReferenceBase(resolve) { - override fun accept(visitor: JKVisitor, data: D): R = visitor.visitClassReference(this, data) -} - -class JKMethodReferenceImpl(resolve: () -> PsiElement?) : JKMethodReference, JKReferenceBase(resolve) { - override fun accept(visitor: JKVisitor, data: D): R = visitor.visitMethodReference(this, data) } \ No newline at end of file diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/k.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/k.kt index ce336c17230..bcfa08c6dff 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/k.kt +++ b/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 accept(visitor: JKVisitor, data: D): R = visitor.visitKtMethodCallExpression(this, data) override fun acceptChildren(visitor: JKVisitor, 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 accept(visitor: JKVisitor, data: D): R = visitor.visitKtFieldAccessExpression(this, data) override fun acceptChildren(visitor: JKVisitor, data: D) { - identifier.accept(visitor, data) + } } diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/symbols.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/symbols.kt index 756a410ba44..44910d7ca20 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/symbols.kt +++ b/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 org.jetbrains.kotlin.j2k.tree.JKElement -import org.jetbrains.kotlin.j2k.tree.JKSymbol +import com.intellij.psi.PsiClass +import com.intellij.psi.PsiField +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 - -abstract class JKBindableSymbol : JKSymbol { - final override lateinit var element: E - private set - - val isBound get() = ::element.isInitialized - - fun bind(new: E) { - element = new - } +interface JKSymbol { + val target: Any + val declaredIn: JKSymbol } -class DelayedPsiSymbol(val psi: PsiElement) : JKBindableSymbol() \ No newline at end of file +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 + +} \ No newline at end of file diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt index 98cf116af22..067d061dcfc 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt +++ b/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 + val constructorSymbol: JKMethodSymbol val arguments: JKExpressionList } diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt index c24fe9c7e2c..4ff3a88f6bc 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt +++ b/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 accept(visitor: JKVisitor, data: D): R @@ -27,23 +28,32 @@ interface JKTreeElement : JKElement { fun acceptChildren(visitor: JKVisitor, data: D) } -interface JKUniverseDeclaration : JKTreeElement, JKDeclaration +interface JKDeclaration : JKTreeElement, JKReferenceTarget -interface JKDeclarationList : JKElement { - val declarations: List +interface JKClass : JKDeclaration, JKModifierListOwner { + val name: JKNameIdentifier + var declarationList: List + var classKind: ClassKind + + enum class ClassKind { + ABSTRACT, ANNOTATION, CLASS, ENUM, INTERFACE + } } -interface JKUDeclarationList : JKDeclarationList { - override var declarations: List +interface JKMethod : JKDeclaration, JKModifierListOwner { + val name: JKNameIdentifier + var valueArguments: List + val returnType: JKType } -interface JKUniverseClass : JKUniverseDeclaration, JKClass { - override var declarationList: List +interface JKField : JKDeclaration, JKModifierListOwner { + val type: JKType + val name: JKNameIdentifier } interface JKModifier : JKTreeElement -interface JKModifierList : JKBranchElement, JKTreeElement { +interface JKModifierList : JKTreeElement { var modifiers: List } @@ -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? + val classReference: JKSymbol? val nullability: Nullability val parameters: List } @@ -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 { diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/k.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/k.kt index 5e83f3abbb3..5ac8ce746cd 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/k.kt +++ b/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 diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/markers.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/markers.kt index 85e5236a3da..5d0512beb6c 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/markers.kt +++ b/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 - var classKind: ClassKind - - enum class ClassKind { - ABSTRACT, ANNOTATION, CLASS, ENUM, INTERFACE - } -} - -interface JKMethod : JKDeclaration, JKModifierListOwner { - val name: JKNameIdentifier - var valueArguments: List - val returnType: JKType -} - -interface JKField : JKDeclaration, JKModifierListOwner { - val type: JKType - val name: JKNameIdentifier -} - -interface JKSymbol { - val element: E -} diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt index 2747652af9a..5cba26b98af 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt +++ b/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 { - fun visitElement(element: JKTreeElement, data: D): R - fun visitUniverseDeclaration(universeDeclaration: JKUniverseDeclaration, data: D): R = visitElement(universeDeclaration, data) - fun visitUniverseClass(universeClass: JKUniverseClass, data: D): R = visitUniverseDeclaration(universeClass, data) - fun visitModifier(modifier: JKModifier, data: D): R = visitElement(modifier, data) - fun visitModifierList(modifierList: JKModifierList, data: D): R = visitElement(modifierList, data) + fun visitTreeElement(treeElement: JKTreeElement, data: D): R + fun visitDeclaration(declaration: JKDeclaration, data: D): R = visitTreeElement(declaration, data) + fun visitClass(klass: JKClass, data: D): R = visitDeclaration(klass, 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 = 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 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 visitType(type: JKType, data: D): R = visitTreeElement(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 visitIdentifier(identifier: JKIdentifier, data: D): R = visitElement(identifier, data) + fun visitBlock(block: JKBlock, data: D): R = visitTreeElement(block, 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 { 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 visitJavaMethod(javaMethod: JKJavaMethod, data: D): R = visitUniverseDeclaration(javaMethod, data) + fun visitJavaField(javaField: JKJavaField, data: D): R = visitField(javaField, 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 { 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 visitKtFunction(ktFunction: JKKtFunction, data: D): R = visitUniverseDeclaration(ktFunction, data) - fun visitKtConstructor(ktConstructor: JKKtConstructor, data: D): R = visitUniverseDeclaration(ktConstructor, data) + fun visitReturnStatement(returnStatement: JKReturnStatement, data: D): R = visitStatement(returnStatement, data) + fun visitKtProperty(ktProperty: JKKtProperty, data: D): R = visitField(ktProperty, 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) diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt index b65dea063c7..9a676220bb0 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt +++ b/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 { - fun visitElement(element: JKTreeElement) - override fun visitElement(element: JKTreeElement, data: Nothing?) = visitElement(element) - fun visitUniverseDeclaration(universeDeclaration: JKUniverseDeclaration) = visitElement(universeDeclaration, null) - override fun visitUniverseDeclaration(universeDeclaration: JKUniverseDeclaration, data: Nothing?) = visitUniverseDeclaration(universeDeclaration) - fun visitUniverseClass(universeClass: JKUniverseClass) = visitUniverseDeclaration(universeClass, null) - override fun visitUniverseClass(universeClass: JKUniverseClass, data: Nothing?) = visitUniverseClass(universeClass) - fun visitModifier(modifier: JKModifier) = visitElement(modifier, null) + fun visitTreeElement(treeElement: JKTreeElement) + override fun visitTreeElement(treeElement: JKTreeElement, data: Nothing?) = visitTreeElement(treeElement) + fun visitDeclaration(declaration: JKDeclaration) = visitTreeElement(declaration, null) + override fun visitDeclaration(declaration: JKDeclaration, data: Nothing?) = visitDeclaration(declaration) + fun visitClass(klass: JKClass) = visitDeclaration(klass, null) + override fun visitClass(klass: JKClass, data: Nothing?) = visitClass(klass) + 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) - 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) + fun visitType(type: JKType) = visitTreeElement(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 { 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 { 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)