KT-11804 J2K: incorrect closing parenthesis position for method split to several lines

#KT-11804 Fixed

j2k/src/org/jetbrains/kotlin/j2k/Converter.kt

@@ -276,7 +276,7 @@ class Converter private constructor(
                 } +
                 otherMethods.map { method -> createParameter(convertType(method.returnType), method) }
 
-        val parameterList = ParameterList(parameters).assignNoPrototype()
+        val parameterList = ParameterList.withNoPrototype(parameters)
         val constructorSignature = if (parameterList.parameters.isNotEmpty())
             PrimaryConstructorSignature(Annotations.Empty, Modifiers.Empty, parameterList).assignNoPrototype()
         else
@@ -355,7 +355,7 @@ class Converter private constructor(
                     val superAccess = QualifiedExpression(superExpression, propertyInfo.identifier).assignNoPrototype()
                     val returnStatement = ReturnStatement(superAccess).assignNoPrototype()
                     val body = Block.of(returnStatement).assignNoPrototype()
-                    val parameterList = ParameterList(emptyList()).assignNoPrototype()
+                    val parameterList = ParameterList.withNoPrototype(emptyList())
                     getter = PropertyAccessor(AccessorKind.GETTER, Annotations.Empty, Modifiers.Empty, parameterList, deferredElement { body })
                     getter.assignNoPrototype()
                 }
@@ -375,7 +375,7 @@ class Converter private constructor(
                     val parameterList = if (method.body != null || !parameterAnnotations.isEmpty) {
                         val parameter = FunctionParameter(convertedParameter.identifier, null, FunctionParameter.VarValModifier.None, parameterAnnotations, Modifiers.Empty)
                                 .assignPrototypesFrom(convertedParameter, CommentsAndSpacesInheritance.NO_SPACES)
-                        ParameterList(listOf(parameter)).assignNoPrototype()
+                        ParameterList.withNoPrototype(listOf(parameter))
                     }
                     else {
                         null
@@ -390,7 +390,7 @@ class Converter private constructor(
                     val assignment = AssignmentExpression(superAccess, valueIdentifier, Operator.EQ).assignNoPrototype()
                     val body = Block.of(assignment).assignNoPrototype()
                     val parameter = FunctionParameter(valueIdentifier, propertyType, FunctionParameter.VarValModifier.None, Annotations.Empty, Modifiers.Empty).assignNoPrototype()
-                    val parameterList = ParameterList(listOf(parameter)).assignNoPrototype()
+                    val parameterList = ParameterList.withNoPrototype(listOf(parameter))
                     setter = PropertyAccessor(AccessorKind.SETTER, Annotations.Empty, accessorModifiers, parameterList, deferredElement { body })
                     setter.assignNoPrototype()
                 }

j2k/src/org/jetbrains/kotlin/j2k/ExpressionConverter.kt

@@ -692,7 +692,7 @@ class DefaultExpressionConverter : JavaElementVisitor(), ExpressionConverter {
             val paramName = Identifier(it.name!!).assignNoPrototype()
             val paramType = if (it.typeElement != null) converter.typeConverter.convertType(it.type) else null
             LambdaParameter(paramName, paramType).assignPrototype(it)
-        }).assignPrototype(parameters)
+        }, lPar = null, rPar = null).assignPrototype(parameters)
 
         val body = expression.body
         when (body) {
@@ -810,7 +810,9 @@ class DefaultExpressionConverter : JavaElementVisitor(), ExpressionConverter {
                     emptyList()
                 } else {
                     parameters.map { LambdaParameter(it.first, it.second).assignNoPrototype() }
-                }).assignNoPrototype()
+                },
+                lPar = null,
+                rPar = null).assignNoPrototype()
 
         val lambdaExpression = LambdaExpression(lambdaParameterList, Block.of(statement).assignNoPrototype()).assignNoPrototype()
 

