TrailingCommaInspection: shouldn't be associated with formatter settings

#KT-34744

idea/testData/inspections/trailingCommaOnWithCodeStyleAndCallSite/ArgumentList.kt

@@ -0,0 +1,225 @@
+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
+    )
+
+    useCallable(object : Callable<Unit> { override fun call() { println("Hello world") }
+    },)
+
+    useCallable(foo() { println("Hello world")
+    },)
+
+    useCallable({
+                    println("Hello world") },)
+
+    useCallable(Callable { println("Hello world") }
+                ,)
+
+    testtest(foofoo, testtest(testtest(
+        foofoo,)), testsa)
+
+    testtest(foofoo, fososos, testtest(testtest(foofoo))
+             ,)
+
+}
+
+fun test() {
+    baz(
+        f = fun(it: Int): String = "$it" /*dwdwd
+        */,
+        name = "" /*
+        */,
+    )
+}

idea/testData/inspections/trailingCommaOnWithCodeStyleAndCallSite/CollectionLiteralInAnnotation.kt

@@ -0,0 +1,112 @@
+@Anno([1])
+fun a() = Unit
+
+@Anno([1,])
+fun a() = Unit
+
+@Anno([1
+      ])
+fun a() = Unit
+
+@Anno([
+          1, ])
+fun a() = Unit
+
+@Anno([
+          1 ])
+fun a() = Unit
+
+@Anno([1,2])
+fun a() = Unit
+
+@Anno([1, 2,])
+fun a() = Unit
+
+@Anno([1, 2
+      ])
+fun a() = Unit
+
+@Anno([
+          1, 2, ])
+fun a() = Unit
+
+@Anno([
+          1, 2 ])
+fun a() = Unit
+
+@Anno([1, 2, 2])
+fun a() = Unit
+
+@Anno([1, 2, 2,])
+fun a() = Unit
+
+@Anno(["1"
+      ])
+fun a() = Unit
+
+@Anno([
+          1, ])
+fun a() = Unit
+
+@Anno([
+         1 , 2  , 2 ])
+fun a() = Unit
+
+@Anno([1/*
+    */])
+fun a() = Unit
+
+@Anno([1, //dw
+      ])
+fun a() = Unit
+
+@Anno([1 // ds
+      ])
+fun a() = Unit
+
+@Anno([/*
+    */ // d
+          1/*
+    */,/*
+    */ ])
+fun a() = Unit
+
+@Anno([
+          /*
+     */ 1 ])
+fun a() = Unit
+
+@Anno([1/*
+    */,2])
+fun a() = Unit
+
+@Anno([1, 2/*
+    */,/*
+    */])
+fun a() = Unit
+
+@Anno([/*
+    */1, 2
+      ])
+fun a() = Unit
+
+@Anno(["1"
+      ])
+fun a() = Unit
+
+@Anno([
+          1, ])
+fun a() = Unit
+
+@Anno([
+          1 , 2  /*
+    */ ])
+fun a() = Unit
+
+@Component(
+    modules = [
+        AppModule::class, DataModule::class,
+        DomainModule::class
+    ],
+)
+fun b() = Unit

idea/testData/inspections/trailingCommaOnWithCodeStyleAndCallSite/DestructionDeclarationsInLambda.kt

