Formatter: support trailing comma in value arguments

#KT-34744

idea/testData/formatter/ArrayLiteral.after.kt

@@ -3,5 +3,5 @@
             AppModule::class,
             DataModule::class,
             DomainModule::class
-        ]
-)
+        ],
+)

idea/testData/formatter/CallLParenthOnNextLine.after.inv.kt

@@ -2,3 +2,4 @@ val x = foo("a",
         "b")
 
 // SET_TRUE: CALL_PARAMETERS_LPAREN_ON_NEXT_LINE
+// TRAILING_COMMA: false

idea/testData/formatter/CallLParenthOnNextLine.after.kt

@@ -3,3 +3,4 @@ val x = foo(
         "b")
 
 // SET_TRUE: CALL_PARAMETERS_LPAREN_ON_NEXT_LINE
+// TRAILING_COMMA: false

idea/testData/formatter/CallLParenthOnNextLine.kt

@@ -2,3 +2,4 @@ val x = foo("a",
         "b")
 
 // SET_TRUE: CALL_PARAMETERS_LPAREN_ON_NEXT_LINE
+// TRAILING_COMMA: false

idea/testData/formatter/CallRParenthOnNextLine.after.inv.kt

@@ -2,3 +2,4 @@ val x = foo("a",
         "b")
 
 // SET_TRUE: CALL_PARAMETERS_RPAREN_ON_NEXT_LINE
+// TRAILING_COMMA: false

idea/testData/formatter/CallRParenthOnNextLine.after.kt

@@ -3,3 +3,4 @@ val x = foo("a",
 )
 
 // SET_TRUE: CALL_PARAMETERS_RPAREN_ON_NEXT_LINE
+// TRAILING_COMMA: false

idea/testData/formatter/CallRParenthOnNextLine.kt

@@ -2,3 +2,4 @@ val x = foo("a",
         "b")
 
 // SET_TRUE: CALL_PARAMETERS_RPAREN_ON_NEXT_LINE
+// TRAILING_COMMA: false

idea/testData/formatter/CommentInFunctionLiteral.after.kt

@@ -37,13 +37,17 @@ val s2 = Shadow { // wdwd
     val a = 42
 }
 
-val s3 = Shadow(fun() {  // wdwd
-    val a = 42
-})
+val s3 = Shadow(
+        fun() {  // wdwd
+            val a = 42
+        },
+)
 