j2k/src/org/jetbrains/kotlin/j2k/OverloadReducer.kt

@@ -181,13 +181,19 @@ fun Converter.convertParameterList(
 ): ParameterList {
     val parameterList = method.parameterList
     val params = parameterList.parameters
-    return ParameterList(params.indices.map { i ->
+    val lParen = parameterList.node.findChildByType(JavaTokenType.LPARENTH)?.psi
-        val parameter = params[i]
+    val rParen = parameterList.node.findChildByType(JavaTokenType.RPARENTH)?.psi
-        val defaultValue = overloadReducer?.parameterDefault(method, i)
+    return ParameterList(
-        val defaultValueConverted = if (defaultValue != null)
+            params.indices.map { i ->
-            deferredElement { codeConverter -> codeConverter.correctCodeConverter().convertExpression(defaultValue, parameter.type) }
+                val parameter = params[i]
-        else
+                val defaultValue = overloadReducer?.parameterDefault(method, i)
-            null
+                val defaultValueConverted = if (defaultValue != null)
-        convertParameter(parameter, defaultValueConverted)
+                    deferredElement { codeConverter -> codeConverter.correctCodeConverter().convertExpression(defaultValue, parameter.type) }
-    }).assignPrototype(parameterList)
+                else
+                    null
+                convertParameter(parameter, defaultValueConverted)
+            },
+            LPar().assignPrototype(lParen, CommentsAndSpacesInheritance.LINE_BREAKS),
+            RPar().assignPrototype(rParen, CommentsAndSpacesInheritance.LINE_BREAKS)
+    ).assignPrototype(parameterList)
 }

j2k/src/org/jetbrains/kotlin/j2k/StatementConverter.kt

