Java to Kotlin converter: code refactoring

j2k/src/org/jetbrains/jet/j2k/ConstructorConverter.kt

@@ -167,8 +167,8 @@ class ConstructorConverter(private val converter: Converter) {
             return generateArtificialPrimaryConstructor(psiClass.getName()!!, classBody)
         }
         else {
-            replaceConstructorCallsInFactoryFunctions(classBody, psiClass.getName()!!)
-            return classBody
+            val updatedFunctions = replaceConstructorCallsInFactoryFunctions(classBody.factoryFunctions, psiClass.getName()!!)
+            return ClassBody(classBody.primaryConstructorSignature, classBody.members, classBody.classObjectMembers, updatedFunctions, classBody.lBrace, classBody.rBrace)
         }
     }
 
@@ -176,13 +176,14 @@ class ConstructorConverter(private val converter: Converter) {
         assert(classBody.primaryConstructorSignature == null)
 
         val fieldsToInitialize = classBody.members.filterIsInstance(javaClass<Field>()).filter { it.isVal }
-        for (factoryFunction in classBody.factoryFunctions) {
-            val body = factoryFunction.body!!
+        val updatedFactoryFunctions = ArrayList<FactoryFunction>()
+        for (function in classBody.factoryFunctions) {
+            val body = function.body!!
             // 2 cases: secondary constructor either calls another constructor or does not call any
             val newStatements = replaceConstructorCallInFactoryFunction(body, className) ?:
                     insertCallToArtificialPrimary(body, className, fieldsToInitialize)
-            factoryFunction.body = Block(newStatements, LBrace().assignNoPrototype(), RBrace().assignNoPrototype()).assignNoPrototype()
-            //TODO: no assignment here
+            val newBody = Block(newStatements, LBrace().assignNoPrototype(), RBrace().assignNoPrototype()).assignNoPrototype()
+            updatedFactoryFunctions.add(function.withBody(newBody))
         }
 
         val parameters = fieldsToInitialize.map { field ->
@@ -196,15 +197,18 @@ class ConstructorConverter(private val converter: Converter) {
         val parameterList = ParameterList(parameters).assignNoPrototype()
         val constructorSignature = PrimaryConstructorSignature(modifiers, parameterList).assignNoPrototype()
         val updatedMembers = classBody.members.filter { !fieldsToInitialize.contains(it) }
-        return ClassBody(constructorSignature, updatedMembers, classBody.classObjectMembers, classBody.factoryFunctions, classBody.lBrace, classBody.rBrace)
+        return ClassBody(constructorSignature, updatedMembers, classBody.classObjectMembers, updatedFactoryFunctions, classBody.lBrace, classBody.rBrace)
     }
 
-    private fun replaceConstructorCallsInFactoryFunctions(classBody: ClassBody, className: String) {
-        for (factoryFunction in classBody.factoryFunctions) {
-            val body = factoryFunction.body!!
+    private fun replaceConstructorCallsInFactoryFunctions(functions: List<FactoryFunction>, className: String): List<FactoryFunction> {
+        return functions.map { function ->
+            val body = function.body!!
             val statements = replaceConstructorCallInFactoryFunction(body, className)
             if (statements != null) {
-                factoryFunction.body = Block(statements, body.lBrace, body.rBrace).assignPrototypesFrom(body)
+                function.withBody(Block(statements, body.lBrace, body.rBrace).assignPrototypesFrom(body))
+            }
+            else {
+                function
             }
         }
     }

j2k/src/org/jetbrains/jet/j2k/ast/Constructors.kt

@@ -58,5 +58,8 @@ class FactoryFunction(name: Identifier,
                       returnType: Type,
                       parameterList: ParameterList,
                       typeParameterList: TypeParameterList,
-                      block: Block)
-: Function(name, annotations, modifiers, returnType, typeParameterList, parameterList, block, false)
+                      body: Block)
+: Function(name, annotations, modifiers, returnType, typeParameterList, parameterList, body, false)
+
+fun FactoryFunction.withBody(body: Block)
+        = FactoryFunction(name, annotations, modifiers, returnType, parameterList, typeParameterList, body).assignPrototypesFrom(this)

j2k/src/org/jetbrains/jet/j2k/ast/Function.kt

@@ -22,10 +22,10 @@ open class Function(
         val name: Identifier,
         annotations: Annotations,
         modifiers: Modifiers,
-        val `type`: Type,
+        val returnType: Type,
         val typeParameterList: TypeParameterList,
         val parameterList: ParameterList,
-        var body: Block?,
+        val body: Block?,
         val isInTrait: Boolean
 ) : Member(annotations, modifiers) {
 
@@ -52,14 +52,14 @@ open class Function(
                 .append(parameterList)
                 .append(")")
 
-        if (!`type`.isUnit()) {
-            builder append ":" append `type`
+        if (!returnType.isUnit()) {
+            builder append ":" append returnType
         }
 
         typeParameterList.appendWhere(builder)
 
         if (body != null) {
-            builder append " " append body!!
+            builder append " " append body
         }
     }
 }