Formatter: support trailing comma in value arguments

#KT-34744

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