diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt index 6580174d784..cacc736f151 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt @@ -101,29 +101,31 @@ class JavaToJKTreeBuilder : ReferenceTargetProvider { } fun PsiBinaryExpression.toJK(): JKExpression { - return JKBinaryExpressionImpl(lOperand.toJK(), rOperand?.toJK(), operationSign.toJK()) + return JKBinaryExpressionImpl(lOperand.toJK(), rOperand?.toJK() ?: TODO(), operationSign.toJK()) } fun PsiLiteralExpression.toJK(): JKLiteralExpression { if (this !is PsiLiteralExpressionImpl) { throw RuntimeException("Not supported") } - return JKJavaLiteralExpressionImpl(innerText!!, when (this.literalElementType) { - JavaTokenType.STRING_LITERAL -> JKLiteralExpression.LiteralType.STRING - JavaTokenType.TRUE_KEYWORD, JavaTokenType.FALSE_KEYWORD -> JKLiteralExpression.LiteralType.BOOLEAN - JavaTokenType.NULL_KEYWORD -> JKLiteralExpression.LiteralType.NULL - else -> throw RuntimeException("Not supported") - }) + return JKJavaLiteralExpressionImpl( + innerText!!, when (this.literalElementType) { + JavaTokenType.STRING_LITERAL -> JKLiteralExpression.LiteralType.STRING + JavaTokenType.TRUE_KEYWORD, JavaTokenType.FALSE_KEYWORD -> JKLiteralExpression.LiteralType.BOOLEAN + JavaTokenType.NULL_KEYWORD -> JKLiteralExpression.LiteralType.NULL + else -> throw RuntimeException("Not supported") + } + ) } - fun PsiJavaToken.toJK(): JKOperatorIdentifier = when (tokenType) { - JavaTokenType.PLUS -> JKJavaOperatorIdentifierImpl.PLUS - JavaTokenType.MINUS -> JKJavaOperatorIdentifierImpl.MINUS + fun PsiJavaToken.toJK(): JKOperator = when (tokenType) { + JavaTokenType.PLUS -> JKJavaOperatorImpl.PLUS + JavaTokenType.MINUS -> JKJavaOperatorImpl.MINUS else -> throw RuntimeException("Not supported") } fun PsiPrefixExpression.toJK(): JKExpression { - return JKPrefixExpressionImpl(operand?.toJK(), operationSign.toJK()) + return JKPrefixExpressionImpl(operand?.toJK() ?: TODO(), operationSign.toJK()) } fun PsiPostfixExpression.toJK(): JKExpression { @@ -136,21 +138,19 @@ class JavaToJKTreeBuilder : ReferenceTargetProvider { val identifier = method.resolve().convertReference() val call = JKJavaMethodCallExpressionImpl(identifier as JKMethodReference, argumentList.toJK()) return if (method.findChildByRole(ChildRole.DOT) != null) { - JKQualifiedExpressionImpl((method.qualifier as PsiExpression).toJK(), JKJavaQualificationIdentifierImpl.DOT, call) - } - else { + JKQualifiedExpressionImpl((method.qualifier as PsiExpression).toJK(), JKJavaQualifierImpl.DOT, call) + } else { call } } fun PsiReferenceExpression.toJK(): JKExpression { val impl = this as PsiReferenceExpressionImpl - val identifier = impl.resolve().convertReference() + val identifier = impl.resolve().convertReference() as JKFieldReference val access = JKJavaFieldAccessExpressionImpl(identifier) return if (impl.findChildByRole(ChildRole.DOT) != null) { - JKQualifiedExpressionImpl((impl.qualifier as PsiExpression).toJK(), JKJavaQualificationIdentifierImpl.DOT, access) - } - else { + JKQualifiedExpressionImpl((impl.qualifier as PsiExpression).toJK(), JKJavaQualifierImpl.DOT, access) + } else { access } } @@ -161,8 +161,7 @@ class JavaToJKTreeBuilder : ReferenceTargetProvider { val arrayInitializer = arrayInitializer if (arrayInitializer != null) { return JKJavaNewArrayImpl(arrayInitializer.initializers.map { toJK() }) - } - else { + } else { val dimensions = mutableListOf() var child = firstChild while (child != null) { @@ -170,8 +169,7 @@ class JavaToJKTreeBuilder : ReferenceTargetProvider { child = child.nextSibling if (child.node.elementType == JavaTokenType.RBRACKET) { dimensions.add(null) - } - else { + } else { dimensions.add(child as PsiLiteralExpression?) } } @@ -184,19 +182,19 @@ class JavaToJKTreeBuilder : ReferenceTargetProvider { } fun PsiArrayAccessExpression.toJK(): JKExpression { - return JKArrayAccessExpressionImpl(arrayExpression.toJK(), indexExpression?.toJK()) + return JKArrayAccessExpressionImpl(arrayExpression.toJK(), indexExpression?.toJK() ?: TODO()) } fun PsiTypeCastExpression.toJK(): JKExpression { - return JKTypeCastExpressionImpl(operand?.toJK(), castType?.type?.toJK()) + return JKTypeCastExpressionImpl(operand?.toJK() ?: TODO(), castType?.type?.toJK() ?: TODO()) } fun PsiParenthesizedExpression.toJK(): JKExpression { - return JKParenthesizedExpressionImpl(expression?.toJK()) + return JKParenthesizedExpressionImpl(expression?.toJK() ?: TODO()) } fun PsiExpressionList?.toJK(): JKExpressionList { - return JKExpressionListImpl(this?.expressions?.map { it.toJK() }?.toTypedArray() ?: emptyArray()) + return JKExpressionListImpl(this?.expressions?.map { it.toJK() } ?: emptyList()) } fun PsiElement?.convertReference(): JKReference = when (this) { @@ -206,18 +204,27 @@ class JavaToJKTreeBuilder : ReferenceTargetProvider { else -> throw Exception("Invalid PSI") } - fun PsiMethod.convertMethodReference(): JKJavaMethodReference { + fun PsiMethod.convertMethodReference(): JKMethodReference { val clazz = this@JavaToJKTreeBuilder.resolveClassReference(containingClass ?: TODO()) - return JKMethodReferenceImpl(clazz, this@JavaToJKTreeBuilder.resolveMethodReference(clazz, this)) + return JKMethodReferenceImpl( + this@JavaToJKTreeBuilder.resolveMethodReference(clazz, this), + if (clazz is JKMultiverseClass) JKReference.JKReferenceType.U2M else JKReference.JKReferenceType.U2U + ) } - fun PsiField.convertFieldReference(): JKJavaFieldReference { + fun PsiField.convertFieldReference(): JKFieldReference { val clazz = this@JavaToJKTreeBuilder.resolveClassReference(containingClass ?: TODO()) - return JKFieldReferenceImpl(clazz, this@JavaToJKTreeBuilder.resolveFieldReference(clazz, this)) + return JKFieldReferenceImpl( + this@JavaToJKTreeBuilder.resolveFieldReference(clazz, this), + if (clazz is JKMultiverseClass) JKReference.JKReferenceType.U2M else JKReference.JKReferenceType.U2U + ) } - fun PsiClass.convertClassReference(): JKJavaClassReference { - return JKClassReferenceImpl(this@JavaToJKTreeBuilder.resolveClassReference(this)) + fun PsiClass.convertClassReference(): JKClassReference { + val clazz = this@JavaToJKTreeBuilder.resolveClassReference(this) + return JKClassReferenceImpl( + clazz, if (clazz is JKMultiverseClass) JKReference.JKReferenceType.U2M else JKReference.JKReferenceType.U2U + ) } fun PsiType.toJK(): JKType { @@ -245,18 +252,21 @@ class JavaToJKTreeBuilder : ReferenceTargetProvider { else -> JKClass.ClassKind.CLASS } return JKClassImpl(with(modifierMapper) { modifierList.toJK() }, JKNameIdentifierImpl(name!!), classKind).apply { - declarations = children.mapNotNull { ElementVisitor(this@DeclarationMapper).apply { it.accept(this) }.resultElement as? JKDeclaration } + declarations = + children.mapNotNull { ElementVisitor(this@DeclarationMapper).apply { it.accept(this) }.resultElement as? JKDeclaration } } } fun PsiField.toJK(): JKJavaField { return JKJavaFieldImpl(with(modifierMapper) { modifierList.toJK() }, with(expressionTreeMapper) { type.toJK() }, - JKNameIdentifierImpl(this.name!!), with(expressionTreeMapper) { initializer?.toJK() }) + JKNameIdentifierImpl(this.name), with(expressionTreeMapper) { initializer?.toJK() } ?: TODO()) } fun PsiMethod.toJK(): JKJavaMethod { - return JKJavaMethodImpl(with(modifierMapper) { modifierList.toJK() }, JKNameIdentifierImpl(name), - parameterList.parameters.map { it -> it.toJK() }, body?.toJK()) + return JKJavaMethodImpl( + with(modifierMapper) { modifierList.toJK() }, JKNameIdentifierImpl(name), + parameterList.parameters.map { it -> it.toJK() }, body?.toJK() ?: TODO() + ) } fun PsiMember.toJK(): JKDeclaration? = when (this) { @@ -282,17 +292,10 @@ class JavaToJKTreeBuilder : ReferenceTargetProvider { } private inner class ModifierMapper { - fun PsiModifierList?.toJK(): JKModifierList { - - val modifierList = JKModifierListImpl() - if (this == null) return modifierList - - modifierList.modifiers = PsiModifier.MODIFIERS - .filter { hasExplicitModifier(it) } - .map { modifierToJK(it) } - - return modifierList - } + fun PsiModifierList?.toJK(): JKModifierList = JKModifierListImpl( + if (this == null) emptyList() + else PsiModifier.MODIFIERS.filter { hasExplicitModifier(it) }.map { modifierToJK(it) }.toMutableList() + ) fun modifierToJK(name: String): JKModifier = when (name) { PsiModifier.PUBLIC -> JKJavaAccessModifierImpl(JKJavaAccessModifier.AccessModifierType.PUBLIC) diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/JavaFieldToKotlinPropertyConversion.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/JavaFieldToKotlinPropertyConversion.kt index ed5d455c641..9d10a1429cd 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/JavaFieldToKotlinPropertyConversion.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/JavaFieldToKotlinPropertyConversion.kt @@ -16,36 +16,50 @@ package org.jetbrains.kotlin.j2k.conversions -import org.jetbrains.kotlin.j2k.tree.JKDeclaration +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.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 JavaFieldToKotlinPropertyConversion : TransformerBasedConversion() { + override fun visitElement(element: JKElement) { + element.acceptChildren(this, null) + } - override fun visitElement(element: JKElement): JKElement = element.also { it.transformChildren(this, null) } - - override fun visitJavaField(javaField: JKJavaField): JKDeclaration { + override fun visitClass(klass: JKClass) { somethingChanged = true - - return JKKtPropertyImpl(javaField.modifierList, javaField.type, javaField.name, javaField.initializer) + klass.declarations = klass.declarations.map { + if (it is JKJavaField) JKKtPropertyImpl( + it.modifierList, + it.type, + it.name, + it.initializer, + JKBlockImpl(), + JKBlockImpl() + ) else it + } } } class JavaMethodToKotlinFunctionConversion : TransformerBasedConversion() { - override fun visitElement(element: JKElement): JKElement = element.also { it.transformChildren(this, null) } + override fun visitElement(element: JKElement) { + element.acceptChildren(this, null) + } - override fun visitJavaMethod(javaMethod: JKJavaMethod): JKDeclaration { + override fun visitClass(klass: JKClass) { somethingChanged = true - return JKKtFunctionImpl( - JKJavaPrimitiveTypeImpl.BOOLEAN, - javaMethod.name, - javaMethod.valueArguments, - javaMethod.block, - javaMethod.modifierList - ) + klass.declarations = klass.declarations.map { + if (it is JKJavaMethod) JKKtFunctionImpl( + JKJavaPrimitiveTypeImpl.BOOLEAN, + it.name, + it.valueArguments, + it.block, + it.modifierList + ) else it + } } } \ No newline at end of file diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/TransformerBasedConversion.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/TransformerBasedConversion.kt index 6c72331ceac..7b0268fa945 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/TransformerBasedConversion.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/TransformerBasedConversion.kt @@ -17,9 +17,9 @@ package org.jetbrains.kotlin.j2k.conversions import org.jetbrains.kotlin.j2k.tree.JKElement -import org.jetbrains.kotlin.j2k.tree.visitors.JKTransformerVoid +import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitorVoid -abstract class TransformerBasedConversion : BaseConversion(), JKTransformerVoid { +abstract class TransformerBasedConversion : BaseConversion(), JKVisitorVoid { protected var somethingChanged = false override fun runConversion(treeRoot: JKElement): Boolean { diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/DebugTreePrinter.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/DebugTreePrinter.kt index d8f7be2c99e..dea92779244 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/DebugTreePrinter.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/DebugTreePrinter.kt @@ -75,12 +75,12 @@ private class DebugTreePrinter : JKVisitorVoid { override fun visitMethodReference(methodReference: JKMethodReference) { printer.println(methodReference.classNameWithoutJK()) - printer.println(methodReference.containerClass.name.name, "@", methodReference.target.name.name) + printer.println(methodReference.target.parent.let { (it as? JKClass)?.name?.name ?: "null" }, "@", methodReference.target.name.name) } override fun visitFieldReference(fieldReference: JKFieldReference) { printer.println(fieldReference.classNameWithoutJK()) - printer.println(fieldReference.containerClass.name.name, "@", fieldReference.target.name.name) + printer.println(fieldReference.target.parent.let { (it as? JKClass)?.name?.name ?: "null" }, "@", fieldReference.target.name.name) } override fun visitClassReference(classReference: JKClassReference) { @@ -91,8 +91,8 @@ private class DebugTreePrinter : JKVisitorVoid { override fun visitType(type: JKType) { printer.println(type.classNameWithoutJK(), " \"") printer.indented { - if(type is JKClassType) - printer.println(type.classReference.target.name.name) + if (type is JKClassType) + printer.println(type.classReference.target.name.name) } printer.println("\"") } diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/conveersionCache/Abstractions.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/conveersionCache/Abstractions.kt index 188af409152..10d450b7db3 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/conveersionCache/Abstractions.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/conveersionCache/Abstractions.kt @@ -14,27 +14,4 @@ * limitations under the License. */ -package org.jetbrains.kotlin.j2k.tree.conveersionCache - -import org.jetbrains.kotlin.j2k.tree.JKDeclaration -import org.jetbrains.kotlin.j2k.tree.JKElement -import org.jetbrains.kotlin.j2k.tree.visitors.JKTransformer -import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor - -interface JKMultiverseDeclaration : JKDeclaration{ - override fun accept(visitor: JKVisitor, data: D): R { - TODO("not implemented") //To change body of created functions use File | Settings | File Templates. - } - - override fun transform(transformer: JKTransformer, data: D): R { - TODO("not implemented") //To change body of created functions use File | Settings | File Templates. - } - - override fun acceptChildren(visitor: JKVisitor, data: D) { - TODO("not implemented") //To change body of created functions use File | Settings | File Templates. - } - - override fun transformChildren(transformer: JKTransformer, data: D) { - TODO("not implemented") //To change body of created functions use File | Settings | File Templates. - } -} +package org.jetbrains.kotlin.j2k.tree.conveersionCache \ No newline at end of file diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/conveersionCache/Implementations.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/conveersionCache/Implementations.kt index c9f3e4f5570..1369fcec67c 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/conveersionCache/Implementations.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/conveersionCache/Implementations.kt @@ -20,43 +20,29 @@ 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 -import org.jetbrains.kotlin.j2k.tree.impl.JKReferenceType -import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor -class JKMultiverseField(override var name: JKNameIdentifier) : JKMultiverseDeclaration, JKJavaField { - override var initializer: JKExpression? = null +class JKMultiverseField(override var name: JKNameIdentifier) : JKField, JKElementBase() { override var modifierList: JKModifierList = JKModifierListImpl() override var type: JKType = JKJavaPrimitiveTypeImpl.BOOLEAN //TODO override val valid: Boolean get() = true } -class JKMultiverseProperty : JKMultiverseDeclaration { - override val valid: Boolean - get() = true -} - -class JKMultiverseMethod(override var name: JKNameIdentifier) : JKMultiverseDeclaration, JKMethod { +class JKMultiverseMethod(override var name: JKNameIdentifier) : JKMethod, JKElementBase() { + override val returnType: JKType + get() = TODO("not implemented") override var modifierList: JKModifierList = JKModifierListImpl() - override var block: JKBlock? = null override var valueArguments: List = listOf() override val valid: Boolean get() = true } -class JKMultiverseClass(override var name: JKNameIdentifier, override var declarations: List, - override var classKind: JKClass.ClassKind, override var modifierList: JKModifierList) : JKClass, JKMultiverseDeclaration { +class JKMultiverseClass( + override var name: JKNameIdentifier, override var declarations: List, + override var classKind: JKClass.ClassKind, override var modifierList: JKModifierList +) : JKClass, JKElementBase() { + override var parent: JKElement? = null override val valid: Boolean get() = true -} - -class JKMultiverseClassReferenceImpl(override val target: JKClass) : JKJavaClassReference, JKElementBase() { - override val referenceType: JKReferenceType = JKReferenceType.M2U - - override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaClassReference(this, data) - - override fun acceptChildren(visitor: JKVisitor, data: D) { - - } } \ No newline at end of file diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/conveersionCache/ReferenceTargetProvider.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/conveersionCache/ReferenceTargetProvider.kt index 6b6e595b17b..6e9e967b3e5 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/conveersionCache/ReferenceTargetProvider.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/conveersionCache/ReferenceTargetProvider.kt @@ -20,6 +20,7 @@ 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.JKJavaField import org.jetbrains.kotlin.j2k.tree.JKMethod import org.jetbrains.kotlin.j2k.tree.impl.JKNameIdentifierImpl @@ -31,11 +32,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.declarations += it } } - fun resolveFieldReference(clazz: JKClass, field: PsiField): JKJavaField { - return clazz.declarations.asSequence().filter { it is JKJavaField && it.name.name == field.name }.firstOrNull() as JKJavaField? - ?: JKMultiverseField(JKNameIdentifierImpl(field.name!!)).also { clazz.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 } } } \ No newline at end of file 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 fb67ba2b7d0..1902f45463c 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt @@ -17,30 +17,29 @@ package org.jetbrains.kotlin.j2k.tree.impl import org.jetbrains.kotlin.j2k.tree.* -import org.jetbrains.kotlin.j2k.tree.visitors.JKTransformer import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor -class JKJavaFieldImpl(override var modifierList: JKModifierList, - override var type: JKType, - override var name: JKNameIdentifier, - override var initializer: JKExpression?) : JKJavaField, JKElementBase() { +class JKJavaFieldImpl( + override var modifierList: JKModifierList, + override var type: JKType, + override var name: JKNameIdentifier, + override var initializer: JKExpression +) : JKJavaField, JKElementBase() { override val valid: Boolean get() = true override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaField(this, data) - override fun acceptChildren(visitor: JKVisitor, data: D) = - listOfNotNull(type, name, initializer).forEach { it.accept(visitor, data) } - - override fun transformChildren(transformer: JKTransformer, data: D) { - type = type.transform(transformer, data) - name = name.transform(transformer, data) - initializer = initializer?.transform(transformer, data) + override fun acceptChildren(visitor: JKVisitor, data: D) { + type.accept(visitor, data) + name.accept(visitor, data) + initializer.accept(visitor, data) } } - -class JKJavaLiteralExpressionImpl(override val literal: String, override val type: JKLiteralExpression.LiteralType) : JKJavaLiteralExpression, JKElementBase() { +class JKJavaLiteralExpressionImpl( + override val literal: String, override val type: JKLiteralExpression.LiteralType +) : JKJavaLiteralExpression, JKElementBase() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaLiteralExpression(this, data) } @@ -57,36 +56,28 @@ class JKJavaMethodImpl( override var modifierList: JKModifierList, override var name: JKNameIdentifier, override var valueArguments: List, - override var block: JKBlock? + override var block: JKBlock ) : JKJavaMethod, JKElementBase() { + override val returnType: JKType + get() = TODO() + override val valid: Boolean get() = true override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaMethod(this, data) - override fun transformChildren(transformer: JKTransformer, data: D) { - modifierList = modifierList.transform(transformer, data) - name = name.transform(transformer, data) - valueArguments = valueArguments.map { it.transform(transformer, data) } - block = block?.transform(transformer, data) - } } -sealed class JKJavaOperatorIdentifierImpl : JKJavaOperatorIdentifier, JKElementBase() { - override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaOperatorIdentifier(this, data) - - object PLUS : JKJavaOperatorIdentifierImpl() - object MINUS : JKJavaOperatorIdentifierImpl() +sealed class JKJavaOperatorImpl : JKOperator, JKElementBase() { + object PLUS : JKJavaOperatorImpl() + object MINUS : JKJavaOperatorImpl() } -sealed class JKJavaQualificationIdentifierImpl : JKJavaQualificationIdentifier, JKElementBase() { - override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaQualificationIdentifier(this, data) - - object DOT : JKJavaQualificationIdentifierImpl() +sealed class JKJavaQualifierImpl : JKQualifier, JKElementBase() { + object DOT : JKJavaQualifierImpl() } class JKJavaMethodCallExpressionImpl( - override var identifier: JKMethodReference, - override var arguments: JKExpressionList + override var identifier: JKMethodReference, override var arguments: JKExpressionList ) : JKJavaMethodCallExpression, JKElementBase() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaMethodCallExpression(this, data) @@ -94,39 +85,24 @@ class JKJavaMethodCallExpressionImpl( identifier.accept(visitor, data) arguments.accept(visitor, data) } - - override fun transformChildren(transformer: JKTransformer, data: D) { - identifier = identifier.transform(transformer, data) - arguments = arguments.transform(transformer, data) - } } -class JKJavaFieldAccessExpressionImpl(override var identifier: JKReference) : JKJavaFieldAccessExpression, JKElementBase() { +class JKJavaFieldAccessExpressionImpl(override var identifier: JKFieldReference) : 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) } - - override fun transformChildren(transformer: JKTransformer, data: D) { - identifier = identifier.transform(transformer, data) - } } class JKJavaNewExpressionImpl( - override var identifier: JKClassReference, - override var arguments: JKExpressionList + override var identifier: JKClassReference, override var arguments: JKExpressionList ) : JKJavaNewExpression, JKElementBase() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaNewExpression(this, data) override fun acceptChildren(visitor: JKVisitor, data: D) { identifier.accept(visitor, data) } - - override fun transformChildren(transformer: JKTransformer, data: D) { - identifier = identifier.transform(transformer, data) - arguments = arguments.transform(transformer, data) - } } class JKJavaNewEmptyArrayImpl(override var initializer: List) : JKJavaNewEmptyArray, JKElementBase() { @@ -135,10 +111,6 @@ class JKJavaNewEmptyArrayImpl(override var initializer: List acceptChildren(visitor: JKVisitor, data: D) { } - - override fun transformChildren(transformer: JKTransformer, data: D) { - initializer = initializer.map { it?.transform(transformer, data) } - } } class JKJavaNewArrayImpl(override var initializer: List) : JKJavaNewArray, JKElementBase() { @@ -147,14 +119,9 @@ class JKJavaNewArrayImpl(override var initializer: List) : JKJavaN override fun acceptChildren(visitor: JKVisitor, data: D) { } - - override fun transformChildren(transformer: JKTransformer, data: D) { - initializer = initializer.map { it.transform(transformer, data) } - } } sealed class JKJavaPrimitiveTypeImpl(override val name: String) : JKJavaPrimitiveType, JKElementBase() { - override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaPrimitiveType(this, data) override fun acceptChildren(visitor: JKVisitor, data: D) { 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 8134457ee90..35a3d3dea79 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt @@ -18,160 +18,135 @@ package org.jetbrains.kotlin.j2k.tree.impl import org.jetbrains.kotlin.j2k.ast.Nullability import org.jetbrains.kotlin.j2k.tree.* -import org.jetbrains.kotlin.j2k.tree.conveersionCache.JKMultiverseClass -import org.jetbrains.kotlin.j2k.tree.visitors.JKTransformer +import org.jetbrains.kotlin.j2k.tree.JKReference.JKReferenceType import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor +import kotlin.reflect.KProperty + +class JKChild(var value: T) { + operator fun getValue(thisRef: JKElement, property: KProperty<*>): T { + return value + } + + operator fun setValue(thisRef: JKElement, property: KProperty<*>, v: T) { + value.parent = null + v.parent = thisRef + value = v + } +} + +class JKListChild(var value: List) { + operator fun getValue(thisRef: JKElement, property: KProperty<*>): List { + return value + } + + operator fun setValue(thisRef: JKElement, property: KProperty<*>, v: List) { + value.forEach { it.parent = null } + v.forEach { it.parent = thisRef } + value = v + } +} abstract class JKElementBase : JKElement { + override var parent: JKElement? = null + + fun D.setParent(p: JKElement): D { + parent = p + return this + } + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitElement(this, data) - override fun transform(transformer: JKTransformer, data: D): R = accept(transformer, data) as R - override fun acceptChildren(visitor: JKVisitor, data: D) {} - - override fun transformChildren(transformer: JKTransformer, data: D) {} } -class JKClassImpl( - override var modifierList: JKModifierList, - override var name: JKNameIdentifier, - override var classKind: JKClass.ClassKind -) : JKClass, JKElementBase() { - override val valid: Boolean - get() = true - override var declarations: List = mutableListOf() +class JKClassImpl(modifierList: JKModifierList, override val name: JKNameIdentifier, override var classKind: JKClass.ClassKind) : JKClass, + JKElementBase() { + override var modifierList by JKChild(modifierList) + override val valid: Boolean = true + + override var declarations by JKListChild(emptyList()) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitClass(this, data) override fun acceptChildren(visitor: JKVisitor, data: D) { - (listOf(modifierList, name) + declarations).forEach { it.accept(visitor, data) } + modifierList.accept(visitor, data) + name.accept(visitor, data) + declarations.forEach { it.accept(visitor, data) } } - - override fun transformChildren(transformer: JKTransformer, data: D) { - modifierList = modifierList.transform(transformer, data) - name = name.transform(transformer, data) - declarations = declarations.map { it.transform(transformer, data) } - } - } -class JKNameIdentifierImpl(override var name: String) : JKNameIdentifier, JKElementBase() { +class JKNameIdentifierImpl(override val name: String) : JKNameIdentifier, JKElementBase() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitNameIdentifier(this, data) } -class JKModifierListImpl : JKModifierList, JKElementBase() { - override var modifiers = listOf() +class JKModifierListImpl(modifiers: List = emptyList()) : JKModifierList, JKElementBase() { + override var modifiers by JKListChild(modifiers) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitModifierList(this, data) - override fun acceptChildren(visitor: JKVisitor, data: D) { modifiers.forEach { it.accept(visitor, data) } } - - override fun transformChildren(transformer: JKTransformer, data: D) { - modifiers = modifiers.map { it.transform(transformer, data) } - } } -class JKValueArgumentImpl(override var type: JKType, - override val name: String) : JKValueArgument, JKElementBase() { +class JKValueArgumentImpl(type: JKType, override val name: String) : JKValueArgument, JKElementBase() { + override var type by JKChild(type) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitValueArgument(this, data) - override fun transformChildren(transformer: JKTransformer, data: D) { - type = type.transform(transformer, data) - } } -class JKBlockImpl(override var statements: List) : JKBlock, JKElementBase() { +class JKBlockImpl(statements: List = emptyList()) : JKBlock, JKElementBase() { + override var statements by JKListChild(statements) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitBlock(this, data) - override fun transformChildren(transformer: JKTransformer, data: D) { - statements = statements.map { it.transform(transformer, data) } - } - override fun acceptChildren(visitor: JKVisitor, data: D) { statements.forEach { it.accept(visitor, data) } } } -class JKBinaryExpressionImpl( - override var left: JKExpression, override var right: JKExpression?, - override var operator: JKOperatorIdentifier -) : JKBinaryExpression, JKElementBase() { +class JKBinaryExpressionImpl(left: JKExpression, right: JKExpression, override var operator: JKOperator) : JKBinaryExpression, + JKElementBase() { + override var right by JKChild(right) + override var left by JKChild(left) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitBinaryExpression(this, data) override fun acceptChildren(visitor: JKVisitor, data: D) { left.accept(visitor, data) - operator.accept(visitor, data) - right?.accept(visitor, data) - } - - override fun transformChildren(transformer: JKTransformer, data: D) { - left = left.transform(transformer, data) - right = right?.transform(transformer, data) - operator = operator.transform(transformer, data) + right.accept(visitor, data) } } -class JKPrefixExpressionImpl( - override var expression: JKExpression?, - override var operator: JKOperatorIdentifier -) : JKPrefixExpression, JKElementBase() { +class JKPrefixExpressionImpl(expression: JKExpression, override var operator: JKOperator) : JKPrefixExpression, JKElementBase() { + override var expression by JKChild(expression) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitPrefixExpression(this, data) override fun acceptChildren(visitor: JKVisitor, data: D) { - expression?.accept(visitor, data) - operator.accept(visitor, data) - } - - override fun transformChildren(transformer: JKTransformer, data: D) { - expression = expression?.transform(transformer, data) - operator = operator.transform(transformer, data) + expression.accept(visitor, data) } } -class JKPostfixExpressionImpl( - override var expression: JKExpression, - override var operator: JKOperatorIdentifier -) : JKPostfixExpression, JKElementBase() { +class JKPostfixExpressionImpl(expression: JKExpression, override var operator: JKOperator) : JKPostfixExpression, JKElementBase() { + override var expression by JKChild(expression) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitPostfixExpression(this, data) override fun acceptChildren(visitor: JKVisitor, data: D) { - expression?.accept(visitor, data) - operator.accept(visitor, data) - } - - override fun transformChildren(transformer: JKTransformer, data: D) { - expression = expression?.transform(transformer, data) - operator = operator.transform(transformer, data) + expression.accept(visitor, data) } } -class JKExpressionListImpl(override var expressions: Array) : JKExpressionList, JKElementBase() { +class JKExpressionListImpl(expressions: List = emptyList()) : JKExpressionList, JKElementBase() { + override var expressions by JKListChild(expressions) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitExpressionList(this, data) override fun acceptChildren(visitor: JKVisitor, data: D) { expressions.forEach { it.accept(visitor, data) } } - - override fun transformChildren(transformer: JKTransformer, data: D) { - expressions = expressions.map { it.transform(transformer, data) }.toTypedArray() - } } class JKQualifiedExpressionImpl( - override var receiver: JKExpression, override var operator: JKQualificationIdentifier, - override var selector: JKStatement + override var receiver: JKExpression, override var operator: JKQualifier, override var selector: JKExpression ) : JKQualifiedExpression, JKElementBase() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitQualifiedExpression(this, data) override fun acceptChildren(visitor: JKVisitor, data: D) { receiver.accept(visitor, data) - operator.accept(visitor, data) selector.accept(visitor, data) } - - override fun transformChildren(transformer: JKTransformer, data: D) { - receiver = receiver.transform(transformer, data) - operator = operator.transform(transformer, data) - selector = selector.transform(transformer, data) - } } class JKExpressionStatementImpl(override val expression: JKExpression) : JKExpressionStatement, JKElementBase() { @@ -181,48 +156,38 @@ class JKExpressionStatementImpl(override val expression: JKExpression) : JKExpre } } -class JKArrayAccessExpressionImpl(override var expression: JKExpression, override var indexExpression: JKExpression?) : +class JKArrayAccessExpressionImpl(override var expression: JKExpression, override var indexExpression: JKExpression) : JKArrayAccessExpression, JKElementBase() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitArrayAccessExpression(this, data) override fun acceptChildren(visitor: JKVisitor, data: D) { expression.accept(visitor, data) - indexExpression?.accept(visitor, data) - } - - override fun transformChildren(transformer: JKTransformer, data: D) { - expression = expression.transform(transformer, data) - indexExpression = expression.transform(transformer, data) + indexExpression.accept(visitor, data) } } -class JKParenthesizedExpressionImpl(override var expression: JKExpression?) : JKParenthesizedExpression, JKElementBase() { +class JKParenthesizedExpressionImpl(override var expression: JKExpression) : JKParenthesizedExpression, JKElementBase() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitParenthesizedExpression(this, data) override fun acceptChildren(visitor: JKVisitor, data: D) { - expression?.accept(visitor, data) - } - - override fun transformChildren(transformer: JKTransformer, data: D) { - expression = expression?.transform(transformer, data) + expression.accept(visitor, data) } } -class JKTypeCastExpressionImpl(override var expression: JKExpression?, override var type: JKType?) : JKTypeCastExpression, JKElementBase() { +class JKTypeCastExpressionImpl(override var expression: JKExpression, override var type: JKType) : JKTypeCastExpression, JKElementBase() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitTypeCastExpression(this, data) override fun acceptChildren(visitor: JKVisitor, data: D) { - expression?.accept(visitor, data) - type?.accept(visitor, data) - } - - override fun transformChildren(transformer: JKTransformer, data: D) { - expression = expression?.transform(transformer, data) - type = type?.transform(transformer, data) + expression.accept(visitor, data) + type.accept(visitor, data) } } -class JKClassTypeImpl(override val classReference: JKClassReference, override val parameters: List, override val nullability: Nullability = Nullability.Default) : JKClassType, JKElementBase() { +class JKClassTypeImpl( + override val classReference: JKClassReference, + override val parameters: List, + override val nullability: Nullability = Nullability.Default +) : JKClassType, JKElementBase() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitClassType(this, data) @@ -231,36 +196,25 @@ class JKClassTypeImpl(override val classReference: JKClassReference, override va } } -sealed class JKReferenceType { - object U2U : JKReferenceType() - object U2M : JKReferenceType() - object M2U : JKReferenceType() -} - -class JKFieldReferenceImpl(override val containerClass: JKClass, override val target: JKJavaField) : JKJavaFieldReference, JKElementBase() { - override val referenceType: JKReferenceType = if (containerClass is JKMultiverseClass) JKReferenceType.U2M else JKReferenceType.U2U - - override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaFieldReference(this, data) +class JKFieldReferenceImpl(override val target: JKField, override val referenceType: JKReferenceType) : JKFieldReference, JKElementBase() { + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitFieldReference(this, data) override fun acceptChildren(visitor: JKVisitor, data: D) { } } -class JKClassReferenceImpl(override val target: JKClass) : JKJavaClassReference, JKElementBase() { - override val referenceType: JKReferenceType = if (target is JKMultiverseClass) JKReferenceType.U2M else JKReferenceType.U2U - - override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaClassReference(this, data) +class JKClassReferenceImpl(override val target: JKClass, override val referenceType: JKReferenceType) : JKClassReference, JKElementBase() { + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitClassReference(this, data) override fun acceptChildren(visitor: JKVisitor, data: D) { } } -class JKMethodReferenceImpl(override val containerClass: JKClass, override val target: JKMethod) : JKJavaMethodReference, JKElementBase() { - override val referenceType: JKReferenceType = if (containerClass is JKMultiverseClass) JKReferenceType.U2M else JKReferenceType.U2U - - override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaMethodReference(this, data) +class JKMethodReferenceImpl(override val target: JKMethod, override val referenceType: JKReferenceType) : JKMethodReference, + JKElementBase() { + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitMethodReference(this, data) override fun acceptChildren(visitor: JKVisitor, data: D) { 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 1612ba18f3b..ce336c17230 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/k.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/k.kt @@ -17,56 +17,51 @@ package org.jetbrains.kotlin.j2k.tree.impl import org.jetbrains.kotlin.j2k.tree.* -import org.jetbrains.kotlin.j2k.tree.visitors.JKTransformer import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor -class JKKtPropertyImpl(override var modifierList: JKModifierList, - override var type: JKType, - override var name: JKNameIdentifier, - override var initializer: JKExpression? = null, - override var getter: JKBlock? = null, - override var setter: JKBlock? = null) : JKElementBase(), JKKtProperty { +class JKKtPropertyImpl( + override var modifierList: JKModifierList, + override var type: JKType, + override var name: JKNameIdentifier, + override var initializer: JKExpression, + override var getter: JKBlock, + override var setter: JKBlock +) : JKElementBase(), JKKtProperty { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitKtProperty(this, data) override fun acceptChildren(visitor: JKVisitor, data: D) { modifierList.accept(visitor, data) type.accept(visitor, data) name.accept(visitor, data) - initializer?.accept(visitor, data) - getter?.accept(visitor, data) - setter?.accept(visitor, data) - } - - override fun transformChildren(transformer: JKTransformer, data: D) { - modifierList = modifierList.transform(transformer, data) - type = type.transform(transformer, data) - name = name.transform(transformer, data) - initializer = initializer?.transform(transformer, data) - getter = getter?.transform(transformer, data) - setter = setter?.transform(transformer, data) + initializer.accept(visitor, data) + getter.accept(visitor, data) + setter.accept(visitor, data) } override val valid: Boolean get() = true } -class JKKtFunctionImpl(override var returnType: JKType, - override var name: JKNameIdentifier, - override var valueArguments: List, - override var block: JKBlock?, - override var modifierList: JKModifierList) : JKElementBase(), JKKtFunction { +class JKKtFunctionImpl( + override var returnType: JKType, + override var name: JKNameIdentifier, + override var valueArguments: List, + override var block: JKBlock, + override var modifierList: JKModifierList +) : JKElementBase(), JKKtFunction { override val valid: Boolean get() = true } -sealed class JKKtQualificationIdentifierImpl : JKKtQualificationIdentifier, JKElementBase() { - override fun accept(visitor: JKVisitor, data: D): R = visitor.visitKtQualificationIdentifier(this, data) +sealed class JKKtQualifierImpl : JKQualifier, JKElementBase() { - object DOT : JKKtQualificationIdentifierImpl() - object SAFE : JKKtQualificationIdentifierImpl() + object DOT : JKKtQualifierImpl() + object SAFE : JKKtQualifierImpl() } -class JKKtCallExpressionImpl(override val identifier: JKMethodReference, - override val arguments: JKExpressionList) : JKKtMethodCallExpression, JKElementBase() { +class JKKtCallExpressionImpl( + override val identifier: JKMethodReference, + 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) { @@ -83,13 +78,12 @@ class JKKtFieldAccessExpressionImpl(override val identifier: JKFieldReference) : } } -class JKKtLiteralExpressionImpl(override val literal: String, override val type: JKLiteralExpression.LiteralType) : JKKtLiteralExpression, JKElementBase() { +class JKKtLiteralExpressionImpl(override val literal: String, override val type: JKLiteralExpression.LiteralType) : JKKtLiteralExpression, + JKElementBase() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitKtLiteralExpression(this, data) } -sealed class JKKtOperatorIdentifierImpl : JKKtOperatorIdentifier, JKElementBase() { - override fun accept(visitor: JKVisitor, data: D): R = visitor.visitKtOperatorIdentifier(this, data) - - object PLUS : JKKtOperatorIdentifierImpl() - object MINUS : JKKtOperatorIdentifierImpl() +sealed class JKKtOperatorImpl : JKOperator, JKElementBase() { + object PLUS : JKKtOperatorImpl() + object MINUS : JKKtOperatorImpl() } \ 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 631581d0daf..97692c15297 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt @@ -16,13 +16,13 @@ package org.jetbrains.kotlin.j2k.tree -interface JKJavaField : JKDeclaration, JKModifierListOwner { - val type: JKType - val name: JKNameIdentifier - val initializer: JKExpression? +interface JKJavaField : JKField { + val initializer: JKExpression } -interface JKJavaMethod : JKMethod +interface JKJavaMethod : JKMethod { + val block: JKBlock +} interface JKJavaForLoop : JKLoop @@ -36,10 +36,6 @@ interface JKJavaArrayType : JKType { val type: JKType } -interface JKJavaOperatorIdentifier : JKOperatorIdentifier - -interface JKJavaQualificationIdentifier : JKQualificationIdentifier - interface JKJavaMethodCallExpression : JKMethodCallExpression interface JKJavaFieldAccessExpression : JKFieldAccessExpression @@ -49,12 +45,6 @@ interface JKJavaNewExpression : JKExpression { val arguments: JKExpressionList } -interface JKJavaMethodReference : JKMethodReference - -interface JKJavaFieldReference : JKFieldReference - -interface JKJavaClassReference : JKClassReference - interface JKJavaAccessModifier : JKAccessModifier { val type: AccessModifierType diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt index 9a70775a718..15ed1c38d1f 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt @@ -17,96 +17,65 @@ package org.jetbrains.kotlin.j2k.tree import org.jetbrains.kotlin.j2k.ast.Nullability -import org.jetbrains.kotlin.j2k.tree.impl.JKReferenceType -import org.jetbrains.kotlin.j2k.tree.visitors.JKTransformer import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor interface JKElement { + var parent: JKElement? + fun accept(visitor: JKVisitor, data: D): R - fun transform(transformer: JKTransformer, data: D): R fun acceptChildren(visitor: JKVisitor, data: D) - fun transformChildren(transformer: JKTransformer, data: D) } +interface JKDeclaration : JKElement, JKReferenceTarget + interface JKClass : JKDeclaration, JKModifierListOwner { val name: JKNameIdentifier - val declarations: MutableList - val classKind: ClassKind + var declarations: List + var classKind: ClassKind enum class ClassKind { ABSTRACT, ANNOTATION, CLASS, ENUM, INTERFACE } } -interface JKStatement : JKElement - -interface JKExpression : JKStatement - -interface JKBinaryExpression : JKExpression { - val left: JKExpression - val right: JKExpression? - val operator: JKOperatorIdentifier +interface JKMethod : JKDeclaration, JKModifierListOwner { + val name: JKNameIdentifier + var valueArguments: List + val returnType: JKType } -interface JKUnaryExpression : JKExpression { - val expression: JKExpression? - val operator: JKOperatorIdentifier +interface JKField : JKDeclaration, JKModifierListOwner { + val type: JKType + val name: JKNameIdentifier } -interface JKPrefixExpression : JKUnaryExpression +interface JKModifier : JKElement -interface JKPostfixExpression : JKUnaryExpression { - override val expression: JKExpression +interface JKModifierList : JKElement { + var modifiers: List } -interface JKQualifiedExpression : JKExpression { - val receiver: JKExpression - val operator: JKQualificationIdentifier - val selector: JKStatement -} +interface JKAccessModifier : JKModifier -interface JKMethodCallExpression : JKExpression { - val identifier: JKMethodReference - val arguments: JKExpressionList -} - -interface JKFieldAccessExpression : JKExpression { - val identifier: JKReference -} - -interface JKArrayAccessExpression : JKExpression { - val expression: JKExpression - val indexExpression: JKExpression? -} - -interface JKParenthesizedExpression : JKExpression { - val expression: JKExpression? -} - -interface JKTypeCastExpression : JKExpression { - val expression: JKExpression? - val type: JKType? -} - -interface JKExpressionList : JKElement { - val expressions: Array -} +interface JKModalityModifier : JKModifier interface JKReference : JKElement { val target: JKReferenceTarget val referenceType: JKReferenceType + + enum class JKReferenceType { + U2U, U2M, M2U + } } interface JKMethodReference : JKReference { - val containerClass: JKClass override val target: JKMethod } interface JKFieldReference : JKReference { - val containerClass: JKClass - override val target: JKJavaField + override val target: JKField } interface JKClassReference : JKReference { @@ -121,16 +90,12 @@ interface JKClassType : JKType { val parameters: List } -interface JKOperatorIdentifier : JKIdentifier - -interface JKQualificationIdentifier : JKIdentifier +interface JKStatement : JKElement interface JKLoop : JKStatement -interface JKDeclaration : JKElement, JKReferenceTarget - interface JKBlock : JKElement { - val statements: List + var statements: List } interface JKIdentifier : JKElement @@ -139,6 +104,60 @@ interface JKNameIdentifier : JKIdentifier { val name: String } +interface JKExpression : JKElement + +interface JKExpressionStatement : JKStatement { + val expression: JKExpression +} + +interface JKBinaryExpression : JKExpression { + var left: JKExpression + var right: JKExpression + var operator: JKOperator +} + +interface JKUnaryExpression : JKExpression { + var expression: JKExpression + var operator: JKOperator +} + +interface JKPrefixExpression : JKUnaryExpression + +interface JKPostfixExpression : JKUnaryExpression + +interface JKQualifiedExpression : JKExpression { + val receiver: JKExpression + val operator: JKQualifier + val selector: JKExpression +} + +interface JKMethodCallExpression : JKExpression { + val identifier: JKMethodReference + val arguments: JKExpressionList +} + +interface JKFieldAccessExpression : JKExpression { + val identifier: JKFieldReference +} + +interface JKArrayAccessExpression : JKExpression { + val expression: JKExpression + val indexExpression: JKExpression +} + +interface JKParenthesizedExpression : JKExpression { + val expression: JKExpression +} + +interface JKTypeCastExpression : JKExpression { + val expression: JKExpression + val type: JKType +} + +interface JKExpressionList : JKElement { + var expressions: List +} + interface JKLiteralExpression : JKExpression { val literal: String val type: LiteralType @@ -148,32 +167,11 @@ interface JKLiteralExpression : JKExpression { } } -interface JKModifierList : JKElement { - val modifiers: List -} - -interface JKModifier : JKElement - -interface JKAccessModifier : JKModifier - interface JKValueArgument : JKElement { - val type: JKType + var type: JKType val name: String } interface JKStringLiteralExpression : JKLiteralExpression { val text: String -} - -interface JKModalityModifier : JKModifier - -interface JKMethod : JKDeclaration { - var modifierList: JKModifierList - var name: JKNameIdentifier - var valueArguments: List - var block: JKBlock? -} - -interface JKExpressionStatement : JKStatement { - val expression: JKExpression } \ No newline at end of file diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/k.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/k.kt index 49d4be88105..5ac8ce746cd 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/k.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/k.kt @@ -16,7 +16,15 @@ package org.jetbrains.kotlin.j2k.tree -interface JKKtFun : JKDeclaration +interface JKKtProperty : JKField { + val initializer: JKExpression + val getter: JKBlock + val setter: JKBlock +} + +interface JKKtFunction : JKMethod { + val block: JKBlock +} interface JKKtConstructor : JKDeclaration @@ -26,20 +34,6 @@ interface JKKtAssignmentStatement : JKStatement interface JKKtCall : JKMethodCallExpression -interface JKKtProperty : JKDeclaration, JKModifierListOwner { - val type: JKType - val name: JKNameIdentifier - val initializer: JKExpression? - val getter: JKBlock? - val setter: JKBlock? -} - -interface JKKtFunction : JKDeclaration, JKModifierListOwner { - val returnType: JKType - val name: JKNameIdentifier - val valueArguments: List - val block: JKBlock? -} interface JKKtModifier : JKModifier { val type: KtModifierType @@ -49,12 +43,8 @@ interface JKKtModifier : JKModifier { } } -interface JKKtQualificationIdentifier : JKQualificationIdentifier - interface JKKtMethodCallExpression : JKMethodCallExpression interface JKKtFieldAccessExpression : JKFieldAccessExpression -interface JKKtLiteralExpression : JKLiteralExpression - -interface JKKtOperatorIdentifier : JKOperatorIdentifier \ No newline at end of file +interface JKKtLiteralExpression : JKLiteralExpression \ No newline at end of file diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/markers.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/markers.kt index 00d56c82cb4..7cf80fefe92 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/markers.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/markers.kt @@ -16,6 +16,10 @@ package org.jetbrains.kotlin.j2k.tree +interface JKOperator + +interface JKQualifier + interface JKModifierListOwner { var modifierList: JKModifierList } diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKTransformer.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKTransformer.kt index edab7c47185..a7e94cf299e 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKTransformer.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKTransformer.kt @@ -4,9 +4,27 @@ import org.jetbrains.kotlin.j2k.tree.* interface JKTransformer : JKVisitor { 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 visitExpression(expression: JKExpression, data: D): JKExpression = visitStatement(expression, data) as JKExpression + 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 @@ -18,58 +36,31 @@ interface JKTransformer : JKVisitor { 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 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 visitOperatorIdentifier(operatorIdentifier: JKOperatorIdentifier, data: D): JKOperatorIdentifier = visitIdentifier(operatorIdentifier, data) as JKOperatorIdentifier - override fun visitQualificationIdentifier(qualificationIdentifier: JKQualificationIdentifier, data: D): JKQualificationIdentifier = visitIdentifier(qualificationIdentifier, data) as JKQualificationIdentifier - override fun visitLoop(loop: JKLoop, data: D): JKLoop = visitStatement(loop, data) as JKLoop - override fun visitDeclaration(declaration: JKDeclaration, data: D): JKDeclaration = visitElement(declaration, data) as JKDeclaration - 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 visitLiteralExpression(literalExpression: JKLiteralExpression, data: D): JKLiteralExpression = visitExpression(literalExpression, data) as JKLiteralExpression - override fun visitModifierList(modifierList: JKModifierList, data: D): JKModifierList = visitElement(modifierList, data) as JKModifierList - override fun visitModifier(modifier: JKModifier, data: D): JKModifier = visitElement(modifier, data) as JKModifier - override fun visitAccessModifier(accessModifier: JKAccessModifier, data: D): JKAccessModifier = visitModifier(accessModifier, data) as JKAccessModifier 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 visitModalityModifier(modalityModifier: JKModalityModifier, data: D): JKModalityModifier = visitModifier(modalityModifier, data) as JKModalityModifier - override fun visitMethod(method: JKMethod, data: D): JKMethod = visitDeclaration(method, data) as JKMethod - override fun visitExpressionStatement(expressionStatement: JKExpressionStatement, data: D): JKExpressionStatement = visitStatement(expressionStatement, data) as JKExpressionStatement - override fun visitJavaField(javaField: JKJavaField, data: D): JKDeclaration = visitDeclaration(javaField, data) + 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 visitJavaOperatorIdentifier(javaOperatorIdentifier: JKJavaOperatorIdentifier, data: D): JKOperatorIdentifier = visitOperatorIdentifier(javaOperatorIdentifier, data) - override fun visitJavaQualificationIdentifier(javaQualificationIdentifier: JKJavaQualificationIdentifier, data: D): JKQualificationIdentifier = visitQualificationIdentifier(javaQualificationIdentifier, 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 visitJavaMethodReference(javaMethodReference: JKJavaMethodReference, data: D): JKMethodReference = visitMethodReference(javaMethodReference, data) - override fun visitJavaFieldReference(javaFieldReference: JKJavaFieldReference, data: D): JKFieldReference = visitFieldReference(javaFieldReference, data) - override fun visitJavaClassReference(javaClassReference: JKJavaClassReference, data: D): JKClassReference = visitClassReference(javaClassReference, 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 visitKtFun(ktFun: JKKtFun, data: D): JKDeclaration = visitDeclaration(ktFun, 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 visitKtProperty(ktProperty: JKKtProperty, data: D): JKDeclaration = visitDeclaration(ktProperty, data) - override fun visitKtFunction(ktFunction: JKKtFunction, data: D): JKDeclaration = visitDeclaration(ktFunction, data) override fun visitKtModifier(ktModifier: JKKtModifier, data: D): JKModifier = visitModifier(ktModifier, data) - override fun visitKtQualificationIdentifier(ktQualificationIdentifier: JKKtQualificationIdentifier, data: D): JKQualificationIdentifier = visitQualificationIdentifier(ktQualificationIdentifier, 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) - override fun visitKtOperatorIdentifier(ktOperatorIdentifier: JKKtOperatorIdentifier, data: D): JKOperatorIdentifier = visitOperatorIdentifier(ktOperatorIdentifier, data) } diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKTransformerVoid.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKTransformerVoid.kt index 49e14a7a54e..5337f994838 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKTransformerVoid.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKTransformerVoid.kt @@ -5,12 +5,48 @@ import org.jetbrains.kotlin.j2k.tree.* interface JKTransformerVoid : JKTransformer { 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 visitExpression(expression: JKExpression): JKExpression = visitStatement(expression) as JKExpression + 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 @@ -33,52 +69,14 @@ interface JKTransformerVoid : JKTransformer { 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 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 visitOperatorIdentifier(operatorIdentifier: JKOperatorIdentifier): JKOperatorIdentifier = visitIdentifier(operatorIdentifier) as JKOperatorIdentifier - override fun visitOperatorIdentifier(operatorIdentifier: JKOperatorIdentifier, data: Nothing?): JKOperatorIdentifier = visitOperatorIdentifier(operatorIdentifier) - fun visitQualificationIdentifier(qualificationIdentifier: JKQualificationIdentifier): JKQualificationIdentifier = visitIdentifier(qualificationIdentifier) as JKQualificationIdentifier - override fun visitQualificationIdentifier(qualificationIdentifier: JKQualificationIdentifier, data: Nothing?): JKQualificationIdentifier = visitQualificationIdentifier(qualificationIdentifier) - fun visitLoop(loop: JKLoop): JKLoop = visitStatement(loop) as JKLoop - override fun visitLoop(loop: JKLoop, data: Nothing?): JKLoop = visitLoop(loop) - fun visitDeclaration(declaration: JKDeclaration): JKDeclaration = visitElement(declaration) as JKDeclaration - override fun visitDeclaration(declaration: JKDeclaration, data: Nothing?): JKDeclaration = visitDeclaration(declaration) - 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 visitLiteralExpression(literalExpression: JKLiteralExpression): JKLiteralExpression = visitExpression(literalExpression) as JKLiteralExpression override fun visitLiteralExpression(literalExpression: JKLiteralExpression, data: Nothing?): JKLiteralExpression = visitLiteralExpression(literalExpression) - fun visitModifierList(modifierList: JKModifierList): JKModifierList = visitElement(modifierList) as JKModifierList - override fun visitModifierList(modifierList: JKModifierList, data: Nothing?): JKModifierList = visitModifierList(modifierList) - fun visitModifier(modifier: JKModifier): JKModifier = visitElement(modifier) as JKModifier - override fun visitModifier(modifier: JKModifier, data: Nothing?): JKModifier = visitModifier(modifier) - fun visitAccessModifier(accessModifier: JKAccessModifier): JKAccessModifier = visitModifier(accessModifier) as JKAccessModifier - override fun visitAccessModifier(accessModifier: JKAccessModifier, data: Nothing?): JKAccessModifier = visitAccessModifier(accessModifier) 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 visitModalityModifier(modalityModifier: JKModalityModifier): JKModalityModifier = visitModifier(modalityModifier) as JKModalityModifier - override fun visitModalityModifier(modalityModifier: JKModalityModifier, data: Nothing?): JKModalityModifier = visitModalityModifier(modalityModifier) - fun visitMethod(method: JKMethod): JKMethod = visitDeclaration(method) as JKMethod - override fun visitMethod(method: JKMethod, data: Nothing?): JKMethod = visitMethod(method) - fun visitExpressionStatement(expressionStatement: JKExpressionStatement): JKExpressionStatement = visitStatement(expressionStatement) as JKExpressionStatement - override fun visitExpressionStatement(expressionStatement: JKExpressionStatement, data: Nothing?): JKExpressionStatement = visitExpressionStatement(expressionStatement) - fun visitJavaField(javaField: JKJavaField): JKDeclaration = visitDeclaration(javaField) - override fun visitJavaField(javaField: JKJavaField, data: Nothing?): JKDeclaration = visitJavaField(javaField) + 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) @@ -89,22 +87,12 @@ interface JKTransformerVoid : JKTransformer { 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 visitJavaOperatorIdentifier(javaOperatorIdentifier: JKJavaOperatorIdentifier): JKOperatorIdentifier = visitOperatorIdentifier(javaOperatorIdentifier) - override fun visitJavaOperatorIdentifier(javaOperatorIdentifier: JKJavaOperatorIdentifier, data: Nothing?): JKOperatorIdentifier = visitJavaOperatorIdentifier(javaOperatorIdentifier) - fun visitJavaQualificationIdentifier(javaQualificationIdentifier: JKJavaQualificationIdentifier): JKQualificationIdentifier = visitQualificationIdentifier(javaQualificationIdentifier) - override fun visitJavaQualificationIdentifier(javaQualificationIdentifier: JKJavaQualificationIdentifier, data: Nothing?): JKQualificationIdentifier = visitJavaQualificationIdentifier(javaQualificationIdentifier) 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 visitJavaMethodReference(javaMethodReference: JKJavaMethodReference): JKMethodReference = visitMethodReference(javaMethodReference) - override fun visitJavaMethodReference(javaMethodReference: JKJavaMethodReference, data: Nothing?): JKMethodReference = visitJavaMethodReference(javaMethodReference) - fun visitJavaFieldReference(javaFieldReference: JKJavaFieldReference): JKFieldReference = visitFieldReference(javaFieldReference) - override fun visitJavaFieldReference(javaFieldReference: JKJavaFieldReference, data: Nothing?): JKFieldReference = visitJavaFieldReference(javaFieldReference) - fun visitJavaClassReference(javaClassReference: JKJavaClassReference): JKClassReference = visitClassReference(javaClassReference) - override fun visitJavaClassReference(javaClassReference: JKJavaClassReference, data: Nothing?): JKClassReference = visitJavaClassReference(javaClassReference) fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier): JKAccessModifier = visitAccessModifier(javaAccessModifier) override fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier, data: Nothing?): JKAccessModifier = visitJavaAccessModifier(javaAccessModifier) fun visitJavaModifier(javaModifier: JKJavaModifier): JKModifier = visitModifier(javaModifier) @@ -115,8 +103,10 @@ interface JKTransformerVoid : JKTransformer { 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 visitKtFun(ktFun: JKKtFun): JKDeclaration = visitDeclaration(ktFun) - override fun visitKtFun(ktFun: JKKtFun, data: Nothing?): JKDeclaration = visitKtFun(ktFun) + 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) @@ -125,20 +115,12 @@ interface JKTransformerVoid : JKTransformer { 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 visitKtProperty(ktProperty: JKKtProperty): JKDeclaration = visitDeclaration(ktProperty) - override fun visitKtProperty(ktProperty: JKKtProperty, data: Nothing?): JKDeclaration = visitKtProperty(ktProperty) - fun visitKtFunction(ktFunction: JKKtFunction): JKDeclaration = visitDeclaration(ktFunction) - override fun visitKtFunction(ktFunction: JKKtFunction, data: Nothing?): JKDeclaration = visitKtFunction(ktFunction) fun visitKtModifier(ktModifier: JKKtModifier): JKModifier = visitModifier(ktModifier) override fun visitKtModifier(ktModifier: JKKtModifier, data: Nothing?): JKModifier = visitKtModifier(ktModifier) - fun visitKtQualificationIdentifier(ktQualificationIdentifier: JKKtQualificationIdentifier): JKQualificationIdentifier = visitQualificationIdentifier(ktQualificationIdentifier) - override fun visitKtQualificationIdentifier(ktQualificationIdentifier: JKKtQualificationIdentifier, data: Nothing?): JKQualificationIdentifier = visitKtQualificationIdentifier(ktQualificationIdentifier) 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) - fun visitKtOperatorIdentifier(ktOperatorIdentifier: JKKtOperatorIdentifier): JKOperatorIdentifier = visitOperatorIdentifier(ktOperatorIdentifier) - override fun visitKtOperatorIdentifier(ktOperatorIdentifier: JKKtOperatorIdentifier, data: Nothing?): JKOperatorIdentifier = visitKtOperatorIdentifier(ktOperatorIdentifier) } 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 40a2115e80f..8ea5055c1ef 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt @@ -4,9 +4,27 @@ import org.jetbrains.kotlin.j2k.tree.* interface JKVisitor { fun visitElement(element: JKElement, data: D): R + fun visitDeclaration(declaration: JKDeclaration, data: D): R = visitElement(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 = visitElement(modifier, data) + fun visitModifierList(modifierList: JKModifierList, data: D): R = visitElement(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 visitClassType(classType: JKClassType, data: D): R = visitType(classType, data) fun visitStatement(statement: JKStatement, data: D): R = visitElement(statement, data) - fun visitExpression(expression: JKExpression, data: D): R = visitStatement(expression, 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 visitNameIdentifier(nameIdentifier: JKNameIdentifier, data: D): R = visitIdentifier(nameIdentifier, data) + fun visitExpression(expression: JKExpression, data: D): R = visitElement(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) fun visitPrefixExpression(prefixExpression: JKPrefixExpression, data: D): R = visitUnaryExpression(prefixExpression, data) @@ -18,58 +36,31 @@ interface JKVisitor { 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 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 visitClassType(classType: JKClassType, data: D): R = visitType(classType, data) - fun visitOperatorIdentifier(operatorIdentifier: JKOperatorIdentifier, data: D): R = visitIdentifier(operatorIdentifier, data) - fun visitQualificationIdentifier(qualificationIdentifier: JKQualificationIdentifier, data: D): R = visitIdentifier(qualificationIdentifier, data) - fun visitLoop(loop: JKLoop, data: D): R = visitStatement(loop, data) - fun visitDeclaration(declaration: JKDeclaration, data: D): R = visitElement(declaration, data) - fun visitBlock(block: JKBlock, data: D): R = visitElement(block, data) - fun visitIdentifier(identifier: JKIdentifier, data: D): R = visitElement(identifier, data) - fun visitNameIdentifier(nameIdentifier: JKNameIdentifier, data: D): R = visitIdentifier(nameIdentifier, data) fun visitLiteralExpression(literalExpression: JKLiteralExpression, data: D): R = visitExpression(literalExpression, data) - fun visitModifierList(modifierList: JKModifierList, data: D): R = visitElement(modifierList, data) - fun visitModifier(modifier: JKModifier, data: D): R = visitElement(modifier, data) - fun visitAccessModifier(accessModifier: JKAccessModifier, data: D): R = visitModifier(accessModifier, data) fun visitValueArgument(valueArgument: JKValueArgument, data: D): R = visitElement(valueArgument, data) fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression, data: D): R = visitLiteralExpression(stringLiteralExpression, data) - fun visitModalityModifier(modalityModifier: JKModalityModifier, data: D): R = visitModifier(modalityModifier, data) - fun visitMethod(method: JKMethod, data: D): R = visitDeclaration(method, data) - fun visitExpressionStatement(expressionStatement: JKExpressionStatement, data: D): R = visitStatement(expressionStatement, data) - fun visitJavaField(javaField: JKJavaField, data: D): R = visitDeclaration(javaField, 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) fun visitJavaArrayType(javaArrayType: JKJavaArrayType, data: D): R = visitType(javaArrayType, data) - fun visitJavaOperatorIdentifier(javaOperatorIdentifier: JKJavaOperatorIdentifier, data: D): R = visitOperatorIdentifier(javaOperatorIdentifier, data) - fun visitJavaQualificationIdentifier(javaQualificationIdentifier: JKJavaQualificationIdentifier, data: D): R = visitQualificationIdentifier(javaQualificationIdentifier, data) fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression, data: D): R = visitMethodCallExpression(javaMethodCallExpression, data) fun visitJavaFieldAccessExpression(javaFieldAccessExpression: JKJavaFieldAccessExpression, data: D): R = visitFieldAccessExpression(javaFieldAccessExpression, data) fun visitJavaNewExpression(javaNewExpression: JKJavaNewExpression, data: D): R = visitExpression(javaNewExpression, data) - fun visitJavaMethodReference(javaMethodReference: JKJavaMethodReference, data: D): R = visitMethodReference(javaMethodReference, data) - fun visitJavaFieldReference(javaFieldReference: JKJavaFieldReference, data: D): R = visitFieldReference(javaFieldReference, data) - fun visitJavaClassReference(javaClassReference: JKJavaClassReference, data: D): R = visitClassReference(javaClassReference, data) fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier, data: D): R = visitAccessModifier(javaAccessModifier, data) fun visitJavaModifier(javaModifier: JKJavaModifier, data: D): R = visitModifier(javaModifier, data) fun visitJavaNewEmptyArray(javaNewEmptyArray: JKJavaNewEmptyArray, data: D): R = visitExpression(javaNewEmptyArray, data) fun visitJavaNewArray(javaNewArray: JKJavaNewArray, data: D): R = visitExpression(javaNewArray, data) fun visitJavaLiteralExpression(javaLiteralExpression: JKJavaLiteralExpression, data: D): R = visitLiteralExpression(javaLiteralExpression, data) - fun visitKtFun(ktFun: JKKtFun, data: D): R = visitDeclaration(ktFun, 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) - fun visitKtProperty(ktProperty: JKKtProperty, data: D): R = visitDeclaration(ktProperty, data) - fun visitKtFunction(ktFunction: JKKtFunction, data: D): R = visitDeclaration(ktFunction, data) fun visitKtModifier(ktModifier: JKKtModifier, data: D): R = visitModifier(ktModifier, data) - fun visitKtQualificationIdentifier(ktQualificationIdentifier: JKKtQualificationIdentifier, data: D): R = visitQualificationIdentifier(ktQualificationIdentifier, data) fun visitKtMethodCallExpression(ktMethodCallExpression: JKKtMethodCallExpression, data: D): R = visitMethodCallExpression(ktMethodCallExpression, data) fun visitKtFieldAccessExpression(ktFieldAccessExpression: JKKtFieldAccessExpression, data: D): R = visitFieldAccessExpression(ktFieldAccessExpression, data) fun visitKtLiteralExpression(ktLiteralExpression: JKKtLiteralExpression, data: D): R = visitLiteralExpression(ktLiteralExpression, data) - fun visitKtOperatorIdentifier(ktOperatorIdentifier: JKKtOperatorIdentifier, data: D): R = visitOperatorIdentifier(ktOperatorIdentifier, 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 838336a81f3..99f8f1f15ed 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt @@ -5,12 +5,48 @@ import org.jetbrains.kotlin.j2k.tree.* interface JKVisitorVoid : JKVisitor { fun visitElement(element: JKElement) override fun visitElement(element: JKElement, data: Nothing?) = visitElement(element) + fun visitDeclaration(declaration: JKDeclaration) = visitElement(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) = visitElement(modifier, null) + override fun visitModifier(modifier: JKModifier, data: Nothing?) = visitModifier(modifier) + fun visitModifierList(modifierList: JKModifierList) = visitElement(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) + 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) override fun visitStatement(statement: JKStatement, data: Nothing?) = visitStatement(statement) - fun visitExpression(expression: JKExpression) = visitStatement(expression, null) + fun visitLoop(loop: JKLoop) = visitStatement(loop, null) + override fun visitLoop(loop: JKLoop, data: Nothing?) = visitLoop(loop) + fun visitBlock(block: JKBlock) = visitElement(block, null) + override fun visitBlock(block: JKBlock, data: Nothing?) = visitBlock(block) + fun visitIdentifier(identifier: JKIdentifier) = visitElement(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) 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) fun visitBinaryExpression(binaryExpression: JKBinaryExpression) = visitExpression(binaryExpression, null) override fun visitBinaryExpression(binaryExpression: JKBinaryExpression, data: Nothing?) = visitBinaryExpression(binaryExpression) fun visitUnaryExpression(unaryExpression: JKUnaryExpression) = visitExpression(unaryExpression, null) @@ -33,51 +69,13 @@ interface JKVisitorVoid : JKVisitor { override fun visitTypeCastExpression(typeCastExpression: JKTypeCastExpression, data: Nothing?) = visitTypeCastExpression(typeCastExpression) fun visitExpressionList(expressionList: JKExpressionList) = visitElement(expressionList, null) override fun visitExpressionList(expressionList: JKExpressionList, data: Nothing?) = visitExpressionList(expressionList) - 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) - 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 visitOperatorIdentifier(operatorIdentifier: JKOperatorIdentifier) = visitIdentifier(operatorIdentifier, null) - override fun visitOperatorIdentifier(operatorIdentifier: JKOperatorIdentifier, data: Nothing?) = visitOperatorIdentifier(operatorIdentifier) - fun visitQualificationIdentifier(qualificationIdentifier: JKQualificationIdentifier) = visitIdentifier(qualificationIdentifier, null) - override fun visitQualificationIdentifier(qualificationIdentifier: JKQualificationIdentifier, data: Nothing?) = visitQualificationIdentifier(qualificationIdentifier) - fun visitLoop(loop: JKLoop) = visitStatement(loop, null) - override fun visitLoop(loop: JKLoop, data: Nothing?) = visitLoop(loop) - fun visitDeclaration(declaration: JKDeclaration) = visitElement(declaration, null) - override fun visitDeclaration(declaration: JKDeclaration, data: Nothing?) = visitDeclaration(declaration) - fun visitBlock(block: JKBlock) = visitElement(block, null) - override fun visitBlock(block: JKBlock, data: Nothing?) = visitBlock(block) - fun visitIdentifier(identifier: JKIdentifier) = visitElement(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 visitLiteralExpression(literalExpression: JKLiteralExpression) = visitExpression(literalExpression, null) override fun visitLiteralExpression(literalExpression: JKLiteralExpression, data: Nothing?) = visitLiteralExpression(literalExpression) - fun visitModifierList(modifierList: JKModifierList) = visitElement(modifierList, null) - override fun visitModifierList(modifierList: JKModifierList, data: Nothing?) = visitModifierList(modifierList) - fun visitModifier(modifier: JKModifier) = visitElement(modifier, null) - override fun visitModifier(modifier: JKModifier, data: Nothing?) = visitModifier(modifier) - fun visitAccessModifier(accessModifier: JKAccessModifier) = visitModifier(accessModifier, null) - override fun visitAccessModifier(accessModifier: JKAccessModifier, data: Nothing?) = visitAccessModifier(accessModifier) fun visitValueArgument(valueArgument: JKValueArgument) = visitElement(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 visitModalityModifier(modalityModifier: JKModalityModifier) = visitModifier(modalityModifier, null) - override fun visitModalityModifier(modalityModifier: JKModalityModifier, data: Nothing?) = visitModalityModifier(modalityModifier) - fun visitMethod(method: JKMethod) = visitDeclaration(method, null) - override fun visitMethod(method: JKMethod, data: Nothing?) = visitMethod(method) - fun visitExpressionStatement(expressionStatement: JKExpressionStatement) = visitStatement(expressionStatement, null) - override fun visitExpressionStatement(expressionStatement: JKExpressionStatement, data: Nothing?) = visitExpressionStatement(expressionStatement) - fun visitJavaField(javaField: JKJavaField) = visitDeclaration(javaField, null) + fun visitJavaField(javaField: JKJavaField) = visitField(javaField, null) override fun visitJavaField(javaField: JKJavaField, data: Nothing?) = visitJavaField(javaField) fun visitJavaMethod(javaMethod: JKJavaMethod) = visitMethod(javaMethod, null) override fun visitJavaMethod(javaMethod: JKJavaMethod, data: Nothing?) = visitJavaMethod(javaMethod) @@ -89,22 +87,12 @@ interface JKVisitorVoid : JKVisitor { override fun visitJavaPrimitiveType(javaPrimitiveType: JKJavaPrimitiveType, data: Nothing?) = visitJavaPrimitiveType(javaPrimitiveType) fun visitJavaArrayType(javaArrayType: JKJavaArrayType) = visitType(javaArrayType, null) override fun visitJavaArrayType(javaArrayType: JKJavaArrayType, data: Nothing?) = visitJavaArrayType(javaArrayType) - fun visitJavaOperatorIdentifier(javaOperatorIdentifier: JKJavaOperatorIdentifier) = visitOperatorIdentifier(javaOperatorIdentifier, null) - override fun visitJavaOperatorIdentifier(javaOperatorIdentifier: JKJavaOperatorIdentifier, data: Nothing?) = visitJavaOperatorIdentifier(javaOperatorIdentifier) - fun visitJavaQualificationIdentifier(javaQualificationIdentifier: JKJavaQualificationIdentifier) = visitQualificationIdentifier(javaQualificationIdentifier, null) - override fun visitJavaQualificationIdentifier(javaQualificationIdentifier: JKJavaQualificationIdentifier, data: Nothing?) = visitJavaQualificationIdentifier(javaQualificationIdentifier) fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression) = visitMethodCallExpression(javaMethodCallExpression, null) override fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression, data: Nothing?) = visitJavaMethodCallExpression(javaMethodCallExpression) fun visitJavaFieldAccessExpression(javaFieldAccessExpression: JKJavaFieldAccessExpression) = visitFieldAccessExpression(javaFieldAccessExpression, null) override fun visitJavaFieldAccessExpression(javaFieldAccessExpression: JKJavaFieldAccessExpression, data: Nothing?) = visitJavaFieldAccessExpression(javaFieldAccessExpression) fun visitJavaNewExpression(javaNewExpression: JKJavaNewExpression) = visitExpression(javaNewExpression, null) override fun visitJavaNewExpression(javaNewExpression: JKJavaNewExpression, data: Nothing?) = visitJavaNewExpression(javaNewExpression) - fun visitJavaMethodReference(javaMethodReference: JKJavaMethodReference) = visitMethodReference(javaMethodReference, null) - override fun visitJavaMethodReference(javaMethodReference: JKJavaMethodReference, data: Nothing?) = visitJavaMethodReference(javaMethodReference) - fun visitJavaFieldReference(javaFieldReference: JKJavaFieldReference) = visitFieldReference(javaFieldReference, null) - override fun visitJavaFieldReference(javaFieldReference: JKJavaFieldReference, data: Nothing?) = visitJavaFieldReference(javaFieldReference) - fun visitJavaClassReference(javaClassReference: JKJavaClassReference) = visitClassReference(javaClassReference, null) - override fun visitJavaClassReference(javaClassReference: JKJavaClassReference, data: Nothing?) = visitJavaClassReference(javaClassReference) fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier) = visitAccessModifier(javaAccessModifier, null) override fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier, data: Nothing?) = visitJavaAccessModifier(javaAccessModifier) fun visitJavaModifier(javaModifier: JKJavaModifier) = visitModifier(javaModifier, null) @@ -115,8 +103,10 @@ 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 visitKtFun(ktFun: JKKtFun) = visitDeclaration(ktFun, null) - override fun visitKtFun(ktFun: JKKtFun, data: Nothing?) = visitKtFun(ktFun) + fun visitKtProperty(ktProperty: JKKtProperty) = visitField(ktProperty, null) + override fun visitKtProperty(ktProperty: JKKtProperty, data: Nothing?) = visitKtProperty(ktProperty) + fun visitKtFunction(ktFunction: JKKtFunction) = visitMethod(ktFunction, null) + override fun visitKtFunction(ktFunction: JKKtFunction, data: Nothing?) = visitKtFunction(ktFunction) fun visitKtConstructor(ktConstructor: JKKtConstructor) = visitDeclaration(ktConstructor, null) override fun visitKtConstructor(ktConstructor: JKKtConstructor, data: Nothing?) = visitKtConstructor(ktConstructor) fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor) = visitKtConstructor(ktPrimaryConstructor, null) @@ -125,20 +115,12 @@ interface JKVisitorVoid : JKVisitor { override fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement, data: Nothing?) = visitKtAssignmentStatement(ktAssignmentStatement) fun visitKtCall(ktCall: JKKtCall) = visitMethodCallExpression(ktCall, null) override fun visitKtCall(ktCall: JKKtCall, data: Nothing?) = visitKtCall(ktCall) - fun visitKtProperty(ktProperty: JKKtProperty) = visitDeclaration(ktProperty, null) - override fun visitKtProperty(ktProperty: JKKtProperty, data: Nothing?) = visitKtProperty(ktProperty) - fun visitKtFunction(ktFunction: JKKtFunction) = visitDeclaration(ktFunction, null) - override fun visitKtFunction(ktFunction: JKKtFunction, data: Nothing?) = visitKtFunction(ktFunction) fun visitKtModifier(ktModifier: JKKtModifier) = visitModifier(ktModifier, null) override fun visitKtModifier(ktModifier: JKKtModifier, data: Nothing?) = visitKtModifier(ktModifier) - fun visitKtQualificationIdentifier(ktQualificationIdentifier: JKKtQualificationIdentifier) = visitQualificationIdentifier(ktQualificationIdentifier, null) - override fun visitKtQualificationIdentifier(ktQualificationIdentifier: JKKtQualificationIdentifier, data: Nothing?) = visitKtQualificationIdentifier(ktQualificationIdentifier) fun visitKtMethodCallExpression(ktMethodCallExpression: JKKtMethodCallExpression) = visitMethodCallExpression(ktMethodCallExpression, null) override fun visitKtMethodCallExpression(ktMethodCallExpression: JKKtMethodCallExpression, data: Nothing?) = visitKtMethodCallExpression(ktMethodCallExpression) fun visitKtFieldAccessExpression(ktFieldAccessExpression: JKKtFieldAccessExpression) = visitFieldAccessExpression(ktFieldAccessExpression, null) override fun visitKtFieldAccessExpression(ktFieldAccessExpression: JKKtFieldAccessExpression, data: Nothing?) = visitKtFieldAccessExpression(ktFieldAccessExpression) fun visitKtLiteralExpression(ktLiteralExpression: JKKtLiteralExpression) = visitLiteralExpression(ktLiteralExpression, null) override fun visitKtLiteralExpression(ktLiteralExpression: JKKtLiteralExpression, data: Nothing?) = visitKtLiteralExpression(ktLiteralExpression) - fun visitKtOperatorIdentifier(ktOperatorIdentifier: JKKtOperatorIdentifier) = visitOperatorIdentifier(ktOperatorIdentifier, null) - override fun visitKtOperatorIdentifier(ktOperatorIdentifier: JKKtOperatorIdentifier, data: Nothing?) = visitKtOperatorIdentifier(ktOperatorIdentifier) }