New J2K: Added basic expression converter.

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

@@ -24,21 +24,68 @@ import org.jetbrains.kotlin.j2k.tree.impl.*
 
 class JavaToJKTreeBuilder {
 
-    private class ExpressionTreeVisitor : JavaElementVisitor() {
+    private object ExpressionTreeMapper {
-
+        fun PsiExpression.toJK(): JKExpression {
-        private var resultExpression: JKExpression? = null
+            when (this) {
-
+                is PsiBinaryExpression -> {
-        override fun visitLiteralExpression(expression: PsiLiteralExpression?) {
+                    return toJK()
-            if (expression is PsiLiteralExpressionImpl) {
-
-                when (expression.literalElementType) {
-                    JavaTokenType.STRING_LITERAL ->
-                        resultExpression = JKJavaStringLiteralExpressionImpl(expression.innerText!!)
                 }
+                is PsiPrefixExpression -> {
+                    return toJK()
+                }
+                is PsiPostfixExpression -> {
+                    return toJK()
+                }
+                is PsiLiteralExpression -> {
+                    return toJK()
+                }
+                is PsiCallExpression -> {
+                    return toJK()
+                }
+            }
+            throw RuntimeException("Not supported")
+        }
+
+        fun PsiBinaryExpression.toJK(): JKExpression {
+            return JKBinaryExpressionImpl(lOperand.toJK(), rOperand?.toJK(), operationSign.toJK())
+        }
+
+        fun PsiLiteralExpression.toJK(): JKExpression {
+            if (this !is PsiLiteralExpressionImpl) {
+                throw RuntimeException("Not supported")
+            }
+            return when (this.literalElementType) {
+                JavaTokenType.STRING_LITERAL -> JKJavaStringLiteralExpressionImpl(innerText!!)
+                else -> throw RuntimeException("Not supported")
             }
         }
 
-        fun result(): JKExpression = resultExpression!!
+        fun PsiJavaToken.toJK(): JKOperatorIdentifier = when (tokenType) {
+            JavaTokenType.PLUS -> JKJavaOperatorIdentifierImpl.PLUS
+            JavaTokenType.MINUS -> JKJavaOperatorIdentifierImpl.MINUS
+            else -> throw RuntimeException("Not supported")
+        }
+
+        fun PsiPrefixExpression.toJK(): JKExpression {
+            return JKPrefixExpressionImpl(operand?.toJK(), operationSign.toJK())
+        }
+
+        fun PsiPostfixExpression.toJK(): JKExpression {
+            return JKPostfixExpressionImpl(operand.toJK(), operationSign.toJK())
+        }
+
+        fun PsiCallExpression.toJK(): JKExpression {
+            return JKJavaCallExpressionImpl(resolveMethod().toJK(), argumentList.toJK())
+        }
+
+        fun PsiExpressionList?.toJK(): JKExpressionList {
+            this ?: return JKExpressionListImpl(emptyArray())
+            return JKExpressionListImpl(expressions.map { it.toJK() }.toTypedArray())
+        }
+
+        fun PsiMethod?.toJK(): JKJavaMethodReference {
+            return JKJavaMethodReferenceImpl()
+        }
     }
 
     private object DeclarationMapper {
@@ -150,11 +197,5 @@ class JavaToJKTreeBuilder {
         psi.accept(elementVisitor)
         return elementVisitor.resultElement
     }
-
-
-    companion object {
-        private fun PsiExpression.buildTreeForExpression(): JKExpression =
-                JavaToJKTreeBuilder.ExpressionTreeVisitor().apply { accept(this) }.result()
-    }
-
 }
+

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

@@ -63,3 +63,34 @@ class JKJavaMethodImpl(override var modifierList: JKModifierList,
 
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaMethod(this, data)
 }
+
+sealed class JKJavaOperatorIdentifierImpl : JKJavaOperatorIdentifier, JKElementBase() {
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaOperatorIdentifier(this, data)
+
+    object PLUS : JKJavaOperatorIdentifierImpl()
+    object MINUS : JKJavaOperatorIdentifierImpl()
+}
+
+sealed class JKJavaQualificationIdentifierImpl : JKJavaQualificationIdentifier, JKElementBase() {
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaQualificationIdentifier(this, data)
+
+    object DOT : JKJavaQualificationIdentifierImpl()
+}
+
+class JKJavaCallExpressionImpl(override val method: JKJavaMethodReference,
+                               override val arguments: JKExpressionList) : JKJavaCallExpression, JKElementBase() {
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaCallExpression(this, data)
+
+    override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
+        method.accept(visitor, data)
+        arguments.accept(visitor, data)
+    }
+}
+
+class JKJavaMethodReferenceImpl() : JKJavaMethodReference, JKElementBase() {
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaMethodReference(this, data)
+
+    override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
+
+    }
+}

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

@@ -76,3 +76,39 @@ class JKBlockImpl(override var statements: List<JKStatement>) : JKBlock, JKEleme
 class JKStringLiteralExpressionImpl(override val text: String) : JKStringLiteralExpression, JKElementBase() {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitStringLiteralExpression(this, data)
 }
+
+class JKBinaryExpressionImpl(override val left: JKExpression, override val right: JKExpression?,
+                             override val operator: JKOperatorIdentifier) : JKBinaryExpression, JKElementBase() {
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitBinaryExpression(this, data)
+    override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
+        left.accept(visitor, data)
+        operator.accept(visitor, data)
+        right?.accept(visitor, data)
+    }
+}
+
+class JKPrefixExpressionImpl(override val expression: JKExpression?,
+                             override val operator: JKOperatorIdentifier) : JKPrefixExpression, JKElementBase() {
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitPrefixExpression(this, data)
+    override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
+        expression?.accept(visitor, data)
+        operator.accept(visitor, data)
+    }
+}
+
+class JKPostfixExpressionImpl(override val expression: JKExpression,
+                              override val operator: JKOperatorIdentifier) : JKPostfixExpression, JKElementBase() {
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitPostfixExpression(this, data)
+    override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
+        expression.accept(visitor, data)
+        operator.accept(visitor, data)
+    }
+}
+
+class JKExpressionListImpl(override val expressions: Array<JKExpression>) : JKExpressionList, JKElementBase() {
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitExpressionList(this, data)
+
+    override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
+        expressions.forEach { it.accept(visitor, data) }
+    }
+}

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

