From 24803e31fdcf3eb761dec26c26c1dac23b102d17 Mon Sep 17 00:00:00 2001 From: Knize Date: Sun, 29 Oct 2017 23:23:23 +0300 Subject: [PATCH] New J2K: Add class mapper --- .../kotlin/j2k/JavaToJKTreeBuilder.kt | 77 ++++++++++++------- .../org/jetbrains/kotlin/j2k/tree/impl/j.kt | 10 ++- .../org/jetbrains/kotlin/j2k/tree/impl/jk.kt | 15 +++- j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt | 7 +- .../org/jetbrains/kotlin/j2k/tree/jk.kt | 13 +++- .../kotlin/j2k/tree/visitors/JKTransformer.kt | 32 ++++---- .../j2k/tree/visitors/JKTransformerVoid.kt | 34 ++++---- .../kotlin/j2k/tree/visitors/JKVisitor.kt | 4 +- .../kotlin/j2k/tree/visitors/JKVisitorVoid.kt | 6 +- 9 files changed, 134 insertions(+), 64 deletions(-) diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt index 85f5892d23d..76395076d88 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt @@ -19,9 +19,6 @@ package org.jetbrains.kotlin.j2k import com.intellij.lang.java.JavaLanguage import com.intellij.psi.* import com.intellij.psi.impl.source.tree.java.PsiLiteralExpressionImpl -import org.jetbrains.kotlin.j2k.ast.CommentsAndSpacesInheritance -import org.jetbrains.kotlin.j2k.ast.Modifiers -import org.jetbrains.kotlin.j2k.ast.assignPrototype import org.jetbrains.kotlin.j2k.tree.* import org.jetbrains.kotlin.j2k.tree.impl.* @@ -44,10 +41,53 @@ class JavaToJKTreeBuilder { fun result(): JKExpression = resultExpression!! } - private object ClassTreeMapper { - fun PsiClass.toJK(): JKClass{ - return JKClassImpl(with(ModifierMapper){modifierList.toJK()}, JKNameIdentifierImpl(this.name!!)) + private object DeclarationMapper { + + fun PsiClass.toJK(): JKClass { + val modifierList = with(ModifierMapper) { modifierList.toJK() } + val declarations = this.children.filterIsInstance().mapNotNull { it.toJK() } + return JKClassImpl(modifierList, JKNameIdentifierImpl(this.name!!)).also { it.declarations = declarations } } + + + fun PsiField.toJK(): JKJavaField { + val initializer = this.initializer?.buildTreeForExpression() + + val type = JKJavaTypeIdentifierImpl(this.type.canonicalText) + val name = JKNameIdentifierImpl(this.name!!) + + val modifierList = with(ModifierMapper) { + modifierList.toJK() + } + + return JKJavaFieldImpl(modifierList, type, name, initializer) + } + + fun PsiMethod.toJK(): JKJavaMethod { + val modifierList = with(ModifierMapper) { modifierList.toJK() } + val name = JKNameIdentifierImpl(name) + val valueArgumentList = this.parameterList.parameters.map { it -> it.toJK() } + val block = body?.toJK() + return JKJavaMethodImpl(modifierList, name, valueArgumentList, block) + } + + fun PsiMember.toJK(): JKDeclaration? = when (this) { + is PsiField -> this.toJK() + is PsiMethod -> this.toJK() + else -> null + } + + fun PsiParameter.toJK(): JKValueArgumentImpl { + //TODO implement PsiType mapping for type name + return JKValueArgumentImpl(JKJavaTypeIdentifierImpl("this.type.getCanonicalText()"), this.name!!) + } + + fun PsiCodeBlock.toJK(): JKBlock { + //TODO block mapping + return JKBlockImpl(listOf(JKStringLiteralExpressionImpl(""))) + } + + } private object ModifierMapper { @@ -77,31 +117,14 @@ class JavaToJKTreeBuilder { element.acceptChildren(this) } - var currentClass: JKClass? = null + var resultElement: JKElement? = null override fun visitClass(aClass: PsiClass) { - - val name = JKNameIdentifierImpl(aClass.name!!) - val modifierList = with(ModifierMapper) { - aClass.modifierList.toJK() - } - - currentClass = JKClassImpl(modifierList, name) - super.visitClass(aClass) + resultElement = with(DeclarationMapper) { aClass.toJK() } } override fun visitField(field: PsiField) { - val initializer = field.initializer?.buildTreeForExpression() - - val type = JKJavaTypeIdentifierImpl(field.type.canonicalText) - val name = JKNameIdentifierImpl(field.name!!) - - val modifierList = with(ModifierMapper) { - field.modifierList.toJK() - } - - currentClass!!.declarations += JKJavaFieldImpl(modifierList, type, name, initializer) - super.visitField(field) + resultElement = with(DeclarationMapper) { field.toJK() } } } @@ -111,7 +134,7 @@ class JavaToJKTreeBuilder { assert(psi.language.`is`(JavaLanguage.INSTANCE)) { "Unable to build JK Tree using Java Visitor for language ${psi.language}" } val elementVisitor = ElementVisitor() psi.accept(elementVisitor) - return elementVisitor.currentClass + return elementVisitor.resultElement } companion object { 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 926366308ca..4d225d7d40f 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt @@ -50,4 +50,12 @@ class JKJavaStringLiteralExpressionImpl(override val text: String) : JKJavaStrin class JKJavaAccessModifierImpl(override val type: JKJavaAccessModifier.AccessModifierType) : JKJavaAccessModifier, JKElementBase() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaAccessModifier(this, data) -} \ No newline at end of file +} + +class JKJavaMethodImpl(override var modifierList: JKModifierList, + override var name: JKNameIdentifier, + override var valueArguments: List, + override var block: JKBlock?) : JKJavaMethod, JKElementBase() { + + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaMethod(this, data) +} 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 892b3a52898..0a0f852ddc2 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt @@ -62,4 +62,17 @@ class JKModifierListImpl : JKModifierList, JKElementBase() { override fun acceptChildren(visitor: JKVisitor, data: D) { modifiers.forEach { it.accept(visitor, data) } } -} \ No newline at end of file +} + +class JKValueArgumentImpl(override val type: JKTypeIdentifier, + override val name: String) : JKValueArgument, JKElementBase() { + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitValueArgument(this, data) +} + +class JKBlockImpl(override var statements: List) : JKBlock, JKElementBase() { + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitBlock(this, data) +} + +class JKStringLiteralExpressionImpl(override val text: String) : JKStringLiteralExpression, JKElementBase() { + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitStringLiteralExpression(this, data) +} diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt index 8f6a97ba18d..4cd99bba63c 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt @@ -22,7 +22,12 @@ interface JKJavaField : JKDeclaration, JKModifierListOwner { var initializer: JKExpression? } -interface JKJavaMethod : JKDeclaration +interface JKJavaMethod : JKDeclaration{ + var modifierList: JKModifierList + var name: JKNameIdentifier + var valueArguments: List + var block: JKBlock? +} interface JKJavaForLoop : JKLoop diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt index 946270f1d4b..777e082d41c 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt @@ -22,7 +22,7 @@ import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor interface JKElement { fun accept(visitor: JKVisitor, data: D): R - fun transform(transformer: JKTransformer, data: D): R + fun transform(transformer: JKTransformer, data: D): R fun acceptChildren(visitor: JKVisitor, data: D) fun transformChildren(transformer: JKTransformer, data: D) @@ -63,4 +63,13 @@ interface JKModifierList : JKElement { interface JKModifier : JKElement -interface JKAccessModifier : JKModifier \ No newline at end of file +interface JKAccessModifier : JKModifier + +interface JKValueArgument : JKElement { + val type: JKTypeIdentifier + val name: String +} + +interface JKStringLiteralExpression : JKLiteralExpression { + val text: String +} \ No newline at end of file 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 b817141c8d7..ad786068682 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 @@ -18,18 +18,20 @@ interface JKTransformer : JKVisitor { override fun visitModifierList(modifierList: JKModifierList, data: D): JKModifierList = visitElement(modifierList, data) as JKModifierList override fun visitModifier(modifier: JKModifier, data: D): JKModifier = visitElement(modifier, data) as JKModifier override fun visitAccessModifier(accessModifier: JKAccessModifier, data: D): JKAccessModifier = visitModifier(accessModifier, data) as JKAccessModifier - override fun 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 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 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 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 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 aa675eea00a..e2ab26406cb 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) @@ -33,32 +33,36 @@ interface JKTransformerVoid : JKTransformer { override fun visitModifier(modifier: JKModifier, data: Nothing?): JKModifier = visitModifier(modifier) fun visitAccessModifier(accessModifier: JKAccessModifier): JKAccessModifier = visitModifier(accessModifier) as JKAccessModifier override fun visitAccessModifier(accessModifier: JKAccessModifier, data: Nothing?): JKAccessModifier = visitAccessModifier(accessModifier) - fun visitJavaField(javaField: JKJavaField): JKDeclaration = visitDeclaration(javaField) + fun visitValueArgument(valueArgument: JKValueArgument): JKValueArgument = visitElement(valueArgument) as JKValueArgument + override fun visitValueArgument(valueArgument: JKValueArgument, data: Nothing?): JKValueArgument = visitValueArgument(valueArgument) + fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression): JKStringLiteralExpression = visitLiteralExpression(stringLiteralExpression) as JKStringLiteralExpression + override fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression, data: Nothing?): JKStringLiteralExpression = visitStringLiteralExpression(stringLiteralExpression) + fun 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 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 adb12691596..e836c4abb5c 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt @@ -3,7 +3,7 @@ package org.jetbrains.kotlin.j2k.tree.visitors import org.jetbrains.kotlin.j2k.tree.* interface JKVisitor { - fun visitElement(element: JKElement, data: D): R + fun visitElement(element: JKElement, data: D): R 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) @@ -18,6 +18,8 @@ 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 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) 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 4181224375e..e0aea26dde7 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt @@ -3,7 +3,7 @@ package org.jetbrains.kotlin.j2k.tree.visitors import org.jetbrains.kotlin.j2k.tree.* interface JKVisitorVoid : JKVisitor { - fun visitElement(element: JKElement) + fun visitElement(element: JKElement) override fun visitElement(element: JKElement, data: Nothing?) = visitElement(element) fun visitClass(klass: JKClass) = visitDeclaration(klass, null) override fun visitClass(klass: JKClass, data: Nothing?) = visitClass(klass) @@ -33,6 +33,10 @@ interface JKVisitorVoid : JKVisitor { override fun visitModifier(modifier: JKModifier, data: Nothing?) = visitModifier(modifier) fun visitAccessModifier(accessModifier: JKAccessModifier) = visitModifier(accessModifier, null) override fun visitAccessModifier(accessModifier: JKAccessModifier, data: Nothing?) = visitAccessModifier(accessModifier) + fun visitValueArgument(valueArgument: JKValueArgument) = visitElement(valueArgument, null) + override fun visitValueArgument(valueArgument: JKValueArgument, data: Nothing?) = visitValueArgument(valueArgument) + fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression) = visitLiteralExpression(stringLiteralExpression, null) + override fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression, data: Nothing?) = visitStringLiteralExpression(stringLiteralExpression) fun visitJavaField(javaField: JKJavaField) = visitDeclaration(javaField, null) override fun visitJavaField(javaField: JKJavaField, data: Nothing?) = visitJavaField(javaField) fun visitJavaMethod(javaMethod: JKJavaMethod) = visitDeclaration(javaMethod, null)