azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

New J2K: Implement transformChildren here and there

Browse Source 
PR (#6)
This commit is contained in:
Kirill Knize
2018-02-10 00:07:31 +03:00
committed by Ilya Kirillov
parent 2f38edb55f
commit c662813b09
6 changed files with 138 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files
j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt
+2 -2
View File
@@ -241,9 +241,9 @@ class JavaToJKTreeBuilder {
val modifierList = JKModifierListImpl()
if (this == null) return modifierList
PsiModifier.MODIFIERS
modifierList.modifiers = PsiModifier.MODIFIERS
.filter { hasExplicitModifier(it) }
.mapTo(modifierList.modifiers) { modifierToJK(it) }
.map { modifierToJK(it) }
return modifierList
}
j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt
+35 -7
View File
@@ -62,6 +62,12 @@ class JKJavaMethodImpl(override var modifierList: JKModifierList,
override var block: JKBlock?) : JKJavaMethod, JKElementBase() {
override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaMethod(this, data)
override fun <D> transformChildren(transformer: JKTransformer<D>, data: D) {
modifierList = modifierList.transform(transformer, data)
name = name.transform(transformer, data)
valueArguments = valueArguments.map { it.transform<JKValueArgument, D>(transformer, data) }
block = block?.transform(transformer, data)
}
}
sealed class JKJavaOperatorIdentifierImpl : JKJavaOperatorIdentifier, JKElementBase() {
@@ -77,31 +83,45 @@ sealed class JKJavaQualificationIdentifierImpl : JKJavaQualificationIdentifier,
object DOT : JKJavaQualificationIdentifierImpl()
}
class JKJavaMethodCallExpressionImpl(override val identifier: JKMethodReference,
override val arguments: JKExpressionList) : JKJavaMethodCallExpression, JKElementBase() {
class JKJavaMethodCallExpressionImpl(override var identifier: JKMethodReference,
override var arguments: JKExpressionList) : JKJavaMethodCallExpression, JKElementBase() {
override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaMethodCallExpression(this, data)
override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
identifier.accept(visitor, data)
arguments.accept(visitor, data)
}
override fun <D> transformChildren(transformer: JKTransformer<D>, data: D) {
identifier = identifier.transform(transformer, data)
arguments = arguments.transform(transformer, data)
}
}
class JKJavaFieldAccessExpressionImpl(override val identifier: JKFieldReference) : JKJavaFieldAccessExpression, JKElementBase() {
class JKJavaFieldAccessExpressionImpl(override var identifier: JKFieldReference) : JKJavaFieldAccessExpression, JKElementBase() {
override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaFieldAccessExpression(this, data)
override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
identifier.accept(visitor, data)
}
override fun <D> transformChildren(transformer: JKTransformer<D>, data: D) {
identifier = identifier.transform(transformer, data)
}
}
class JKJavaNewExpressionImpl(override val identifier: JKClassReference,
override val arguments: JKExpressionList) : JKJavaNewExpression, JKElementBase() {
class JKJavaNewExpressionImpl(override var identifier: JKClassReference,
override var arguments: JKExpressionList) : JKJavaNewExpression, JKElementBase() {
override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaNewExpression(this, data)
override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
identifier.accept(visitor, data)
}
override fun <D> transformChildren(transformer: JKTransformer<D>, data: D) {
identifier = identifier.transform(transformer, data)
arguments = arguments.transform(transformer, data)
}
}
class JKJavaMethodReferenceImpl() : JKJavaMethodReference, JKElementBase() {
@@ -128,18 +148,26 @@ class JKJavaClassReferenceImpl() : JKJavaClassReference, JKElementBase() {
}
}
class JKJavaNewEmptyArrayImpl(override val initializer: List<JKLiteralExpression?>) : JKJavaNewEmptyArray, JKElementBase() {
class JKJavaNewEmptyArrayImpl(override var initializer: List<JKLiteralExpression?>) : JKJavaNewEmptyArray, JKElementBase() {
override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaNewEmptyArray(this, data)
override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
}
override fun <D> transformChildren(transformer: JKTransformer<D>, data: D) {
initializer = initializer.map { it?.transform<JKLiteralExpression, D>(transformer, data) }
}
}
class JKJavaNewArrayImpl(override val initializer: List<JKExpression>) : JKJavaNewArray, JKElementBase() {
class JKJavaNewArrayImpl(override var initializer: List<JKExpression>) : JKJavaNewArray, JKElementBase() {
override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaNewArray(this, data)
override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
}
override fun <D> transformChildren(transformer: JKTransformer<D>, data: D) {
initializer = initializer.map { it.transform<JKLiteralExpression, D>(transformer, data) }
}
}
j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt
+70 -21
View File
@@ -49,104 +49,153 @@ class JKClassImpl(override var modifierList: JKModifierList, override var name:
}
class JKNameIdentifierImpl(override val name: String) : JKNameIdentifier, JKElementBase() {
class JKNameIdentifierImpl(override var name: String) : JKNameIdentifier, JKElementBase() {
override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitNameIdentifier(this, data)
}
class JKModifierListImpl : JKModifierList, JKElementBase() {
override val modifiers = mutableListOf<JKModifier>()
override var modifiers = listOf<JKModifier>()
override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitModifierList(this, data)
override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
modifiers.forEach { it.accept(visitor, data) }
}
override fun <D> transformChildren(transformer: JKTransformer<D>, data: D) {
modifiers = modifiers.map { it.transform<JKModifier, D>(transformer, data) }
}
}
class JKValueArgumentImpl(override val type: JKTypeIdentifier,
class JKValueArgumentImpl(override var type: JKTypeIdentifier,
override val name: String) : JKValueArgument, JKElementBase() {
override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitValueArgument(this, data)
override fun <D> transformChildren(transformer: JKTransformer<D>, data: D) {
type = type.transform(transformer, data)
}
}
class JKBlockImpl(override var statements: List<JKStatement>) : JKBlock, JKElementBase() {
override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitBlock(this, data)
override fun <D> transformChildren(transformer: JKTransformer<D>, data: D) {
statements = statements.map { it.transform<JKStatement, D>(transformer, data) }
}
}
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() {
class JKBinaryExpressionImpl(override var left: JKExpression, override var right: JKExpression?,
override var 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)
}
override fun <D> transformChildren(transformer: JKTransformer<D>, data: D) {
left = left.transform(transformer, data)
right = right?.transform(transformer, data)
operator = operator.transform(transformer, data)
}
}
class JKPrefixExpressionImpl(override val expression: JKExpression?,
override val operator: JKOperatorIdentifier) : JKPrefixExpression, JKElementBase() {
class JKPrefixExpressionImpl(override var expression: JKExpression,
override var 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)
override fun <D> transformChildren(transformer: JKTransformer<D>, data: D) {
expression = expression?.transform(transformer, data)
operator = operator.transform(transformer, data)
}
}
class JKExpressionListImpl(override val expressions: Array<JKExpression>) : JKExpressionList, JKElementBase() {
class JKPostfixExpressionImpl(override var expression: JKExpression,
override var 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)
}
override fun <D> transformChildren(transformer: JKTransformer<D>, data: D) {
expression = expression?.transform(transformer, data)
operator = operator.transform(transformer, data)
}
}
class JKExpressionListImpl(override var 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) }
}
override fun <D> transformChildren(transformer: JKTransformer<D>, data: D) {
expressions = expressions.map { it.transform<JKExpression, D>(transformer, data) }.toTypedArray()
}
}
class JKQualifiedExpressionImpl(override val receiver: JKExpression, override val operator: JKQualificationIdentifier,
override val selector: JKStatement) : JKQualifiedExpression, JKElementBase() {
class JKQualifiedExpressionImpl(override var receiver: JKExpression, override var operator: JKQualificationIdentifier,
override var selector: JKStatement) : JKQualifiedExpression, JKElementBase() {
override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitQualifiedExpression(this, data)
override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
receiver.accept(visitor, data)
operator.accept(visitor, data)
selector.accept(visitor, data)
}
override fun <D> transformChildren(transformer: JKTransformer<D>, data: D) {
receiver = receiver.transform(transformer, data)
operator = operator.transform(transformer, data)
selector = selector.transform(transformer, data)
}
}
class JKArrayAccessExpressionImpl(override val expression: JKExpression, override val indexExpression: JKExpression?) : JKArrayAccessExpression, JKElementBase() {
class JKArrayAccessExpressionImpl(override var expression: JKExpression, override var indexExpression: JKExpression?) : JKArrayAccessExpression, JKElementBase() {
override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitArrayAccessExpression(this, data)
override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
expression.accept(visitor, data)
indexExpression?.accept(visitor, data)
}
override fun <D> transformChildren(transformer: JKTransformer<D>, data: D) {
expression = expression.transform(transformer, data)
indexExpression = expression.transform(transformer, data)
}
}
class JKParenthesizedExpressionImpl(override val expression: JKExpression?) : JKParenthesizedExpression, JKElementBase() {
class JKParenthesizedExpressionImpl(override var expression: JKExpression?) : JKParenthesizedExpression, JKElementBase() {
override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitParenthesizedExpression(this, data)
override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
expression?.accept(visitor, data)
}
override fun <D> transformChildren(transformer: JKTransformer<D>, data: D) {
expression = expression?.transform(transformer, data)
}
}
class JKTypeCastExpressionImpl(override val expression: JKExpression?, override val type: JKTypeReference?) : JKTypeCastExpression, JKElementBase() {
class JKTypeCastExpressionImpl(override var expression: JKExpression?, override var type: JKTypeReference?) : JKTypeCastExpression, JKElementBase() {
override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitTypeCastExpression(this, data)
override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
expression?.accept(visitor, data)
type?.accept(visitor, data)
}
override fun <D> transformChildren(transformer: JKTransformer<D>, data: D) {
expression = expression?.transform(transformer, data)
type = type?.transform(transformer, data)
}
}
class JKTypeReferenceImpl() : JKTypeReference, JKElementBase() {
j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/k.kt
+19 -1
View File
@@ -17,6 +17,8 @@
package org.jetbrains.kotlin.j2k.tree.impl
import org.jetbrains.kotlin.j2k.tree.*
import org.jetbrains.kotlin.j2k.tree.visitors.JKTransformer
import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor
class JKKtPropertyImpl(override var modifierList: JKModifierList,
override var type: JKTypeIdentifier,
@@ -24,6 +26,22 @@ class JKKtPropertyImpl(override var modifierList: JKModifierList,
override var initializer: JKExpression? = null,
override var getter: JKBlock? = null,
override var setter: JKBlock? = null) : JKElementBase(), JKKtProperty {
override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtProperty(this, data)
override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
modifierList.accept(visitor, data)
type.accept(visitor, data)
name.accept(visitor, data)
initializer?.accept(visitor, data)
getter?.accept(visitor, data)
setter?.accept(visitor, data)
}
override fun <D> transformChildren(transformer: JKTransformer<D>, data: D) {
modifierList = modifierList.transform(transformer, data)
type = type.transform(transformer, data)
name = name.transform(transformer, data)
initializer = initializer?.transform(transformer, data)
getter = getter?.transform(transformer, data)
setter = setter?.transform(transformer, data)
}
}
j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt
+7 -7
View File
@@ -17,16 +17,16 @@
package org.jetbrains.kotlin.j2k.tree
interface JKJavaField : JKDeclaration, JKModifierListOwner {
var type: JKTypeIdentifier
var name: JKNameIdentifier
var initializer: JKExpression?
val type: JKTypeIdentifier
val name: JKNameIdentifier
val initializer: JKExpression?
}
interface JKJavaMethod : JKDeclaration {
var modifierList: JKModifierList
var name: JKNameIdentifier
var valueArguments: List<JKValueArgument>
var block: JKBlock?
val modifierList: JKModifierList
val name: JKNameIdentifier
val valueArguments: List<JKValueArgument>
val block: JKBlock?
}
interface JKJavaForLoop : JKLoop
j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt
+5 -5
View File
@@ -29,9 +29,9 @@ interface JKElement {
}
interface JKClass : JKDeclaration, JKModifierListOwner {
var name: JKNameIdentifier
var declarations: List<JKDeclaration>
var classKind: ClassKind
val name: JKNameIdentifier
val declarations: List<JKDeclaration>
val classKind: ClassKind
enum class ClassKind {
ABSTRACT, ANNOTATION, CLASS, ENUM, INTERFACE
@@ -117,7 +117,7 @@ interface JKLoop : JKStatement
interface JKDeclaration : JKElement
interface JKBlock : JKElement {
var statements: List<JKStatement>
val statements: List<JKStatement>
}
interface JKIdentifier : JKElement
@@ -131,7 +131,7 @@ interface JKNameIdentifier : JKIdentifier {
interface JKLiteralExpression : JKExpression
interface JKModifierList : JKElement {
val modifiers: MutableList<JKModifier>
val modifiers: List<JKModifier>
}
interface JKModifier : JKElement