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/JKTransformer.kt

@@ -3,7 +3,7 @@ package org.jetbrains.kotlin.j2k.tree.visitors
 import org.jetbrains.kotlin.j2k.tree.*
 
 interface JKTransformer<in D> : JKVisitor<JKElement, D> {
-    override fun visitElement(element: JKElement, data: D): JKElement 
+    override fun visitElement(element: JKElement, data: D): JKElement
     override fun visitClass(klass: JKClass, data: D): JKClass = visitDeclaration(klass, data) as JKClass
     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
@@ -21,19 +21,19 @@ interface JKTransformer<in D> : JKVisitor<JKElement, D> {
     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 visitJavaField(javaField: JKJavaField, data: D): JKDeclaration = visitDeclaration(javaField, data) 
+    override fun visitJavaField(javaField: JKJavaField, data: D): JKDeclaration = visitDeclaration(javaField, data)
-    override fun visitJavaMethod(javaMethod: JKJavaMethod, data: D): JKDeclaration = visitDeclaration(javaMethod, data) 
+    override fun visitJavaMethod(javaMethod: JKJavaMethod, data: D): JKDeclaration = visitDeclaration(javaMethod, data)
-    override fun visitJavaForLoop(javaForLoop: JKJavaForLoop, data: D): JKLoop = visitLoop(javaForLoop, 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 visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: D): JKExpression = visitExpression(javaAssignmentExpression, data)
-    override fun visitJavaCall(javaCall: JKJavaCall, data: D): JKCall = visitCall(javaCall, data) 
+    override fun visitJavaCall(javaCall: JKJavaCall, data: D): JKCall = visitCall(javaCall, data)
-    override fun visitJavaTypeIdentifier(javaTypeIdentifier: JKJavaTypeIdentifier, data: D): JKTypeIdentifier = visitTypeIdentifier(javaTypeIdentifier, data) 
+    override fun visitJavaTypeIdentifier(javaTypeIdentifier: JKJavaTypeIdentifier, data: D): JKTypeIdentifier = visitTypeIdentifier(javaTypeIdentifier, data)
-    override fun visitJavaStringLiteralExpression(javaStringLiteralExpression: JKJavaStringLiteralExpression, data: D): JKLiteralExpression = visitLiteralExpression(javaStringLiteralExpression, data) 
+    override fun visitJavaStringLiteralExpression(javaStringLiteralExpression: JKJavaStringLiteralExpression, data: D): JKLiteralExpression = visitLiteralExpression(javaStringLiteralExpression, data)
-    override fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier, data: D): JKAccessModifier = visitAccessModifier(javaAccessModifier, 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 visitJavaModifier(javaModifier: JKJavaModifier, data: D): JKModifier = visitModifier(javaModifier, data)
-    override fun visitKtFun(ktFun: JKKtFun, data: D): JKDeclaration = visitDeclaration(ktFun, data) 
+    override fun visitKtFun(ktFun: JKKtFun, data: D): JKDeclaration = visitDeclaration(ktFun, data)
-    override fun visitKtConstructor(ktConstructor: JKKtConstructor, data: D): JKDeclaration = visitDeclaration(ktConstructor, 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 visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor, data: D): JKDeclaration = visitKtConstructor(ktPrimaryConstructor, data)
-    override fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement, data: D): JKStatement = visitStatement(ktAssignmentStatement, data) 
+    override fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement, data: D): JKStatement = visitStatement(ktAssignmentStatement, data)
-    override fun visitKtCall(ktCall: JKKtCall, data: D): JKCall = visitCall(ktCall, data) 
+    override fun visitKtCall(ktCall: JKKtCall, data: D): JKCall = visitCall(ktCall, data)
-    override fun visitKtProperty(ktProperty: JKKtProperty, data: D): JKDeclaration = visitDeclaration(ktProperty, data) 
+    override fun visitKtProperty(ktProperty: JKKtProperty, data: D): JKDeclaration = visitDeclaration(ktProperty, data)
 }

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

@@ -3,7 +3,7 @@ package org.jetbrains.kotlin.j2k.tree.visitors
 import org.jetbrains.kotlin.j2k.tree.*
 
 interface JKTransformerVoid : JKTransformer<Nothing?> {
-    fun visitElement(element: JKElement): JKElement 
+    fun visitElement(element: JKElement): JKElement
     override fun visitElement(element: JKElement, data: Nothing?): JKElement = visitElement(element)
     fun visitClass(klass: JKClass): JKClass = visitDeclaration(klass) as JKClass
     override fun visitClass(klass: JKClass, data: Nothing?): JKClass = visitClass(klass)
@@ -39,34 +39,34 @@ interface JKTransformerVoid : JKTransformer<Nothing?> {
     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 visitJavaField(javaField: JKJavaField): JKDeclaration = visitDeclaration(javaField) 
+    fun visitJavaField(javaField: JKJavaField): JKDeclaration = visitDeclaration(javaField)
     override fun visitJavaField(javaField: JKJavaField, data: Nothing?): JKDeclaration = visitJavaField(javaField)
-    fun visitJavaMethod(javaMethod: JKJavaMethod): JKDeclaration = visitDeclaration(javaMethod) 
+    fun visitJavaMethod(javaMethod: JKJavaMethod): JKDeclaration = visitDeclaration(javaMethod)
     override fun visitJavaMethod(javaMethod: JKJavaMethod, data: Nothing?): JKDeclaration = visitJavaMethod(javaMethod)
-    fun visitJavaForLoop(javaForLoop: JKJavaForLoop): JKLoop = visitLoop(javaForLoop) 
+    fun visitJavaForLoop(javaForLoop: JKJavaForLoop): JKLoop = visitLoop(javaForLoop)
     override fun visitJavaForLoop(javaForLoop: JKJavaForLoop, data: Nothing?): JKLoop = visitJavaForLoop(javaForLoop)
-    fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression): JKExpression = visitExpression(javaAssignmentExpression) 
+    fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression): JKExpression = visitExpression(javaAssignmentExpression)
     override fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: Nothing?): JKExpression = visitJavaAssignmentExpression(javaAssignmentExpression)