@@ -0,0 +1,64 @@
+val x: (Pair<Int, Int>, Int) -> Unit = { (x, y,), z, ->
+    println(x)
+}
+
+val x: (Pair<Int, Int>, Int) -> Unit = { (x, y), z, ->
+    println(x)
+}
+
+val x: (Pair<Int, Int>, Int) -> Unit = { (x,
+                                             y), z, ->
+    println(x)
+}
+
+val x: (Pair<Int, Int>, Int) -> Unit = { (
+                                             x,
+                                             y), z, ->
+    println(x)
+}
+
+val x: (Pair<Int, Int>, Int) -> Unit = { (
+                                             x // adw
+                                             ,y,), z, ->
+    println(x)
+}
+
+val x: (Pair<Int, Int>, Int) -> Unit = { (x /* val x: (Pair<Int, Int>, Int) -> Unit = { (x, y), z, ->
+    println(x)
+}*/,), z, ->
+    println(x)
+}
+
+val x: (Pair<Int, Int>, Int) -> Unit = { (x, y), z, ->
+    println(x)
+}
+
+val x: (Pair<Int, Int>, Int) -> Unit = { (x, y/**/), z, ->
+    println(x)
+}
+
+val x: (Pair<Int, Int>, Int) -> Unit = { (x, y/*
+*/), z, ->
+    println(x)
+}
+
+val x: (Pair<Int, Int>, Int) -> Unit = { (/**/x /**/  /*
+*/, // awdawd
+                                             y/*
+*/), z, ->
+    println(x)
+}
+
+val x: (Pair<Int, Int>, Int) -> Unit = {
+        (/**/x /**/  /*
+*/, // awdawd
+                                             y/*
+*/),
+        z, ->
+    println(x)
+}
+
+val x: (Pair<Int, Int>, Int) -> Unit = { (x, y,),
+                                         z, ->
+    println(x)
+}

idea/testData/inspections/trailingCommaOnWithCodeStyleAndCallSite/Enum.kt

@@ -0,0 +1,38 @@
+enum class Enum1 {
+    A, B,;
+}
+
+enum class Enum2 {
+    A, B;
+}
+
+enum class Enum3 {
+    A, B
+    ;
+}
+
+enum class Enum4 {
+    A, B,
+}
+
+enum class Enum5 {
+    A, B,
+}
+
+enum class Enum6(val a: Int) {
+    A(
+        1
+    ), B,
+}
+
+enum class Enum7(val a: Int) {
+    A(
+        1
+    ), B,;
+}
+
+enum class Enum8(val a: Int) {
+    A(
+        1
+    ), B;
+}

idea/testData/inspections/trailingCommaOnWithCodeStyleAndCallSite/IndicesAccess.kt

