ClassOrdering rule reports a list of errors

detekt-rules-style/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/style/ClassOrdering.kt

@@ -68,22 +68,28 @@ class ClassOrdering(config: Config = Config.empty) : Rule(config) {
     override fun visitClassBody(classBody: KtClassBody) {
         super.visitClassBody(classBody)
 
-        comparator.findOutOfOrder(classBody.declarations)?.let {
-            report(CodeSmell(issue, Entity.from(classBody), generateMessage(it)))
+        val misorders = comparator.findOutOfOrder(classBody.declarations)
+        if (misorders.isNotEmpty()) {
+            report(
+                misorders.map {
+                    CodeSmell(
+                        issue = issue,
+                        entity = Entity.from(it.first),
+                        message = "${it.first.description} should not come before ${it.second.description}",
+                        references = listOf(Entity.from(classBody))
+                    )
+                }
+            )
         }
     }
-
-    private fun generateMessage(misordered: Pair<KtDeclaration, KtDeclaration>): String {
-        return "${misordered.first.description} should not come before ${misordered.second.description}"
-    }
 }
 
 private fun Comparator<KtDeclaration>.findOutOfOrder(
     declarations: List<KtDeclaration>
-): Pair<KtDeclaration, KtDeclaration>? {
-    declarations.zipWithNext { a, b -> if (compare(a, b) > 0) return Pair(a, b) }
-    return null
-}
+): List<Pair<KtDeclaration, KtDeclaration>> =
+    declarations
+        .zipWithNext { a, b -> if (compare(a, b) > 0) Pair(a, b) else null }
+        .filterNotNull()
 
 private val KtDeclaration.description: String
     get() = when (this) {

detekt-rules-style/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/style/ClassOrderingSpec.kt

@@ -196,5 +196,30 @@ class ClassOrderingSpec : Spek({
 
             assertThat(subject.compileAndLint(code)).hasSize(0)
         }
+
+        it("does report all issues in a class with multiple misorderings") {
+            val code = """
+                class MultipleMisorders(private val x: String) {
+                    companion object {
+                        const val IMPORTANT_VALUE = 3
+                    }
+
+                    fun returnX() = x
+
+                    constructor(z: Int): this(z.toString())
+
+                    val y = x
+                }
+            """.trimIndent()
+
+            val findings = subject.compileAndLint(code)
+            assertThat(findings).hasSize(3)
+            assertThat(findings[0].message)
+                .isEqualTo("Companion object should not come before returnX (function)")
+            assertThat(findings[1].message)
+                .isEqualTo("returnX (function) should not come before MultipleMisorders (secondary constructor)")
+            assertThat(findings[2].message)
+                .isEqualTo("MultipleMisorders (secondary constructor) should not come before y (property)")
+        }
     }
 })