From a94957aa0fbb51c07d820f829b8660a693880e41 Mon Sep 17 00:00:00 2001 From: Dimach Date: Tue, 7 Nov 2017 08:19:08 +0200 Subject: [PATCH] New J2K: Added java -> jk converter for new array, type cast, array access and parenthesized expression. --- .../kotlin/j2k/JavaToJKTreeBuilder.kt | 52 ++++++++++++++++++- .../org/jetbrains/kotlin/j2k/tree/impl/j.kt | 16 ++++++ .../org/jetbrains/kotlin/j2k/tree/impl/jk.kt | 34 ++++++++++++ j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt | 13 ++++- .../org/jetbrains/kotlin/j2k/tree/jk.kt | 19 +++++-- .../kotlin/j2k/tree/visitors/JKVisitor.kt | 8 --- .../kotlin/j2k/tree/visitors/JKVisitorVoid.kt | 16 ++++-- 7 files changed, 141 insertions(+), 17 deletions(-) diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt index 96d8b78cc49..72f3675514a 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt @@ -20,6 +20,7 @@ import com.intellij.lang.java.JavaLanguage import com.intellij.psi.* import com.intellij.psi.impl.source.tree.ChildRole import com.intellij.psi.impl.source.tree.java.PsiLiteralExpressionImpl +import com.intellij.psi.impl.source.tree.java.PsiNewExpressionImpl import com.intellij.psi.impl.source.tree.java.PsiReferenceExpressionImpl import org.jetbrains.kotlin.j2k.tree.* import org.jetbrains.kotlin.j2k.tree.impl.* @@ -50,6 +51,15 @@ class JavaToJKTreeBuilder { is PsiNewExpression -> { return toJK() } + is PsiArrayAccessExpression -> { + return toJK() + } + is PsiTypeCastExpression -> { + return toJK() + } + is PsiParenthesizedExpression -> { + return toJK() + } } throw RuntimeException("Not supported") } @@ -58,7 +68,7 @@ class JavaToJKTreeBuilder { return JKBinaryExpressionImpl(lOperand.toJK(), rOperand?.toJK(), operationSign.toJK()) } - fun PsiLiteralExpression.toJK(): JKExpression { + fun PsiLiteralExpression.toJK(): JKLiteralExpression { if (this !is PsiLiteralExpressionImpl) { throw RuntimeException("Not supported") } @@ -107,9 +117,45 @@ class JavaToJKTreeBuilder { } fun PsiNewExpression.toJK(): JKExpression { + assert(this is PsiNewExpressionImpl) + if ((this as PsiNewExpressionImpl).findChildByRole(ChildRole.LBRACKET) != null) { + val arrayInitializer = arrayInitializer + if (arrayInitializer != null) { + return JKJavaNewArrayImpl(arrayInitializer.initializers.map { toJK() }) + } + else { + val dimensions = mutableListOf() + var child = firstChild + while (child != null) { + if (child.node.elementType == JavaTokenType.LBRACKET) { + child = child.nextSibling + if (child.node.elementType == JavaTokenType.RBRACKET) { + dimensions.add(null) + } + else { + dimensions.add(child as PsiLiteralExpression?) + } + } + child = child.nextSibling + } + return JKJavaNewEmptyArrayImpl(dimensions.map { it?.toJK() }) + } + } return JKJavaNewExpressionImpl((classReference as PsiIdentifier).convertClassReference(), argumentList.toJK()) } + fun PsiArrayAccessExpression.toJK(): JKExpression { + return JKArrayAccessExpressionImpl(arrayExpression.toJK(), indexExpression?.toJK()) + } + + fun PsiTypeCastExpression.toJK(): JKExpression { + return JKTypeCastExpressionImpl(operand?.toJK(), castType?.convertTypeReference()) + } + + fun PsiParenthesizedExpression.toJK(): JKExpression { + return JKParenthesizedExpressionImpl(expression?.toJK()) + } + fun PsiExpressionList?.toJK(): JKExpressionList { return JKExpressionListImpl(this?.expressions?.map { it.toJK() }?.toTypedArray() ?: emptyArray()) } @@ -125,6 +171,10 @@ class JavaToJKTreeBuilder { fun PsiIdentifier.convertClassReference(): JKJavaClassReference { return JKJavaClassReferenceImpl() } + + fun PsiTypeElement.convertTypeReference(): JKTypeReference { + return JKTypeReferenceImpl() + } } private object DeclarationMapper { 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 ea6eb2bc3a0..4b50b58e593 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt @@ -125,5 +125,21 @@ class JKJavaClassReferenceImpl() : JKJavaClassReference, JKElementBase() { override fun acceptChildren(visitor: JKVisitor, data: D) { + } +} + +class JKJavaNewEmptyArrayImpl(override val initializer: List) : JKJavaNewEmptyArray, JKElementBase() { + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaNewEmptyArray(this, data) + + override fun acceptChildren(visitor: JKVisitor, data: D) { + + } +} + +class JKJavaNewArrayImpl(override val initializer: List) : JKJavaNewArray, JKElementBase() { + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaNewArray(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/impl/jk.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt index df31b0b4369..2c97572c11e 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt @@ -121,4 +121,38 @@ class JKQualifiedExpressionImpl(override val receiver: JKExpression, override va operator.accept(visitor, data) selector.accept(visitor, data) } +} + +class JKArrayAccessExpressionImpl(override val expression: JKExpression, override val 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) + } +} + +class JKParenthesizedExpressionImpl(override val 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) + } +} + +class JKTypeCastExpressionImpl(override val expression: JKExpression?, override val type: JKTypeReference?) : 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) + } +} + +class JKTypeReferenceImpl() : JKTypeReference, JKElementBase() { + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitTypeReference(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/j.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt index 29e2562a56a..0f291d6ffe3 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt @@ -53,8 +53,9 @@ interface JKJavaFieldAccessExpression : JKFieldAccessExpression { } -interface JKJavaNewExpression : JKNewExpression { - +interface JKJavaNewExpression : JKExpression { + val identifier: JKClassReference + val arguments: JKExpressionList } interface JKJavaMethodReference : JKMethodReference @@ -77,4 +78,12 @@ interface JKJavaModifier : JKModifier { enum class JavaModifierType { ABSTRACT, FINAL, NATIVE, STATIC, STRICTFP, SYNCHRONIZED, TRANSIENT, VOLATILE } +} + +interface JKJavaNewEmptyArray : JKExpression { + val initializer: List +} + +interface JKJavaNewArray : JKExpression { + val initializer: List } \ No newline at end of file diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt index daefce990ae..8554ebcce1a 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt @@ -74,9 +74,18 @@ interface JKFieldAccessExpression : JKExpression { val identifier: JKFieldReference } -interface JKNewExpression : JKExpression { - val identifier: JKClassReference - val arguments: JKExpressionList +interface JKArrayAccessExpression : JKExpression { + val expression : JKExpression + val indexExpression : JKExpression? +} + +interface JKParenthesizedExpression : JKExpression { + val expression : JKExpression? +} + +interface JKTypeCastExpression : JKExpression { + val expression : JKExpression? + val type : JKTypeReference? } interface JKExpressionList : JKElement { @@ -95,6 +104,10 @@ interface JKClassReference : JKElement { } +interface JKTypeReference : JKElement { + +} + interface JKOperatorIdentifier : JKIdentifier interface JKQualificationIdentifier : JKIdentifier 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 35cc37b7fca..311e9d81ef9 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt @@ -24,7 +24,6 @@ interface JKVisitor { 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 visitCall(call: JKCall, data: D): R = visitExpression(call, data) fun visitIdentifier(identifier: JKIdentifier, data: D): R = visitElement(identifier, data) fun visitTypeIdentifier(typeIdentifier: JKTypeIdentifier, data: D): R = visitIdentifier(typeIdentifier, data) fun visitNameIdentifier(nameIdentifier: JKNameIdentifier, data: D): R = visitIdentifier(nameIdentifier, data) @@ -32,14 +31,10 @@ interface JKVisitor { 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 visitJavaField(javaField: JKJavaField, data: D): R = visitDeclaration(javaField, data) fun visitJavaMethod(javaMethod: JKJavaMethod, data: D): R = visitDeclaration(javaMethod, data) fun visitJavaForLoop(javaForLoop: JKJavaForLoop, data: D): R = visitLoop(javaForLoop, data) fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: D): R = visitExpression(javaAssignmentExpression, data) - fun visitJavaCall(javaCall: JKJavaCall, data: D): R = visitCall(javaCall, data) fun visitJavaTypeIdentifier(javaTypeIdentifier: JKJavaTypeIdentifier, data: D): R = visitTypeIdentifier(javaTypeIdentifier, data) fun visitJavaStringLiteralExpression(javaStringLiteralExpression: JKJavaStringLiteralExpression, data: D): R = visitLiteralExpression(javaStringLiteralExpression, data) fun visitJavaOperatorIdentifier(javaOperatorIdentifier: JKJavaOperatorIdentifier, data: D): R = visitOperatorIdentifier(javaOperatorIdentifier, data) @@ -51,11 +46,8 @@ interface JKVisitor { 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 visitKtFun(ktFun: JKKtFun, data: D): R = visitDeclaration(ktFun, 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 = visitCall(ktCall, data) - fun visitKtProperty(ktProperty: JKKtProperty, data: D): R = visitDeclaration(ktProperty, 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 6292523d7db..62ea794e8a4 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt @@ -25,8 +25,12 @@ interface JKVisitorVoid : JKVisitor { override fun visitMethodCallExpression(methodCallExpression: JKMethodCallExpression, data: Nothing?) = visitMethodCallExpression(methodCallExpression) fun visitFieldAccessExpression(fieldAccessExpression: JKFieldAccessExpression) = visitExpression(fieldAccessExpression, null) override fun visitFieldAccessExpression(fieldAccessExpression: JKFieldAccessExpression, data: Nothing?) = visitFieldAccessExpression(fieldAccessExpression) - fun visitNewExpression(newExpression: JKNewExpression) = visitExpression(newExpression, null) - override fun visitNewExpression(newExpression: JKNewExpression, data: Nothing?) = visitNewExpression(newExpression) + fun visitArrayAccessExpression(arrayAccessExpression: JKArrayAccessExpression) = visitExpression(arrayAccessExpression, null) + override fun visitArrayAccessExpression(arrayAccessExpression: JKArrayAccessExpression, data: Nothing?) = visitArrayAccessExpression(arrayAccessExpression) + fun visitParenthesizedExpression(parenthesizedExpression: JKParenthesizedExpression) = visitExpression(parenthesizedExpression, null) + override fun visitParenthesizedExpression(parenthesizedExpression: JKParenthesizedExpression, data: Nothing?) = visitParenthesizedExpression(parenthesizedExpression) + fun visitTypeCastExpression(typeCastExpression: JKTypeCastExpression) = visitExpression(typeCastExpression, null) + override fun visitTypeCastExpression(typeCastExpression: JKTypeCastExpression, data: Nothing?) = visitTypeCastExpression(typeCastExpression) fun visitExpressionList(expressionList: JKExpressionList) = visitElement(expressionList, null) override fun visitExpressionList(expressionList: JKExpressionList, data: Nothing?) = visitExpressionList(expressionList) fun visitMethodReference(methodReference: JKMethodReference) = visitElement(methodReference, null) @@ -35,6 +39,8 @@ interface JKVisitorVoid : JKVisitor { override fun visitFieldReference(fieldReference: JKFieldReference, data: Nothing?) = visitFieldReference(fieldReference) fun visitClassReference(classReference: JKClassReference) = visitElement(classReference, null) override fun visitClassReference(classReference: JKClassReference, data: Nothing?) = visitClassReference(classReference) + fun visitTypeReference(typeReference: JKTypeReference) = visitElement(typeReference, null) + override fun visitTypeReference(typeReference: JKTypeReference, data: Nothing?) = visitTypeReference(typeReference) fun visitOperatorIdentifier(operatorIdentifier: JKOperatorIdentifier) = visitIdentifier(operatorIdentifier, null) override fun visitOperatorIdentifier(operatorIdentifier: JKOperatorIdentifier, data: Nothing?) = visitOperatorIdentifier(operatorIdentifier) fun visitQualificationIdentifier(qualificationIdentifier: JKQualificationIdentifier) = visitIdentifier(qualificationIdentifier, null) @@ -83,7 +89,7 @@ interface JKVisitorVoid : JKVisitor { 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) = visitNewExpression(javaNewExpression, null) + 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) @@ -93,6 +99,10 @@ interface JKVisitorVoid : JKVisitor { 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 visitJavaNewEmptyArray(javaNewEmptyArray: JKJavaNewEmptyArray) = visitExpression(javaNewEmptyArray, null) + override fun visitJavaNewEmptyArray(javaNewEmptyArray: JKJavaNewEmptyArray, data: Nothing?) = visitJavaNewEmptyArray(javaNewEmptyArray) + fun visitJavaNewArray(javaNewArray: JKJavaNewArray) = visitExpression(javaNewArray, null) + override fun visitJavaNewArray(javaNewArray: JKJavaNewArray, data: Nothing?) = visitJavaNewArray(javaNewArray) fun visitKtFun(ktFun: JKKtFun) = visitDeclaration(ktFun, null) override fun visitKtFun(ktFun: JKKtFun, data: Nothing?) = visitKtFun(ktFun) fun visitKtConstructor(ktConstructor: JKKtConstructor) = visitDeclaration(ktConstructor, null)