From 9bfd8e4453014dedf2cfc39f0dbfe7407e673fb3 Mon Sep 17 00:00:00 2001 From: Dimach Date: Tue, 17 Oct 2017 20:19:27 +0300 Subject: [PATCH] New J2K: Added basic expression converter. --- .../kotlin/j2k/JavaToJKTreeBuilder.kt | 77 ++++++++++++++----- .../org/jetbrains/kotlin/j2k/tree/impl/j.kt | 31 ++++++++ .../org/jetbrains/kotlin/j2k/tree/impl/jk.kt | 36 +++++++++ j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt | 10 +++ .../org/jetbrains/kotlin/j2k/tree/jk.kt | 40 ++++++++++ .../kotlin/j2k/tree/visitors/JKTransformer.kt | 32 ++++---- .../j2k/tree/visitors/JKTransformerVoid.kt | 32 ++++---- .../kotlin/j2k/tree/visitors/JKVisitor.kt | 14 ++++ .../kotlin/j2k/tree/visitors/JKVisitorVoid.kt | 28 +++++++ 9 files changed, 250 insertions(+), 50 deletions(-) diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt index 02f3dea0bbb..964fcce9cab 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt +++ b/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 var resultExpression: JKExpression? = null - - override fun visitLiteralExpression(expression: PsiLiteralExpression?) { - if (expression is PsiLiteralExpressionImpl) { - - when (expression.literalElementType) { - JavaTokenType.STRING_LITERAL -> - resultExpression = JKJavaStringLiteralExpressionImpl(expression.innerText!!) + private object ExpressionTreeMapper { + fun PsiExpression.toJK(): JKExpression { + when (this) { + is PsiBinaryExpression -> { + return toJK() } + 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() - } - -} \ 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 3a072ebe9e6..e4e31297917 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt @@ -63,3 +63,34 @@ class JKJavaMethodImpl(override var modifierList: JKModifierList, override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaMethod(this, 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 JKJavaQualificationIdentifierImpl : JKJavaQualificationIdentifier, JKElementBase() { + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaQualificationIdentifier(this, data) + + object DOT : JKJavaQualificationIdentifierImpl() +} + +class JKJavaCallExpressionImpl(override val method: JKJavaMethodReference, + override val arguments: JKExpressionList) : JKJavaCallExpression, JKElementBase() { + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaCallExpression(this, data) + + override fun acceptChildren(visitor: JKVisitor, data: D) { + method.accept(visitor, data) + arguments.accept(visitor, data) + } +} + +class JKJavaMethodReferenceImpl() : JKJavaMethodReference, JKElementBase() { + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaMethodReference(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 45481d99f37..3afbd9de808 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt @@ -76,3 +76,39 @@ class JKBlockImpl(override var statements: List) : JKBlock, JKEleme class JKStringLiteralExpressionImpl(override val text: String) : JKStringLiteralExpression, JKElementBase() { override fun accept(visitor: JKVisitor, 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 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) + } +} + +class JKPrefixExpressionImpl(override val expression: JKExpression?, + override val operator: JKOperatorIdentifier) : JKPrefixExpression, JKElementBase() { + 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) + } +} + +class JKPostfixExpressionImpl(override val expression: JKExpression, + override val operator: JKOperatorIdentifier) : JKPostfixExpression, JKElementBase() { + 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) + } +} + +class JKExpressionListImpl(override val expressions: Array) : JKExpressionList, JKElementBase() { + 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) } + } +} \ 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 082b2090ecd..51f442e3d80 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt +++ b/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 diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt index edcdb23a467..edfce28cb4c 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt +++ b/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 +} + +interface JKMethodReference : JKElement { + +} + +interface JKOperatorIdentifier : JKIdentifier + +interface JKQualificationIdentifier : JKIdentifier + interface JKLoop : JKStatement interface JKDeclaration : JKElement 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 5e7473101ea..18d057a9c19 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKTransformer.kt +++ b/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 : JKVisitor { - 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 : JKVisitor { 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 visitJavaMethod(javaMethod: JKJavaMethod, data: D): JKDeclaration = visitDeclaration(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 visitJavaCall(javaCall: JKJavaCall, data: D): JKCall = visitCall(javaCall, 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 visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier, data: D): JKAccessModifier = visitAccessModifier(javaAccessModifier, 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 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): JKCall = visitCall(ktCall, data) - override fun visitKtProperty(ktProperty: JKKtProperty, data: D): JKDeclaration = visitDeclaration(ktProperty, 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 visitJavaForLoop(javaForLoop: JKJavaForLoop, data: D): JKLoop = visitLoop(javaForLoop, 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 visitJavaTypeIdentifier(javaTypeIdentifier: JKJavaTypeIdentifier, data: D): JKTypeIdentifier = visitTypeIdentifier(javaTypeIdentifier, 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 visitJavaModifier(javaModifier: JKJavaModifier, data: D): JKModifier = visitModifier(javaModifier, 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 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): JKCall = visitCall(ktCall, data) + override fun visitKtProperty(ktProperty: JKKtProperty, data: D): JKDeclaration = visitDeclaration(ktProperty, 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 d1c25a64922..a96f4387529 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKTransformerVoid.kt +++ b/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 { - 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 { 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) } 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 56390b0e5ce..6f3889e05c6 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt @@ -7,6 +7,16 @@ interface JKVisitor { 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 { 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) 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 a1f9c34fbf2..47e54f1dd2f 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt @@ -11,6 +11,26 @@ interface JKVisitorVoid : JKVisitor { 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 { 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)