-val s4 = Shadow(fun() { /* s */
-    val a = 42
-})
+val s4 = Shadow(
+        fun() { /* s */
+            val a = 42
+        },
+)
 
 val s5 = Shadow { ->
     // wdwd
@@ -55,15 +59,19 @@ val s6 = Shadow {
     val a = 42
 }
 
-val s7 = Shadow(fun() {
-    // wdwd
-    val a = 42
-})
+val s7 = Shadow(
+        fun() {
+            // wdwd
+            val a = 42
+        },
+)
 
-val s8 = Shadow(fun() {
-    // wdwd
-    val a = 42
-})
+val s8 = Shadow(
+        fun() {
+            // wdwd
+            val a = 42
+        },
+)
 
 val s9 = Shadow { ->   /* s */
     val a = 42

idea/testData/formatter/ElvisIndent.after.inv.kt

@@ -4,7 +4,7 @@ fun foo() {
                     ?: DescriptorUtils.getParentOfType(
                             referencedDescriptor,
                             TypeAliasConstructorDescriptor::class.java,
-                            false
+                            false,
                     )?.typeAliasDescriptor
                     ?: DescriptorUtils.getParentOfType(referencedDescriptor, FunctionDescriptor::class.java, false)
                     ?: return emptyList()

idea/testData/formatter/ElvisIndent.after.kt

@@ -4,7 +4,7 @@ fun foo() {
                 ?: DescriptorUtils.getParentOfType(
                     referencedDescriptor,
                     TypeAliasConstructorDescriptor::class.java,
-                    false
+                    false,
                 )?.typeAliasDescriptor
                 ?: DescriptorUtils.getParentOfType(referencedDescriptor, FunctionDescriptor::class.java, false)
                 ?: return emptyList()

idea/testData/formatter/EnumInitializerList.after.kt

@@ -3,6 +3,6 @@ package test
 enum class EnumTest(val value: Int) {
     VALUE_1
     (
-            value = 0
+            value = 0,
     )
 }

idea/testData/formatter/ExtendsListAlignEnum.after.inv.kt

@@ -2,7 +2,7 @@
 
 enum class EnumTest(val value: Int) {
     VALUE_1(
-            value = 0
+            value = 0,
     )
 }
 

idea/testData/formatter/ExtendsListAlignEnum.after.kt

@@ -2,7 +2,7 @@
 
 enum class EnumTest(val value: Int) {
     VALUE_1(
-            value = 0
+            value = 0,
     )
 }
 

idea/testData/formatter/FunctionCallParametersAlign.after.kt

@@ -1,6 +1,8 @@
 fun test() {
-    someTestLong(12,
-                 13)
+    someTestLong(
+            12,
+            13,
+    )
 }
 
 // SET_TRUE: ALIGN_MULTILINE_PARAMETERS_IN_CALLS

idea/testData/formatter/FunctionExpression.after.kt

@@ -13,8 +13,10 @@ val c = fun() = 4
 fun test() = fun test() = 4
 
 fun test() {
-    test(fun() {
-    })
+    test(
+            fun() {
+            },
+    )
     test(fun test() {})
     test(fun test() = 5)
 

idea/testData/formatter/ParameterAnnotationWrap.after.kt

@@ -1,4 +1,5 @@
-fun foo(@Deprecated("x")
+fun foo(
+        @Deprecated("x")
         x: Int,
         @Deprecated("y")
         @Deprecated("z")

idea/testData/formatter/callChain/CallChainWrapping.after.inv.kt

@@ -41,10 +41,12 @@ val x8 = foo!!!!!!!!
 val x9 = ((b!!)!!!!)!!
         .f
 
-val y = xyzzy(foo
-        .bar()
-        .baz()
-        .quux())
+val y = xyzzy(
+        foo
+                .bar()
+                .baz()
+                .quux(),
+)
 
 fun foo() {
     foo

idea/testData/formatter/callChain/CallChainWrapping.after.kt

@@ -30,9 +30,11 @@ val x8 = foo!!!!!!!!.bar()
 
 val x9 = ((b!!)!!!!)!!.f
 
-val y = xyzzy(foo.bar()
-        .baz()
-        .quux())
+val y = xyzzy(
+        foo.bar()
+                .baz()
+                .quux(),
+)
 
 fun foo() {
     foo.bar()

idea/testData/formatter/callChain/FunctionLiteralsInChainCalls.after.inv.kt

@@ -12,12 +12,16 @@ fun test() {
 
 fun test1() {
     val abc = ArrayList<Int>()
-        .map({
-            it * 2
-        })
-        .filter({
-            it > 4
-        })
+        .map(
+                {
+                    it * 2
+                },
+        )
+        .filter(
+                {
+                    it > 4
+                },
+        )
 }
 
 fun test2() {
@@ -35,7 +39,7 @@ fun test3() {
 
 fun test4() {
     val abc = ArrayList<Int>().mapTo(
-            LinkedHashSet()
+            LinkedHashSet(),
     ) {
         it * 2
     }

idea/testData/formatter/callChain/FunctionLiteralsInChainCalls.after.kt

@@ -12,12 +12,16 @@ fun test() {
 
 fun test1() {
     val abc = ArrayList<Int>()
-            .map({
-                it * 2
-            })
-            .filter({
-                it > 4
-            })
+            .map(
+                    {
+                        it * 2
+                    },
+            )
+            .filter(
+                    {
+                        it > 4
+                    },
+            )
 }
 
 fun test2() {
@@ -35,7 +39,7 @@ fun test3() {
 
 fun test4() {
     val abc = ArrayList<Int>().mapTo(
-            LinkedHashSet()
+            LinkedHashSet(),
     ) {
         it * 2
     }

idea/testData/formatter/callChain/KT22148.after.kt

@@ -6,9 +6,11 @@ fun foo() {
         finish()
     }
 
-    FirebaseAuth.getInstance().addAuthStateListener(object : FirebaseAuth.AuthStateListener {
-        override fun onAuthStateChanged(auth: FirebaseAuth) {
-            // ...
-        }
-    })
+    FirebaseAuth.getInstance().addAuthStateListener(
+            object : FirebaseAuth.AuthStateListener {
+                override fun onAuthStateChanged(auth: FirebaseAuth) {
+                    // ...
+                }
+            },
+    )
 }

idea/testData/formatter/parameterList/ArgumentListChopAsNeeded.after.kt

@@ -10,12 +10,15 @@ fun foo() {
     testtest(foofoo)
 
     testtesttesttest(
-            foofoofoofoofoofoofoofoofoofoofoofoo)
+            foofoofoofoofoofoofoofoofoofoofoofoo,
+    )
 
     testtest(foobar, barfoo)
 
-    testtesttesttest(foofoo,
-                     barbar,
-                     foobar,
-                     barfoo)
+    testtesttesttest(
+            foofoo,
+            barbar,
+            foobar,
+            barfoo,
+    )
 }

idea/testData/formatter/parameterList/ArgumentListWrapAlways.after.kt

@@ -11,11 +11,15 @@ fun foo() {
 
     testtesttesttest(foofoofoofoofoofoofoofoofoofoofoofoo)
 
-    testtest(foobar,
-             barfoo)
+    testtest(
+            foobar,
+            barfoo,
+    )
 
-    testtesttesttest(foofoo,
-                     barbar,
-                     foobar,
-                     barfoo)
+    testtesttesttest(
+            foofoo,
+            barbar,
+            foobar,
+            barfoo,
+    )
 }

idea/testData/formatter/parameterList/ArgumentListWrapAsNeeded.after.kt

@@ -10,12 +10,15 @@ fun foo() {
     testtest(foofoo)
 
     testtesttesttest(
-            foofoofoofoofoofoofoofoofoofoofoofoo)
+            foofoofoofoofoofoofoofoofoofoofoofoo,
+    )
 
     testtest(foobar, barfoo)
 
-    testtesttesttest(foofoo,
-                     barbar,
-                     foobar,
-                     barfoo)
+    testtesttesttest(
+            foofoo,
+            barbar,
+            foobar,
+            barfoo,
+    )
 }

idea/testData/formatter/parameterList/ArgumentListWrapLParen.after.kt

@@ -4,8 +4,10 @@
 fun foo() {
     foo(bar, baz)
 
-    foo(object : Quux {
-        override fun foo() {
-        }
-    })
+    foo(
+            object : Quux {
+                override fun foo() {
+                }
+            },
+    )
 }

idea/testData/formatter/parameterList/KT19727.after.kt

@@ -5,19 +5,28 @@ fun useCallable(tag: String, callable: Callable<*>) {
 fun main(args: Array<String>) {
     useCallable("A", Callable { println("Hello world") })
 
-    useCallable("B", Callable {
-        println("Hello world")
-    })
+    useCallable(
+            "B",
+            Callable {
+                println("Hello world")
+            },
+    )
 
-    useCallable("C", object : Callable<Unit> {
-        override fun call() {
-            println("Hello world")
-        }
-    })
+    useCallable(
+            "C",
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
 
-    useCallable("B", fun() {
-        println("Hello world")
-    })
+    useCallable(
+            "B",
+            fun() {
+                println("Hello world")
+            },
+    )
 }
 
 // SET_TRUE: CALL_PARAMETERS_LPAREN_ON_NEXT_LINE

idea/testData/formatter/parameterList/ParameterListChopAsNeeded.after.kt

@@ -12,10 +12,11 @@ fun testtesttesttest(foofoo: Int)
 
 fun test(foo: Int, bar: Int)
 
-fun testtesttesttest(foofoo: Int,
-                     barbar: Int,
-                     foobar: Int,
-                     barfoo: Int,
+fun testtesttesttest(
+        foofoo: Int,
+        barbar: Int,
+        foobar: Int,
+        barfoo: Int,
 )
 
 fun test() {
@@ -40,7 +41,8 @@ class LongLongLongLongNameCLass
 class ShorName
 class SN
 
-class A(longLongLongLongNameCLass1: LongLongLongLongNameCLass,
+class A(
+        longLongLongLongNameCLass1: LongLongLongLongNameCLass,
         longLongLongLongNameCLass2: LongLongLongLongNameCLass,
         longLongLongLongNameCLass3: LongLongLongLongNameCLass,
 ) {
@@ -52,18 +54,21 @@ class A(longLongLongLongNameCLass1: LongLongLongLongNameCLass,
     }
 }
 
-class B(a: LongLongLongLongNameCLass,
+class B(
+        a: LongLongLongLongNameCLass,
         b: LongLongLongLongNameCLass,
         c: LongLongLongLongNameCLass,
 ) {
-    constructor(a: LongLongLongLongNameCLass,
-                b: LongLongLongLongNameCLass,
-                c: LongLongLongLongNameCLass,
+    constructor(
+            a: LongLongLongLongNameCLass,
+            b: LongLongLongLongNameCLass,
+            c: LongLongLongLongNameCLass,
     ) {
     }
 }
 
-class C(sn1: ShorName,
+class C(
+        sn1: ShorName,
         sn2: ShorName,
         sn3: ShorName,
         sn4: ShorName,
@@ -73,20 +78,22 @@ class C(sn1: ShorName,
         sn8: ShorName,
         sn9: ShorName,
 ) {
-    constructor(sn1: ShorName,
-                sn2: ShorName,
-                sn3: ShorName,
-                sn4: ShorName,
-                sn5: ShorName,
-                sn6: ShorName,
-                sn6: ShorName,
-                sn8: ShorName,
-                sn9: ShorName,
+    constructor(
+            sn1: ShorName,
+            sn2: ShorName,
+            sn3: ShorName,
+            sn4: ShorName,
+            sn5: ShorName,
+            sn6: ShorName,
+            sn6: ShorName,
+            sn8: ShorName,
+            sn9: ShorName,
     ) {
     }
 }
 
-class D(sn1: SN,
+class D(
+        sn1: SN,
         sn2: SN,
         sn3: SN,
         sn4: SN,
@@ -101,20 +108,21 @@ class D(sn1: SN,
         sn13: SN,
         sn14: SN,
 ) {
-    constructor(sn1: SN,
-                sn2: SN,
-                sn3: SN,
-                sn4: SN,
-                sn5: SN,
-                sn6: SN,
-                sn6: SN,
-                sn8: SN,
-                sn9: SN,
-                sn10: SN,
-                sn11: SN,
-                sn12: SN,
-                sn13: SN,
-                sn14: SN,
+    constructor(
+            sn1: SN,
+            sn2: SN,
+            sn3: SN,
+            sn4: SN,
+            sn5: SN,
+            sn6: SN,
+            sn6: SN,
+            sn8: SN,
+            sn9: SN,
+            sn10: SN,
+            sn11: SN,
+            sn12: SN,
+            sn13: SN,
+            sn14: SN,
     ) {
     }
 }

idea/testData/formatter/parameterList/ParameterListWrapAlways.after.kt

@@ -10,26 +10,30 @@ fun testtest(foofoo: Int)
 
 fun testtesttesttest(foofoo: Int)
 
-fun test(foo: Int,
-         bar: Int,
+fun test(
+        foo: Int,
+        bar: Int,
 )
 
-fun testtesttesttest(foofoo: Int,
-                     barbar: Int,
-                     foobar: Int,
-                     barfoo: Int,
+fun testtesttesttest(
+        foofoo: Int,
+        barbar: Int,
+        foobar: Int,
+        barfoo: Int,
 )
 
-fun testtesttesttest(foofoo: Int,
-                     @Some barbar: Int,
-                     foobar: Int,
-                     barfoo: Int,
+fun testtesttesttest(
+        foofoo: Int,
+        @Some barbar: Int,
+        foobar: Int,
+        barfoo: Int,
 )
 
-fun testtesttesttest(@Some foofoo: Int,
-                     @Some barbar: Int,
-                     @Some foobar: Int,
-                     barfoo: Int,
+fun testtesttesttest(
+        @Some foofoo: Int,
+        @Some barbar: Int,
+        @Some foobar: Int,
+        barfoo: Int,
 )
 
 fun test() {
@@ -54,29 +58,34 @@ class LongLongLongLongNameCLass
 class ShorName
 class SN
 
-class A(longLongLongLongNameCLass1: LongLongLongLongNameCLass,
+class A(
+        longLongLongLongNameCLass1: LongLongLongLongNameCLass,
         longLongLongLongNameCLass2: LongLongLongLongNameCLass,
         longLongLongLongNameCLass3: LongLongLongLongNameCLass,
 ) {
-    constructor(longLongLongLongNameCLass1: LongLongLongLongNameCLass,
-                longLongLongLongNameCLass2: LongLongLongLongNameCLass,
-                longLongLongLongNameCLass3: LongLongLongLongNameCLass,
+    constructor(
+            longLongLongLongNameCLass1: LongLongLongLongNameCLass,
+            longLongLongLongNameCLass2: LongLongLongLongNameCLass,
+            longLongLongLongNameCLass3: LongLongLongLongNameCLass,
     ) {
     }
 }
 
-class B(a: LongLongLongLongNameCLass,
+class B(
+        a: LongLongLongLongNameCLass,
         b: LongLongLongLongNameCLass,
         c: LongLongLongLongNameCLass,
 ) {
-    constructor(a: LongLongLongLongNameCLass,
-                b: LongLongLongLongNameCLass,
-                c: LongLongLongLongNameCLass,
+    constructor(
+            a: LongLongLongLongNameCLass,
+            b: LongLongLongLongNameCLass,
+            c: LongLongLongLongNameCLass,
     ) {
     }
 }
 
-class C(sn1: ShorName,
+class C(
+        sn1: ShorName,
         sn2: ShorName,
         sn3: ShorName,
         sn4: ShorName,
@@ -86,20 +95,22 @@ class C(sn1: ShorName,
         sn8: ShorName,
         sn9: ShorName,
 ) {
-    constructor(sn1: ShorName,
-                sn2: ShorName,
-                sn3: ShorName,
-                sn4: ShorName,
-                sn5: ShorName,
-                sn6: ShorName,
-                sn6: ShorName,
-                sn8: ShorName,
-                sn9: ShorName,
+    constructor(
+            sn1: ShorName,
+            sn2: ShorName,
+            sn3: ShorName,
+            sn4: ShorName,
+            sn5: ShorName,
+            sn6: ShorName,
+            sn6: ShorName,
+            sn8: ShorName,
+            sn9: ShorName,
     ) {
     }
 }
 
-class D(sn1: SN,
+class D(
+        sn1: SN,
         sn2: SN,
         sn3: SN,
         sn4: SN,
@@ -114,20 +125,21 @@ class D(sn1: SN,
         sn13: SN,
         sn14: SN,
 ) {
-    constructor(sn1: SN,
-                sn2: SN,
-                sn3: SN,
-                sn4: SN,
-                sn5: SN,
-                sn6: SN,
-                sn6: SN,
-                sn8: SN,
-                sn9: SN,
-                sn10: SN,
-                sn11: SN,
-                sn12: SN,
-                sn13: SN,
-                sn14: SN,
+    constructor(
+            sn1: SN,
+            sn2: SN,
+            sn3: SN,
+            sn4: SN,
+            sn5: SN,
+            sn6: SN,
+            sn6: SN,
+            sn8: SN,
+            sn9: SN,
+            sn10: SN,
+            sn11: SN,
+            sn12: SN,
+            sn13: SN,
+            sn14: SN,
     ) {
     }
 }
@@ -147,14 +159,16 @@ class G(sn1: ShorName) {
     }
 }
 
-class H(sn1: SN,
+class H(
+        sn1: SN,
         sn2: SN,
 ) {
     constructor(sn1: SN) {
     }
 }
 
-class I(sn1: SN,
+class I(
+        sn1: SN,
         @field:Some val sn2: SN,
         sn3: SN,
         sn4: SN,
@@ -169,20 +183,21 @@ class I(sn1: SN,
         sn13: SN,
         sn14: SN,
 ) {
-    constructor(sn1: SN,
-                sn2: SN,
-                sn3: SN,
-                @Some sn4: SN,
-                sn5: SN,
-                sn6: SN,
-                sn6: SN,
-                sn8: SN,
-                sn9: SN,
-                sn10: SN,
-                sn11: SN,
-                sn12: SN,
-                sn13: SN,
-                sn14: SN,
+    constructor(
+            sn1: SN,
+            sn2: SN,
+            sn3: SN,
+            @Some sn4: SN,
+            sn5: SN,
+            sn6: SN,
+            sn6: SN,
+            sn8: SN,
+            sn9: SN,
+            sn10: SN,
+            sn11: SN,
+            sn12: SN,
+            sn13: SN,
+            sn14: SN,
     ) {
     }
 }

idea/testData/formatter/parameterList/ParameterListWrapAsNeeded.after.kt

@@ -43,7 +43,8 @@ class LongLongLongLongNameCLass
 class ShorName
 class SN
 
-class A(longLongLongLongNameCLass1: LongLongLongLongNameCLass,
+class A(
+        longLongLongLongNameCLass1: LongLongLongLongNameCLass,
         longLongLongLongNameCLass2: LongLongLongLongNameCLass,
         longLongLongLongNameCLass3: LongLongLongLongNameCLass,
 ) {
@@ -55,7 +56,8 @@ class A(longLongLongLongNameCLass1: LongLongLongLongNameCLass,
     }
 }
 
-class B(a: LongLongLongLongNameCLass,
+class B(
+        a: LongLongLongLongNameCLass,
         b: LongLongLongLongNameCLass,
         c: LongLongLongLongNameCLass,
 ) {
@@ -67,7 +69,8 @@ class B(a: LongLongLongLongNameCLass,
     }
 }
 
-class C(sn1: ShorName,
+class C(
+        sn1: ShorName,
         sn2: ShorName,
         sn3: ShorName,
         sn4: ShorName,
@@ -77,20 +80,22 @@ class C(sn1: ShorName,
         sn8: ShorName,
         sn9: ShorName,
 ) {
-    constructor(sn1: ShorName,
-                sn2: ShorName,
-                sn3: ShorName,
-                sn4: ShorName,
-                sn5: ShorName,
-                sn6: ShorName,
-                sn6: ShorName,
-                sn8: ShorName,
-                sn9: ShorName,
+    constructor(
+            sn1: ShorName,
+            sn2: ShorName,
+            sn3: ShorName,
+            sn4: ShorName,
+            sn5: ShorName,
+            sn6: ShorName,
+            sn6: ShorName,
+            sn8: ShorName,
+            sn9: ShorName,
     ) {
     }
 }
 
-class D(sn1: SN, sn2: SN,
+class D(
+        sn1: SN, sn2: SN,
         sn3: SN, sn4: SN,
         sn5: SN, sn6: SN,
         sn6: SN, sn8: SN,
@@ -98,20 +103,21 @@ class D(sn1: SN, sn2: SN,
         sn11: SN, sn12: SN,
         sn13: SN, sn14: SN,
 ) {
-    constructor(sn1: SN,
-                sn2: SN,
-                sn3: SN,
-                sn4: SN,
-                sn5: SN,
-                sn6: SN,
-                sn6: SN,
-                sn8: SN,
-                sn9: SN,
-                sn10: SN,
-                sn11: SN,
-                sn12: SN,
-                sn13: SN,
-                sn14: SN,
+    constructor(
+            sn1: SN,
+            sn2: SN,
+            sn3: SN,
+            sn4: SN,
+            sn5: SN,
+            sn6: SN,
+            sn6: SN,
+            sn8: SN,
+            sn9: SN,
+            sn10: SN,
+            sn11: SN,
+            sn12: SN,
+            sn13: SN,
+            sn14: SN,
     ) {
     }
 }

idea/testData/formatter/trailingComma/valueArguments/ArgumentListChopAsNeeded.after.inv.kt

@@ -0,0 +1,278 @@
+// SET_INT: CALL_PARAMETERS_WRAP = 4
+// SET_TRUE: ALLOW_TRAILING_COMMA
+
+fun foo() {
+    testtest(foofoo, foofoo, foofoo,
+            foofoo, bar)
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo, bar
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo,
+            bar
+    )
+
+    testtest(foofoo
+    )
+
+    testtest(
+            foofoo)
+
+    testtest(
+            foofoo
+    )
+
+    testtest(
+            foofoo,
+    )
+
+    testtest(foofoo, testtest(testtest(foofoo)))
+
+    testtest(
+            foofoo, fososos, testtest(testtest(foofoo)),
+    )
+
+    testtest(foofoo,
+            testtest(testtest(
+                    foofoo,
+            )),
+            testsa)
+
+    testtest(foofoo,
+            seee,
+            testtest(testtest(
+                    foofoo,
+            )),
+            testsa)
+
+    useCallable("A", Callable { println("Hello world") })
+
+    useCallable("B", "C", Callable {
+        println("Hello world")
+    }, Callable {
+        println("Hello world")
+    })
+
+    useCallable(Callable { println("Hello world") })
+
+    useCallable(
+            Callable { println("Hello world") },
+    )
+
+    useCallable(Callable { println("Hello world") }
+    )
+
+    useCallable(Callable { println("Hello world") }) {
+
+    }
+
+    useCallable(
+            Callable { println("Hello world") })
+
+    useCallable("A", { println("Hello world") })
+
+    useCallable("B", "C", {
+        println("Hello world")
+    }, {
+        println("Hello world")
+    })
+
+    useCallable({ println("Hello world") })
+
+    useCallable(
+            { println("Hello world") },
+    )
+
+    useCallable({ println("Hello world") }
+    )
+
+    useCallable({ println("Hello world") }) {
+
+    }
+
+    useCallable(
+            { println("Hello world") })
+
+    useCallable("A", foo() { println("Hello world") })
+
+    useCallable("B", "C", foo() {
+        println("Hello world")
+    }, foo() {
+        println("Hello world")
+    })
+
+    useCallable(foo() { println("Hello world") })
+
+    useCallable(
+            foo() { println("Hello world") },
+    )
+
+    useCallable(foo() { println("Hello world") }
+    )
+
+    useCallable(foo() { println("Hello world") }) {
+
+    }
+
+    useCallable(
+            foo() { println("Hello world") })
+
+    useCallable("A", object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    })
+
+    useCallable("A", object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    })
+
+    useCallable("B", "C", object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    }, foo() {
+        println("Hello world")
+    })
+
+    useCallable(object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    })
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    }
+    )
+
+    useCallable(object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    }) {
+
+    }
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            })
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo,
+            bar /*
+    */, /* */ foo
+    )
+
+    testtest(/*
+    */foofoo, foofoo, foofoo, /*
+
+    */
+            foofoo, bar)
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar/*
+    */)
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar // awdawda
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo, /*
+
+    */
+            bar
+    )
+
+    testtest(foofoo // fd
+    )
+
+    testtest( /**/
+            foofoo
+    )
+
+    testtest(
+            foofoo,/**/
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo/*
+     */, /* */ bar
+    )
+
+    testtest(foofoo // fd
+    )
+
+    testtest( /**/
+            foofoo
+    )
+
+    testtest(
+            foofoo,/**/
+    )
+
+    testtest(
+            foofoo, fososos,/*
+    */
+            testtest(testtest(foofoo)),
+    )
+
+    testtest(foofoo,
+            testtest(testtest(
+                    foofoo,
+            )), /**/
+            testsa)
+
+    testtest(foofoo,
+            testtest(testtest(
+                    foofoo,
+            ))/* */, /**/
+            testsa)
+
+    testtest(foofoo,
+            testtest(testtest(
+                    foofoo,
+            ))/*
+    */,
+            testsa)
+
+    testtest(foofoo,
+            seee,
+            testtest(testtest(
+                    foofoo,
+            )), /**/
+            testsa)
+
+    testtest(foofoo,
+            seee,
+            testtest(testtest(
+                    foofoo,
+            )), /*
+    */
+            testsa)
+
+    useCallable("B", "C", Callable {
+        println("Hello world")
+    }, /* */ Callable {
+        println("Hello world")
+    })
+
+    useCallable(Callable { println("Hello world") } // ffd
+    )
+}

idea/testData/formatter/trailingComma/valueArguments/ArgumentListChopAsNeeded.after.kt

@@ -0,0 +1,367 @@
+// SET_INT: CALL_PARAMETERS_WRAP = 4
+// SET_TRUE: ALLOW_TRAILING_COMMA
+
+fun foo() {
+    testtest(
+            foofoo, foofoo, foofoo,
+            foofoo, bar,
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo, bar,
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo, bar,
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo,
+            bar,
+    )
+
+    testtest(
+            foofoo,
+    )
+
+    testtest(
+            foofoo,
+    )
+
+    testtest(
+            foofoo,
+    )
+
+    testtest(
+            foofoo,
+    )
+
+    testtest(foofoo, testtest(testtest(foofoo)))
+
+    testtest(
+            foofoo, fososos, testtest(testtest(foofoo)),
+    )
+
+    testtest(
+            foofoo,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ),
+            testsa,
+    )
+
+    testtest(
+            foofoo,
+            seee,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ),
+            testsa,
+    )
+
+    useCallable("A", Callable { println("Hello world") })
+
+    useCallable(
+            "B", "C",
+            Callable {
+                println("Hello world")
+            },
+            Callable {
+                println("Hello world")
+            },
+    )
+
+    useCallable(Callable { println("Hello world") })
+
+    useCallable(
+            Callable { println("Hello world") },
+    )
+
+    useCallable(
+            Callable { println("Hello world") },
+    )
+
+    useCallable(Callable { println("Hello world") }) {
+
+    }
+
+    useCallable(
+            Callable { println("Hello world") },
+    )
+
+    useCallable("A", { println("Hello world") })
+
+    useCallable(
+            "B", "C",
+            {
+                println("Hello world")
+            },
+            {
+                println("Hello world")
+            },
+    )
+
+    useCallable({ println("Hello world") })
+
+    useCallable(
+            { println("Hello world") },
+    )
+
+    useCallable(
+            { println("Hello world") },
+    )
+
+    useCallable({ println("Hello world") }) {
+
+    }
+
+    useCallable(
+            { println("Hello world") },
+    )
+
+    useCallable("A", foo() { println("Hello world") })
+
+    useCallable(
+            "B", "C",
+            foo() {
+                println("Hello world")
+            },
+            foo() {
+                println("Hello world")
+            },
+    )
+
+    useCallable(foo() { println("Hello world") })
+
+    useCallable(
+            foo() { println("Hello world") },
+    )
+
+    useCallable(
+            foo() { println("Hello world") },
+    )
+
+    useCallable(foo() { println("Hello world") }) {
+
+    }
+
+    useCallable(
+            foo() { println("Hello world") },
+    )
+
+    useCallable(
+            "A",
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(
+            "A",
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(
+            "B", "C",
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+            foo() {
+                println("Hello world")
+            },
+    )
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    ) {
+
+    }
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo,
+            bar, /*
+    */ /* */
+            foo,
+    )
+
+    testtest(
+/*
+    */
+            foofoo, foofoo, foofoo, /*
+
+    */
+            foofoo, bar,
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo,
+            bar,/*
+    */
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo, bar, // awdawda
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo, /*
+
+    */
+            bar,
+    )
+
+    testtest(
+            foofoo, // fd
+    )
+
+    testtest(
+            /**/
+            foofoo,
+    )
+
+    testtest(
+            foofoo,/**/
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo,
+            foofoo,/*
+     */ /* */
+            bar,
+    )
+
+    testtest(
+            foofoo, // fd
+    )
+
+    testtest(
+            /**/
+            foofoo,
+    )
+
+    testtest(
+            foofoo,/**/
+    )
+
+    testtest(
+            foofoo, fososos,/*
+    */
+            testtest(testtest(foofoo)),
+    )
+
+    testtest(
+            foofoo,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ), /**/
+            testsa,
+    )
+
+    testtest(
+            foofoo,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ),/* */ /**/
+            testsa,
+    )
+
+    testtest(
+            foofoo,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ),/*
+    */
+            testsa,
+    )
+
+    testtest(
+            foofoo,
+            seee,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ), /**/
+            testsa,
+    )
+
+    testtest(
+            foofoo,
+            seee,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ), /*
+    */
+            testsa,
+    )
+
+    useCallable(
+            "B", "C",
+            Callable {
+                println("Hello world")
+            }, /* */
+            Callable {
+                println("Hello world")
+            },
+    )
+
+    useCallable(
+            Callable { println("Hello world") }, // ffd
+    )
+}

idea/testData/formatter/trailingComma/valueArguments/ArgumentListChopAsNeeded.kt

@@ -0,0 +1,200 @@
+// SET_INT: CALL_PARAMETERS_WRAP = 4
+// SET_TRUE: ALLOW_TRAILING_COMMA
+
+fun foo() {
+    testtest(foofoo, foofoo, foofoo,
+             foofoo, bar)
+
+    testtest(
+        foofoo, foofoo, foofoo, foofoo, bar
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo,
+             bar
+    )
+
+    testtest(foofoo
+    )
+
+    testtest(
+        foofoo)
+
+    testtest(
+        foofoo
+        )
+
+    testtest(foofoo,)
+
+    testtest(foofoo, testtest(testtest(foofoo)))
+
+    testtest(foofoo, fososos, testtest(testtest(foofoo)),)
+
+    testtest(foofoo, testtest(testtest(foofoo,)), testsa)
+
+    testtest(foofoo, seee, testtest(testtest(foofoo,)), testsa)
+
+    useCallable("A", Callable { println("Hello world") })
+
+    useCallable("B", "C", Callable {
+        println("Hello world")
+    }, Callable {
+        println("Hello world")
+    })
+
+    useCallable(Callable { println("Hello world") })
+
+    useCallable(Callable { println("Hello world") },)
+
+    useCallable(Callable { println("Hello world") }
+    )
+    
+    useCallable(Callable { println("Hello world") }){
+        
+    }
+
+    useCallable(
+        Callable { println("Hello world") })
+    
+    useCallable("A", { println("Hello world") })
+
+    useCallable("B", "C", {
+        println("Hello world")
+    }, {
+        println("Hello world")
+    })
+
+    useCallable({ println("Hello world") })
+
+    useCallable({ println("Hello world") },)
+
+    useCallable({ println("Hello world") }
+    )
+
+    useCallable({ println("Hello world") }){
+
+    }
+
+    useCallable(
+        { println("Hello world") })
+
+    useCallable("A", foo() { println("Hello world") })
+
+    useCallable("B", "C", foo() {
+        println("Hello world")
+    }, foo() {
+                    println("Hello world")
+                })
+
+    useCallable(foo() { println("Hello world") })
+
+    useCallable(foo() { println("Hello world") },)
+
+    useCallable(foo() { println("Hello world") }
+    )
+
+    useCallable(foo() { println("Hello world") }) {
+
+    }
+
+    useCallable(
+        foo() { println("Hello world") })
+
+    useCallable("A", object : Callable<Unit> { override fun call() { println("Hello world") } })
+
+    useCallable("A", object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    })
+
+    useCallable("B", "C", object : Callable<Unit> { override fun call() { println("Hello world") } }, foo() {
+        println("Hello world")
+    })
+
+    useCallable(object : Callable<Unit> { override fun call() { println("Hello world") } })
+
+    useCallable(object : Callable<Unit> { override fun call() { println("Hello world") } },)
+
+    useCallable(object : Callable<Unit> { override fun call() { println("Hello world") } }
+    )
+
+    useCallable(object : Callable<Unit> { override fun call() { println("Hello world") } }) {
+
+    }
+
+    useCallable(
+        object : Callable<Unit> { override fun call() { println("Hello world") } })
+
+    testtest(
+        foofoo, foofoo, foofoo, foofoo,
+        bar /*
+    */, /* */ foo
+    )
+
+    testtest(/*
+    */foofoo, foofoo, foofoo, /*
+
+    */
+      foofoo, bar)
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar/*
+    */)
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar // awdawda
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo, /*
+
+    */
+             bar
+    )
+
+    testtest(foofoo // fd
+    )
+
+    testtest( /**/
+        foofoo
+    )
+
+    testtest(foofoo,/**/)
+
+    testtest(foofoo, foofoo, foofoo, foofoo/*
+     */ , /* */ bar
+    )
+
+    testtest(foofoo // fd
+    )
+
+    testtest( /**/
+        foofoo
+    )
+
+    testtest(foofoo,/**/)
+
+    testtest(foofoo, fososos,/*
+    */ testtest(testtest(foofoo)),)
+
+    testtest(foofoo, testtest(testtest(foofoo,)), /**/testsa)
+
+    testtest(foofoo, testtest(testtest(foofoo,))/* */ , /**/testsa)
+
+    testtest(foofoo, testtest(testtest(foofoo,))/*
+    */ ,testsa)
+
+    testtest(foofoo, seee, testtest(testtest(foofoo,)), /**/testsa)
+
+    testtest(foofoo, seee, testtest(testtest(foofoo,)), /*
+    */testsa)
+
+    useCallable("B", "C", Callable {
+        println("Hello world")
+    }, /* */ Callable {
+        println("Hello world")
+    })
+
+    useCallable(Callable { println("Hello world") } // ffd
+    )
+}

idea/testData/formatter/trailingComma/valueArguments/ArgumentListDoNotWrap.after.inv.kt

@@ -0,0 +1,261 @@
+// SET_INT: CALL_PARAMETERS_WRAP = 0
+// SET_TRUE: ALLOW_TRAILING_COMMA
+
+fun foo() {
+    testtest(foofoo, foofoo, foofoo,
+            foofoo, bar)
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo, bar
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo,
+            bar
+    )
+
+    testtest(foofoo
+    )
+
+    testtest(
+            foofoo)
+
+    testtest(
+            foofoo
+    )
+
+    testtest(
+            foofoo,
+    )
+
+    testtest(foofoo, testtest(testtest(foofoo)))
+
+    testtest(
+            foofoo, fososos, testtest(testtest(foofoo)),
+    )
+
+    testtest(foofoo, testtest(testtest(
+            foofoo,
+    )), testsa)
+
+    testtest(foofoo, seee, testtest(testtest(
+            foofoo,
+    )), testsa)
+
+    useCallable("A", Callable { println("Hello world") })
+
+    useCallable("B", "C", Callable {
+        println("Hello world")
+    }, Callable {
+        println("Hello world")
+    })
+
+    useCallable(Callable { println("Hello world") })
+
+    useCallable(
+            Callable { println("Hello world") },
+    )
+
+    useCallable(Callable { println("Hello world") }
+    )
+
+    useCallable(Callable { println("Hello world") }) {
+
+    }
+
+    useCallable(
+            Callable { println("Hello world") })
+
+    useCallable("A", { println("Hello world") })
+
+    useCallable("B", "C", {
+        println("Hello world")
+    }, {
+        println("Hello world")
+    })
+
+    useCallable({ println("Hello world") })
+
+    useCallable(
+            { println("Hello world") },
+    )
+
+    useCallable({ println("Hello world") }
+    )
+
+    useCallable({ println("Hello world") }) {
+
+    }
+
+    useCallable(
+            { println("Hello world") })
+
+    useCallable("A", foo() { println("Hello world") })
+
+    useCallable("B", "C", foo() {
+        println("Hello world")
+    }, foo() {
+        println("Hello world")
+    })
+
+    useCallable(foo() { println("Hello world") })
+
+    useCallable(
+            foo() { println("Hello world") },
+    )
+
+    useCallable(foo() { println("Hello world") }
+    )
+
+    useCallable(foo() { println("Hello world") }) {
+
+    }
+
+    useCallable(
+            foo() { println("Hello world") })
+
+    useCallable("A", object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    })
+
+    useCallable("A", object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    })
+
+    useCallable("B", "C", object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    }, foo() {
+        println("Hello world")
+    })
+
+    useCallable(object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    })
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    }
+    )
+
+    useCallable(object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    }) {
+
+    }
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            })
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo,
+            bar /*
+    */, /* */ foo
+    )
+
+    testtest(/*
+    */foofoo, foofoo, foofoo, /*
+
+    */
+            foofoo, bar)
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar/*
+    */)
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar // awdawda
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo, /*
+
+    */
+            bar
+    )
+
+    testtest(foofoo // fd
+    )
+
+    testtest( /**/
+            foofoo
+    )
+
+    testtest(
+            foofoo,/**/
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo/*
+     */, /* */ bar
+    )
+
+    testtest(foofoo // fd
+    )
+
+    testtest( /**/
+            foofoo
+    )
+
+    testtest(
+            foofoo,/**/
+    )
+
+    testtest(
+            foofoo, fososos,/*
+    */
+            testtest(testtest(foofoo)),
+    )
+
+    testtest(foofoo, testtest(testtest(
+            foofoo,
+    )), /**/testsa)
+
+    testtest(foofoo, testtest(testtest(
+            foofoo,
+    ))/* */, /**/testsa)
+
+    testtest(foofoo, testtest(testtest(
+            foofoo,
+    ))/*
+    */, testsa)
+
+    testtest(foofoo, seee, testtest(testtest(
+            foofoo,
+    )), /**/testsa)
+
+    testtest(foofoo, seee, testtest(testtest(
+            foofoo,
+    )), /*
+    */testsa)
+
+    useCallable("B", "C", Callable {
+        println("Hello world")
+    }, /* */ Callable {
+        println("Hello world")
+    })
+
+    useCallable(Callable { println("Hello world") } // ffd
+    )
+}

idea/testData/formatter/trailingComma/valueArguments/ArgumentListDoNotWrap.after.kt

@@ -0,0 +1,364 @@
+// SET_INT: CALL_PARAMETERS_WRAP = 0
+// SET_TRUE: ALLOW_TRAILING_COMMA
+
+fun foo() {
+    testtest(
+            foofoo, foofoo, foofoo,
+            foofoo, bar,
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo, bar,
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo, bar,
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo,
+            bar,
+    )
+
+    testtest(
+            foofoo,
+    )
+
+    testtest(
+            foofoo,
+    )
+
+    testtest(
+            foofoo,
+    )
+
+    testtest(
+            foofoo,
+    )
+
+    testtest(foofoo, testtest(testtest(foofoo)))
+
+    testtest(
+            foofoo, fososos, testtest(testtest(foofoo)),
+    )
+
+    testtest(
+            foofoo,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ),
+            testsa,
+    )
+
+    testtest(
+            foofoo, seee,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ),
+            testsa,
+    )
+
+    useCallable("A", Callable { println("Hello world") })
+
+    useCallable(
+            "B", "C",
+            Callable {
+                println("Hello world")
+            },
+            Callable {
+                println("Hello world")
+            },
+    )
+
+    useCallable(Callable { println("Hello world") })
+
+    useCallable(
+            Callable { println("Hello world") },
+    )
+
+    useCallable(
+            Callable { println("Hello world") },
+    )
+
+    useCallable(Callable { println("Hello world") }) {
+
+    }
+
+    useCallable(
+            Callable { println("Hello world") },
+    )
+
+    useCallable("A", { println("Hello world") })
+
+    useCallable(
+            "B", "C",
+            {
+                println("Hello world")
+            },
+            {
+                println("Hello world")
+            },
+    )
+
+    useCallable({ println("Hello world") })
+
+    useCallable(
+            { println("Hello world") },
+    )
+
+    useCallable(
+            { println("Hello world") },
+    )
+
+    useCallable({ println("Hello world") }) {
+
+    }
+
+    useCallable(
+            { println("Hello world") },
+    )
+
+    useCallable("A", foo() { println("Hello world") })
+
+    useCallable(
+            "B", "C",
+            foo() {
+                println("Hello world")
+            },
+            foo() {
+                println("Hello world")
+            },
+    )
+
+    useCallable(foo() { println("Hello world") })
+
+    useCallable(
+            foo() { println("Hello world") },
+    )
+
+    useCallable(
+            foo() { println("Hello world") },
+    )
+
+    useCallable(foo() { println("Hello world") }) {
+
+    }
+
+    useCallable(
+            foo() { println("Hello world") },
+    )
+
+    useCallable(
+            "A",
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(
+            "A",
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(
+            "B", "C",
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+            foo() {
+                println("Hello world")
+            },
+    )
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    ) {
+
+    }
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo,
+            bar, /*
+    */ /* */
+            foo,
+    )
+
+    testtest(
+/*
+    */
+            foofoo, foofoo, foofoo, /*
+
+    */
+            foofoo, bar,
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo,
+            bar,/*
+    */
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo, bar, // awdawda
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo, /*
+
+    */
+            bar,
+    )
+
+    testtest(
+            foofoo, // fd
+    )
+
+    testtest(
+            /**/
+            foofoo,
+    )
+
+    testtest(
+            foofoo,/**/
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo,
+            foofoo,/*
+     */ /* */
+            bar,
+    )
+
+    testtest(
+            foofoo, // fd
+    )
+
+    testtest(
+            /**/
+            foofoo,
+    )
+
+    testtest(
+            foofoo,/**/
+    )
+
+    testtest(
+            foofoo, fososos,/*
+    */
+            testtest(testtest(foofoo)),
+    )
+
+    testtest(
+            foofoo,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ), /**/
+            testsa,
+    )
+
+    testtest(
+            foofoo,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ),/* */ /**/
+            testsa,
+    )
+
+    testtest(
+            foofoo,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ),/*
+    */
+            testsa,
+    )
+
+    testtest(
+            foofoo, seee,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ), /**/
+            testsa,
+    )
+
+    testtest(
+            foofoo, seee,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ), /*
+    */
+            testsa,
+    )
+
+    useCallable(
+            "B", "C",
+            Callable {
+                println("Hello world")
+            }, /* */
+            Callable {
+                println("Hello world")
+            },
+    )
+
+    useCallable(
+            Callable { println("Hello world") }, // ffd
+    )
+}

idea/testData/formatter/trailingComma/valueArguments/ArgumentListDoNotWrap.kt

@@ -0,0 +1,200 @@
+// SET_INT: CALL_PARAMETERS_WRAP = 0
+// SET_TRUE: ALLOW_TRAILING_COMMA
+
+fun foo() {
+    testtest(foofoo, foofoo, foofoo,
+             foofoo, bar)
+
+    testtest(
+        foofoo, foofoo, foofoo, foofoo, bar
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo,
+             bar
+    )
+
+    testtest(foofoo
+    )
+
+    testtest(
+        foofoo)
+
+    testtest(
+        foofoo
+    )
+
+    testtest(foofoo,)
+
+    testtest(foofoo, testtest(testtest(foofoo)))
+
+    testtest(foofoo, fososos, testtest(testtest(foofoo)),)
+
+    testtest(foofoo, testtest(testtest(foofoo,)), testsa)
+
+    testtest(foofoo, seee, testtest(testtest(foofoo,)), testsa)
+
+    useCallable("A", Callable { println("Hello world") })
+
+    useCallable("B", "C", Callable {
+        println("Hello world")
+    }, Callable {
+        println("Hello world")
+    })
+
+    useCallable(Callable { println("Hello world") })
+
+    useCallable(Callable { println("Hello world") },)
+
+    useCallable(Callable { println("Hello world") }
+    )
+
+    useCallable(Callable { println("Hello world") }){
+
+    }
+
+    useCallable(
+        Callable { println("Hello world") })
+
+    useCallable("A", { println("Hello world") })
+
+    useCallable("B", "C", {
+        println("Hello world")
+    }, {
+                    println("Hello world")
+                })
+
+    useCallable({ println("Hello world") })
+
+    useCallable({ println("Hello world") },)
+
+    useCallable({ println("Hello world") }
+    )
+
+    useCallable({ println("Hello world") }){
+
+    }
+
+    useCallable(
+        { println("Hello world") })
+
+    useCallable("A", foo() { println("Hello world") })
+
+    useCallable("B", "C", foo() {
+        println("Hello world")
+    }, foo() {
+        println("Hello world")
+    })
+
+    useCallable(foo() { println("Hello world") })
+
+    useCallable(foo() { println("Hello world") },)
+
+    useCallable(foo() { println("Hello world") }
+    )
+
+    useCallable(foo() { println("Hello world") }) {
+
+    }
+
+    useCallable(
+        foo() { println("Hello world") })
+
+    useCallable("A", object : Callable<Unit> { override fun call() { println("Hello world") } })
+
+    useCallable("A", object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    })
+
+    useCallable("B", "C", object : Callable<Unit> { override fun call() { println("Hello world") } }, foo() {
+        println("Hello world")
+    })
+
+    useCallable(object : Callable<Unit> { override fun call() { println("Hello world") } })
+
+    useCallable(object : Callable<Unit> { override fun call() { println("Hello world") } },)
+
+    useCallable(object : Callable<Unit> { override fun call() { println("Hello world") } }
+    )
+
+    useCallable(object : Callable<Unit> { override fun call() { println("Hello world") } }) {
+
+    }
+
+    useCallable(
+        object : Callable<Unit> { override fun call() { println("Hello world") } })
+
+    testtest(
+        foofoo, foofoo, foofoo, foofoo,
+        bar /*
+    */, /* */ foo
+    )
+
+    testtest(/*
+    */foofoo, foofoo, foofoo, /*
+
+    */
+      foofoo, bar)
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar/*
+    */)
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar // awdawda
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo, /*
+
+    */
+             bar
+    )
+
+    testtest(foofoo // fd
+    )
+
+    testtest( /**/
+        foofoo
+    )
+
+    testtest(foofoo,/**/)
+
+    testtest(foofoo, foofoo, foofoo, foofoo/*
+     */ , /* */ bar
+    )
+
+    testtest(foofoo // fd
+    )
+
+    testtest( /**/
+        foofoo
+    )
+
+    testtest(foofoo,/**/)
+
+    testtest(foofoo, fososos,/*
+    */ testtest(testtest(foofoo)),)
+
+    testtest(foofoo, testtest(testtest(foofoo,)), /**/testsa)
+
+    testtest(foofoo, testtest(testtest(foofoo,))/* */ , /**/testsa)
+
+    testtest(foofoo, testtest(testtest(foofoo,))/*
+    */ ,testsa)
+
+    testtest(foofoo, seee, testtest(testtest(foofoo,)), /**/testsa)
+
+    testtest(foofoo, seee, testtest(testtest(foofoo,)), /*
+    */testsa)
+
+    useCallable("B", "C", Callable {
+        println("Hello world")
+    }, /* */ Callable {
+        println("Hello world")
+    })
+
+    useCallable(Callable { println("Hello world") } // ffd
+    )
+}

idea/testData/formatter/trailingComma/valueArguments/ArgumentListWrapAlways.after.inv.kt

@@ -0,0 +1,348 @@
+// SET_INT: CALL_PARAMETERS_WRAP = 2
+// SET_TRUE: ALLOW_TRAILING_COMMA
+
+fun foo() {
+    testtest(
+            foofoo,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ),
+            testsa,
+    )
+
+    testtest(foofoo,
+            foofoo,
+            foofoo,
+            foofoo,
+            bar)
+
+    testtest(
+            foofoo,
+            foofoo,
+            foofoo,
+            foofoo,
+            bar
+    )
+
+    testtest(foofoo,
+            foofoo,
+            foofoo,
+            foofoo,
+            bar
+    )
+
+    testtest(foofoo,
+            foofoo,
+            foofoo,
+            foofoo,
+            bar
+    )
+
+    testtest(foofoo
+    )
+
+    testtest(
+            foofoo)
+
+    testtest(
+            foofoo
+    )
+
+    testtest(
+            foofoo,
+    )
+
+    testtest(foofoo,
+            testtest(testtest(foofoo)))
+
+    testtest(
+            foofoo,
+            fososos,
+            testtest(testtest(foofoo)),
+    )
+
+    testtest(foofoo,
+            testtest(testtest(
+                    foofoo,
+            )),
+            testsa)
+
+    testtest(foofoo,
+            seee,
+            testtest(testtest(
+                    foofoo,
+            )),
+            testsa)
+
+    useCallable("A",
+            Callable { println("Hello world") })
+
+    useCallable("B",
+            "C",
+            Callable {
+                println("Hello world")
+            },
+            Callable {
+                println("Hello world")
+            })
+
+    useCallable(Callable { println("Hello world") })
+
+    useCallable(
+            Callable { println("Hello world") },
+    )
+
+    useCallable(Callable { println("Hello world") }
+    )
+
+    useCallable(Callable { println("Hello world") }) {
+
+    }
+
+    useCallable(
+            Callable { println("Hello world") })
+
+    useCallable("A",
+            { println("Hello world") })
+
+    useCallable("B",
+            "C",
+            {
+                println("Hello world")
+            },
+            {
+                println("Hello world")
+            })
+
+    useCallable({ println("Hello world") })
+
+    useCallable(
+            { println("Hello world") },
+    )
+
+    useCallable({ println("Hello world") }
+    )
+
+    useCallable({ println("Hello world") }) {
+
+    }
+
+    useCallable(
+            { println("Hello world") })
+
+    useCallable("A",
+            foo() { println("Hello world") })
+
+    useCallable("B",
+            "C",
+            foo() {
+                println("Hello world")
+            },
+            foo() {
+                println("Hello world")
+            })
+
+    useCallable(foo() { println("Hello world") })
+
+    useCallable(
+            foo() { println("Hello world") },
+    )
+
+    useCallable(foo() { println("Hello world") }
+    )
+
+    useCallable(foo() { println("Hello world") }) {
+
+    }
+
+    useCallable(
+            foo() { println("Hello world") })
+
+    useCallable("A",
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            })
+
+    useCallable("A",
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            })
+
+    useCallable("B",
+            "C",
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+            foo() {
+                println("Hello world")
+            })
+
+    useCallable(object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    })
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    }
+    )
+
+    useCallable(object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    }) {
+
+    }
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            })
+
+    testtest(
+            foofoo,
+            foofoo,
+            foofoo,
+            foofoo,
+            bar /*
+    */, /* */
+            foo
+    )
+
+    testtest(/*
+    */foofoo,
+            foofoo,
+            foofoo, /*
+
+    */
+            foofoo,
+            bar)
+
+    testtest(foofoo,
+            foofoo,
+            foofoo,
+            foofoo,
+            bar/*
+    */)
+
+    testtest(foofoo,
+            foofoo,
+            foofoo,
+            foofoo,
+            bar // awdawda
+    )
+
+    testtest(foofoo,
+            foofoo,
+            foofoo,
+            foofoo, /*
+
+    */
+            bar
+    )
+
+    testtest(foofoo // fd
+    )
+
+    testtest( /**/
+            foofoo
+    )
+
+    testtest(
+            foofoo,/**/
+    )
+
+    testtest(foofoo,
+            foofoo,
+            foofoo,
+            foofoo/*
+     */, /* */
+            bar
+    )
+
+    testtest(foofoo // fd
+    )
+
+    testtest( /**/
+            foofoo
+    )
+
+    testtest(
+            foofoo,/**/
+    )
+
+    testtest(
+            foofoo,
+            fososos,/*
+    */
+            testtest(testtest(foofoo)),
+    )
+
+    testtest(foofoo,
+            testtest(testtest(
+                    foofoo,
+            )), /**/
+            testsa)
+
+    testtest(foofoo,
+            testtest(testtest(
+                    foofoo,
+            ))/* */, /**/
+            testsa)
+
+    testtest(foofoo,
+            testtest(testtest(
+                    foofoo,
+            ))/*
+    */,
+            testsa)
+
+    testtest(foofoo,
+            seee,
+            testtest(testtest(
+                    foofoo,
+            )), /**/
+            testsa)
+
+    testtest(foofoo,
+            seee,
+            testtest(testtest(
+                    foofoo,
+            )), /*
+    */
+            testsa)
+
+    useCallable("B",
+            "C",
+            Callable {
+                println("Hello world")
+            }, /* */
+            Callable {
+                println("Hello world")
+            })
+
+    useCallable(Callable { println("Hello world") } // ffd
+    )
+}

