fix: keep leading block comment of clause item on its own line

A block comment placed before the first item of a clause (e.g.
`SELECT /* c */ foo FROM tbl`) was formatted inline on the first pass,
but moved onto its own line when the result was formatted again, making
formatting non-idempotent.

The inline-vs-standalone decision for a block comment was based solely on
its `precedingWhitespace`. The formatter always emits a newline before the
first item of a clause body, so on a second pass that structural newline
becomes the comment's preceding whitespace and flips the decision.

Treat a block comment as standalone whenever it is already at the start of
a line in the output being built, in addition to the existing checks. This
makes the first pass place such comments on their own line directly, so the
output is stable under repeated formatting. Inline block comments that
follow other tokens on the same line (trailing comments, comments between a
function name and its parentheses, or around the `.` of a qualified name)
are unaffected.

Author: sarathfrancis90

src/formatter/ExpressionFormatter.ts

@@ -378,7 +378,7 @@ export default class ExpressionFormatter {
   }
 
   private formatBlockComment(node: BlockCommentNode | DisableCommentNode) {
-    if (node.type === NodeType.block_comment && this.isMultilineBlockComment(node)) {
+    if (node.type === NodeType.block_comment && this.isStandaloneBlockComment(node)) {
       this.splitBlockComment(node.text).forEach(line => {
         this.layout.add(WS.NEWLINE, WS.INDENT, line);
       });
@@ -388,8 +388,17 @@ export default class ExpressionFormatter {
     }
   }
 
-  private isMultilineBlockComment(node: BlockCommentNode): boolean {
-    return isMultiline(node.text) || isMultiline(node.precedingWhitespace || '');
+  private isStandaloneBlockComment(node: BlockCommentNode): boolean {
+    return (
+      isMultiline(node.text) ||
+      isMultiline(node.precedingWhitespace || '') ||
+      // The comment is the first thing on its line in the output being built
+      // (e.g. a comment leading the first item of a clause body, which the
+      // formatter always places on a fresh line). Keeping it inline here would
+      // make formatting non-idempotent, since reformatting would then see a
+      // newline before the comment and move it onto its own line.
+      this.layout.isAtStartOfLine()
+    );
   }
 
   private isDocComment(comment: string): boolean {

src/formatter/Layout.ts

@@ -111,6 +111,22 @@ export default class Layout {
     return this.items;
   }
 
+  /**
+   * True when some content has already been added and nothing but indentation
+   * has been emitted since the last newline, meaning the next token would be
+   * placed at the start of a fresh (non-first) line.
+   */
+  public isAtStartOfLine(): boolean {
+    for (let i = this.items.length - 1; i >= 0; i--) {
+      const item = this.items[i];
+      if (item === WS.SINGLE_INDENT) {
+        continue;
+      }
+      return item === WS.NEWLINE || item === WS.MANDATORY_NEWLINE;
+    }
+    return false;
+  }
+
   private itemToString(item: LayoutItem): string {
     switch (item) {
       case WS.SPACE:

test/features/comments.ts

@@ -61,6 +61,19 @@ export default function supportsComments(format: FormatFn, opts: CommentsConfig
     expect(format(sql)).toBe(sql);
   });
 
+  it('moves a leading block comment of a clause item onto its own line', () => {
+    const result = format('SELECT /* comment */ foo FROM tbl');
+    expect(result).toBe(dedent`
+      SELECT
+        /* comment */
+        foo
+      FROM
+        tbl
+    `);
+    // Formatting must be idempotent: re-formatting the result must not change it.
+    expect(format(result)).toBe(result);
+  });
+
   it('formats tricky line comments', () => {
     expect(format('SELECT a--comment, here\nFROM b--comment')).toBe(dedent`
       SELECT