@@ -196,7 +196,7 @@ class DefaultStatementConverter : JavaElementVisitor(), StatementConverter {
             else
                 listOf(parameterType)
             for (t in types) {
-                var convertedType = codeConverter.typeConverter.convertType(t, Nullability.NotNull)
+                val convertedType = codeConverter.typeConverter.convertType(t, Nullability.NotNull)
                 val convertedParameter = FunctionParameter(parameter.declarationIdentifier(),
                                                            convertedType,
                                                            FunctionParameter.VarValModifier.None,
@@ -216,7 +216,7 @@ class DefaultStatementConverter : JavaElementVisitor(), StatementConverter {
         var expression: Expression = Expression.Empty
         for (variable in resourceVariables.asReversed()) {
             val parameter = LambdaParameter(Identifier(variable.name!!).assignNoPrototype(), null).assignNoPrototype()
-            val parameterList = ParameterList(listOf(parameter)).assignNoPrototype()
+            val parameterList = ParameterList(listOf(parameter), lPar = null, rPar = null).assignNoPrototype()
             val lambda = LambdaExpression(parameterList, block)
             expression = MethodCallExpression.build(codeConverter.convertExpression(variable.initializer), "use", listOf(lambda), listOf(), false)
             expression.assignNoPrototype()

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

@@ -75,10 +75,10 @@ class PrimaryConstructorSignature(val annotations: Annotations, private val modi
         }
 
         if (needConstructorKeyword) {
-            builder append " constructor"
+            builder.append(" constructor")
         }
 
-        builder append "(" append parameterList append ")"
+        builder.append(parameterList)
     }
 }
 
@@ -93,9 +93,8 @@ class SecondaryConstructor(
     override fun generateCode(builder: CodeBuilder) {
         builder.append(annotations)
                 .appendWithSpaceAfter(modifiers)
-                .append("constructor(")
+                .append("constructor")
                 .append(parameterList)
-                .append(")")
 
         if (thisOrSuperCall != null) {
             builder append " : " append thisOrSuperCall

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

@@ -61,9 +61,7 @@ class Function(
                 .append("fun ")
                 .appendWithSuffix(typeParameterList, " ")
                 .append(name)
-                .append("(")
                 .append(parameterList)
-                .append(")")
 
         if (!returnType.isUnit()) {
             builder append ":" append returnType

j2k/src/org/jetbrains/kotlin/j2k/ast/ParameterList.kt

@@ -19,9 +19,35 @@ package org.jetbrains.kotlin.j2k.ast
 import org.jetbrains.kotlin.j2k.CodeBuilder
 import org.jetbrains.kotlin.j2k.append
 
-class ParameterList(val parameters: List<Parameter>) : Element() {
+class ParameterList(
+        val parameters: List<Parameter>,
+        val lPar: LPar?,
+        val rPar: RPar?
+) : Element() {
     override fun generateCode(builder: CodeBuilder) {
+        lPar?.let { builder.append(it) }
+
         builder.append(parameters, ", ")
+
+        rPar?.let { builder.append(it) }
+    }
+
+    companion object {
+        fun withNoPrototype(parameters: List<Parameter>): ParameterList {
+            return ParameterList(parameters, LPar().assignNoPrototype(), RPar().assignNoPrototype()).assignNoPrototype()
+        }
     }
 }
 
+// we use LPar and RPar elements to better handle comments and line breaks around them
+class LPar : Element() {
+    override fun generateCode(builder: CodeBuilder) {
+        builder.append("(")
+    }
+}
+
+class RPar : Element() {
+    override fun generateCode(builder: CodeBuilder) {
+        builder.append(")")
+    }
+}

j2k/src/org/jetbrains/kotlin/j2k/ast/Property.kt

@@ -94,11 +94,11 @@ class PropertyAccessor(
         }
 
         if (parameterList != null) {
-            builder append "(" append parameterList append ")"
+            builder.append(parameterList)
         }
 
         if (body != null) {
-            builder append " " append body
+            builder.append(" ").append(body)
         }
     }
 }

j2k/testData/fileOrElement/formatting/parameterList.java

@@ -0,0 +1,6 @@
+public interface Aaa {
+    void foo(
+            String e1,
+            String e2
+    );
+}

j2k/testData/fileOrElement/formatting/parameterList.kt

@@ -0,0 +1,6 @@
+interface Aaa {
+    fun foo(
+            e1: String,
+            e2: String
+    )
+}

j2k/testData/fileOrElement/function/lineBreaksBetweenParameters.kt

@@ -13,6 +13,7 @@ internal class C {
 
     fun foo4(
             p1: Int, p2: Int,
-            p3: Int, p4: Int) {
+            p3: Int, p4: Int
+    ) {
     }
 }

j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterForWebDemoTestGenerated.java

@@ -2308,6 +2308,12 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo
             doTest(fileName);
         }
 
+        @TestMetadata("parameterList.java")
+        public void testParameterList() throws Exception {
+            String fileName = KotlinTestUtils.navigationMetadata("j2k/testData/fileOrElement/formatting/parameterList.java");
+            doTest(fileName);
+        }
+
         @TestMetadata("staticAndNonStaticMembersWithComments.java")
         public void testStaticAndNonStaticMembersWithComments() throws Exception {
             String fileName = KotlinTestUtils.navigationMetadata("j2k/testData/fileOrElement/formatting/staticAndNonStaticMembersWithComments.java");

j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterSingleFileTestGenerated.java

@@ -2308,6 +2308,12 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo
             doTest(fileName);
         }
 
+        @TestMetadata("parameterList.java")
+        public void testParameterList() throws Exception {
+            String fileName = KotlinTestUtils.navigationMetadata("j2k/testData/fileOrElement/formatting/parameterList.java");
+            doTest(fileName);
+        }
+
         @TestMetadata("staticAndNonStaticMembersWithComments.java")
         public void testStaticAndNonStaticMembersWithComments() throws Exception {
             String fileName = KotlinTestUtils.navigationMetadata("j2k/testData/fileOrElement/formatting/staticAndNonStaticMembersWithComments.java");