idea/testData/formatter/trailingComma/valueArguments/ArgumentListWrapAlways.after.kt

@@ -0,0 +1,429 @@
+// SET_INT: CALL_PARAMETERS_WRAP = 2
+// SET_TRUE: ALLOW_TRAILING_COMMA
+
+fun foo() {
+    testtest(
+            foofoo,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ),
+            testsa,
+    )
+
+    testtest(
+            foofoo,
+            foofoo,
+            foofoo,
+            foofoo,
+            bar,
+    )
+
+    testtest(
+            foofoo,
+            foofoo,
+            foofoo,
+            foofoo,
+            bar,
+    )
+
+    testtest(
+            foofoo,
+            foofoo,
+            foofoo,
+            foofoo,
+            bar,
+    )
+
+    testtest(
+            foofoo,
+            foofoo,
+            foofoo,
+            foofoo,
+            bar,
+    )
+
+    testtest(
+            foofoo,
+    )
+
+    testtest(
+            foofoo,
+    )
+
+    testtest(
+            foofoo,
+    )
+
+    testtest(
+            foofoo,
+    )
+
+    testtest(
+            foofoo,
+            testtest(testtest(foofoo)),
+    )
+
+    testtest(
+            foofoo,
+            fososos,
+            testtest(testtest(foofoo)),
+    )
+
+    testtest(
+            foofoo,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ),
+            testsa,
+    )
+
+    testtest(
+            foofoo,
+            seee,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ),
+            testsa,
+    )
+
+    useCallable(
+            "A",
+            Callable { println("Hello world") },
+    )
+
+    useCallable(
+            "B",
+            "C",
+            Callable {
+                println("Hello world")
+            },
+            Callable {
+                println("Hello world")
+            },
+    )
+
+    useCallable(Callable { println("Hello world") })
+
+    useCallable(
+            Callable { println("Hello world") },
+    )
+
+    useCallable(
+            Callable { println("Hello world") },
+    )
+
+    useCallable(Callable { println("Hello world") }) {
+
+    }
+
+    useCallable(
+            Callable { println("Hello world") },
+    )
+
+    useCallable(
+            "A",
+            { println("Hello world") },
+    )
+
+    useCallable(
+            "B",
+            "C",
+            {
+                println("Hello world")
+            },
+            {
+                println("Hello world")
+            },
+    )
+
+    useCallable({ println("Hello world") })
+
+    useCallable(
+            { println("Hello world") },
+    )
+
+    useCallable(
+            { println("Hello world") },
+    )
+
+    useCallable({ println("Hello world") }) {
+
+    }
+
+    useCallable(
+            { println("Hello world") },
+    )
+
+    useCallable(
+            "A",
+            foo() { println("Hello world") },
+    )
+
+    useCallable(
+            "B",
+            "C",
+            foo() {
+                println("Hello world")
+            },
+            foo() {
+                println("Hello world")
+            },
+    )
+
+    useCallable(foo() { println("Hello world") })
+
+    useCallable(
+            foo() { println("Hello world") },
+    )
+
+    useCallable(
+            foo() { println("Hello world") },
+    )
+
+    useCallable(foo() { println("Hello world") }) {
+
+    }
+
+    useCallable(
+            foo() { println("Hello world") },
+    )
+
+    useCallable(
+            "A",
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(
+            "A",
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(
+            "B",
+            "C",
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+            foo() {
+                println("Hello world")
+            },
+    )
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    ) {
+
+    }
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    testtest(
+            foofoo,
+            foofoo,
+            foofoo,
+            foofoo,
+            bar, /*
+    */ /* */
+            foo,
+    )
+
+    testtest(
+/*
+    */
+            foofoo,
+            foofoo,
+            foofoo, /*
+
+    */
+            foofoo,
+            bar,
+    )
+
+    testtest(
+            foofoo,
+            foofoo,
+            foofoo,
+            foofoo,
+            bar,/*
+    */
+    )
+
+    testtest(
+            foofoo,
+            foofoo,
+            foofoo,
+            foofoo,
+            bar, // awdawda
+    )
+
+    testtest(
+            foofoo,
+            foofoo,
+            foofoo,
+            foofoo, /*
+
+    */
+            bar,
+    )
+
+    testtest(
+            foofoo, // fd
+    )
+
+    testtest(
+            /**/
+            foofoo,
+    )
+
+    testtest(
+            foofoo,/**/
+    )
+
+    testtest(
+            foofoo,
+            foofoo,
+            foofoo,
+            foofoo,/*
+     */ /* */
+            bar,
+    )
+
+    testtest(
+            foofoo, // fd
+    )
+
+    testtest(
+            /**/
+            foofoo,
+    )
+
+    testtest(
+            foofoo,/**/
+    )
+
+    testtest(
+            foofoo,
+            fososos,/*
+    */
+            testtest(testtest(foofoo)),
+    )
+
+    testtest(
+            foofoo,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ), /**/
+            testsa,
+    )
+
+    testtest(
+            foofoo,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ),/* */ /**/
+            testsa,
+    )
+
+    testtest(
+            foofoo,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ),/*
+    */
+            testsa,
+    )
+
+    testtest(
+            foofoo,
+            seee,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ), /**/
+            testsa,
+    )
+
+    testtest(
+            foofoo,
+            seee,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ), /*
+    */
+            testsa,
+    )
+
+    useCallable(
+            "B",
+            "C",
+            Callable {
+                println("Hello world")
+            }, /* */
+            Callable {
+                println("Hello world")
+            },
+    )
+
+    useCallable(
+            Callable { println("Hello world") }, // ffd
+    )
+}

