New J2K: Add class mapper

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 {
+    private object DeclarationMapper {
-        fun PsiClass.toJK(): JKClass{
+
-            return JKClassImpl(with(ModifierMapper){modifierList.toJK()}, JKNameIdentifierImpl(this.name!!))
+        fun PsiClass.toJK(): JKClass {
+            val modifierList = with(ModifierMapper) { modifierList.toJK() }
+            val declarations = this.children.filterIsInstance<PsiMember>().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) {
-
+            resultElement = with(DeclarationMapper) { aClass.toJK() }
-            val name = JKNameIdentifierImpl(aClass.name!!)
-            val modifierList = with(ModifierMapper) {
-                aClass.modifierList.toJK()
-            }
-
-            currentClass = JKClassImpl(modifierList, name)
-            super.visitClass(aClass)
         }
 
         override fun visitField(field: PsiField) {
-            val initializer = field.initializer?.buildTreeForExpression()
+            resultElement = with(DeclarationMapper) { field.toJK() }
-
-            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)
         }
 
     }
@@ -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 {

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 <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaAccessModifier(this, data)
-}
+}
+
+class JKJavaMethodImpl(override var modifierList: JKModifierList,
+                       override var name: JKNameIdentifier,
+                       override var valueArguments: List<JKValueArgument>,
+                       override var block: JKBlock?) : JKJavaMethod, JKElementBase() {
+
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaMethod(this, data)
+}

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

@@ -62,4 +62,17 @@ class JKModifierListImpl : JKModifierList, JKElementBase() {
     override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
         modifiers.forEach { it.accept(visitor, data) }
     }
-}
+}
+
+class JKValueArgumentImpl(override val type: JKTypeIdentifier,
+                          override val name: String) : JKValueArgument, JKElementBase() {
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitValueArgument(this, 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)
+}
+
+class JKStringLiteralExpressionImpl(override val text: String) : JKStringLiteralExpression, JKElementBase() {
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitStringLiteralExpression(this, data)
+}

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<JKValueArgument>
+    var block: JKBlock?
+}
 
 interface JKJavaForLoop : JKLoop
 

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

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor
 
 interface JKElement {
     fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R
-    fun <R: JKElement, D> transform(transformer: JKTransformer<D>, data: D): R
+    fun <R : JKElement, D> transform(transformer: JKTransformer<D>, data: D): R
 
     fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D)
     fun <D> transformChildren(transformer: JKTransformer<D>, data: D)
@@ -63,4 +63,13 @@ interface JKModifierList : JKElement {
 
 interface JKModifier : JKElement
 
-interface JKAccessModifier : JKModifier
+interface JKAccessModifier : JKModifier
+
+interface JKValueArgument : JKElement {
+    val type: JKTypeIdentifier
+    val name: String
+}
+
+interface JKStringLiteralExpression : JKLiteralExpression {
+    val text: String
+}

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<in D> : JKVisitor<JKElement, D> {
-    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<in D> : JKVisitor<JKElement, D> {
     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 visitValueArgument(valueArgument: JKValueArgument, data: D): JKValueArgument = visitElement(valueArgument, data) as JKValueArgument
-    override fun visitJavaMethod(javaMethod: JKJavaMethod, data: D): JKDeclaration = visitDeclaration(javaMethod, data) 
+    override fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression, data: D): JKStringLiteralExpression = visitLiteralExpression(stringLiteralExpression, data) as JKStringLiteralExpression
-    override fun visitJavaForLoop(javaForLoop: JKJavaForLoop, data: D): JKLoop = visitLoop(javaForLoop, data) 
+    override fun visitJavaField(javaField: JKJavaField, data: D): JKDeclaration = visitDeclaration(javaField, data)
-    override fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: D): JKExpression = visitExpression(javaAssignmentExpression, data) 
+    override fun visitJavaMethod(javaMethod: JKJavaMethod, data: D): JKDeclaration = visitDeclaration(javaMethod, data)
-    override fun visitJavaCall(javaCall: JKJavaCall, data: D): JKCall = visitCall(javaCall, data) 
+    override fun visitJavaForLoop(javaForLoop: JKJavaForLoop, data: D): JKLoop = visitLoop(javaForLoop, data)
-    override fun visitJavaTypeIdentifier(javaTypeIdentifier: JKJavaTypeIdentifier, data: D): JKTypeIdentifier = visitTypeIdentifier(javaTypeIdentifier, data) 
+    override fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: D): JKExpression = visitExpression(javaAssignmentExpression, data)
-    override fun visitJavaStringLiteralExpression(javaStringLiteralExpression: JKJavaStringLiteralExpression, data: D): JKLiteralExpression = visitLiteralExpression(javaStringLiteralExpression, data) 
+    override fun visitJavaCall(javaCall: JKJavaCall, data: D): JKCall = visitCall(javaCall, data)
-    override fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier, data: D): JKAccessModifier = visitAccessModifier(javaAccessModifier, data) 
+    override fun visitJavaTypeIdentifier(javaTypeIdentifier: JKJavaTypeIdentifier, data: D): JKTypeIdentifier = visitTypeIdentifier(javaTypeIdentifier, data)
-    override fun visitKtFun(ktFun: JKKtFun, data: D): JKDeclaration = visitDeclaration(ktFun, data) 
+    override fun visitJavaStringLiteralExpression(javaStringLiteralExpression: JKJavaStringLiteralExpression, data: D): JKLiteralExpression = visitLiteralExpression(javaStringLiteralExpression, data)
-    override fun visitKtConstructor(ktConstructor: JKKtConstructor, data: D): JKDeclaration = visitDeclaration(ktConstructor, data) 
+    override fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier, data: D): JKAccessModifier = visitAccessModifier(javaAccessModifier, data)
-    override fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor, data: D): JKDeclaration = visitKtConstructor(ktPrimaryConstructor, data) 
+    override fun visitKtFun(ktFun: JKKtFun, data: D): JKDeclaration = visitDeclaration(ktFun, data)
-    override fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement, data: D): JKStatement = visitStatement(ktAssignmentStatement, data) 
+    override fun visitKtConstructor(ktConstructor: JKKtConstructor, data: D): JKDeclaration = visitDeclaration(ktConstructor, data)
-    override fun visitKtCall(ktCall: JKKtCall, data: D): JKCall = visitCall(ktCall, data) 
+    override fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor, data: D): JKDeclaration = visitKtConstructor(ktPrimaryConstructor, data)
-    override fun visitKtProperty(ktProperty: JKKtProperty, data: D): JKDeclaration = visitDeclaration(ktProperty, 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)
 }

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<Nothing?> {
-    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<Nothing?> {
     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)
 }

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<out R, in D> {
-    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<out R, in D> {
     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)

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<Unit, Nothing?> {
-    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<Unit, Nothing?> {
     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)