From 4ecbd13e063684b756a1414c84f7c7e88b0e8944 Mon Sep 17 00:00:00 2001 From: Dimach Date: Fri, 20 Oct 2017 02:36:47 +0300 Subject: [PATCH] New J2K: Added java -> jk converter for new expression. --- .../kotlin/j2k/JavaToJKTreeBuilder.kt | 17 +++- .../org/jetbrains/kotlin/j2k/tree/impl/j.kt | 21 ++++- j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt | 6 ++ .../org/jetbrains/kotlin/j2k/tree/jk.kt | 9 +++ .../kotlin/j2k/tree/visitors/JKTransformer.kt | 78 +++++++++++-------- .../kotlin/j2k/tree/visitors/JKVisitor.kt | 4 + .../kotlin/j2k/tree/visitors/JKVisitorVoid.kt | 8 ++ 7 files changed, 104 insertions(+), 39 deletions(-) diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt index cbf836c9c4a..96d8b78cc49 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt @@ -47,6 +47,9 @@ class JavaToJKTreeBuilder { is PsiReferenceExpression -> { return toJK() } + is PsiNewExpression -> { + return toJK() + } } throw RuntimeException("Not supported") } @@ -82,7 +85,7 @@ class JavaToJKTreeBuilder { fun PsiMethodCallExpression.toJK(): JKExpression { val method = methodExpression as PsiReferenceExpressionImpl val identifier = (method.referenceNameElement as PsiIdentifier).convertMethodReference() - val call = JKJavaMethodCallExpressionImpl(argumentList.toJK(), identifier) + val call = JKJavaMethodCallExpressionImpl(identifier, argumentList.toJK()) return if (method.findChildByRole(ChildRole.DOT) != null) { JKQualifiedExpressionImpl((method.qualifier as PsiExpression).toJK(), JKJavaQualificationIdentifierImpl.DOT, call) } @@ -103,8 +106,12 @@ class JavaToJKTreeBuilder { } } - fun PsiExpressionList.toJK(): JKExpressionList { - return JKExpressionListImpl(expressions.map { it.toJK() }.toTypedArray()) + fun PsiNewExpression.toJK(): JKExpression { + return JKJavaNewExpressionImpl((classReference as PsiIdentifier).convertClassReference(), argumentList.toJK()) + } + + fun PsiExpressionList?.toJK(): JKExpressionList { + return JKExpressionListImpl(this?.expressions?.map { it.toJK() }?.toTypedArray() ?: emptyArray()) } fun PsiIdentifier.convertMethodReference(): JKJavaMethodReference { @@ -114,6 +121,10 @@ class JavaToJKTreeBuilder { fun PsiIdentifier.convertFieldReference(): JKJavaFieldReference { return JKJavaFieldReferenceImpl() } + + fun PsiIdentifier.convertClassReference(): JKJavaClassReference { + return JKJavaClassReferenceImpl() + } } private object DeclarationMapper { diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt index bd61faf46b5..ea6eb2bc3a0 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt @@ -77,8 +77,8 @@ sealed class JKJavaQualificationIdentifierImpl : JKJavaQualificationIdentifier, object DOT : JKJavaQualificationIdentifierImpl() } -class JKJavaMethodCallExpressionImpl(override val arguments: JKExpressionList, - override val identifier: JKMethodReference) : JKJavaMethodCallExpression, JKElementBase() { +class JKJavaMethodCallExpressionImpl(override val identifier: JKMethodReference, + override val arguments: JKExpressionList) : JKJavaMethodCallExpression, JKElementBase() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaMethodCallExpression(this, data) override fun acceptChildren(visitor: JKVisitor, data: D) { @@ -95,6 +95,15 @@ class JKJavaFieldAccessExpressionImpl(override val identifier: JKFieldReference) } } +class JKJavaNewExpressionImpl(override val identifier: JKClassReference, + override val arguments: JKExpressionList) : JKJavaNewExpression, JKElementBase() { + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaNewExpression(this, data) + + override fun acceptChildren(visitor: JKVisitor, data: D) { + identifier.accept(visitor, data) + } +} + class JKJavaMethodReferenceImpl() : JKJavaMethodReference, JKElementBase() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaMethodReference(this, data) @@ -108,5 +117,13 @@ class JKJavaFieldReferenceImpl() : JKJavaFieldReference, JKElementBase() { override fun acceptChildren(visitor: JKVisitor, data: D) { + } +} + +class JKJavaClassReferenceImpl() : JKJavaClassReference, JKElementBase() { + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaClassReference(this, data) + + override fun acceptChildren(visitor: JKVisitor, data: D) { + } } \ No newline at end of file diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt index 8cfce408fb3..29e2562a56a 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt @@ -53,10 +53,16 @@ interface JKJavaFieldAccessExpression : JKFieldAccessExpression { } +interface JKJavaNewExpression : JKNewExpression { + +} + interface JKJavaMethodReference : JKMethodReference interface JKJavaFieldReference : JKFieldReference +interface JKJavaClassReference : JKClassReference + 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 21e78e588cc..daefce990ae 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt @@ -74,6 +74,11 @@ interface JKFieldAccessExpression : JKExpression { val identifier: JKFieldReference } +interface JKNewExpression : JKExpression { + val identifier: JKClassReference + val arguments: JKExpressionList +} + interface JKExpressionList : JKElement { val expressions: Array } @@ -86,6 +91,10 @@ interface JKFieldReference : JKElement { } +interface JKClassReference : JKElement { + +} + interface JKOperatorIdentifier : JKIdentifier interface JKQualificationIdentifier : JKIdentifier 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 18d057a9c19..afdf2bf14e1 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKTransformer.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKTransformer.kt @@ -2,38 +2,48 @@ 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 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 - override fun visitLoop(loop: JKLoop, data: D): JKLoop = visitStatement(loop, data) as JKLoop - override fun visitDeclaration(declaration: JKDeclaration, data: D): JKDeclaration = visitElement(declaration, data) as JKDeclaration - override fun visitBlock(block: JKBlock, data: D): JKBlock = visitElement(block, data) as JKBlock - override fun visitCall(call: JKCall, data: D): JKCall = visitExpression(call, data) as JKCall - override fun visitIdentifier(identifier: JKIdentifier, data: D): JKIdentifier = visitElement(identifier, data) as JKIdentifier - override fun visitTypeIdentifier(typeIdentifier: JKTypeIdentifier, data: D): JKTypeIdentifier = visitIdentifier(typeIdentifier, data) as JKTypeIdentifier - override fun visitNameIdentifier(nameIdentifier: JKNameIdentifier, data: D): JKNameIdentifier = visitIdentifier(nameIdentifier, data) as JKNameIdentifier - override fun visitLiteralExpression(literalExpression: JKLiteralExpression, data: D): JKLiteralExpression = visitExpression(literalExpression, data) as JKLiteralExpression - 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 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) +interface JKTransformer { + fun transformElement(element: JKElement, data: D): E + fun transformClass(klass: JKClass, data: D): E = transformDeclaration(klass, data) + fun transformStatement(statement: JKStatement, data: D): E = transformElement(statement, data) + fun transformExpression(expression: JKExpression, data: D): E = transformStatement(expression, data) + fun transformBinaryExpression(binaryExpression: JKBinaryExpression, data: D): E = transformExpression(binaryExpression, data) + fun transformUnaryExpression(unaryExpression: JKUnaryExpression, data: D): E = transformExpression(unaryExpression, data) + fun transformPrefixExpression(prefixExpression: JKPrefixExpression, data: D): E = transformUnaryExpression(prefixExpression, data) + fun transformPostfixExpression(postfixExpression: JKPostfixExpression, data: D): E = transformUnaryExpression(postfixExpression, data) + fun transformQualifiedExpression(qualifiedExpression: JKQualifiedExpression, data: D): E = transformExpression(qualifiedExpression, data) + fun transformMethodCallExpression(methodCallExpression: JKMethodCallExpression, data: D): E = transformExpression(methodCallExpression, data) + fun transformFieldAccessExpression(fieldAccessExpression: JKFieldAccessExpression, data: D): E = transformExpression(fieldAccessExpression, data) + fun transformExpressionList(expressionList: JKExpressionList, data: D): E = transformElement(expressionList, data) + fun transformMethodReference(methodReference: JKMethodReference, data: D): E = transformElement(methodReference, data) + fun transformFieldReference(fieldReference: JKFieldReference, data: D): E = transformElement(fieldReference, data) + fun transformOperatorIdentifier(operatorIdentifier: JKOperatorIdentifier, data: D): E = transformIdentifier(operatorIdentifier, data) + fun transformQualificationIdentifier(qualificationIdentifier: JKQualificationIdentifier, data: D): E = transformIdentifier(qualificationIdentifier, data) + fun transformLoop(loop: JKLoop, data: D): E = transformStatement(loop, data) + fun transformDeclaration(declaration: JKDeclaration, data: D): E = transformElement(declaration, data) + fun transformBlock(block: JKBlock, data: D): E = transformElement(block, data) + fun transformIdentifier(identifier: JKIdentifier, data: D): E = transformElement(identifier, data) + fun transformTypeIdentifier(typeIdentifier: JKTypeIdentifier, data: D): E = transformIdentifier(typeIdentifier, data) + fun transformNameIdentifier(nameIdentifier: JKNameIdentifier, data: D): E = transformIdentifier(nameIdentifier, data) + fun transformLiteralExpression(literalExpression: JKLiteralExpression, data: D): E = transformExpression(literalExpression, data) + fun transformModifierList(modifierList: JKModifierList, data: D): E = transformElement(modifierList, data) + fun transformModifier(modifier: JKModifier, data: D): E = transformElement(modifier, data) + fun transformAccessModifier(accessModifier: JKAccessModifier, data: D): E = transformModifier(accessModifier, data) + fun transformJavaField(javaField: JKJavaField, data: D): E = transformDeclaration(javaField, data) + fun transformJavaMethod(javaMethod: JKJavaMethod, data: D): E = transformDeclaration(javaMethod, data) + fun transformJavaForLoop(javaForLoop: JKJavaForLoop, data: D): E = transformLoop(javaForLoop, data) + fun transformJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: D): E = transformExpression(javaAssignmentExpression, data) + fun transformJavaTypeIdentifier(javaTypeIdentifier: JKJavaTypeIdentifier, data: D): E = transformTypeIdentifier(javaTypeIdentifier, data) + fun transformJavaStringLiteralExpression(javaStringLiteralExpression: JKJavaStringLiteralExpression, data: D): E = transformLiteralExpression(javaStringLiteralExpression, data) + fun transformJavaOperatorIdentifier(javaOperatorIdentifier: JKJavaOperatorIdentifier, data: D): E = transformOperatorIdentifier(javaOperatorIdentifier, data) + fun transformJavaQualificationIdentifier(javaQualificationIdentifier: JKJavaQualificationIdentifier, data: D): E = transformQualificationIdentifier(javaQualificationIdentifier, data) + fun transformJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression, data: D): E = transformMethodCallExpression(javaMethodCallExpression, data) + fun transformJavaFieldAccessExpression(javaFieldAccessExpression: JKJavaFieldAccessExpression, data: D): E = transformFieldAccessExpression(javaFieldAccessExpression, data) + fun transformJavaMethodReference(javaMethodReference: JKJavaMethodReference, data: D): E = transformMethodReference(javaMethodReference, data) + fun transformJavaFieldReference(javaFieldReference: JKJavaFieldReference, data: D): E = transformFieldReference(javaFieldReference, data) + fun transformJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier, data: D): E = transformAccessModifier(javaAccessModifier, data) + fun transformKtFun(ktFun: JKKtFun, data: D): E = transformDeclaration(ktFun, data) + fun transformKtConstructor(ktConstructor: JKKtConstructor, data: D): E = transformDeclaration(ktConstructor, data) + fun transformKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor, data: D): E = transformKtConstructor(ktPrimaryConstructor, data) + fun transformKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement, data: D): E = transformStatement(ktAssignmentStatement, data) } 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 346005394f7..35cc37b7fca 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt @@ -14,9 +14,11 @@ interface JKVisitor { fun visitQualifiedExpression(qualifiedExpression: JKQualifiedExpression, data: D): R = visitExpression(qualifiedExpression, data) fun visitMethodCallExpression(methodCallExpression: JKMethodCallExpression, data: D): R = visitExpression(methodCallExpression, data) fun visitFieldAccessExpression(fieldAccessExpression: JKFieldAccessExpression, data: D): R = visitExpression(fieldAccessExpression, data) + fun visitNewExpression(newExpression: JKNewExpression, data: D): R = visitExpression(newExpression, data) fun visitExpressionList(expressionList: JKExpressionList, data: D): R = visitElement(expressionList, data) fun visitMethodReference(methodReference: JKMethodReference, data: D): R = visitElement(methodReference, data) fun visitFieldReference(fieldReference: JKFieldReference, data: D): R = visitElement(fieldReference, data) + fun visitClassReference(classReference: JKClassReference, data: D): R = visitElement(classReference, 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) @@ -44,8 +46,10 @@ interface JKVisitor { fun visitJavaQualificationIdentifier(javaQualificationIdentifier: JKJavaQualificationIdentifier, data: D): R = visitQualificationIdentifier(javaQualificationIdentifier, data) fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression, data: D): R = visitMethodCallExpression(javaMethodCallExpression, data) fun visitJavaFieldAccessExpression(javaFieldAccessExpression: JKJavaFieldAccessExpression, data: D): R = visitFieldAccessExpression(javaFieldAccessExpression, data) + fun visitJavaNewExpression(javaNewExpression: JKJavaNewExpression, data: D): R = visitNewExpression(javaNewExpression, data) fun visitJavaMethodReference(javaMethodReference: JKJavaMethodReference, data: D): R = visitMethodReference(javaMethodReference, data) fun visitJavaFieldReference(javaFieldReference: JKJavaFieldReference, data: D): R = visitFieldReference(javaFieldReference, data) + fun visitJavaClassReference(javaClassReference: JKJavaClassReference, data: D): R = visitClassReference(javaClassReference, data) fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier, data: D): R = visitAccessModifier(javaAccessModifier, data) fun visitJavaModifier(javaModifier: JKJavaModifier, data: D): R = visitModifier(javaModifier, data) fun visitKtFun(ktFun: JKKtFun, data: D): R = visitDeclaration(ktFun, data) 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 3adf0c85c14..6292523d7db 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt @@ -25,12 +25,16 @@ interface JKVisitorVoid : JKVisitor { override fun visitMethodCallExpression(methodCallExpression: JKMethodCallExpression, data: Nothing?) = visitMethodCallExpression(methodCallExpression) fun visitFieldAccessExpression(fieldAccessExpression: JKFieldAccessExpression) = visitExpression(fieldAccessExpression, null) override fun visitFieldAccessExpression(fieldAccessExpression: JKFieldAccessExpression, data: Nothing?) = visitFieldAccessExpression(fieldAccessExpression) + fun visitNewExpression(newExpression: JKNewExpression) = visitExpression(newExpression, null) + override fun visitNewExpression(newExpression: JKNewExpression, data: Nothing?) = visitNewExpression(newExpression) fun 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 visitFieldReference(fieldReference: JKFieldReference) = visitElement(fieldReference, null) override fun visitFieldReference(fieldReference: JKFieldReference, data: Nothing?) = visitFieldReference(fieldReference) + fun visitClassReference(classReference: JKClassReference) = visitElement(classReference, null) + override fun visitClassReference(classReference: JKClassReference, data: Nothing?) = visitClassReference(classReference) fun visitOperatorIdentifier(operatorIdentifier: JKOperatorIdentifier) = visitIdentifier(operatorIdentifier, null) override fun visitOperatorIdentifier(operatorIdentifier: JKOperatorIdentifier, data: Nothing?) = visitOperatorIdentifier(operatorIdentifier) fun visitQualificationIdentifier(qualificationIdentifier: JKQualificationIdentifier) = visitIdentifier(qualificationIdentifier, null) @@ -79,10 +83,14 @@ interface JKVisitorVoid : JKVisitor { override fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression, data: Nothing?) = visitJavaMethodCallExpression(javaMethodCallExpression) fun visitJavaFieldAccessExpression(javaFieldAccessExpression: JKJavaFieldAccessExpression) = visitFieldAccessExpression(javaFieldAccessExpression, null) override fun visitJavaFieldAccessExpression(javaFieldAccessExpression: JKJavaFieldAccessExpression, data: Nothing?) = visitJavaFieldAccessExpression(javaFieldAccessExpression) + fun visitJavaNewExpression(javaNewExpression: JKJavaNewExpression) = visitNewExpression(javaNewExpression, null) + override fun visitJavaNewExpression(javaNewExpression: JKJavaNewExpression, data: Nothing?) = visitJavaNewExpression(javaNewExpression) fun visitJavaMethodReference(javaMethodReference: JKJavaMethodReference) = visitMethodReference(javaMethodReference, null) override fun visitJavaMethodReference(javaMethodReference: JKJavaMethodReference, data: Nothing?) = visitJavaMethodReference(javaMethodReference) fun visitJavaFieldReference(javaFieldReference: JKJavaFieldReference) = visitFieldReference(javaFieldReference, null) override fun visitJavaFieldReference(javaFieldReference: JKJavaFieldReference, data: Nothing?) = visitJavaFieldReference(javaFieldReference) + fun visitJavaClassReference(javaClassReference: JKJavaClassReference) = visitClassReference(javaClassReference, null) + override fun visitJavaClassReference(javaClassReference: JKJavaClassReference, data: Nothing?) = visitJavaClassReference(javaClassReference) fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier) = visitAccessModifier(javaAccessModifier, null) override fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier, data: Nothing?) = visitJavaAccessModifier(javaAccessModifier) fun visitKtFun(ktFun: JKKtFun) = visitDeclaration(ktFun, null)