idea/testData/formatter/trailingComma/valueArguments/ArgumentListWrapAlways.kt

@@ -0,0 +1,208 @@
+// SET_INT: CALL_PARAMETERS_WRAP = 2
+// SET_TRUE: ALLOW_TRAILING_COMMA
+
+fun foo() {
+    testtest(foofoo,
+             testtest(testtest(
+                 foofoo,
+             ),
+             ),
+             testsa,
+    )
+
+    testtest(foofoo, foofoo, foofoo,
+             foofoo, bar)
+
+    testtest(
+        foofoo, foofoo, foofoo, foofoo, bar
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo,
+             bar
+    )
+
+    testtest(foofoo
+    )
+
+    testtest(
+        foofoo)
+
+    testtest(
+        foofoo
+    )
+
+    testtest(foofoo,)
+
+    testtest(foofoo, testtest(testtest(foofoo)))
+
+    testtest(foofoo, fososos, testtest(testtest(foofoo)),)
+
+    testtest(foofoo, testtest(testtest(foofoo,)), testsa)
+
+    testtest(foofoo, seee, testtest(testtest(foofoo,)), testsa)
+
+    useCallable("A", Callable { println("Hello world") })
+
+    useCallable("B", "C", Callable {
+        println("Hello world")
+    }, Callable {
+        println("Hello world")
+    })
+
+    useCallable(Callable { println("Hello world") })
+
+    useCallable(Callable { println("Hello world") },)
+
+    useCallable(Callable { println("Hello world") }
+    )
+
+    useCallable(Callable { println("Hello world") }){
+
+    }
+
+    useCallable(
+        Callable { println("Hello world") })
+
+    useCallable("A", { println("Hello world") })
+
+    useCallable("B", "C", {
+        println("Hello world")
+    }, {
+                    println("Hello world")
+                })
+
+    useCallable({ println("Hello world") })
+
+    useCallable({ println("Hello world") },)
+
+    useCallable({ println("Hello world") }
+    )
+
+    useCallable({ println("Hello world") }){
+
+    }
+
+    useCallable(
+        { println("Hello world") })
+
+    useCallable("A", foo() { println("Hello world") })
+
+    useCallable("B", "C", foo() {
+        println("Hello world")
+    }, foo() {
+        println("Hello world")
+    })
+
+    useCallable(foo() { println("Hello world") })
+
+    useCallable(foo() { println("Hello world") },)
+
+    useCallable(foo() { println("Hello world") }
+    )
+
+    useCallable(foo() { println("Hello world") }) {
+
+    }
+
+    useCallable(
+        foo() { println("Hello world") })
+
+    useCallable("A", object : Callable<Unit> { override fun call() { println("Hello world") } })
+
+    useCallable("A", object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    })
+
+    useCallable("B", "C", object : Callable<Unit> { override fun call() { println("Hello world") } }, foo() {
+        println("Hello world")
+    })
+
+    useCallable(object : Callable<Unit> { override fun call() { println("Hello world") } })
+
+    useCallable(object : Callable<Unit> { override fun call() { println("Hello world") } },)
+
+    useCallable(object : Callable<Unit> { override fun call() { println("Hello world") } }
+    )
+
+    useCallable(object : Callable<Unit> { override fun call() { println("Hello world") } }) {
+
+    }
+
+    useCallable(
+        object : Callable<Unit> { override fun call() { println("Hello world") } })
+
+    testtest(
+        foofoo, foofoo, foofoo, foofoo,
+        bar /*
+    */, /* */ foo
+    )
+
+    testtest(/*
+    */foofoo, foofoo, foofoo, /*
+
+    */
+      foofoo, bar)
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar/*
+    */)
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar // awdawda
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo, /*
+
+    */
+             bar
+    )
+
+    testtest(foofoo // fd
+    )
+
+    testtest( /**/
+        foofoo
+    )
+
+    testtest(foofoo,/**/)
+
+    testtest(foofoo, foofoo, foofoo, foofoo/*
+     */ , /* */ bar
+    )
+
+    testtest(foofoo // fd
+    )
+
+    testtest( /**/
+        foofoo
+    )
+
+    testtest(foofoo,/**/)
+
+    testtest(foofoo, fososos,/*
+    */ testtest(testtest(foofoo)),)
+
+    testtest(foofoo, testtest(testtest(foofoo,)), /**/testsa)
+
+    testtest(foofoo, testtest(testtest(foofoo,))/* */ , /**/testsa)
+
+    testtest(foofoo, testtest(testtest(foofoo,))/*
+    */ ,testsa)
+
+    testtest(foofoo, seee, testtest(testtest(foofoo,)), /**/testsa)
+
+    testtest(foofoo, seee, testtest(testtest(foofoo,)), /*
+    */testsa)
+
+    useCallable("B", "C", Callable {
+        println("Hello world")
+    }, /* */ Callable {
+        println("Hello world")
+    })
+
+    useCallable(Callable { println("Hello world") } // ffd
+    )
+}

idea/testData/formatter/trailingComma/valueArguments/ArgumentListWrapAsNeeded.after.inv.kt

@@ -0,0 +1,261 @@
+// SET_INT: CALL_PARAMETERS_WRAP = 1
+// SET_TRUE: ALLOW_TRAILING_COMMA
+
+fun foo() {
+    testtest(foofoo, foofoo, foofoo,
+            foofoo, bar)
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo, bar
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo,
+            bar
+    )
+
+    testtest(foofoo
+    )
+
+    testtest(
+            foofoo)
+
+    testtest(
+            foofoo
+    )
+
+    testtest(
+            foofoo,
+    )
+
+    testtest(foofoo, testtest(testtest(foofoo)))
+
+    testtest(
+            foofoo, fososos, testtest(testtest(foofoo)),
+    )
+
+    testtest(foofoo, testtest(testtest(
+            foofoo,
+    )), testsa)
+
+    testtest(foofoo, seee, testtest(testtest(
+            foofoo,
+    )), testsa)
+
+    useCallable("A", Callable { println("Hello world") })
+
+    useCallable("B", "C", Callable {
+        println("Hello world")
+    }, Callable {
+        println("Hello world")
+    })
+
+    useCallable(Callable { println("Hello world") })
+
+    useCallable(
+            Callable { println("Hello world") },
+    )
+
+    useCallable(Callable { println("Hello world") }
+    )
+
+    useCallable(Callable { println("Hello world") }) {
+
+    }
+
+    useCallable(
+            Callable { println("Hello world") })
+
+    useCallable("A", { println("Hello world") })
+
+    useCallable("B", "C", {
+        println("Hello world")
+    }, {
+        println("Hello world")
+    })
+
+    useCallable({ println("Hello world") })
+
+    useCallable(
+            { println("Hello world") },
+    )
+
+    useCallable({ println("Hello world") }
+    )
+
+    useCallable({ println("Hello world") }) {
+
+    }
+
+    useCallable(
+            { println("Hello world") })
+
+    useCallable("A", foo() { println("Hello world") })
+
+    useCallable("B", "C", foo() {
+        println("Hello world")
+    }, foo() {
+        println("Hello world")
+    })
+
+    useCallable(foo() { println("Hello world") })
+
+    useCallable(
+            foo() { println("Hello world") },
+    )
+
+    useCallable(foo() { println("Hello world") }
+    )
+
+    useCallable(foo() { println("Hello world") }) {
+
+    }
+
+    useCallable(
+            foo() { println("Hello world") })
+
+    useCallable("A", object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    })
+
+    useCallable("A", object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    })
+
+    useCallable("B", "C", object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    }, foo() {
+        println("Hello world")
+    })
+
+    useCallable(object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    })
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    }
+    )
+
+    useCallable(object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    }) {
+
+    }
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            })
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo,
+            bar /*
+    */, /* */ foo
+    )
+
+    testtest(/*
+    */foofoo, foofoo, foofoo, /*
+
+    */
+            foofoo, bar)
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar/*
+    */)
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar // awdawda
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo, /*
+
+    */
+            bar
+    )
+
+    testtest(foofoo // fd
+    )
+
+    testtest( /**/
+            foofoo
+    )
+
+    testtest(
+            foofoo,/**/
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo/*
+     */, /* */ bar
+    )
+
+    testtest(foofoo // fd
+    )
+
+    testtest( /**/
+            foofoo
+    )
+
+    testtest(
+            foofoo,/**/
+    )
+
+    testtest(
+            foofoo, fososos,/*
+    */
+            testtest(testtest(foofoo)),
+    )
+
+    testtest(foofoo, testtest(testtest(
+            foofoo,
+    )), /**/testsa)
+
+    testtest(foofoo, testtest(testtest(
+            foofoo,
+    ))/* */, /**/testsa)
+
+    testtest(foofoo, testtest(testtest(
+            foofoo,
+    ))/*
+    */, testsa)
+
+    testtest(foofoo, seee, testtest(testtest(
+            foofoo,
+    )), /**/testsa)
+
+    testtest(foofoo, seee, testtest(testtest(
+            foofoo,
+    )), /*
+    */testsa)
+
+    useCallable("B", "C", Callable {
+        println("Hello world")
+    }, /* */ Callable {
+        println("Hello world")
+    })
+
+    useCallable(Callable { println("Hello world") } // ffd
+    )
+}

idea/testData/formatter/trailingComma/valueArguments/ArgumentListWrapAsNeeded.after.kt

@@ -0,0 +1,364 @@
+// SET_INT: CALL_PARAMETERS_WRAP = 1
+// SET_TRUE: ALLOW_TRAILING_COMMA
+
+fun foo() {
+    testtest(
+            foofoo, foofoo, foofoo,
+            foofoo, bar,
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo, bar,
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo, bar,
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo,
+            bar,
+    )
+
+    testtest(
+            foofoo,
+    )
+
+    testtest(
+            foofoo,
+    )
+
+    testtest(
+            foofoo,
+    )
+
+    testtest(
+            foofoo,
+    )
+
+    testtest(foofoo, testtest(testtest(foofoo)))
+
+    testtest(
+            foofoo, fososos, testtest(testtest(foofoo)),
+    )
+
+    testtest(
+            foofoo,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ),
+            testsa,
+    )
+
+    testtest(
+            foofoo, seee,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ),
+            testsa,
+    )
+
+    useCallable("A", Callable { println("Hello world") })
+
+    useCallable(
+            "B", "C",
+            Callable {
+                println("Hello world")
+            },
+            Callable {
+                println("Hello world")
+            },
+    )
+
+    useCallable(Callable { println("Hello world") })
+
+    useCallable(
+            Callable { println("Hello world") },
+    )
+
+    useCallable(
+            Callable { println("Hello world") },
+    )
+
+    useCallable(Callable { println("Hello world") }) {
+
+    }
+
+    useCallable(
+            Callable { println("Hello world") },
+    )
+
+    useCallable("A", { println("Hello world") })
+
+    useCallable(
+            "B", "C",
+            {
+                println("Hello world")
+            },
+            {
+                println("Hello world")
+            },
+    )
+
+    useCallable({ println("Hello world") })
+
+    useCallable(
+            { println("Hello world") },
+    )
+
+    useCallable(
+            { println("Hello world") },
+    )
+
+    useCallable({ println("Hello world") }) {
+
+    }
+
+    useCallable(
+            { println("Hello world") },
+    )
+
+    useCallable("A", foo() { println("Hello world") })
+
+    useCallable(
+            "B", "C",
+            foo() {
+                println("Hello world")
+            },
+            foo() {
+                println("Hello world")
+            },
+    )
+
+    useCallable(foo() { println("Hello world") })
+
+    useCallable(
+            foo() { println("Hello world") },
+    )
+
+    useCallable(
+            foo() { println("Hello world") },
+    )
+
+    useCallable(foo() { println("Hello world") }) {
+
+    }
+
+    useCallable(
+            foo() { println("Hello world") },
+    )
+
+    useCallable(
+            "A",
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(
+            "A",
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(
+            "B", "C",
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+            foo() {
+                println("Hello world")
+            },
+    )
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    ) {
+
+    }
+
+    useCallable(
+            object : Callable<Unit> {
+                override fun call() {
+                    println("Hello world")
+                }
+            },
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo,
+            bar, /*
+    */ /* */
+            foo,
+    )
+
+    testtest(
+/*
+    */
+            foofoo, foofoo, foofoo, /*
+
+    */
+            foofoo, bar,
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo,
+            bar,/*
+    */
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo, bar, // awdawda
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo, foofoo, /*
+
+    */
+            bar,
+    )
+
+    testtest(
+            foofoo, // fd
+    )
+
+    testtest(
+            /**/
+            foofoo,
+    )
+
+    testtest(
+            foofoo,/**/
+    )
+
+    testtest(
+            foofoo, foofoo, foofoo,
+            foofoo,/*
+     */ /* */
+            bar,
+    )
+
+    testtest(
+            foofoo, // fd
+    )
+
+    testtest(
+            /**/
+            foofoo,
+    )
+
+    testtest(
+            foofoo,/**/
+    )
+
+    testtest(
+            foofoo, fososos,/*
+    */
+            testtest(testtest(foofoo)),
+    )
+
+    testtest(
+            foofoo,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ), /**/
+            testsa,
+    )
+
+    testtest(
+            foofoo,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ),/* */ /**/
+            testsa,
+    )
+
+    testtest(
+            foofoo,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ),/*
+    */
+            testsa,
+    )
+
+    testtest(
+            foofoo, seee,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ), /**/
+            testsa,
+    )
+
+    testtest(
+            foofoo, seee,
+            testtest(
+                    testtest(
+                            foofoo,
+                    ),
+            ), /*
+    */
+            testsa,
+    )
+
+    useCallable(
+            "B", "C",
+            Callable {
+                println("Hello world")
+            }, /* */
+            Callable {
+                println("Hello world")
+            },
+    )
+
+    useCallable(
+            Callable { println("Hello world") }, // ffd
+    )
+}

idea/testData/formatter/trailingComma/valueArguments/ArgumentListWrapAsNeeded.kt

@@ -0,0 +1,200 @@
+// SET_INT: CALL_PARAMETERS_WRAP = 1
+// SET_TRUE: ALLOW_TRAILING_COMMA
+
+fun foo() {
+    testtest(foofoo, foofoo, foofoo,
+             foofoo, bar)
+
+    testtest(
+        foofoo, foofoo, foofoo, foofoo, bar
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo,
+             bar
+    )
+
+    testtest(foofoo
+    )
+
+    testtest(
+        foofoo)
+
+    testtest(
+        foofoo
+    )
+
+    testtest(foofoo,)
+
+    testtest(foofoo, testtest(testtest(foofoo)))
+
+    testtest(foofoo, fososos, testtest(testtest(foofoo)),)
+
+    testtest(foofoo, testtest(testtest(foofoo,)), testsa)
+
+    testtest(foofoo, seee, testtest(testtest(foofoo,)), testsa)
+
+    useCallable("A", Callable { println("Hello world") })
+
+    useCallable("B", "C", Callable {
+        println("Hello world")
+    }, Callable {
+        println("Hello world")
+    })
+
+    useCallable(Callable { println("Hello world") })
+
+    useCallable(Callable { println("Hello world") },)
+
+    useCallable(Callable { println("Hello world") }
+    )
+
+    useCallable(Callable { println("Hello world") }){
+
+    }
+
+    useCallable(
+        Callable { println("Hello world") })
+
+    useCallable("A", { println("Hello world") })
+
+    useCallable("B", "C", {
+        println("Hello world")
+    }, {
+                    println("Hello world")
+                })
+
+    useCallable({ println("Hello world") })
+
+    useCallable({ println("Hello world") },)
+
+    useCallable({ println("Hello world") }
+    )
+
+    useCallable({ println("Hello world") }){
+
+    }
+
+    useCallable(
+        { println("Hello world") })
+
+    useCallable("A", foo() { println("Hello world") })
+
+    useCallable("B", "C", foo() {
+        println("Hello world")
+    }, foo() {
+        println("Hello world")
+    })
+
+    useCallable(foo() { println("Hello world") })
+
+    useCallable(foo() { println("Hello world") },)
+
+    useCallable(foo() { println("Hello world") }
+    )
+
+    useCallable(foo() { println("Hello world") }) {
+
+    }
+
+    useCallable(
+        foo() { println("Hello world") })
+
+    useCallable("A", object : Callable<Unit> { override fun call() { println("Hello world") } })
+
+    useCallable("A", object : Callable<Unit> {
+        override fun call() {
+            println("Hello world")
+        }
+    })
+
+    useCallable("B", "C", object : Callable<Unit> { override fun call() { println("Hello world") } }, foo() {
+        println("Hello world")
+    })
+
+    useCallable(object : Callable<Unit> { override fun call() { println("Hello world") } })
+
+    useCallable(object : Callable<Unit> { override fun call() { println("Hello world") } },)
+
+    useCallable(object : Callable<Unit> { override fun call() { println("Hello world") } }
+    )
+
+    useCallable(object : Callable<Unit> { override fun call() { println("Hello world") } }) {
+
+    }
+
+    useCallable(
+        object : Callable<Unit> { override fun call() { println("Hello world") } })
+
+    testtest(
+        foofoo, foofoo, foofoo, foofoo,
+        bar /*
+    */, /* */ foo
+    )
+
+    testtest(/*
+    */foofoo, foofoo, foofoo, /*
+
+    */
+      foofoo, bar)
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar/*
+    */)
+
+    testtest(foofoo, foofoo, foofoo, foofoo, bar // awdawda
+    )
+
+    testtest(foofoo, foofoo, foofoo, foofoo, /*
+
+    */
+             bar
+    )
+
+    testtest(foofoo // fd
+    )
+
+    testtest( /**/
+        foofoo
+    )
+
+    testtest(foofoo,/**/)
+
+    testtest(foofoo, foofoo, foofoo, foofoo/*
+     */ , /* */ bar
+    )
+
+    testtest(foofoo // fd
+    )
+
+    testtest( /**/
+        foofoo
+    )
+
+    testtest(foofoo,/**/)
+
+    testtest(foofoo, fososos,/*
+    */ testtest(testtest(foofoo)),)
+
+    testtest(foofoo, testtest(testtest(foofoo,)), /**/testsa)
+
+    testtest(foofoo, testtest(testtest(foofoo,))/* */ , /**/testsa)
+
+    testtest(foofoo, testtest(testtest(foofoo,))/*
+    */ ,testsa)
+
+    testtest(foofoo, seee, testtest(testtest(foofoo,)), /**/testsa)
+
+    testtest(foofoo, seee, testtest(testtest(foofoo,)), /*
+    */testsa)
+
+    useCallable("B", "C", Callable {
+        println("Hello world")
+    }, /* */ Callable {
+        println("Hello world")
+    })
+
+    useCallable(Callable { println("Hello world") } // ffd
+    )
+}

idea/testData/formatter/trailingComma/valueParameters/Function.after.inv.kt

@@ -1,85 +0,0 @@
-fun a1(
-        x: String,
-        y: String,
-) = Unit
-
-fun b1(
-        x: String,
-        y: String
-) = Unit
-
-fun c1(
-        x: String,
-        y: String,
-) = Unit
-
-fun d1(
-        x: String,
-        y: String,
-) = Unit
-
-fun a2(
-        x: String,
-        y: String,
-        z: String,
-) = Unit
-
-fun b2(
-        x: String,
-        y: String,
-        z: String
-) = Unit
-
-fun c2(
-        x: String,
-        y: String,
-        z: String,
-) = Unit
-
-fun d2(
-        x: String,
-        y: String,
-        z: String,
-) = Unit
-
-fun a3(
-        x: String,
-) = Unit
-
-fun b3(
-        x: String
-) = Unit
-
-fun c3(
-        x: String,
-) = Unit
-
-fun d3(
-        x: String,
-) = Unit
-
-fun a4(
-        x: String,
-        y: String,
-        z: String,
-) = Unit
-
-fun b4(
-        x: String,
-        y: String,
-        z: String
-) = Unit
-
-fun c4(
-        x: String,
-        y: String,
-        z: String,
-) = Unit
-
-fun d4(
-        x: String,
-        y: String,
-        z: String,
-) = Unit
-
-// SET_TRUE: ALLOW_TRAILING_COMMA