-    fun visitJavaCall(javaCall: JKJavaCall): JKCall = visitCall(javaCall) 
+    fun visitJavaCall(javaCall: JKJavaCall): JKCall = visitCall(javaCall)
     override fun visitJavaCall(javaCall: JKJavaCall, data: Nothing?): JKCall = visitJavaCall(javaCall)
-    fun visitJavaTypeIdentifier(javaTypeIdentifier: JKJavaTypeIdentifier): JKTypeIdentifier = visitTypeIdentifier(javaTypeIdentifier) 
+    fun visitJavaTypeIdentifier(javaTypeIdentifier: JKJavaTypeIdentifier): JKTypeIdentifier = visitTypeIdentifier(javaTypeIdentifier)
     override fun visitJavaTypeIdentifier(javaTypeIdentifier: JKJavaTypeIdentifier, data: Nothing?): JKTypeIdentifier = visitJavaTypeIdentifier(javaTypeIdentifier)
-    fun visitJavaStringLiteralExpression(javaStringLiteralExpression: JKJavaStringLiteralExpression): JKLiteralExpression = visitLiteralExpression(javaStringLiteralExpression) 
+    fun visitJavaStringLiteralExpression(javaStringLiteralExpression: JKJavaStringLiteralExpression): JKLiteralExpression = visitLiteralExpression(javaStringLiteralExpression)
     override fun visitJavaStringLiteralExpression(javaStringLiteralExpression: JKJavaStringLiteralExpression, data: Nothing?): JKLiteralExpression = visitJavaStringLiteralExpression(javaStringLiteralExpression)
-    fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier): JKAccessModifier = visitAccessModifier(javaAccessModifier) 
+    fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier): JKAccessModifier = visitAccessModifier(javaAccessModifier)
     override fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier, data: Nothing?): JKAccessModifier = visitJavaAccessModifier(javaAccessModifier)
-    fun visitJavaModifier(javaModifier: JKJavaModifier): JKModifier = visitModifier(javaModifier) 
+    fun visitJavaModifier(javaModifier: JKJavaModifier): JKModifier = visitModifier(javaModifier)
     override fun visitJavaModifier(javaModifier: JKJavaModifier, data: Nothing?): JKModifier = visitJavaModifier(javaModifier)
-    fun visitKtFun(ktFun: JKKtFun): JKDeclaration = visitDeclaration(ktFun) 
+    fun visitKtFun(ktFun: JKKtFun): JKDeclaration = visitDeclaration(ktFun)
     override fun visitKtFun(ktFun: JKKtFun, data: Nothing?): JKDeclaration = visitKtFun(ktFun)
-    fun visitKtConstructor(ktConstructor: JKKtConstructor): JKDeclaration = visitDeclaration(ktConstructor) 
+    fun visitKtConstructor(ktConstructor: JKKtConstructor): JKDeclaration = visitDeclaration(ktConstructor)
     override fun visitKtConstructor(ktConstructor: JKKtConstructor, data: Nothing?): JKDeclaration = visitKtConstructor(ktConstructor)
-    fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor): JKDeclaration = visitKtConstructor(ktPrimaryConstructor) 
+    fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor): JKDeclaration = visitKtConstructor(ktPrimaryConstructor)
     override fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor, data: Nothing?): JKDeclaration = visitKtPrimaryConstructor(ktPrimaryConstructor)
-    fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement): JKStatement = visitStatement(ktAssignmentStatement) 
+    fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement): JKStatement = visitStatement(ktAssignmentStatement)
     override fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement, data: Nothing?): JKStatement = visitKtAssignmentStatement(ktAssignmentStatement)
-    fun visitKtCall(ktCall: JKKtCall): JKCall = visitCall(ktCall) 
+    fun visitKtCall(ktCall: JKKtCall): JKCall = visitCall(ktCall)
     override fun visitKtCall(ktCall: JKKtCall, data: Nothing?): JKCall = visitKtCall(ktCall)
-    fun visitKtProperty(ktProperty: JKKtProperty): JKDeclaration = visitDeclaration(ktProperty) 
+    fun visitKtProperty(ktProperty: JKKtProperty): JKDeclaration = visitDeclaration(ktProperty)
     override fun visitKtProperty(ktProperty: JKKtProperty, data: Nothing?): JKDeclaration = visitKtProperty(ktProperty)
 }

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)