New J2K: Implement transformChildren here and there

PR (#6)

j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt

@@ -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

@@ -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,
+class JKJavaMethodCallExpressionImpl(override var identifier: JKMethodReference,
-                                     override val arguments: JKExpressionList) : JKJavaMethodCallExpression, JKElementBase() {
+                                     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,
+class JKJavaNewExpressionImpl(override var identifier: JKClassReference,
-                              override val arguments: JKExpressionList) : JKJavaNewExpression, JKElementBase() {
+                              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

@@ -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?,
+class JKBinaryExpressionImpl(override var left: JKExpression, override var right: JKExpression?,
-                             override val operator: JKOperatorIdentifier) : JKBinaryExpression, JKElementBase() {
+                             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?,
+class JKPrefixExpressionImpl(override var expression: JKExpression,
-                             override val operator: JKOperatorIdentifier) : JKPrefixExpression, JKElementBase() {
+                             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 fun <D> transformChildren(transformer: JKTransformer<D>, data: D) {
-                              override val operator: JKOperatorIdentifier) : JKPostfixExpression, JKElementBase() {
+        expression = expression?.transform(transformer, data)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitPostfixExpression(this, data)
+        operator = operator.transform(transformer, data)
-    override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
-        expression.accept(visitor, data)
-        operator.accept(visitor, data)
     }
 }
 
-class JKExpressionListImpl(override val expressions: Array<JKExpression>) : JKExpressionList, JKElementBase() {
+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,
+class JKQualifiedExpressionImpl(override var receiver: JKExpression, override var operator: JKQualificationIdentifier,
-                                override val selector: JKStatement) : JKQualifiedExpression, JKElementBase() {
+                                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

@@ -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

@@ -17,16 +17,16 @@
 package org.jetbrains.kotlin.j2k.tree
 
 interface JKJavaField : JKDeclaration, JKModifierListOwner {
-    var type: JKTypeIdentifier
+    val type: JKTypeIdentifier
-    var name: JKNameIdentifier
+    val name: JKNameIdentifier
-    var initializer: JKExpression?
+    val initializer: JKExpression?
 }
 
 interface JKJavaMethod : JKDeclaration {
-    var modifierList: JKModifierList
+    val modifierList: JKModifierList
-    var name: JKNameIdentifier
+    val name: JKNameIdentifier
-    var valueArguments: List<JKValueArgument>
+    val valueArguments: List<JKValueArgument>
-    var block: JKBlock?
+    val block: JKBlock?
 }
 
 interface JKJavaForLoop : JKLoop

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt

@@ -29,9 +29,9 @@ interface JKElement {
 }
 
 interface JKClass : JKDeclaration, JKModifierListOwner {
-    var name: JKNameIdentifier
+    val name: JKNameIdentifier
-    var declarations: List<JKDeclaration>
+    val declarations: List<JKDeclaration>
-    var classKind: ClassKind
+    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