idea/testData/formatter/trailingComma/valueParameters/Function.after.kt

@@ -1,85 +0,0 @@
-fun a1(
-        x: String,
-        y: String,
-) = Unit
-
-fun b1(
-        x: String,
-        y: String,
-) = Unit
-
-fun c1(
-        x: String,
-        y: String,
-) = Unit
-
-fun d1(
-        x: String,
-        y: String,
-) = Unit
-
-fun a2(
-        x: String,
-        y: String,
-        z: String,
-) = Unit
-
-fun b2(
-        x: String,
-        y: String,
-        z: String,
-) = Unit
-
-fun c2(
-        x: String,
-        y: String,
-        z: String,
-) = Unit
-
-fun d2(
-        x: String,
-        y: String,
-        z: String,
-) = Unit
-
-fun a3(
-        x: String,
-) = Unit
-
-fun b3(
-        x: String,
-) = Unit
-
-fun c3(
-        x: String,
-) = Unit
-
-fun d3(
-        x: String,
-) = Unit
-
-fun a4(
-        x: String,
-        y: String,
-        z: String,
-) = Unit
-
-fun b4(
-        x: String,
-        y: String,
-        z: String,
-) = Unit
-
-fun c4(
-        x: String,
-        y: String,
-        z: String,
-) = Unit
-
-fun d4(
-        x: String,
-        y: String,
-        z: String,
-) = Unit
-
-// SET_TRUE: ALLOW_TRAILING_COMMA

idea/testData/formatter/trailingComma/valueParameters/Function.kt

@@ -1,81 +0,0 @@
-fun a1(
-    x: String,
-    y: String,
-) = Unit
-
-fun b1(
-    x: String,
-    y: String
-) = Unit
-
-fun c1(
-    x: String,
-    y: String,) = Unit
-
-fun d1(
-    x: String,
-    y: String
-    ,) = Unit
-
-fun a2(
-    x: String,
-    y: String,
-    z: String,
-) = Unit
-
-fun b2(
-    x: String,
-    y: String,
-    z: String
-) = Unit
-
-fun c2(
-    x: String,
-    y: String,
-    z: String,) = Unit
-
-fun d2(
-    x: String,
-    y: String,
-    z: String
-    ,) = Unit
-
-fun a3(
-    x: String,
-) = Unit
-
-fun b3(
-    x: String
-) = Unit
-
-fun c3(
-    x: String,) = Unit
-
-fun d3(
-    x: String
-    ,) = Unit
-
-fun a4(
-    x: String
-    ,
-        y: String,
-    z: String   ,
-) = Unit
-
-fun b4(
-    x: String,
-    y: String,
-    z: String
-) = Unit
-
-fun c4(x: String,
-    y: String,
-    z: String   ,) = Unit
-
-fun d4(
-    x: String,
-    y: String,
-    z: String
-,   ) = Unit
-
-// SET_TRUE: ALLOW_TRAILING_COMMA

idea/testData/formatter/trailingComma/valueParameters/OptionalTypes.after.inv.kt

@@ -1,75 +0,0 @@
-val foo1: (Int, Int) -> Int = fun(
-        x,
-        y,
-): Int = 42
-
-val foo2: (Int, Int) -> Int = fun(
-        x,
-        y
-): Int {
-    return x + y
-}
-
-val foo3: (Int, Int) -> Int = fun(
-        x, y,
-): Int {
-    return x + y
-}
-
-val foo4: (Int) -> Int = fun(
-        x,
-): Int = 42
-
-val foo5: (Int) -> Int = fun(
-        x
-): Int = 42
-
-val foo6: (Int) -> Int = fun(
-        x,
-): Int = 42
-
-val foo7: (Int) -> Int = fun(x): Int = 42
-
-val foo8: (Int, Int, Int) -> Int = fun(
-        x, y: Int, z,
-): Int {
-    return x + y
-}
-
-val foo9: (Int, Int, Int) -> Int = fun(
-        x,
-        y: Int,
-        z,
-): Int = 42
-
-val foo10: (Int, Int, Int) -> Int = fun(
-        x,
-        y: Int,
-        z: Int
-): Int = 43
-
-val foo10 = fun(
-        x: Int,
-        y: Int,
-        z: Int
-): Int = 43
-
-val foo11 = fun(
-        x: Int,
-        y: Int,
-        z: Int,
-): Int = 43
-
-val foo12 = fun(
-        x: Int, y: Int, z: Int,
-): Int = 43
-
-val foo13 = fun(
-        x: Int, y: Int, z: Int,
-): Int = 43
-
-val foo14 = fun(
-        x: Int, y: Int, z: Int,
-): Int = 43
-
-// SET_TRUE: ALLOW_TRAILING_COMMA

idea/testData/formatter/trailingComma/valueParameters/OptionalTypes.after.kt

@@ -1,75 +0,0 @@
-val foo1: (Int, Int) -> Int = fun(
-        x,
-        y,
-): Int = 42
-
-val foo2: (Int, Int) -> Int = fun(
-        x,
-        y,
-): Int {
-    return x + y
-}
-
-val foo3: (Int, Int) -> Int = fun(
-        x, y,
-): Int {
-    return x + y
-}
-
-val foo4: (Int) -> Int = fun(
-        x,
-): Int = 42
-
-val foo5: (Int) -> Int = fun(
-        x,
-): Int = 42
-
-val foo6: (Int) -> Int = fun(
-        x,
-): Int = 42
-
-val foo7: (Int) -> Int = fun(x): Int = 42
-
-val foo8: (Int, Int, Int) -> Int = fun(
-        x, y: Int, z,
-): Int {
-    return x + y
-}
-
-val foo9: (Int, Int, Int) -> Int = fun(
-        x,
-        y: Int,
-        z,
-): Int = 42
-
-val foo10: (Int, Int, Int) -> Int = fun(
-        x,
-        y: Int,
-        z: Int,
-): Int = 43
-
-val foo10 = fun(
-        x: Int,
-        y: Int,
-        z: Int,
-): Int = 43
-
-val foo11 = fun(
-        x: Int,
-        y: Int,
-        z: Int,
-): Int = 43
-
-val foo12 = fun(
-        x: Int, y: Int, z: Int,
-): Int = 43
-
-val foo13 = fun(
-        x: Int, y: Int, z: Int,
-): Int = 43
-
-val foo14 = fun(
-        x: Int, y: Int, z: Int,
-): Int = 43
-
-// SET_TRUE: ALLOW_TRAILING_COMMA

idea/testData/formatter/trailingComma/valueParameters/OptionalTypes.kt

@@ -1,69 +0,0 @@
-val foo1: (Int, Int) -> Int = fun(
-    x,
-    y,
-): Int = 42
-
-val foo2: (Int, Int) -> Int = fun(
-    x,
-    y
-): Int {
-    return x + y
-}
-
-val foo3: (Int, Int) -> Int = fun(
-    x, y,
-): Int {
-    return x + y
-}
-
-val foo4: (Int) -> Int = fun(
-    x,
-): Int = 42
-
-val foo5: (Int) -> Int = fun(
-    x
-): Int = 42
-
-val foo6: (Int) -> Int = fun(x,): Int = 42
-
-val foo7: (Int) -> Int = fun(x): Int = 42
-
-val foo8: (Int, Int, Int) -> Int = fun (x, y: Int, z,): Int {
-        return x + y
-    }
-
-val foo9: (Int, Int, Int) -> Int = fun (
-    x,
-    y: Int,
-    z,
-): Int = 42
-
-val foo10: (Int, Int, Int) -> Int = fun (
-    x,
-    y: Int,
-    z: Int
-): Int = 43
-
-val foo10 = fun (
-    x: Int,
-    y: Int,
-    z: Int
-): Int = 43
-
-val foo11 = fun (
-    x: Int,
-    y: Int,
-    z: Int,
-): Int = 43
-
-val foo12 = fun (
-    x: Int, y: Int, z: Int,
-): Int = 43
-
-val foo13 = fun (x: Int, y: Int, z: Int,
-): Int = 43
-
-val foo14 = fun (x: Int, y: Int, z: Int
-                 ,): Int = 43
-
-// SET_TRUE: ALLOW_TRAILING_COMMA

idea/testData/formatter/trailingComma/valueParameters/ParameterListChopAsNeeded.after.inv.kt

@@ -0,0 +1,485 @@
+class A1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class B1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class C1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class D1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class A2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class B2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class C2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class D2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class A3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class B3 {
+    val x: String
+
+    constructor(x: String) {
+        this.x = x
+    }
+}
+
+class C3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class D3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class E1 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String, z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class E2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String, z: String) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class A1(
+        val x: String,
+        y: String,
+)
+
+class B1(
+        val x: String,
+        val y: String
+)
+
+class C1(
+        val x: String,
+        val y: String,
+)
+
+class D1(
+        val x: String,
+        val y: String,
+)
+
+class A2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class B2(
+        val x: String,
+        val y: String,
+        val z: String
+)
+
+class C2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class D2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class A3(
+        val x: String,
+)
+
+class B3(
+        val x: String
+)
+
+class C3(
+        val x: String,
+)
+
+class D3(
+        val x: String,
+)
+
+class A4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class B4(
+        val x: String,
+        val y: String,
+        val z: String
+)
+
+class C4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class D4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class E1(
+        val x: String, val y: String,
+        val z: String,
+)
+
+class E2(
+        val x: String, val y: String, val z: String
+)
+
+class C(
+        z: String, val v: Int, val x: Int =
+                42, val y: Int =
+                42
+)
+
+val foo1: (Int, Int) -> Int = fun(
+        x,
+        y,
+): Int = 42
+
+val foo2: (Int, Int) -> Int = fun(
+        x,
+        y
+): Int {
+    return x + y
+}
+
+val foo3: (Int, Int) -> Int = fun(
+        x, y,
+): Int {
+    return x + y
+}
+
+val foo4: (Int) -> Int = fun(
+        x,
+): Int = 42
+
+val foo5: (Int) -> Int = fun(
+        x
+): Int = 42
+
+val foo6: (Int) -> Int = fun(
+        x,
+): Int = 42
+
+val foo7: (Int) -> Int = fun(x): Int = 42
+
+val foo8: (Int, Int, Int) -> Int = fun(
+        x, y: Int, z,
+): Int {
+    return x + y
+}
+
+val foo9: (Int, Int, Int) -> Int = fun(
+        x,
+        y: Int,
+        z,
+): Int = 42
+
+val foo10: (Int, Int, Int) -> Int = fun(
+        x,
+        y: Int,
+        z: Int
+): Int = 43
+
+val foo10 = fun(
+        x: Int,
+        y: Int,
+        z: Int
+): Int = 43
+
+val foo11 = fun(
+        x: Int,
+        y: Int,
+        z: Int,
+): Int = 43
+
+val foo12 = fun(
+        x: Int, y: Int, z: Int,
+): Int = 43
+
+val foo13 = fun(
+        x: Int, y: Int, z: Int,
+): Int = 43
+
+val foo14 = fun(
+        x: Int, y: Int, z: Int,
+): Int = 43
+
+fun a1(
+        x: String,
+        y: String,
+) = Unit
+
+fun b1(
+        x: String,
+        y: String
+) = Unit
+
+fun c1(
+        x: String,
+        y: String,
+) = Unit
+
+fun d1(
+        x: String,
+        y: String,
+) = Unit
+
+fun a2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun b2(
+        x: String,
+        y: String,
+        z: String
+) = Unit
+
+fun c2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun d2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun a3(
+        x: String,
+) = Unit
+
+fun b3(
+        x: String
+) = Unit
+
+fun c3(
+        x: String,
+) = Unit
+
+fun d3(
+        x: String,
+) = Unit
+
+fun a4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun b4(
+        x: String,
+        y: String,
+        z: String
+) = Unit
+
+fun c4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun d4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun foo(
+        x: Int =
+                42
+) {
+}
+
+class C(
+        val x: Int =
+                42
+)
+
+class G(
+        val x: String, val y: String
+        = "", /* */ val z: String
+)
+
+class G(
+        val x: String, val y: String
+        = "" /* */, /* */ val z: String
+)
+
+class H(
+        val x: String, /*
+    */
+        val y: String,
+        val z: String,
+)
+
+class J(
+        val x: String, val y: String,
+        val z: String /*
+     */,
+)
+
+class K(
+        val x: String, val y: String,
+        val z: String,
+)
+
+class L(
+        val x: String, val y: String, val z: String
+)
+
+// SET_TRUE: ALLOW_TRAILING_COMMA
+// SET_INT: METHOD_PARAMETERS_WRAP = 4

idea/testData/formatter/trailingComma/valueParameters/ParameterListChopAsNeeded.after.kt

@@ -0,0 +1,492 @@
+class A1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class B1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class C1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class D1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class A2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class B2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class C2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class D2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class A3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class B3 {
+    val x: String
+
+    constructor(x: String) {
+        this.x = x
+    }
+}
+
+class C3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class D3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class E1 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String, z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class E2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String, z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class A1(
+        val x: String,
+        y: String,
+)
+
+class B1(
+        val x: String,
+        val y: String,
+)
+
+class C1(
+        val x: String,
+        val y: String,
+)
+
+class D1(
+        val x: String,
+        val y: String,
+)
+
+class A2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class B2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class C2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class D2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class A3(
+        val x: String,
+)
+
+class B3(
+        val x: String,
+)
+
+class C3(
+        val x: String,
+)
+
+class D3(
+        val x: String,
+)
+
+class A4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class B4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class C4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class D4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class E1(
+        val x: String, val y: String,
+        val z: String,
+)
+
+class E2(
+        val x: String, val y: String, val z: String,
+)
+
+class C(
+        z: String, val v: Int,
+        val x: Int =
+                42,
+        val y: Int =
+                42,
+)
+
+val foo1: (Int, Int) -> Int = fun(
+        x,
+        y,
+): Int = 42
+
+val foo2: (Int, Int) -> Int = fun(
+        x,
+        y,
+): Int {
+    return x + y
+}
+
+val foo3: (Int, Int) -> Int = fun(
+        x, y,
+): Int {
+    return x + y
+}
+
+val foo4: (Int) -> Int = fun(
+        x,
+): Int = 42
+
+val foo5: (Int) -> Int = fun(
+        x,
+): Int = 42
+
+val foo6: (Int) -> Int = fun(
+        x,
+): Int = 42
+
+val foo7: (Int) -> Int = fun(x): Int = 42
+
+val foo8: (Int, Int, Int) -> Int = fun(
+        x, y: Int, z,
+): Int {
+    return x + y
+}
+
+val foo9: (Int, Int, Int) -> Int = fun(
+        x,
+        y: Int,
+        z,
+): Int = 42
+
+val foo10: (Int, Int, Int) -> Int = fun(
+        x,
+        y: Int,
+        z: Int,
+): Int = 43
+
+val foo10 = fun(
+        x: Int,
+        y: Int,
+        z: Int,
+): Int = 43
+
+val foo11 = fun(
+        x: Int,
+        y: Int,
+        z: Int,
+): Int = 43
+
+val foo12 = fun(
+        x: Int, y: Int, z: Int,
+): Int = 43
+
+val foo13 = fun(
+        x: Int, y: Int, z: Int,
+): Int = 43
+
+val foo14 = fun(
+        x: Int, y: Int, z: Int,
+): Int = 43
+
+fun a1(
+        x: String,
+        y: String,
+) = Unit
+
+fun b1(
+        x: String,
+        y: String,
+) = Unit
+
+fun c1(
+        x: String,
+        y: String,
+) = Unit
+
+fun d1(
+        x: String,
+        y: String,
+) = Unit
+
+fun a2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun b2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun c2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun d2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun a3(
+        x: String,
+) = Unit
+
+fun b3(
+        x: String,
+) = Unit
+
+fun c3(
+        x: String,
+) = Unit
+
+fun d3(
+        x: String,
+) = Unit
+
+fun a4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun b4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun c4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun d4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun foo(
+        x: Int =
+                42,
+) {
+}
+
+class C(
+        val x: Int =
+                42,
+)
+
+class G(
+        val x: String,
+        val y: String
+        = "", /* */
+        val z: String,
+)
+
+class G(
+        val x: String,
+        val y: String
+        = "" /* */, /* */
+        val z: String,
+)
+
+class H(
+        val x: String, /*
+    */
+        val y: String,
+        val z: String,
+)
+
+class J(
+        val x: String, val y: String,
+        val z: String /*
+     */,
+)
+
+class K(
+        val x: String, val y: String,
+        val z: String,
+)
+
+class L(
+        val x: String, val y: String, val z: String,
+)
+
+// SET_TRUE: ALLOW_TRAILING_COMMA
+// SET_INT: METHOD_PARAMETERS_WRAP = 4

idea/testData/formatter/trailingComma/valueParameters/ParameterListChopAsNeeded.kt