@@ -0,0 +1,176 @@
+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[
+        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", 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[0,]]
+
+    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/inspections/trailingCommaOnWithCodeStyleAndCallSite/LambdaParameterList.kt

@@ -0,0 +1,190 @@
+val x = {
+    x: Comparable<Comparable<Number>>,
+    y: String,
+->
+            println("1")
+    }
+
+val x = {x: Comparable<Comparable<Number>>, y: String->
+            println("1")
+    }
+
+val x = {x: String, y
+: String->
+            println("1")
+    }
+
+val x = {
+    x: String,
+    y: String
+->
+            println("1")
+    }
+
+val x = {
+    x: String,
+    y: Comparable<Comparable<Number>>,->
+            println("1")
+    }
+
+val x = {
+    x: Comparable<Comparable<Number>>,
+    y: String
+    ,->
+            println("1")
+    }
+
+val x = {
+    x: String,
+    y: Comparable<Comparable<Number>>,
+    z: String,
+->
+            println("1")
+    }
+
+val x = {
+    x: String,
+    y: String,
+    z: String
+->
+            println("1")
+    }
+
+val x = {
+    x: String,
+    y: String,
+    z: String,->
+            println("1")
+    }
+
+val x = {
+    x: String,
+    y: String,
+    z: String
+    ,->
+            println("1")
+    }
+
+val x = {
+    x: String,
+->
+            println("1")
+    }
+
+val x = {
+    x: String
+->
+            println("1")
+    }
+
+val x = {
+    x: String,->
+            println("1")
+    }
+
+val x = {
+    x: String
+    ,->
+            println("1")
+    }
+
+val x = {
+    x: String   ,
+    y: String,
+->
+            println("1")
+    }
+
+val x = {
+    x: String,
+    z: String
+->
+            println("1")
+    }
+
+val x = {
+    x: String,
+    y: String,
+    z: String   ,->
+            println("1")
+    }
+
+val x = {
+    x: String,
+    z: String
+    ,   ->
+            println("1")
+    }
+
+val x = {
+    x, y: String,
+    z: String
+    ,   ->
+            println("1")
+    }
+
+val x = {
+    x: String, y: String, z: String
+->
+            println("1")
+    }
+
+val x = {
+    z: String, v: Comparable<Comparable<Number>>,
+
+->
+            println("1")
+    }
+
+val x = {x: String,
+    y: Comparable<Comparable<Number>>,
+->
+            println("1")
+    }
+
+val x = {
+    x: Int
+->
+            println("1")
+    }
+
+val x = {
+    x: String, y: String
+    , /* */ z: String
+->
+            println("1")
+    }
+
+val x = {
+    x: String, y: String
+    /* */, /* */ z: String
+->
+            println("1")
+    }()
+
+val x = {
+    x: String, /*
+    */ y: String,
+    z: String   ,->
+            println("1")
+    }
+
+val x = {
+    x: String, y: String , z: String /*
+     */
+    ,   ->
+            println("1")
+    }
+
+val x = {
+    x: Comparable<Comparable<Number>>, y: String,
+    z: String
+    ,   ->
+            println("1")
+    }
+
+val x = {
+    x: String, y: String, z: String
+->
+            println("1")
+    }

idea/testData/inspections/trailingCommaOnWithCodeStyleAndCallSite/LambdaValueParameters.kt

@@ -0,0 +1,83 @@
+fun main() {
+    val x: (
+        y: Comparable<Comparable<Number>>,
+        z: Iterable<Iterable<Number>> // trailing comma
+    ) -> Int = {
+        10
+    }
+
+    val x: (
+        y: Comparable<Comparable<Number>>,
+        z: Iterable<Iterable<Number>>
+    ) -> Int = {
+        10
+    }
+
+    val x: (y: Comparable<Comparable<Number>>, z: Iterable<Iterable<Number>>) -> Int = {
+        10
+    }
+
+    val x: (y: Comparable<Comparable<Number>>, z: Iterable<Iterable<Number>>,) -> Int = {
+        10
+    }
+
+    val x: (y: Comparable<Comparable<Number>>, z: Iterable<Iterable<Number>>,
+    ) -> Int = {
+        10
+    }
+
+    val x: (y: Comparable<Comparable<Number>>) -> Int = {
+        10
+    }
+
+    val x: (y: Comparable<Comparable<Number>>,) -> Int = {
+        10
+    }
+
+    val x: (y: Comparable<Comparable<Number>>
+    ) -> Int = {
+        10
+    }
+
+    val x: (
+        y: Comparable<Comparable<Number>>) -> Int = {
+        10
+    }
+
+    val x: (
+        y: Comparable<Comparable<Number>>, //
+        z: Iterable<Iterable<Number>> // /**/
+    ) -> Int = {
+        10
+    }
+
+    val x: (y: Comparable<Comparable<Number>>, z: Iterable<Iterable<Number>>
+        // wd
+    ) -> Int = {
+        10
+    }
+
+    val x: (y: Comparable<Comparable<Number>>/*
+    */, z: Iterable<Iterable<Number>>, /* //
+    */) -> Int = {
+        10
+    }
+
+    val x: (/**/y: Comparable<Comparable<Number>>/**/) -> Int = {
+        10
+    }
+
+    val x: (y: Comparable<Comparable<Number>>/**/,) -> Int = {
+        10
+    }
+
+    val x: (y: Comparable<Comparable<Number>>
+    ) -> Int = {
+        10
+    }
+
+    val x: ( /*
+        */y: Comparable<Comparable<Number>>) -> Int = {
+        10
+    }
+}

idea/testData/inspections/trailingCommaOnWithCodeStyleAndCallSite/MultiVariableDeclaration.kt

@@ -0,0 +1,99 @@
+fun test() {
+    val (a, b) = 1 to 2
+
+    val (a, b) = 1 to
+            2
+
+    val (a, b) = 1
+    to
+    2
+
+
+    val (a, b,) = 1 to 2
+
+    val (a,) =
+        b
+
+    val (a,
+    ) =
+        b
+
+    val (a
+    ) =
+        b
+
+    val (a,) = b
+
+    val (
+        a,) = b
+
+    val (a, b
+    ) = 1 to 2
+
+    val (a,
+        b) = 1 to 2
+
+    val (
+        a, b
+    ) = 1 to 2
+
+    val (
+        a, b,
+    ) = 1 to 2
+
+    val (a, b, c,
+        d, f
+    ) = 1 to 2
+
+    val (a, b, c,
+        d, f,
+    ) = 1 to 2
+
+    val (a, b/**/) = 1 to 2
+
+    val (a, /**/b/**/) /**/=/**/ 1 to
+            2
+
+    val (a,/**/ b) = 1
+    to
+    2
+
+    val (a, b/**/,) = 1 to 2
+
+    val (a/**/, b/**/,/**/) = 1 to 2
+
+    val (a/**/,/**/) =
+        b
+
+    val (a,) = b
+
+    val (a, b/**/
+    ) = 1 to 2
+
+    val (a, b// awd
+    ) = 1 to 2
+
+    val (a,/**/ b /**/       // awd
+    ) = 1 to 2
+
+    val (a, // ad
+            /**/b) = 1 to 2
+
+    val (
+        a, b // fe
+    /**/)/**/ = 1 to 2
+
+    val (
+        a, b, // awd
+    ) = 1 to 2
+
+    val (a, b, c,
+        d, f // awd
+            /*
+        */) = 1 to 2
+
+    val (a, b, c,
+        d, f // awd
+            ,
+    ) = 1 to 2
+}

idea/testData/inspections/trailingCommaOnWithCodeStyleAndCallSite/ParameterList.kt

@@ -0,0 +1,458 @@
+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 // adwd
+)

