Finish support for proper formatting of file-level annotations

formatter/src/main/kotlin/org/kotlin/formatter/scanning/FileAnnotationListScanner.kt

@@ -0,0 +1,54 @@
+package org.kotlin.formatter.scanning
+
+import org.jetbrains.kotlin.KtNodeTypes
+import org.jetbrains.kotlin.com.intellij.lang.ASTNode
+import org.jetbrains.kotlin.psi.psiUtil.children
+import org.kotlin.formatter.ForceSynchronizedBreaksInBlockToken
+import org.kotlin.formatter.ForcedBreakToken
+import org.kotlin.formatter.Token
+import org.kotlin.formatter.WhitespaceToken
+import org.kotlin.formatter.scanning.nodepattern.NodePatternBuilder
+import org.kotlin.formatter.scanning.nodepattern.nodePattern
+
+/** A [NodeScanner] for the list of annotations at the top of a Kotlin file. */
+internal class FileAnnotationListScanner(private val kotlinScanner: KotlinScanner) : NodeScanner {
+    private val nodePattern =
+        nodePattern {
+            zeroOrMore {
+                either {
+                    simpleAnnotation() thenMapToTokens { nodes ->
+                        kotlinScanner.scanNodes(nodes, ScannerState.STATEMENT)
+                    }
+                } or {
+                    nodeOfOneOfTypes(
+                        KtNodeTypes.ANNOTATION,
+                        KtNodeTypes.ANNOTATION_ENTRY
+                    ) thenMapToTokens { nodes ->
+                        kotlinScanner.scanNodes(nodes, ScannerState.STATEMENT)
+                            .plus(ForceSynchronizedBreaksInBlockToken)
+                    }
+                }
+                possibleWhitespace() thenMapToTokens { nodes ->
+                    if (nodes.firstOrNull()?.textContains('\n') == true) {
+                        listOf(ForcedBreakToken(count = 1))
+                    } else {
+                        listOf(WhitespaceToken(" "))
+                    }
+                }
+                zeroOrOne {
+                    comment() thenMapTokens { tokens -> tokens.plus(ForcedBreakToken(count = 1)) }
+                }
+                possibleWhitespace()
+            }
+            end()
+        }
+
+    private fun NodePatternBuilder.simpleAnnotation(): NodePatternBuilder =
+        nodeMatching {
+            it.elementType == KtNodeTypes.ANNOTATION_ENTRY &&
+                it.lastChildNode.elementType == KtNodeTypes.CONSTRUCTOR_CALLEE
+        }
+
+    override fun scan(node: ASTNode, scannerState: ScannerState): List<Token> =
+        nodePattern.matchSequence(node.children().asIterable())
+}

formatter/src/main/kotlin/org/kotlin/formatter/scanning/NodeScanner.kt

@@ -56,6 +56,7 @@ internal class NodeScannerProvider(
             SimpleBlockScanner(kotlinScanner, ScannerState.PACKAGE_IMPORT, State.PACKAGE_IMPORT)
         }
     private val modifierListScanner = lazy { ModifierListScanner(kotlinScanner) }
+    private val fileAnnotationListScanner = lazy { FileAnnotationListScanner(kotlinScanner) }
     private val returnScanner = lazy { ReturnScanner(kotlinScanner) }
     private val throwScanner = lazy { ThrowScanner(kotlinScanner) }
     private val tryScanner = lazy { TryScanner(kotlinScanner) }
@@ -121,8 +122,9 @@ internal class NodeScannerProvider(
             KtNodeTypes.LABELED_EXPRESSION -> labeledExpressionScanner.value
             KtNodeTypes.ANNOTATED_EXPRESSION -> annotatedExpressionScanner.value
             KtFileElementType.INSTANCE -> kotlinFileScanner.value
-            KtFileElementType.INSTANCE, is KtScriptElementType,
-                KtNodeTypes.LITERAL_STRING_TEMPLATE_ENTRY -> simpleScannerForBlock.value
+            is KtScriptElementType, KtNodeTypes.LITERAL_STRING_TEMPLATE_ENTRY ->
+                simpleScannerForBlock.value
+            KtNodeTypes.FILE_ANNOTATION_LIST -> fileAnnotationListScanner.value
             KtNodeTypes.TYPE_REFERENCE -> typeReferenceScanner.value
             KtNodeTypes.WHEN_ENTRY, KtNodeTypes.ANNOTATION_ENTRY, KtNodeTypes.PREFIX_EXPRESSION,
                 KtNodeTypes.VALUE_PARAMETER, KtNodeTypes.SUPER_TYPE_ENTRY,

formatter/src/test/kotlin/org/kotlin/formatter/KotlinFormatterTest.kt

@@ -3772,7 +3772,7 @@ class KotlinFormatterTest {
             .isEqualTo(
                 """
                     @file:AnAnnotation
-
+                    
                     package apackage
                     
                     import anotherpackage.AClass
@@ -3787,7 +3787,62 @@ class KotlinFormatterTest {
                 .format(
                     """
                         @file:AnAnnotation // A comment
+                        
+                        package apackage
+                        
+                        import anotherpackage.AClass
+                    """.trimIndent()
+                )
+
+        assertThat(result)
+            .isEqualTo(
+                """
+                    @file:AnAnnotation // A comment
+                    
+                    package apackage
+                    
+                    import anotherpackage.AClass
+                """.trimIndent()
+            )
+    }
 
+    @Test
+    fun `adds newline between file annotations with attributes`() {
+        val result =
+            KotlinFormatter(importPolicySupplier = { { _, _ -> true } })
+                .format(
+                    """
+                        @file:AnAnnotation("A value")
+                        @file:AnotherAnnotation
+                        
+                        package apackage
+                        
+                        import anotherpackage.AClass
+                    """.trimIndent()
+                )
+
+        assertThat(result)
+            .isEqualTo(
+                """
+                    @file:AnAnnotation("A value")
+                    @file:AnotherAnnotation
+                    
+                    package apackage
+                    
+                    import anotherpackage.AClass
+                """.trimIndent()
+            )
+    }
+
+    @Test
+    fun `preserves comments between file annotations`() {
+        val result =
+            KotlinFormatter(importPolicySupplier = { { _, _ -> true } })
+                .format(
+                    """
+                        @file:AnAnnotation // A comment
+                        @file:AnotherAnnotation
+                        
                         package apackage
                         
                         import anotherpackage.AClass
@@ -3798,7 +3853,38 @@ class KotlinFormatterTest {
             .isEqualTo(
                 """
                     @file:AnAnnotation // A comment
+                    @file:AnotherAnnotation
+                    
+                    package apackage
+                    
+                    import anotherpackage.AClass
+                """.trimIndent()
+            )
+    }
 
+    @Test
+    fun `preserves block between file annotations`() {
+        val result =
+            KotlinFormatter(importPolicySupplier = { { _, _ -> true } })
+                .format(
+                    """
+                        @file:AnAnnotation
+                        /* A comment */
+                        @file:AnotherAnnotation
+                        
+                        package apackage
+                        
+                        import anotherpackage.AClass
+                    """.trimIndent()
+                )
+
+        assertThat(result)
+            .isEqualTo(
+                """
+                    @file:AnAnnotation
+                    /* A comment */
+                    @file:AnotherAnnotation
+                    
                     package apackage
                     
                     import anotherpackage.AClass
@@ -3823,7 +3909,7 @@ class KotlinFormatterTest {
             .isEqualTo(
                 """
                     @file:[AnAnnotation AnotherAnnotation]
-
+                    
                     package apackage
                     
                     import anotherpackage.AClass