@@ -0,0 +1,461 @@
+class A1 {
+    val x: String
+    val y: String
+
+    constructor(
+        x: String,
+        y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class B1 {
+    val x: String
+    val y: String
+
+    constructor(
+        x: String,
+        y: String
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class C1 {
+    val x: String
+    val y: String
+
+    constructor(
+        x: String,
+        y: String,) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class D1 {
+    val x: String
+    val y: String
+
+    constructor(
+        x: String,
+        y: String
+        ,) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class A2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String,
+        z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class B2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String,
+        z: String
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class C2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String,
+        z: String,) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class D2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String,
+        z: String
+        ,) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class A3 {
+    val x: String
+
+    constructor(x: String,) {
+        this.x = x
+    }
+}
+
+class B3 {
+    val x: String
+
+    constructor(x: String) {
+        this.x = x
+    }
+}
+
+class C3 {
+    val x: String
+
+    constructor(
+        x: String,) {
+        this.x = x
+    }
+}
+
+class D3 {
+    val x: String
+
+    constructor(
+        x: String
+        ,) {
+        this.x = x
+    }
+}
+
+class E1 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String, z: String,) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class E2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String, z: String) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+class A1(
+    val x: String,
+    y: String,
+)
+
+class B1(
+    val x: String,
+    val y: String
+)
+
+class C1(
+    val x: String,
+    val y: String,)
+
+class D1(
+    val x: String,
+    val y: String
+    ,)
+
+class A2(
+    val x: String,
+    val y: String,
+    val z: String,
+)
+
+class B2(
+    val x: String,
+    val y: String,
+    val z: String
+)
+
+class C2(
+    val x: String,
+    val y: String,
+    val z: String,)
+
+class D2(
+    val x: String,
+    val y: String,
+    val z: String
+    ,)
+
+class A3(
+    val x: String,
+)
+
+class B3(
+    val x: String
+)
+
+class C3(
+    val x: String,)
+
+class D3(
+    val x: String
+    ,)
+
+class A4(
+    val x: String   ,
+    val y: String,
+    val z: String   ,
+)
+
+class B4(
+    val x: String,
+    val y: String,
+    val z: String
+)
+
+class C4(
+    val x: String,
+    val y: String,
+    val z: String   ,)
+
+class D4(
+    val x: String,
+    val y: String,
+    val z: String
+    ,   )
+
+class E1(
+    val x: String, val y: String,
+    val z: String
+    ,   )
+
+class E2(
+    val x: String, val y: String, val z: String
+)
+
+class C(
+    z: String, val v: Int, val x: Int =
+        42, val y: Int =
+        42
+)
+
+val foo1: (Int, Int) -> Int = fun(
+    x,
+    y,
+): Int = 42
+
+val foo2: (Int, Int) -> Int = fun(
+    x,
+    y
+): Int {
+    return x + y
+}
+
+val foo3: (Int, Int) -> Int = fun(
+    x, y,
+): Int {
+    return x + y
+}
+
+val foo4: (Int) -> Int = fun(
+    x,
+): Int = 42
+
+val foo5: (Int) -> Int = fun(
+    x
+): Int = 42
+
+val foo6: (Int) -> Int = fun(x,): Int = 42
+
+val foo7: (Int) -> Int = fun(x): Int = 42
+
+val foo8: (Int, Int, Int) -> Int = fun (x, y: Int, z,): Int {
+    return x + y
+}
+
+val foo9: (Int, Int, Int) -> Int = fun (
+    x,
+    y: Int,
+    z,
+): Int = 42
+
+val foo10: (Int, Int, Int) -> Int = fun (
+    x,
+    y: Int,
+    z: Int
+): Int = 43
+
+val foo10 = fun (
+    x: Int,
+    y: Int,
+    z: Int
+): Int = 43
+
+val foo11 = fun (
+    x: Int,
+    y: Int,
+    z: Int,
+): Int = 43
+
+val foo12 = fun (
+    x: Int, y: Int, z: Int,
+): Int = 43
+
+val foo13 = fun (x: Int, y: Int, z: Int,
+): Int = 43
+
+val foo14 = fun (x: Int, y: Int, z: Int
+                 ,): Int = 43
+
+fun a1(
+    x: String,
+    y: String,
+) = Unit
+
+fun b1(
+    x: String,
+    y: String
+) = Unit
+
+fun c1(
+    x: String,
+    y: String,) = Unit
+
+fun d1(
+    x: String,
+    y: String
+    ,) = Unit
+
+fun a2(
+    x: String,
+    y: String,
+    z: String,
+) = Unit
+
+fun b2(
+    x: String,
+    y: String,
+    z: String
+) = Unit
+
+fun c2(
+    x: String,
+    y: String,
+    z: String,) = Unit
+
+fun d2(
+    x: String,
+    y: String,
+    z: String
+    ,) = Unit
+
+fun a3(
+    x: String,
+) = Unit
+
+fun b3(
+    x: String
+) = Unit
+
+fun c3(
+    x: String,) = Unit
+
+fun d3(
+    x: String
+    ,) = Unit
+
+fun a4(
+    x: String
+    ,
+    y: String,
+    z: String   ,
+) = Unit
+
+fun b4(
+    x: String,
+    y: String,
+    z: String
+) = Unit
+
+fun c4(x: String,
+       y: String,
+       z: String   ,) = Unit
+
+fun d4(
+    x: String,
+    y: String,
+    z: String
+    ,   ) = Unit
+
+fun foo(
+    x: Int =
+        42
+) {
+}
+
+class C(
+    val x: Int =
+        42
+)
+
+class G(
+    val x: String, val y: String
+    = "", /* */ val z: String
+)
+
+class G(
+    val x: String, val y: String
+    = "" /* */, /* */ val z: String
+)
+
+class H(
+    val x: String, /*
+    */ val y: String,
+    val z: String   ,)
+
+class J(
+    val x: String, val y: String , val z: String /*
+     */
+    ,   )
+
+class K(
+    val x: String, val y: String,
+    val z: String
+    ,   )
+
+class L(
+    val x: String, val y: String, val z: String
+)
+
+// SET_TRUE: ALLOW_TRAILING_COMMA
+// SET_INT: METHOD_PARAMETERS_WRAP = 4

idea/testData/formatter/trailingComma/valueParameters/ParameterListDoNotWrap.after.inv.kt

@@ -0,0 +1,485 @@
+class A1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class B1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class C1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class D1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class A2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class B2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class C2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class D2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class A3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class B3 {
+    val x: String
+
+    constructor(x: String) {
+        this.x = x
+    }
+}
+
+class C3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class D3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class E1 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String, z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class E2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String, z: String) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class A1(
+        val x: String,
+        y: String,
+)
+
+class B1(
+        val x: String,
+        val y: String
+)
+
+class C1(
+        val x: String,
+        val y: String,
+)
+
+class D1(
+        val x: String,
+        val y: String,
+)
+
+class A2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class B2(
+        val x: String,
+        val y: String,
+        val z: String
+)
+
+class C2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class D2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class A3(
+        val x: String,
+)
+
+class B3(
+        val x: String
+)
+
+class C3(
+        val x: String,
+)
+
+class D3(
+        val x: String,
+)
+
+class A4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class B4(
+        val x: String,
+        val y: String,
+        val z: String
+)
+
+class C4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class D4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class E1(
+        val x: String, val y: String,
+        val z: String,
+)
+
+class E2(
+        val x: String, val y: String, val z: String
+)
+
+class C(
+        z: String, val v: Int, val x: Int =
+                42, val y: Int =
+                42
+)
+
+val foo1: (Int, Int) -> Int = fun(
+        x,
+        y,
+): Int = 42
+
+val foo2: (Int, Int) -> Int = fun(
+        x,
+        y
+): Int {
+    return x + y
+}
+
+val foo3: (Int, Int) -> Int = fun(
+        x, y,
+): Int {
+    return x + y
+}
+
+val foo4: (Int) -> Int = fun(
+        x,
+): Int = 42
+
+val foo5: (Int) -> Int = fun(
+        x
+): Int = 42
+
+val foo6: (Int) -> Int = fun(
+        x,
+): Int = 42
+
+val foo7: (Int) -> Int = fun(x): Int = 42
+
+val foo8: (Int, Int, Int) -> Int = fun(
+        x, y: Int, z,
+): Int {
+    return x + y
+}
+
+val foo9: (Int, Int, Int) -> Int = fun(
+        x,
+        y: Int,
+        z,
+): Int = 42
+
+val foo10: (Int, Int, Int) -> Int = fun(
+        x,
+        y: Int,
+        z: Int
+): Int = 43
+
+val foo10 = fun(
+        x: Int,
+        y: Int,
+        z: Int
+): Int = 43
+
+val foo11 = fun(
+        x: Int,
+        y: Int,
+        z: Int,
+): Int = 43
+
+val foo12 = fun(
+        x: Int, y: Int, z: Int,
+): Int = 43
+
+val foo13 = fun(
+        x: Int, y: Int, z: Int,
+): Int = 43
+
+val foo14 = fun(
+        x: Int, y: Int, z: Int,
+): Int = 43
+
+fun a1(
+        x: String,
+        y: String,
+) = Unit
+
+fun b1(
+        x: String,
+        y: String
+) = Unit
+
+fun c1(
+        x: String,
+        y: String,
+) = Unit
+
+fun d1(
+        x: String,
+        y: String,
+) = Unit
+
+fun a2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun b2(
+        x: String,
+        y: String,
+        z: String
+) = Unit
+
+fun c2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun d2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun a3(
+        x: String,
+) = Unit
+
+fun b3(
+        x: String
+) = Unit
+
+fun c3(
+        x: String,
+) = Unit
+
+fun d3(
+        x: String,
+) = Unit
+
+fun a4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun b4(
+        x: String,
+        y: String,
+        z: String
+) = Unit
+
+fun c4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun d4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun foo(
+        x: Int =
+                42
+) {
+}
+
+class C(
+        val x: Int =
+                42
+)
+
+class G(
+        val x: String, val y: String
+        = "", /* */ val z: String
+)
+
+class G(
+        val x: String, val y: String
+        = "" /* */, /* */ val z: String
+)
+
+class H(
+        val x: String, /*
+    */
+        val y: String,
+        val z: String,
+)
+
+class J(
+        val x: String, val y: String,
+        val z: String /*
+     */,
+)
+
+class K(
+        val x: String, val y: String,
+        val z: String,
+)
+
+class L(
+        val x: String, val y: String, val z: String
+)
+
+// SET_TRUE: ALLOW_TRAILING_COMMA
+// SET_INT: METHOD_PARAMETERS_WRAP = 0

idea/testData/formatter/trailingComma/valueParameters/ParameterListDoNotWrap.after.kt

@@ -0,0 +1,492 @@
+class A1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class B1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class C1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class D1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class A2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class B2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class C2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class D2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class A3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class B3 {
+    val x: String
+
+    constructor(x: String) {
+        this.x = x
+    }
+}
+
+class C3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class D3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class E1 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String, z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class E2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String, z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class A1(
+        val x: String,
+        y: String,
+)
+
+class B1(
+        val x: String,
+        val y: String,
+)
+
+class C1(
+        val x: String,
+        val y: String,
+)
+
+class D1(
+        val x: String,
+        val y: String,
+)
+
+class A2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class B2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class C2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class D2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class A3(
+        val x: String,
+)
+
+class B3(
+        val x: String,
+)
+
+class C3(
+        val x: String,
+)
+
+class D3(
+        val x: String,
+)
+
+class A4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class B4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class C4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class D4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class E1(
+        val x: String, val y: String,
+        val z: String,
+)
+
+class E2(
+        val x: String, val y: String, val z: String,
+)
+
+class C(
+        z: String, val v: Int,
+        val x: Int =
+                42,
+        val y: Int =
+                42,
+)
+
+val foo1: (Int, Int) -> Int = fun(
+        x,
+        y,
+): Int = 42
+
+val foo2: (Int, Int) -> Int = fun(
+        x,
+        y,
+): Int {
+    return x + y
+}
+
+val foo3: (Int, Int) -> Int = fun(
+        x, y,
+): Int {
+    return x + y
+}
+
+val foo4: (Int) -> Int = fun(
+        x,
+): Int = 42
+
+val foo5: (Int) -> Int = fun(
+        x,
+): Int = 42
+
+val foo6: (Int) -> Int = fun(
+        x,
+): Int = 42
+
+val foo7: (Int) -> Int = fun(x): Int = 42
+
+val foo8: (Int, Int, Int) -> Int = fun(
+        x, y: Int, z,
+): Int {
+    return x + y
+}
+
+val foo9: (Int, Int, Int) -> Int = fun(
+        x,
+        y: Int,
+        z,
+): Int = 42
+
+val foo10: (Int, Int, Int) -> Int = fun(
+        x,
+        y: Int,
+        z: Int,
+): Int = 43
+
+val foo10 = fun(
+        x: Int,
+        y: Int,
+        z: Int,
+): Int = 43
+
+val foo11 = fun(
+        x: Int,
+        y: Int,
+        z: Int,
+): Int = 43
+
+val foo12 = fun(
+        x: Int, y: Int, z: Int,
+): Int = 43
+
+val foo13 = fun(
+        x: Int, y: Int, z: Int,
+): Int = 43
+
+val foo14 = fun(
+        x: Int, y: Int, z: Int,
+): Int = 43
+
+fun a1(
+        x: String,
+        y: String,
+) = Unit
+
+fun b1(
+        x: String,
+        y: String,
+) = Unit
+
+fun c1(
+        x: String,
+        y: String,
+) = Unit
+
+fun d1(
+        x: String,
+        y: String,
+) = Unit
+
+fun a2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun b2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun c2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun d2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun a3(
+        x: String,
+) = Unit
+
+fun b3(
+        x: String,
+) = Unit
+
+fun c3(
+        x: String,
+) = Unit
+
+fun d3(
+        x: String,
+) = Unit
+
+fun a4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun b4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun c4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun d4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun foo(
+        x: Int =
+                42,
+) {
+}
+
+class C(
+        val x: Int =
+                42,
+)
+
+class G(
+        val x: String,
+        val y: String
+        = "", /* */
+        val z: String,
+)
+
+class G(
+        val x: String,
+        val y: String
+        = "" /* */, /* */
+        val z: String,
+)
+
+class H(
+        val x: String, /*
+    */
+        val y: String,
+        val z: String,
+)
+
+class J(
+        val x: String, val y: String,
+        val z: String /*
+     */,
+)
+
+class K(
+        val x: String, val y: String,
+        val z: String,
+)
+
+class L(
+        val x: String, val y: String, val z: String,
+)
+
+// SET_TRUE: ALLOW_TRAILING_COMMA
+// SET_INT: METHOD_PARAMETERS_WRAP = 0

idea/testData/formatter/trailingComma/valueParameters/ParameterListDoNotWrap.kt

@@ -0,0 +1,461 @@
+class A1 {
+    val x: String
+    val y: String
+
+    constructor(
+        x: String,
+        y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class B1 {
+    val x: String
+    val y: String
+
+    constructor(
+        x: String,
+        y: String
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class C1 {
+    val x: String
+    val y: String
+
+    constructor(
+        x: String,
+        y: String,) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class D1 {
+    val x: String
+    val y: String
+
+    constructor(
+        x: String,
+        y: String
+        ,) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class A2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String,
+        z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class B2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String,
+        z: String
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class C2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String,
+        z: String,) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class D2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String,
+        z: String
+        ,) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class A3 {
+    val x: String
+
+    constructor(x: String,) {
+        this.x = x
+    }
+}
+
+class B3 {
+    val x: String
+
+    constructor(x: String) {
+        this.x = x
+    }
+}
+
+class C3 {
+    val x: String
+
+    constructor(
+        x: String,) {
+        this.x = x
+    }
+}
+
+class D3 {
+    val x: String
+
+    constructor(
+        x: String
+        ,) {
+        this.x = x
+    }
+}
+
+class E1 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String, z: String,) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class E2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String, z: String) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+class A1(
+    val x: String,
+    y: String,
+)
+
+class B1(
+    val x: String,
+    val y: String
+)
+
+class C1(
+    val x: String,
+    val y: String,)
+
+class D1(
+    val x: String,
+    val y: String
+    ,)
+
+class A2(
+    val x: String,
+    val y: String,
+    val z: String,
+)
+
+class B2(
+    val x: String,
+    val y: String,
+    val z: String
+)
+
+class C2(
+    val x: String,
+    val y: String,
+    val z: String,)
+
+class D2(
+    val x: String,
+    val y: String,
+    val z: String
+    ,)
+
+class A3(
+    val x: String,
+)
+
+class B3(
+    val x: String
+)
+
+class C3(
+    val x: String,)
+
+class D3(
+    val x: String
+    ,)
+
+class A4(
+    val x: String   ,
+    val y: String,
+    val z: String   ,
+)
+
+class B4(
+    val x: String,
+    val y: String,
+    val z: String
+)
+
+class C4(
+    val x: String,
+    val y: String,
+    val z: String   ,)
+
+class D4(
+    val x: String,
+    val y: String,
+    val z: String
+    ,   )
+
+class E1(
+    val x: String, val y: String,
+    val z: String
+    ,   )
+
+class E2(
+    val x: String, val y: String, val z: String
+)
+
+class C(
+    z: String, val v: Int, val x: Int =
+        42, val y: Int =
+        42
+)
+
+val foo1: (Int, Int) -> Int = fun(
+    x,
+    y,
+): Int = 42
+
+val foo2: (Int, Int) -> Int = fun(
+    x,
+    y
+): Int {
+    return x + y
+}
+
+val foo3: (Int, Int) -> Int = fun(
+    x, y,
+): Int {
+    return x + y
+}
+
+val foo4: (Int) -> Int = fun(
+    x,
+): Int = 42
+
+val foo5: (Int) -> Int = fun(
+    x
+): Int = 42
+
+val foo6: (Int) -> Int = fun(x,): Int = 42
+
+val foo7: (Int) -> Int = fun(x): Int = 42
+
+val foo8: (Int, Int, Int) -> Int = fun (x, y: Int, z,): Int {
+    return x + y
+}
+
+val foo9: (Int, Int, Int) -> Int = fun (
+    x,
+    y: Int,
+    z,
+): Int = 42
+
+val foo10: (Int, Int, Int) -> Int = fun (
+    x,
+    y: Int,
+    z: Int
+): Int = 43
+
+val foo10 = fun (
+    x: Int,
+    y: Int,
+    z: Int
+): Int = 43
+
+val foo11 = fun (
+    x: Int,
+    y: Int,
+    z: Int,
+): Int = 43
+
+val foo12 = fun (
+    x: Int, y: Int, z: Int,
+): Int = 43
+
+val foo13 = fun (x: Int, y: Int, z: Int,
+): Int = 43
+
+val foo14 = fun (x: Int, y: Int, z: Int
+                 ,): Int = 43
+
+fun a1(
+    x: String,
+    y: String,
+) = Unit
+
+fun b1(
+    x: String,
+    y: String
+) = Unit
+
+fun c1(
+    x: String,
+    y: String,) = Unit
+
+fun d1(
+    x: String,
+    y: String
+    ,) = Unit
+
+fun a2(
+    x: String,
+    y: String,
+    z: String,
+) = Unit
+
+fun b2(
+    x: String,
+    y: String,
+    z: String
+) = Unit
+
+fun c2(
+    x: String,
+    y: String,
+    z: String,) = Unit
+
+fun d2(
+    x: String,
+    y: String,
+    z: String
+    ,) = Unit
+
+fun a3(
+    x: String,
+) = Unit
+
+fun b3(
+    x: String
+) = Unit
+
+fun c3(
+    x: String,) = Unit
+
+fun d3(
+    x: String
+    ,) = Unit
+
+fun a4(
+    x: String
+    ,
+    y: String,
+    z: String   ,
+) = Unit
+
+fun b4(
+    x: String,
+    y: String,
+    z: String
+) = Unit
+
+fun c4(x: String,
+       y: String,
+       z: String   ,) = Unit
+
+fun d4(
+    x: String,
+    y: String,
+    z: String
+    ,   ) = Unit
+
+fun foo(
+    x: Int =
+        42
+) {
+}
+
+class C(
+    val x: Int =
+        42
+)
+
+class G(
+    val x: String, val y: String
+    = "", /* */ val z: String
+)
+
+class G(
+    val x: String, val y: String
+    = "" /* */, /* */ val z: String
+)
+
+class H(
+    val x: String, /*
+    */ val y: String,
+    val z: String   ,)
+
+class J(
+    val x: String, val y: String , val z: String /*
+     */
+    ,   )
+
+class K(
+    val x: String, val y: String,
+    val z: String
+    ,   )
+
+class L(
+    val x: String, val y: String, val z: String
+)
+
+// SET_TRUE: ALLOW_TRAILING_COMMA
+// SET_INT: METHOD_PARAMETERS_WRAP = 0

idea/testData/formatter/trailingComma/valueParameters/ParameterListWrapAlways.after.inv.kt

@@ -0,0 +1,510 @@
+class A1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class B1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class C1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class D1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class A2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class B2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class C2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class D2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class A3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class B3 {
+    val x: String
+
+    constructor(x: String) {
+        this.x = x
+    }
+}
+
+class C3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class D3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class E1 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class E2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class A1(
+        val x: String,
+        y: String,
+)
+
+class B1(
+        val x: String,
+        val y: String
+)
+
+class C1(
+        val x: String,
+        val y: String,
+)
+
+class D1(
+        val x: String,
+        val y: String,
+)
+
+class A2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class B2(
+        val x: String,
+        val y: String,
+        val z: String
+)
+
+class C2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class D2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class A3(
+        val x: String,
+)
+
+class B3(
+        val x: String
+)
+
+class C3(
+        val x: String,
+)
+
+class D3(
+        val x: String,
+)
+
+class A4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class B4(
+        val x: String,
+        val y: String,
+        val z: String
+)
+
+class C4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class D4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class E1(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class E2(
+        val x: String,
+        val y: String,
+        val z: String
+)
+
+class C(
+        z: String,
+        val v: Int,
+        val x: Int =
+                42,
+        val y: Int =
+                42
+)
+
+val foo1: (Int, Int) -> Int = fun(
+        x,
+        y,
+): Int = 42
+
+val foo2: (Int, Int) -> Int = fun(
+        x,
+        y
+): Int {
+    return x + y
+}
+
+val foo3: (Int, Int) -> Int = fun(
+        x,
+        y,
+): Int {
+    return x + y
+}
+
+val foo4: (Int) -> Int = fun(
+        x,
+): Int = 42
+
+val foo5: (Int) -> Int = fun(
+        x
+): Int = 42
+
+val foo6: (Int) -> Int = fun(
+        x,
+): Int = 42
+
+val foo7: (Int) -> Int = fun(x): Int = 42
+
+val foo8: (Int, Int, Int) -> Int = fun(
+        x,
+        y: Int,
+        z,
+): Int {
+    return x + y
+}
+
+val foo9: (Int, Int, Int) -> Int = fun(
+        x,
+        y: Int,
+        z,
+): Int = 42
+
+val foo10: (Int, Int, Int) -> Int = fun(
+        x,
+        y: Int,
+        z: Int
+): Int = 43
+
+val foo10 = fun(
+        x: Int,
+        y: Int,
+        z: Int
+): Int = 43
+
+val foo11 = fun(
+        x: Int,
+        y: Int,
+        z: Int,
+): Int = 43
+
+val foo12 = fun(
+        x: Int,
+        y: Int,
+        z: Int,
+): Int = 43
+
+val foo13 = fun(
+        x: Int,
+        y: Int,
+        z: Int,
+): Int = 43
+
+val foo14 = fun(
+        x: Int,
+        y: Int,
+        z: Int,
+): Int = 43
+
+fun a1(
+        x: String,
+        y: String,
+) = Unit
+
+fun b1(
+        x: String,
+        y: String
+) = Unit
+
+fun c1(
+        x: String,
+        y: String,
+) = Unit
+
+fun d1(
+        x: String,
+        y: String,
+) = Unit
+
+fun a2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun b2(
+        x: String,
+        y: String,
+        z: String
+) = Unit
+
+fun c2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun d2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun a3(
+        x: String,
+) = Unit
+
+fun b3(
+        x: String
+) = Unit
+
+fun c3(
+        x: String,
+) = Unit
+
+fun d3(
+        x: String,
+) = Unit
+
+fun a4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun b4(
+        x: String,
+        y: String,
+        z: String
+) = Unit
+
+fun c4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun d4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun foo(
+        x: Int =
+                42
+) {
+}
+
+class C(
+        val x: Int =
+                42
+)
+
+class G(
+        val x: String,
+        val y: String
+        = "", /* */
+        val z: String
+)
+
+class G(
+        val x: String,
+        val y: String
+        = "" /* */, /* */
+        val z: String
+)
+
+class H(
+        val x: String, /*
+    */
+        val y: String,
+        val z: String,
+)
+
+class J(
+        val x: String,
+        val y: String,
+        val z: String /*
+     */,
+)
+
+class K(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class L(
+        val x: String,
+        val y: String,
+        val z: String
+)
+
+// SET_TRUE: ALLOW_TRAILING_COMMA
+// SET_INT: METHOD_PARAMETERS_WRAP = 2

idea/testData/formatter/trailingComma/valueParameters/ParameterListWrapAlways.after.kt

@@ -0,0 +1,511 @@
+class A1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class B1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class C1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class D1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class A2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class B2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class C2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class D2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class A3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class B3 {
+    val x: String
+
+    constructor(x: String) {
+        this.x = x
+    }
+}
+
+class C3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class D3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class E1 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class E2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class A1(
+        val x: String,
+        y: String,
+)
+
+class B1(
+        val x: String,
+        val y: String,
+)
+
+class C1(
+        val x: String,
+        val y: String,
+)
+
+class D1(
+        val x: String,
+        val y: String,
+)
+
+class A2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class B2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class C2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class D2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class A3(
+        val x: String,
+)
+
+class B3(
+        val x: String,
+)
+
+class C3(
+        val x: String,
+)
+
+class D3(
+        val x: String,
+)
+
+class A4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class B4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class C4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class D4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class E1(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class E2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class C(
+        z: String,
+        val v: Int,
+        val x: Int =
+                42,
+        val y: Int =
+                42,
+)
+
+val foo1: (Int, Int) -> Int = fun(
+        x,
+        y,
+): Int = 42
+
+val foo2: (Int, Int) -> Int = fun(
+        x,
+        y,
+): Int {
+    return x + y
+}
+
+val foo3: (Int, Int) -> Int = fun(
+        x,
+        y,
+): Int {
+    return x + y
+}
+
+val foo4: (Int) -> Int = fun(
+        x,
+): Int = 42
+
+val foo5: (Int) -> Int = fun(
+        x,
+): Int = 42
+
+val foo6: (Int) -> Int = fun(
+        x,
+): Int = 42
+
+val foo7: (Int) -> Int = fun(x): Int = 42
+
+val foo8: (Int, Int, Int) -> Int = fun(
+        x,
+        y: Int,
+        z,
+): Int {
+    return x + y
+}
+
+val foo9: (Int, Int, Int) -> Int = fun(
+        x,
+        y: Int,
+        z,
+): Int = 42
+
+val foo10: (Int, Int, Int) -> Int = fun(
+        x,
+        y: Int,
+        z: Int,
+): Int = 43
+
+val foo10 = fun(
+        x: Int,
+        y: Int,
+        z: Int,
+): Int = 43
+
+val foo11 = fun(
+        x: Int,
+        y: Int,
+        z: Int,
+): Int = 43
+
+val foo12 = fun(
+        x: Int,
+        y: Int,
+        z: Int,
+): Int = 43
+
+val foo13 = fun(
+        x: Int,
+        y: Int,
+        z: Int,
+): Int = 43
+
+val foo14 = fun(
+        x: Int,
+        y: Int,
+        z: Int,
+): Int = 43
+
+fun a1(
+        x: String,
+        y: String,
+) = Unit
+
+fun b1(
+        x: String,
+        y: String,
+) = Unit
+
+fun c1(
+        x: String,
+        y: String,
+) = Unit
+
+fun d1(
+        x: String,
+        y: String,
+) = Unit
+
+fun a2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun b2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun c2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun d2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun a3(
+        x: String,
+) = Unit
+
+fun b3(
+        x: String,
+) = Unit
+
+fun c3(
+        x: String,
+) = Unit
+
+fun d3(
+        x: String,
+) = Unit
+
+fun a4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun b4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun c4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun d4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun foo(
+        x: Int =
+                42,
+) {
+}
+
+class C(
+        val x: Int =
+                42,
+)
+
+class G(
+        val x: String,
+        val y: String
+        = "", /* */
+        val z: String,
+)
+
+class G(
+        val x: String,
+        val y: String
+        = "" /* */, /* */
+        val z: String,
+)
+
+class H(
+        val x: String, /*
+    */
+        val y: String,
+        val z: String,
+)
+
+class J(
+        val x: String,
+        val y: String,
+        val z: String /*
+     */,
+)
+
+class K(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class L(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+// SET_TRUE: ALLOW_TRAILING_COMMA
+// SET_INT: METHOD_PARAMETERS_WRAP = 2

idea/testData/formatter/trailingComma/valueParameters/ParameterListWrapAlways.kt

@@ -0,0 +1,461 @@
+class A1 {
+    val x: String
+    val y: String
+
+    constructor(
+        x: String,
+        y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class B1 {
+    val x: String
+    val y: String
+
+    constructor(
+        x: String,
+        y: String
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class C1 {
+    val x: String
+    val y: String
+
+    constructor(
+        x: String,
+        y: String,) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class D1 {
+    val x: String
+    val y: String
+
+    constructor(
+        x: String,
+        y: String
+        ,) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class A2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String,
+        z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class B2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String,
+        z: String
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class C2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String,
+        z: String,) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class D2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String,
+        z: String
+        ,) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class A3 {
+    val x: String
+
+    constructor(x: String,) {
+        this.x = x
+    }
+}
+
+class B3 {
+    val x: String
+
+    constructor(x: String) {
+        this.x = x
+    }
+}
+
+class C3 {
+    val x: String
+
+    constructor(
+        x: String,) {
+        this.x = x
+    }
+}
+
+class D3 {
+    val x: String
+
+    constructor(
+        x: String
+        ,) {
+        this.x = x
+    }
+}
+
+class E1 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String, z: String,) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class E2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String, z: String) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+class A1(
+    val x: String,
+    y: String,
+)
+
+class B1(
+    val x: String,
+    val y: String
+)
+
+class C1(
+    val x: String,
+    val y: String,)
+
+class D1(
+    val x: String,
+    val y: String
+    ,)
+
+class A2(
+    val x: String,
+    val y: String,
+    val z: String,
+)
+
+class B2(
+    val x: String,
+    val y: String,
+    val z: String
+)
+
+class C2(
+    val x: String,
+    val y: String,
+    val z: String,)
+
+class D2(
+    val x: String,
+    val y: String,
+    val z: String
+    ,)
+
+class A3(
+    val x: String,
+)
+
+class B3(
+    val x: String
+)
+
+class C3(
+    val x: String,)
+
+class D3(
+    val x: String
+    ,)
+
+class A4(
+    val x: String   ,
+    val y: String,
+    val z: String   ,
+)
+
+class B4(
+    val x: String,
+    val y: String,
+    val z: String
+)
+
+class C4(
+    val x: String,
+    val y: String,
+    val z: String   ,)
+
+class D4(
+    val x: String,
+    val y: String,
+    val z: String
+    ,   )
+
+class E1(
+    val x: String, val y: String,
+    val z: String
+    ,   )
+
+class E2(
+    val x: String, val y: String, val z: String
+)
+
+class C(
+    z: String, val v: Int, val x: Int =
+        42, val y: Int =
+        42
+)
+
+val foo1: (Int, Int) -> Int = fun(
+    x,
+    y,
+): Int = 42
+
+val foo2: (Int, Int) -> Int = fun(
+    x,
+    y
+): Int {
+    return x + y
+}
+
+val foo3: (Int, Int) -> Int = fun(
+    x, y,
+): Int {
+    return x + y
+}
+
+val foo4: (Int) -> Int = fun(
+    x,
+): Int = 42
+
+val foo5: (Int) -> Int = fun(
+    x
+): Int = 42
+
+val foo6: (Int) -> Int = fun(x,): Int = 42
+
+val foo7: (Int) -> Int = fun(x): Int = 42
+
+val foo8: (Int, Int, Int) -> Int = fun (x, y: Int, z,): Int {
+    return x + y
+}
+
+val foo9: (Int, Int, Int) -> Int = fun (
+    x,
+    y: Int,
+    z,
+): Int = 42
+
+val foo10: (Int, Int, Int) -> Int = fun (
+    x,
+    y: Int,
+    z: Int
+): Int = 43
+
+val foo10 = fun (
+    x: Int,
+    y: Int,
+    z: Int
+): Int = 43
+
+val foo11 = fun (
+    x: Int,
+    y: Int,
+    z: Int,
+): Int = 43
+
+val foo12 = fun (
+    x: Int, y: Int, z: Int,
+): Int = 43
+
+val foo13 = fun (x: Int, y: Int, z: Int,
+): Int = 43
+
+val foo14 = fun (x: Int, y: Int, z: Int
+                 ,): Int = 43
+
+fun a1(
+    x: String,
+    y: String,
+) = Unit
+
+fun b1(
+    x: String,
+    y: String
+) = Unit
+
+fun c1(
+    x: String,
+    y: String,) = Unit
+
+fun d1(
+    x: String,
+    y: String
+    ,) = Unit
+
+fun a2(
+    x: String,
+    y: String,
+    z: String,
+) = Unit
+
+fun b2(
+    x: String,
+    y: String,
+    z: String
+) = Unit
+
+fun c2(
+    x: String,
+    y: String,
+    z: String,) = Unit
+
+fun d2(
+    x: String,
+    y: String,
+    z: String
+    ,) = Unit
+
+fun a3(
+    x: String,
+) = Unit
+
+fun b3(
+    x: String
+) = Unit
+
+fun c3(
+    x: String,) = Unit
+
+fun d3(
+    x: String
+    ,) = Unit
+
+fun a4(
+    x: String
+    ,
+    y: String,
+    z: String   ,
+) = Unit
+
+fun b4(
+    x: String,
+    y: String,
+    z: String
+) = Unit
+
+fun c4(x: String,
+       y: String,
+       z: String   ,) = Unit
+
+fun d4(
+    x: String,
+    y: String,
+    z: String
+    ,   ) = Unit
+
+fun foo(
+    x: Int =
+        42
+) {
+}
+
+class C(
+    val x: Int =
+        42
+)
+
+class G(
+    val x: String, val y: String
+    = "", /* */ val z: String
+)
+
+class G(
+    val x: String, val y: String
+    = "" /* */, /* */ val z: String
+)
+
+class H(
+    val x: String, /*
+    */ val y: String,
+    val z: String   ,)
+
+class J(
+    val x: String, val y: String , val z: String /*
+     */
+    ,   )
+
+class K(
+    val x: String, val y: String,
+    val z: String
+    ,   )
+
+class L(
+    val x: String, val y: String, val z: String
+)
+
+// SET_TRUE: ALLOW_TRAILING_COMMA
+// SET_INT: METHOD_PARAMETERS_WRAP = 2

idea/testData/formatter/trailingComma/valueParameters/ParameterListWrapAsNeeded.after.inv.kt

@@ -0,0 +1,485 @@
+class A1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class B1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class C1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class D1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class A2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class B2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class C2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class D2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class A3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class B3 {
+    val x: String
+
+    constructor(x: String) {
+        this.x = x
+    }
+}
+
+class C3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class D3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class E1 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String, z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class E2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String, z: String) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class A1(
+        val x: String,
+        y: String,
+)
+
+class B1(
+        val x: String,
+        val y: String
+)
+
+class C1(
+        val x: String,
+        val y: String,
+)
+
+class D1(
+        val x: String,
+        val y: String,
+)
+
+class A2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class B2(
+        val x: String,
+        val y: String,
+        val z: String
+)
+
+class C2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class D2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class A3(
+        val x: String,
+)
+
+class B3(
+        val x: String
+)
+
+class C3(
+        val x: String,
+)
+
+class D3(
+        val x: String,
+)
+
+class A4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class B4(
+        val x: String,
+        val y: String,
+        val z: String
+)
+
+class C4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class D4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class E1(
+        val x: String, val y: String,
+        val z: String,
+)
+
+class E2(
+        val x: String, val y: String, val z: String
+)
+
+class C(
+        z: String, val v: Int, val x: Int =
+                42, val y: Int =
+                42
+)
+
+val foo1: (Int, Int) -> Int = fun(
+        x,
+        y,
+): Int = 42
+
+val foo2: (Int, Int) -> Int = fun(
+        x,
+        y
+): Int {
+    return x + y
+}
+
+val foo3: (Int, Int) -> Int = fun(
+        x, y,
+): Int {
+    return x + y
+}
+
+val foo4: (Int) -> Int = fun(
+        x,
+): Int = 42
+
+val foo5: (Int) -> Int = fun(
+        x
+): Int = 42
+
+val foo6: (Int) -> Int = fun(
+        x,
+): Int = 42
+
+val foo7: (Int) -> Int = fun(x): Int = 42
+
+val foo8: (Int, Int, Int) -> Int = fun(
+        x, y: Int, z,
+): Int {
+    return x + y
+}
+
+val foo9: (Int, Int, Int) -> Int = fun(
+        x,
+        y: Int,
+        z,
+): Int = 42
+
+val foo10: (Int, Int, Int) -> Int = fun(
+        x,
+        y: Int,
+        z: Int
+): Int = 43
+
+val foo10 = fun(
+        x: Int,
+        y: Int,
+        z: Int
+): Int = 43
+
+val foo11 = fun(
+        x: Int,
+        y: Int,
+        z: Int,
+): Int = 43
+
+val foo12 = fun(
+        x: Int, y: Int, z: Int,
+): Int = 43
+
+val foo13 = fun(
+        x: Int, y: Int, z: Int,
+): Int = 43
+
+val foo14 = fun(
+        x: Int, y: Int, z: Int,
+): Int = 43
+
+fun a1(
+        x: String,
+        y: String,
+) = Unit
+
+fun b1(
+        x: String,
+        y: String
+) = Unit
+
+fun c1(
+        x: String,
+        y: String,
+) = Unit
+
+fun d1(
+        x: String,
+        y: String,
+) = Unit
+
+fun a2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun b2(
+        x: String,
+        y: String,
+        z: String
+) = Unit
+
+fun c2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun d2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun a3(
+        x: String,
+) = Unit
+
+fun b3(
+        x: String
+) = Unit
+
+fun c3(
+        x: String,
+) = Unit
+
+fun d3(
+        x: String,
+) = Unit
+
+fun a4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun b4(
+        x: String,
+        y: String,
+        z: String
+) = Unit
+
+fun c4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun d4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun foo(
+        x: Int =
+                42
+) {
+}
+
+class C(
+        val x: Int =
+                42
+)
+
+class G(
+        val x: String, val y: String
+        = "", /* */ val z: String
+)
+
+class G(
+        val x: String, val y: String
+        = "" /* */, /* */ val z: String
+)
+
+class H(
+        val x: String, /*
+    */
+        val y: String,
+        val z: String,
+)
+
+class J(
+        val x: String, val y: String,
+        val z: String /*
+     */,
+)
+
+class K(
+        val x: String, val y: String,
+        val z: String,
+)
+
+class L(
+        val x: String, val y: String, val z: String
+)
+
+// SET_TRUE: ALLOW_TRAILING_COMMA
+// SET_INT: METHOD_PARAMETERS_WRAP = 1

idea/testData/formatter/trailingComma/valueParameters/ParameterListWrapAsNeeded.after.kt

@@ -0,0 +1,492 @@
+class A1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class B1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class C1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class D1 {
+    val x: String
+    val y: String
+
+    constructor(
+            x: String,
+            y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class A2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class B2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class C2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class D2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String,
+            z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class A3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class B3 {
+    val x: String
+
+    constructor(x: String) {
+        this.x = x
+    }
+}
+
+class C3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class D3 {
+    val x: String
+
+    constructor(
+            x: String,
+    ) {
+        this.x = x
+    }
+}
+
+class E1 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String, z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class E2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+            x: String,
+            y: String, z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class A1(
+        val x: String,
+        y: String,
+)
+
+class B1(
+        val x: String,
+        val y: String,
+)
+
+class C1(
+        val x: String,
+        val y: String,
+)
+
+class D1(
+        val x: String,
+        val y: String,
+)
+
+class A2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class B2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class C2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class D2(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class A3(
+        val x: String,
+)
+
+class B3(
+        val x: String,
+)
+
+class C3(
+        val x: String,
+)
+
+class D3(
+        val x: String,
+)
+
+class A4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class B4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class C4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class D4(
+        val x: String,
+        val y: String,
+        val z: String,
+)
+
+class E1(
+        val x: String, val y: String,
+        val z: String,
+)
+
+class E2(
+        val x: String, val y: String, val z: String,
+)
+
+class C(
+        z: String, val v: Int,
+        val x: Int =
+                42,
+        val y: Int =
+                42,
+)
+
+val foo1: (Int, Int) -> Int = fun(
+        x,
+        y,
+): Int = 42
+
+val foo2: (Int, Int) -> Int = fun(
+        x,
+        y,
+): Int {
+    return x + y
+}
+
+val foo3: (Int, Int) -> Int = fun(
+        x, y,
+): Int {
+    return x + y
+}
+
+val foo4: (Int) -> Int = fun(
+        x,
+): Int = 42
+
+val foo5: (Int) -> Int = fun(
+        x,
+): Int = 42
+
+val foo6: (Int) -> Int = fun(
+        x,
+): Int = 42
+
+val foo7: (Int) -> Int = fun(x): Int = 42
+
+val foo8: (Int, Int, Int) -> Int = fun(
+        x, y: Int, z,
+): Int {
+    return x + y
+}
+
+val foo9: (Int, Int, Int) -> Int = fun(
+        x,
+        y: Int,
+        z,
+): Int = 42
+
+val foo10: (Int, Int, Int) -> Int = fun(
+        x,
+        y: Int,
+        z: Int,
+): Int = 43
+
+val foo10 = fun(
+        x: Int,
+        y: Int,
+        z: Int,
+): Int = 43
+
+val foo11 = fun(
+        x: Int,
+        y: Int,
+        z: Int,
+): Int = 43
+
+val foo12 = fun(
+        x: Int, y: Int, z: Int,
+): Int = 43
+
+val foo13 = fun(
+        x: Int, y: Int, z: Int,
+): Int = 43
+
+val foo14 = fun(
+        x: Int, y: Int, z: Int,
+): Int = 43
+
+fun a1(
+        x: String,
+        y: String,
+) = Unit
+
+fun b1(
+        x: String,
+        y: String,
+) = Unit
+
+fun c1(
+        x: String,
+        y: String,
+) = Unit
+
+fun d1(
+        x: String,
+        y: String,
+) = Unit
+
+fun a2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun b2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun c2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun d2(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun a3(
+        x: String,
+) = Unit
+
+fun b3(
+        x: String,
+) = Unit
+
+fun c3(
+        x: String,
+) = Unit
+
+fun d3(
+        x: String,
+) = Unit
+
+fun a4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun b4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun c4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun d4(
+        x: String,
+        y: String,
+        z: String,
+) = Unit
+
+fun foo(
+        x: Int =
+                42,
+) {
+}
+
+class C(
+        val x: Int =
+                42,
+)
+
+class G(
+        val x: String,
+        val y: String
+        = "", /* */
+        val z: String,
+)
+
+class G(
+        val x: String,
+        val y: String
+        = "" /* */, /* */
+        val z: String,
+)
+
+class H(
+        val x: String, /*
+    */
+        val y: String,
+        val z: String,
+)
+
+class J(
+        val x: String, val y: String,
+        val z: String /*
+     */,
+)
+
+class K(
+        val x: String, val y: String,
+        val z: String,
+)
+
+class L(
+        val x: String, val y: String, val z: String,
+)
+
+// SET_TRUE: ALLOW_TRAILING_COMMA
+// SET_INT: METHOD_PARAMETERS_WRAP = 1

idea/testData/formatter/trailingComma/valueParameters/ParameterListWrapAsNeeded.kt

@@ -0,0 +1,461 @@
+class A1 {
+    val x: String
+    val y: String
+
+    constructor(
+        x: String,
+        y: String,
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class B1 {
+    val x: String
+    val y: String
+
+    constructor(
+        x: String,
+        y: String
+    ) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class C1 {
+    val x: String
+    val y: String
+
+    constructor(
+        x: String,
+        y: String,) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class D1 {
+    val x: String
+    val y: String
+
+    constructor(
+        x: String,
+        y: String
+        ,) {
+        this.x = x
+        this.y = y
+    }
+}
+
+class A2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String,
+        z: String,
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class B2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String,
+        z: String
+    ) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class C2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String,
+        z: String,) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class D2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String,
+        z: String
+        ,) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class A3 {
+    val x: String
+
+    constructor(x: String,) {
+        this.x = x
+    }
+}
+
+class B3 {
+    val x: String
+
+    constructor(x: String) {
+        this.x = x
+    }
+}
+
+class C3 {
+    val x: String
+
+    constructor(
+        x: String,) {
+        this.x = x
+    }
+}
+
+class D3 {
+    val x: String
+
+    constructor(
+        x: String
+        ,) {
+        this.x = x
+    }
+}
+
+class E1 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String, z: String,) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+
+class E2 {
+    val x: String
+    val y: String
+    val z: String
+
+    constructor(
+        x: String,
+        y: String, z: String) {
+        this.x = x
+        this.y = y
+        this.z = z
+    }
+}
+class A1(
+    val x: String,
+    y: String,
+)
+
+class B1(
+    val x: String,
+    val y: String
+)
+
+class C1(
+    val x: String,
+    val y: String,)
+
+class D1(
+    val x: String,
+    val y: String
+    ,)
+
+class A2(
+    val x: String,
+    val y: String,
+    val z: String,
+)
+
+class B2(
+    val x: String,
+    val y: String,
+    val z: String
+)
+
+class C2(
+    val x: String,
+    val y: String,
+    val z: String,)
+
+class D2(
+    val x: String,
+    val y: String,
+    val z: String
+    ,)
+
+class A3(
+    val x: String,
+)
+
+class B3(
+    val x: String
+)
+
+class C3(
+    val x: String,)
+
+class D3(
+    val x: String
+    ,)
+
+class A4(
+    val x: String   ,
+    val y: String,
+    val z: String   ,
+)
+
+class B4(
+    val x: String,
+    val y: String,
+    val z: String
+)
+
+class C4(
+    val x: String,
+    val y: String,
+    val z: String   ,)
+
+class D4(
+    val x: String,
+    val y: String,
+    val z: String
+    ,   )
+
+class E1(
+    val x: String, val y: String,
+    val z: String
+    ,   )
+
+class E2(
+    val x: String, val y: String, val z: String
+)
+
+class C(
+    z: String, val v: Int, val x: Int =
+        42, val y: Int =
+        42
+)
+
+val foo1: (Int, Int) -> Int = fun(
+    x,
+    y,
+): Int = 42
+
+val foo2: (Int, Int) -> Int = fun(
+    x,
+    y
+): Int {
+    return x + y
+}
+
+val foo3: (Int, Int) -> Int = fun(
+    x, y,
+): Int {
+    return x + y
+}
+
+val foo4: (Int) -> Int = fun(
+    x,
+): Int = 42
+
+val foo5: (Int) -> Int = fun(
+    x
+): Int = 42
+
+val foo6: (Int) -> Int = fun(x,): Int = 42
+
+val foo7: (Int) -> Int = fun(x): Int = 42
+
+val foo8: (Int, Int, Int) -> Int = fun (x, y: Int, z,): Int {
+    return x + y
+}
+
+val foo9: (Int, Int, Int) -> Int = fun (
+    x,
+    y: Int,
+    z,
+): Int = 42
+
+val foo10: (Int, Int, Int) -> Int = fun (
+    x,
+    y: Int,
+    z: Int
+): Int = 43
+
+val foo10 = fun (
+    x: Int,
+    y: Int,
+    z: Int
+): Int = 43
+
+val foo11 = fun (
+    x: Int,
+    y: Int,
+    z: Int,
+): Int = 43
+
+val foo12 = fun (
+    x: Int, y: Int, z: Int,
+): Int = 43
+
+val foo13 = fun (x: Int, y: Int, z: Int,
+): Int = 43
+
+val foo14 = fun (x: Int, y: Int, z: Int
+                 ,): Int = 43
+
+fun a1(
+    x: String,
+    y: String,
+) = Unit
+
+fun b1(
+    x: String,
+    y: String
+) = Unit
+
+fun c1(
+    x: String,
+    y: String,) = Unit
+
+fun d1(
+    x: String,
+    y: String
+    ,) = Unit
+
+fun a2(
+    x: String,
+    y: String,
+    z: String,
+) = Unit
+
+fun b2(
+    x: String,
+    y: String,
+    z: String
+) = Unit
+
+fun c2(
+    x: String,
+    y: String,
+    z: String,) = Unit
+
+fun d2(
+    x: String,
+    y: String,
+    z: String
+    ,) = Unit
+
+fun a3(
+    x: String,
+) = Unit
+
+fun b3(
+    x: String
+) = Unit
+
+fun c3(
+    x: String,) = Unit
+
+fun d3(
+    x: String
+    ,) = Unit
+
+fun a4(
+    x: String
+    ,
+    y: String,
+    z: String   ,
+) = Unit
+
+fun b4(
+    x: String,
+    y: String,
+    z: String
+) = Unit
+
+fun c4(x: String,
+       y: String,
+       z: String   ,) = Unit
+
+fun d4(
+    x: String,
+    y: String,
+    z: String
+    ,   ) = Unit
+
+fun foo(
+    x: Int =
+        42
+) {
+}
+
+class C(
+    val x: Int =
+        42
+)
+
+class G(
+    val x: String, val y: String
+    = "", /* */ val z: String
+)
+
+class G(
+    val x: String, val y: String
+    = "" /* */, /* */ val z: String
+)
+
+class H(
+    val x: String, /*
+    */ val y: String,
+    val z: String   ,)
+
+class J(
+    val x: String, val y: String , val z: String /*
+     */
+    ,   )
+
+class K(
+    val x: String, val y: String,
+    val z: String
+    ,   )
+
+class L(
+    val x: String, val y: String, val z: String
+)
+
+// SET_TRUE: ALLOW_TRAILING_COMMA
+// SET_INT: METHOD_PARAMETERS_WRAP = 1

idea/testData/formatter/trailingComma/valueParameters/PrimaryConstructor.after.inv.kt

@@ -1,94 +0,0 @@
-class A1(
-        val x: String,
-        y: String,
-)
-
-class B1(
-        val x: String,
-        val y: String
-)
-
-class C1(
-        val x: String,
-        val y: String,
-)
-
-class D1(
-        val x: String,
-        val y: String,
-)
-
-class A2(
-        val x: String,
-        val y: String,
-        val z: String,
-)
-
-class B2(
-        val x: String,
-        val y: String,
-        val z: String
-)
-
-class C2(
-        val x: String,
-        val y: String,
-        val z: String,
-)
-
-class D2(
-        val x: String,
-        val y: String,
-        val z: String,
-)
-
-class A3(
-        val x: String,
-)
-
-class B3(
-        val x: String
-)
-
-class C3(
-        val x: String,
-)
-
-class D3(
-        val x: String,
-)
-
-class A4(
-        val x: String,
-        val y: String,
-        val z: String,
-)
-
-class B4(
-        val x: String,
-        val y: String,
-        val z: String
-)
-
-class C4(
-        val x: String,
-        val y: String,
-        val z: String,
-)
-
-class D4(
-        val x: String,
-        val y: String,
-        val z: String,
-)
-
-class E1(
-        val x: String, val y: String,
-        val z: String,
-)
-
-class E2(
-        val x: String, val y: String, val z: String
-)
-
-// SET_TRUE: ALLOW_TRAILING_COMMA

idea/testData/formatter/trailingComma/valueParameters/PrimaryConstructor.after.kt

@@ -1,94 +0,0 @@
-class A1(
-        val x: String,
-        y: String,
-)
-
-class B1(
-        val x: String,
-        val y: String,
-)
-
-class C1(
-        val x: String,
-        val y: String,
-)
-
-class D1(
-        val x: String,
-        val y: String,
-)
-
-class A2(
-        val x: String,
-        val y: String,
-        val z: String,
-)
-
-class B2(
-        val x: String,
-        val y: String,
-        val z: String,
-)
-
-class C2(
-        val x: String,
-        val y: String,
-        val z: String,
-)
-
-class D2(
-        val x: String,
-        val y: String,
-        val z: String,
-)
-
-class A3(
-        val x: String,
-)
-
-class B3(
-        val x: String,
-)
-
-class C3(
-        val x: String,
-)
-
-class D3(
-        val x: String,
-)
-
-class A4(
-        val x: String,
-        val y: String,
-        val z: String,
-)
-
-class B4(
-        val x: String,
-        val y: String,
-        val z: String,
-)
-
-class C4(
-        val x: String,
-        val y: String,
-        val z: String,
-)
-
-class D4(
-        val x: String,
-        val y: String,
-        val z: String,
-)
-
-class E1(
-        val x: String, val y: String,
-        val z: String,
-)
-
-class E2(
-        val x: String, val y: String, val z: String,
-)
-
-// SET_TRUE: ALLOW_TRAILING_COMMA

idea/testData/formatter/trailingComma/valueParameters/PrimaryConstructor.kt

@@ -1,90 +0,0 @@
-class A1(
-    val x: String,
-    y: String,
-)
-
-class B1(
-    val x: String,
-    val y: String
-)
-
-class C1(
-    val x: String,
-    val y: String,)
-
-class D1(
-    val x: String,
-    val y: String
-    ,)
-
-class A2(
-    val x: String,
-    val y: String,
-    val z: String,
-)
-
-class B2(
-    val x: String,
-    val y: String,
-    val z: String
-)
-
-class C2(
-    val x: String,
-    val y: String,
-    val z: String,)
-
-class D2(
-    val x: String,
-    val y: String,
-    val z: String
-    ,)
-
-class A3(
-    val x: String,
-)
-
-class B3(
-    val x: String
-)
-
-class C3(
-    val x: String,)
-
-class D3(
-    val x: String
-    ,)
-
-class A4(
-    val x: String   ,
-    val y: String,
-    val z: String   ,
-)
-
-class B4(
-    val x: String,
-    val y: String,
-    val z: String
-)
-
-class C4(
-    val x: String,
-    val y: String,
-    val z: String   ,)
-
-class D4(
-    val x: String,
-    val y: String,
-    val z: String
-,   )
-
-class E1(
-    val x: String, val y: String,
-    val z: String
-,   )
-
-class E2(
-    val x: String, val y: String, val z: String
-)
-
-// SET_TRUE: ALLOW_TRAILING_COMMA

idea/testData/formatter/trailingComma/valueParameters/SecondConstructor.after.inv.kt

@@ -1,184 +0,0 @@
-class A1 {
-    val x: String
-    val y: String
-
-    constructor(
-            x: String,
-            y: String,
-    ) {
-        this.x = x
-        this.y = y
-    }
-}
-
-class B1 {
-    val x: String
-    val y: String
-
-    constructor(
-            x: String,
-            y: String
-    ) {
-        this.x = x
-        this.y = y
-    }
-}
-
-class C1 {
-    val x: String
-    val y: String
-
-    constructor(
-            x: String,
-            y: String,
-    ) {
-        this.x = x
-        this.y = y
-    }
-}
-
-class D1 {
-    val x: String
-    val y: String
-
-    constructor(
-            x: String,
-            y: String,
-    ) {
-        this.x = x
-        this.y = y
-    }
-}
-
-class A2 {
-    val x: String
-    val y: String
-    val z: String
-
-    constructor(
-            x: String,
-            y: String,
-            z: String,
-    ) {
-        this.x = x
-        this.y = y
-        this.z = z
-    }
-}
-
-class B2 {
-    val x: String
-    val y: String
-    val z: String
-
-    constructor(
-            x: String,
-            y: String,
-            z: String
-    ) {
-        this.x = x
-        this.y = y
-        this.z = z
-    }
-}
-
-class C2 {
-    val x: String
-    val y: String
-    val z: String
-
-    constructor(
-            x: String,
-            y: String,
-            z: String,
-    ) {
-        this.x = x
-        this.y = y
-        this.z = z
-    }
-}
-
-class D2 {
-    val x: String
-    val y: String
-    val z: String
-
-    constructor(
-            x: String,
-            y: String,
-            z: String,
-    ) {
-        this.x = x
-        this.y = y
-        this.z = z
-    }
-}
-
-class A3 {
-    val x: String
-
-    constructor(
-            x: String,
-    ) {
-        this.x = x
-    }
-}
-
-class B3 {
-    val x: String
-
-    constructor(x: String) {
-        this.x = x
-    }
-}
-
-class C3 {
-    val x: String
-
-    constructor(
-            x: String,
-    ) {
-        this.x = x
-    }
-}
-
-class D3 {
-    val x: String
-
-    constructor(
-            x: String,
-    ) {
-        this.x = x
-    }
-}
-
-class E1 {
-    val x: String
-    val y: String
-    val z: String
-
-    constructor(
-            x: String,
-            y: String, z: String,
-    ) {
-        this.x = x
-        this.y = y
-        this.z = z
-    }
-}
-
-class E2 {
-    val x: String
-    val y: String
-    val z: String
-
-    constructor(
-            x: String,
-            y: String, z: String) {
-        this.x = x
-        this.y = y
-        this.z = z
-    }
-}
-
-// SET_TRUE: ALLOW_TRAILING_COMMA

idea/testData/formatter/trailingComma/valueParameters/SecondConstructor.after.kt

@@ -1,185 +0,0 @@
-class A1 {
-    val x: String
-    val y: String
-
-    constructor(
-            x: String,
-            y: String,
-    ) {
-        this.x = x
-        this.y = y
-    }
-}
-
-class B1 {
-    val x: String
-    val y: String
-
-    constructor(
-            x: String,
-            y: String,
-    ) {
-        this.x = x
-        this.y = y
-    }
-}
-
-class C1 {
-    val x: String
-    val y: String
-
-    constructor(
-            x: String,
-            y: String,
-    ) {
-        this.x = x
-        this.y = y
-    }
-}
-
-class D1 {
-    val x: String
-    val y: String
-
-    constructor(
-            x: String,
-            y: String,
-    ) {
-        this.x = x
-        this.y = y
-    }
-}
-
-class A2 {
-    val x: String
-    val y: String
-    val z: String
-
-    constructor(
-            x: String,
-            y: String,
-            z: String,
-    ) {
-        this.x = x
-        this.y = y
-        this.z = z
-    }
-}
-
-class B2 {
-    val x: String
-    val y: String
-    val z: String
-
-    constructor(
-            x: String,
-            y: String,
-            z: String,
-    ) {
-        this.x = x
-        this.y = y
-        this.z = z
-    }
-}
-
-class C2 {
-    val x: String
-    val y: String
-    val z: String
-
-    constructor(
-            x: String,
-            y: String,
-            z: String,
-    ) {
-        this.x = x
-        this.y = y
-        this.z = z
-    }
-}
-
-class D2 {
-    val x: String
-    val y: String
-    val z: String
-
-    constructor(
-            x: String,
-            y: String,
-            z: String,
-    ) {
-        this.x = x
-        this.y = y
-        this.z = z
-    }
-}
-
-class A3 {
-    val x: String
-
-    constructor(
-            x: String,
-    ) {
-        this.x = x
-    }
-}
-
-class B3 {
-    val x: String
-
-    constructor(x: String) {
-        this.x = x
-    }
-}
-
-class C3 {
-    val x: String
-
-    constructor(
-            x: String,
-    ) {
-        this.x = x
-    }
-}
-
-class D3 {
-    val x: String
-
-    constructor(
-            x: String,
-    ) {
-        this.x = x
-    }
-}
-
-class E1 {
-    val x: String
-    val y: String
-    val z: String
-
-    constructor(
-            x: String,
-            y: String, z: String,
-    ) {
-        this.x = x
-        this.y = y
-        this.z = z
-    }
-}
-
-class E2 {
-    val x: String
-    val y: String
-    val z: String
-
-    constructor(
-            x: String,
-            y: String, z: String,
-    ) {
-        this.x = x
-        this.y = y
-        this.z = z
-    }
-}
-
-// SET_TRUE: ALLOW_TRAILING_COMMA

idea/testData/formatter/trailingComma/valueParameters/SecondConstructor.kt

@@ -1,178 +0,0 @@
-class A1 {
-    val x: String
-    val y: String
-
-    constructor(
-        x: String,
-        y: String,
-    ) {
-        this.x = x
-        this.y = y
-    }
-}
-
-class B1 {
-    val x: String
-    val y: String
-
-    constructor(
-        x: String,
-        y: String
-    ) {
-        this.x = x
-        this.y = y
-    }
-}
-
-class C1 {
-    val x: String
-    val y: String
-
-    constructor(
-        x: String,
-        y: String,) {
-        this.x = x
-        this.y = y
-    }
-}
-
-class D1 {
-    val x: String
-    val y: String
-
-    constructor(
-        x: String,
-        y: String
-    ,) {
-        this.x = x
-        this.y = y
-    }
-}
-
-class A2 {
-    val x: String
-    val y: String
-    val z: String
-
-    constructor(
-        x: String,
-        y: String,
-        z: String,
-    ) {
-        this.x = x
-        this.y = y
-        this.z = z
-    }
-}
-
-class B2 {
-    val x: String
-    val y: String
-    val z: String
-
-    constructor(
-        x: String,
-        y: String,
-        z: String
-    ) {
-        this.x = x
-        this.y = y
-        this.z = z
-    }
-}
-
-class C2 {
-    val x: String
-    val y: String
-    val z: String
-
-    constructor(
-        x: String,
-        y: String,
-        z: String,) {
-        this.x = x
-        this.y = y
-        this.z = z
-    }
-}
-
-class D2 {
-    val x: String
-    val y: String
-    val z: String
-
-    constructor(
-        x: String,
-        y: String,
-        z: String
-    ,) {
-        this.x = x
-        this.y = y
-        this.z = z
-    }
-}
-
-class A3 {
-    val x: String
-
-    constructor(x: String,) {
-        this.x = x
-    }
-}
-
-class B3 {
-    val x: String
-
-    constructor(x: String) {
-        this.x = x
-    }
-}
-
-class C3 {
-    val x: String
-
-    constructor(
-        x: String,) {
-        this.x = x
-    }
-}
-
-class D3 {
-    val x: String
-
-    constructor(
-        x: String
-    ,) {
-        this.x = x
-    }
-}
-
-class E1 {
-    val x: String
-    val y: String
-    val z: String
-
-    constructor(
-        x: String,
-        y: String, z: String,) {
-        this.x = x
-        this.y = y
-        this.z = z
-    }
-}
-
-class E2 {
-    val x: String
-    val y: String
-    val z: String
-
-    constructor(
-        x: String,
-        y: String, z: String) {
-        this.x = x
-        this.y = y
-        this.z = z
-    }
-}
-
-// SET_TRUE: ALLOW_TRAILING_COMMA