idea/testData/inspections/trailingCommaOnWithCodeStyleAndCallSite/TypeArgumentList.kt

@@ -0,0 +1,113 @@
+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, fososos, testtest<testtest<foofoo>>
+            ,>()
+
+    testtest<foofoo, testtest<testtest<foofoo,>>, testsa>()
+
+    testtest<foofoo, *, testtest<testtest<foofoo,>>, testsa>()
+
+    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,/*
+    */>()
+
+    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>()
+}

idea/testData/inspections/trailingCommaOnWithCodeStyleAndCallSite/TypeParameterList.kt

@@ -0,0 +1,261 @@
+class A1<
+    x: String,
+    y: String,
+>
+
+class F<x: String, y: String>
+
+class F2<x: String, y
+: String>
+
+class B1<
+    x: String,
+    y: String
+>
+
+class C1<
+    x: String,
+    y: String,>
+
+class D1<
+    x: String,
+    y: String
+    ,>
+
+class A2<
+    x: String,
+    y: String,
+    z: String,
+>
+
+class B2<
+    x: String,
+    y: String,
+    z: String
+>
+
+class C2<
+    x: String,
+    y: String,
+    z: String,>
+
+class D2<
+    x: String,
+    y: String,
+    z: String
+    ,>
+
+class A3<
+    x: String,
+>
+
+class B3<
+    x: String
+>
+
+class C3<
+    x: String,>
+
+class D3<
+    x: String
+    ,>
+
+class A4<
+    x: String   ,
+    y: String,
+    z   ,
+>
+
+class B4<
+    x: String,
+    y,
+    z: String
+>
+
+class C4<
+    x: String,
+    y: String,
+    z: String   ,>
+
+class D4<
+    x: String,
+    y,
+    z: String
+    ,   >
+
+class E1<
+    x, y: String,
+    z: String
+    ,   >
+
+class E2<
+    x: String, y: String, z: String
+>
+
+class C<
+    z: String, v
+
+>
+
+fun <x: String,
+    y: String,
+> a1() = Unit
+
+fun <x: String,
+    y: String
+> b1() = Unit
+
+fun <
+    x: String,
+    y: String,> c1() = Unit
+
+fun <
+    x: String,
+    y: String
+    ,> d1() = Unit
+
+fun <
+    x: String,
+    y: String,
+    z: String,
+> a2() = Unit
+
+fun <
+    x: String,
+    y: String,
+    z: String
+> b2() = Unit
+
+fun <
+    x: String,
+    y: String,
+    z: String,> c2() = Unit
+
+fun <
+    x: String,
+    y: String,
+    z: String
+    ,> d2() = Unit
+
+fun <
+    x: String,
+> a3() = Unit
+
+fun <
+    x: String
+> b3() = Unit
+
+fun <
+    x: String,> c3() = Unit
+
+fun <
+    x: String
+    ,> d3() = Unit
+
+fun <
+    x: String
+    ,
+    y: String,
+    z: String   ,
+> a4() = Unit
+
+fun <
+    x: String,
+    y: String,
+    z: String
+> b4() = Unit
+
+fun <x: String,
+       y: String,
+       z: String   ,> c4() = Unit
+
+fun <
+    x: String,
+    y: String,
+    z: String
+    ,   > d4() = Unit
+
+fun <
+    x
+> foo() {
+}
+
+fun <T> ag() {
+
+}
+
+fun <T,> ag() {
+
+}
+
+fun <
+        T> ag() {
+
+}
+
+class C<
+    x: Int
+>
+
+class G<
+    x: String, y: String
+    , /* */ z: String
+>
+
+class G<
+    x: String, y: String
+    /* */, /* */ z: String
+>()
+
+class H<
+    x: String, /*
+    */ y: String,
+    z: String   ,>
+
+class J<
+    x: String, y: String , z: String /*
+     */
+    ,   >
+
+class K<
+    x: String, y: String,
+    z: String
+    ,   >
+
+class L<
+    x: String, y: String, z: String
+>
+
+class C<
+    x: Int // adad
+>
+
+class G<
+    x: String, y: String
+    , /* */ z: String // adad
+>
+
+class G<
+    x: String, y: String
+    /* */, /* */ z: String /**/,
+>()
+
+class H<
+    x: String, /*
+    */ y: String,
+    z: String /*
+    */  ,>
+
+class J<
+    x: String, y: String , z: String /*
+     */
+    , /**/  >
+
+class K<
+    x: String, y: String,
+    z: String // aw
+    ,   >
+
+class L<
+    x: String, y: String, z: String //awd
+>