@@ -43,6 +43,16 @@ interface JKJavaStringLiteralExpression : JKLiteralExpression {
     val text: String
 }
 
+interface JKJavaOperatorIdentifier : JKOperatorIdentifier
+
+interface JKJavaQualificationIdentifier : JKQualificationIdentifier
+
+interface JKJavaCallExpression : JKCallExpression {
+    override val method: JKJavaMethodReference
+}
+
+interface JKJavaMethodReference : JKMethodReference
+
 interface JKJavaAccessModifier : JKAccessModifier {
     val type: AccessModifierType
 

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

@@ -42,6 +42,46 @@ interface JKStatement : JKElement
 
 interface JKExpression : JKStatement
 
+interface JKBinaryExpression : JKExpression {
+    val left: JKExpression
+    val right: JKExpression?
+    val operator: JKOperatorIdentifier
+}
+
+interface JKUnaryExpression : JKExpression {
+    val expression: JKExpression?
+    val operator: JKOperatorIdentifier
+}
+
+interface JKPrefixExpression : JKUnaryExpression
+
+interface JKPostfixExpression : JKUnaryExpression {
+    override val expression: JKExpression
+}
+
+interface JKQualifiedExpression : JKExpression {
+    val reciever: JKExpression
+    val operator: JKQualificationIdentifier
+    val selector: JKStatement
+}
+
+interface JKCallExpression : JKExpression {
+    val arguments: JKExpressionList
+    val method: JKMethodReference
+}
+
+interface JKExpressionList : JKElement {
+    val expressions: Array<JKExpression>
+}
+
+interface JKMethodReference : JKElement {
+
+}
+
+interface JKOperatorIdentifier : JKIdentifier
+
+interface JKQualificationIdentifier : JKIdentifier
+
 interface JKLoop : JKStatement
 
 interface JKDeclaration : JKElement

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

@@ -7,6 +7,16 @@ interface JKVisitor<out R, in D> {
     fun visitClass(klass: JKClass, data: D): R = visitDeclaration(klass, data)
     fun visitStatement(statement: JKStatement, data: D): R = visitElement(statement, data)
     fun visitExpression(expression: JKExpression, data: D): R = visitStatement(expression, 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)
+    fun visitPostfixExpression(postfixExpression: JKPostfixExpression, data: D): R = visitUnaryExpression(postfixExpression, data)
+    fun visitQualifiedExpression(qualifiedExpression: JKQualifiedExpression, data: D): R = visitExpression(qualifiedExpression, data)
+    fun visitCallExpression(callExpression: JKCallExpression, data: D): R = visitExpression(callExpression, data)
+    fun visitExpressionList(expressionList: JKExpressionList, data: D): R = visitElement(expressionList, data)
+    fun visitMethodReference(methodReference: JKMethodReference, data: D): R = visitElement(methodReference, 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)
@@ -28,6 +38,10 @@ interface JKVisitor<out R, in D> {
     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)
+    fun visitJavaQualificationIdentifier(javaQualificationIdentifier: JKJavaQualificationIdentifier, data: D): R = visitQualificationIdentifier(javaQualificationIdentifier, data)
+    fun visitJavaCallExpression(javaCallExpression: JKJavaCallExpression, data: D): R = visitCallExpression(javaCallExpression, data)
+    fun visitJavaMethodReference(javaMethodReference: JKJavaMethodReference, data: D): R = visitMethodReference(javaMethodReference, 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)

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

@@ -11,6 +11,26 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitStatement(statement: JKStatement, data: Nothing?) = visitStatement(statement)
     fun visitExpression(expression: JKExpression) = visitStatement(expression, null)
     override fun visitExpression(expression: JKExpression, data: Nothing?) = visitExpression(expression)
+    fun visitBinaryExpression(binaryExpression: JKBinaryExpression) = visitExpression(binaryExpression, null)
+    override fun visitBinaryExpression(binaryExpression: JKBinaryExpression, data: Nothing?) = visitBinaryExpression(binaryExpression)
+    fun visitUnaryExpression(unaryExpression: JKUnaryExpression) = visitExpression(unaryExpression, null)
+    override fun visitUnaryExpression(unaryExpression: JKUnaryExpression, data: Nothing?) = visitUnaryExpression(unaryExpression)
+    fun visitPrefixExpression(prefixExpression: JKPrefixExpression) = visitUnaryExpression(prefixExpression, null)
+    override fun visitPrefixExpression(prefixExpression: JKPrefixExpression, data: Nothing?) = visitPrefixExpression(prefixExpression)
+    fun visitPostfixExpression(postfixExpression: JKPostfixExpression) = visitUnaryExpression(postfixExpression, null)
+    override fun visitPostfixExpression(postfixExpression: JKPostfixExpression, data: Nothing?) = visitPostfixExpression(postfixExpression)
+    fun visitQualifiedExpression(qualifiedExpression: JKQualifiedExpression) = visitExpression(qualifiedExpression, null)
+    override fun visitQualifiedExpression(qualifiedExpression: JKQualifiedExpression, data: Nothing?) = visitQualifiedExpression(qualifiedExpression)
+    fun visitCallExpression(callExpression: JKCallExpression) = visitExpression(callExpression, null)
+    override fun visitCallExpression(callExpression: JKCallExpression, data: Nothing?) = visitCallExpression(callExpression)
+    fun visitExpressionList(expressionList: JKExpressionList) = visitElement(expressionList, null)
+    override fun visitExpressionList(expressionList: JKExpressionList, data: Nothing?) = visitExpressionList(expressionList)
+    fun visitMethodReference(methodReference: JKMethodReference) = visitElement(methodReference, null)
+    override fun visitMethodReference(methodReference: JKMethodReference, data: Nothing?) = visitMethodReference(methodReference)
+    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)
@@ -53,6 +73,14 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitJavaTypeIdentifier(javaTypeIdentifier: JKJavaTypeIdentifier, data: Nothing?) = visitJavaTypeIdentifier(javaTypeIdentifier)
     fun visitJavaStringLiteralExpression(javaStringLiteralExpression: JKJavaStringLiteralExpression) = visitLiteralExpression(javaStringLiteralExpression, null)
     override fun visitJavaStringLiteralExpression(javaStringLiteralExpression: JKJavaStringLiteralExpression, data: Nothing?) = visitJavaStringLiteralExpression(javaStringLiteralExpression)
+    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 visitJavaCallExpression(javaCallExpression: JKJavaCallExpression) = visitCallExpression(javaCallExpression, null)
+    override fun visitJavaCallExpression(javaCallExpression: JKJavaCallExpression, data: Nothing?) = visitJavaCallExpression(javaCallExpression)
+    fun visitJavaMethodReference(javaMethodReference: JKJavaMethodReference) = visitMethodReference(javaMethodReference, null)
+    override fun visitJavaMethodReference(javaMethodReference: JKJavaMethodReference, data: Nothing?) = visitJavaMethodReference(javaMethodReference)
     fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier) = visitAccessModifier(javaAccessModifier, null)
     override fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier, data: Nothing?) = visitJavaAccessModifier(javaAccessModifier)
     fun visitJavaModifier(javaModifier: JKJavaModifier) = visitModifier(javaModifier, null)