Coalesce bare ) / [ onto one line in pretty-printer output

When a closing ) sits alone on a line and the next line starts with [,
they are joined as ) [ — most visible when block-form let() is followed
by a vector or list comprehension body.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: revarbat

docs/PRETTY_PRINTING.md

@@ -163,7 +163,7 @@ function f(x) =
     y + 1;
 ```
 
-**Block** — two or more assignments, or any single assignment whose value is multiline (e.g. a ternary): `let(` opens, each assignment on its own line indented one level, `)` closes at the original indent:
+**Block** — two or more assignments, or any single assignment whose value is multiline (e.g. a ternary): `let(` opens, each assignment on its own line indented one level, `)` closes at the original indent. When the body is a plain expression, it follows on the next line:
 
 ```
 function f(a, b) =
@@ -182,6 +182,15 @@ function f(x) =
     y + 1;
 ```
 
+When the body is a vector or list comprehension, the closing `)` and opening `[` are coalesced onto one line (see [§5 `) / [` Coalescing](#--coalescing)):
+
+```
+x = let(
+    a = 1,
+    b = 2
+) [a, b, a + b];
+```
+
 This same inline/block rule applies to `let()` inside `let()` module calls and inside list comprehensions.
 
 ### Long Function Call Expressions
@@ -341,6 +350,29 @@ The precedence table (low → high):
 | 80 | unary `-`, `!`, `~` |
 | 90 | `^` (right-associative) |
 
+### `)` / `[` Coalescing
+
+When a closing `)` lands on a line by itself and the very next line starts with `[`, the two are joined onto one line as `) [`. This most commonly occurs when a block-form `let(` is followed by a vector or list comprehension body:
+
+```
+// two or more assignments → block let, body is a vector
+x = let(
+    a = 1,
+    b = 2
+) [a, b, a + b];
+
+// block let followed by an expanding list comprehension
+x = let(
+    a = 1,
+    b = 2
+) [
+    for (i = [0:5])
+        i + a
+];
+```
+
+The indentation of the resulting `) [` line is taken from the `)` line. A `)` with any trailing content (e.g. `);` or `) {`) is not coalesced.
+
 ### Other Expressions
 
 All other expressions (ranges, identifiers, etc.) are rendered on a single line.

src/openscad_parser/ast/pretty_print.py

@@ -47,7 +47,27 @@ def to_openscad(nodes: list[ASTNode], indent_width: int = 4) -> str:
             parts.append("")
         parts.append(_fmt_node(node, 0, indent_width))
         prev_complex = is_complex
-    return "\n".join(parts)
+    return _coalesce_paren_bracket("\n".join(parts))
+
+
+def _coalesce_paren_bracket(text: str) -> str:
+    """Join consecutive lines where one is a bare ')' and the next starts with '['."""
+    lines = text.split("\n")
+    result = []
+    i = 0
+    while i < len(lines):
+        if (
+            i + 1 < len(lines)
+            and lines[i].strip() == ")"
+            and lines[i + 1].lstrip().startswith("[")
+        ):
+            indent = len(lines[i]) - len(lines[i].lstrip())
+            result.append(" " * indent + ") " + lines[i + 1].lstrip())
+            i += 2
+        else:
+            result.append(lines[i])
+            i += 1
+    return "\n".join(result)
 
 
 # Line length beyond which call arguments are formatted one-per-line.

tests/test_pretty_print.py

@@ -6,7 +6,7 @@
     Assignment, FunctionDeclaration, ModuleDeclaration,
     ModularCall, ModularFor, ModularIf, ModularIfElse,
 )
-from openscad_parser.ast.pretty_print import _as_list
+from openscad_parser.ast.pretty_print import _as_list, _coalesce_paren_bracket
 
 
 def _roundtrip(code: str) -> list:
@@ -644,3 +644,45 @@ def test_none_returns_empty(self):
     def test_single_value_wraps(self):
         assert _as_list("x") == ["x"]
         assert _as_list(42) == [42]
+
+
+class TestCoalesceParenBracket:
+    """Unit tests for the ) / [ line-coalescing post-processor."""
+
+    def test_bare_paren_bracket_joined(self):
+        inp = "    )\n    ["
+        assert _coalesce_paren_bracket(inp) == "    ) ["
+
+    def test_bracket_content_preserved(self):
+        inp = "    )\n    [1, 2, 3]"
+        assert _coalesce_paren_bracket(inp) == "    ) [1, 2, 3]"
+
+    def test_indentation_from_paren_line(self):
+        # The coalesced line uses the indent of the ')' line, not the '[' line.
+        inp = "        )\n            [x, y]"
+        assert _coalesce_paren_bracket(inp) == "        ) [x, y]"
+
+    def test_no_coalesce_when_paren_has_trailing_content(self):
+        inp = "    ) {\n    ["
+        assert _coalesce_paren_bracket(inp) == "    ) {\n    ["
+
+    def test_no_coalesce_when_bracket_preceded_by_non_paren(self):
+        inp = "    x = 1\n    [1, 2]"
+        assert _coalesce_paren_bracket(inp) == "    x = 1\n    [1, 2]"
+
+    def test_multiple_occurrences(self):
+        inp = ")\n[\n)\n["
+        assert _coalesce_paren_bracket(inp) == ") [\n) ["
+
+    def test_let_block_with_vector_body(self):
+        out = _fmt("x = let(a = 1, b = 2) [a, b];")
+        assert ") [a, b];" in out
+        assert "\n)" not in out.split(") [")[0].split("\n")[-1]  # no bare ) before the join
+
+    def test_let_block_with_list_comp_body(self):
+        out = _fmt("x = let(a = 1, b = 2) [for (i = [0:5]) i + a];")
+        assert ") [\n" in out
+        # no consecutive lines of bare ) then [
+        lines = out.split("\n")
+        for i in range(len(lines) - 1):
+            assert not (lines[i].strip() == ")" and lines[i + 1].lstrip().startswith("["))