idea/testData/inspections/trailingCommaOnWithCodeStyleAndCallSite/WhenEntry.kt

@@ -0,0 +1,75 @@
+fun foo(x: Any) = when (x) {
+    Comparable::class, Iterable::class, String::class, // trailing comma
+    -> println(1)
+    else -> println(3)
+}
+
+fun foo(x: Any) {
+    when (x) {
+        Comparable::class, Iterable::class, String::class /*// trailing comma*/ -> println(1)
+        else -> println(3)
+    }
+
+    when (x) {
+        Comparable::class, Iterable::class,
+        String::class /*// trailing comma*/ -> println(1)
+        else -> println(3)
+    }
+
+    when (x) {
+        Comparable::class, Iterable::class,
+        String::class /*// trailing comma*/, -> println(1)
+        else -> println(3)
+    }
+
+    when (x) {
+        Comparable::class, Iterable::class, String::class /*// trailing comma*/ -> println(1)
+        else -> println(3)
+    }
+
+    when (x) {
+        1 -> {
+
+        }
+        else -> println(3)
+    }
+
+    when (x) {
+        1, -> {
+
+        }
+        else -> println(3)
+    }
+
+    when (x) {
+        1
+        -> {
+
+        }
+        else -> println(3)
+    }
+
+    when (x) {
+        1, 2,
+        3 /**/ -> {
+
+        }
+        else -> println(3)
+    }
+
+    when (val c = x) {
+        1, 2,
+        3 /**/ -> {
+
+        }
+        else -> println(3)
+    }
+
+    when {
+        x in coll
+        -> {
+
+        }
+        else -> println(3)
+    }
+}

idea/testData/inspections/trailingCommaOnWithCodeStyleAndCallSite/inspectionData/inspections.test

@@ -0,0 +1,3 @@
+// INSPECTION_CLASS: org.jetbrains.kotlin.idea.inspections.TrailingCommaInspection
+// COMPILER_ARGUMENTS: -XXLanguage:+TrailingCommas
+// REGISTRY: kotlin.formatter.allowTrailingCommaOnCallSite true