prettycsharp 1.1.4__tar.gz → 1.1.6__tar.gz

{prettycsharp-1.1.4 → prettycsharp-1.1.6}/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 Each release's section becomes the body of its GitHub release.
 
+## [1.1.6] - 2026-10-18
+
+- `for` headers keep a space between semicolons when the condition is
+  omitted, such as `for (var start = 0; ;)`, avoiding Visual Studio's
+  IDE0055 formatting diagnostic. Fully empty headers print `for (; ; )`.
+
+## [1.1.5] - 2026-10-18
+
+- Nullable array types print tight, `object?[]?`, instead of
+  `object? []?`, and spread elements are spaced, `[.. items]`, as Visual
+  Studio formats them (IDE0055). Ranges such as `items[..2]` stay tight.
+- An empty collection `[]` is never split across lines. When it does not
+  fit, the line breaks after `=>` or `=` and `[]` goes to the next line.
+- No blank line is left directly above or below `#if`, `#elif`, `#else`
+  and `#endif`. A comment above an `#if` keeps the blank line above the
+  comment. The new setting `directive_blank_lines = "preserve"` keeps the
+  blank lines as written.
+
 ## [1.1.4] - 2026-10-17
 
 - An empty body `{ }` after a header that spans lines goes on its own line,

{prettycsharp-1.1.4 → prettycsharp-1.1.6}/DESIGN.md

@@ -134,6 +134,7 @@ while (item != null);
 | `member_blank_lines` | `group_fields`: consecutive fields and auto-properties stay tight, one blank line around methods, constructors, and other members with bodies | `all`, `preserve` |
 | `blank_lines_around_blocks` | `true`: a block statement gets a blank line before and after it, except right after `{` or right before `}` | `false` |
 | `max_blank_lines` | `1`: author's blank lines between plain statements are kept, runs collapse to one | any integer, `0` |
+| `directive_blank_lines` | `remove`: no blank line directly above or below `#if`, `#elif`, `#else` and `#endif` | `preserve` |
 
 No blank line ever follows `{` or precedes `}`. A comment directly above a block moves with
 it, so the blank line goes above the comment.
@@ -160,6 +161,10 @@ public void Ship()
 
 ### Line breaking
 
+`for` headers keep a space after each semicolon even when the next clause
+is omitted: `for (var i = 0; ;)`. There is no space before the closing
+parenthesis unless all three clauses are empty: `for (; ; )`.
+
 | Setting | Default | Alternatives |
 | --- | --- | --- |
 | `argument_wrap` | `one_per_line`: each argument on its own line, `)` on its own line. Also applies to parameter lists. | `one_per_line_close_on_last`, `fill`, `align` |

{prettycsharp-1.1.4 → prettycsharp-1.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: prettycsharp
-Version: 1.1.4
+Version: 1.1.6
 Summary: An opinionated formatter for C#, in the spirit of Prettier
 Project-URL: Homepage, https://github.com/WilliamSmithEdward/prettyCSharp
 Project-URL: Repository, https://github.com/WilliamSmithEdward/prettyCSharp

{prettycsharp-1.1.4 → prettycsharp-1.1.6}/src/prettycsharp/__init__.py

@@ -4,7 +4,7 @@ from prettycsharp.formatter import FormatResult, FormattingError, format_details
 from prettycsharp.parsing import CSharpSyntaxError
 from prettycsharp.settings import Settings, SettingsError
 
-__version__ = "1.1.4"
+__version__ = "1.1.6"
 
 __all__ = [
     "CSharpSyntaxError",

{prettycsharp-1.1.4 → prettycsharp-1.1.6}/src/prettycsharp/conditional.py

@@ -369,18 +369,53 @@ def covering_sets(source: str, usable: Callable[[str], bool] = parses) -> list[f
     return chosen
 
 
+def tighten(text: str, hidden: dict[str, str]) -> str:
+    """Drop the blank lines next to conditional directive lines behind placeholders.
+
+    A placeholder whose hidden text starts with #if, #elif, #else or #endif
+    loses the blank lines above it; one whose hidden text ends with one loses
+    the blank lines below it.
+    """
+    lines = _split_lines(text)
+    drop: set[int] = set()
+    for number, line in enumerate(lines):
+        match = _PLACEHOLDER.match(_content(line))
+        if match is None or match.group(1) not in hidden:
+            continue
+        rows = hidden[match.group(1)].splitlines()
+        if _conditional(rows[0]):
+            above = number - 1
+            while above >= 0 and not _content(lines[above]).strip():
+                drop.add(above)
+                above -= 1
+        if _conditional(rows[-1]):
+            below = number + 1
+            while below < len(lines) and not _content(lines[below]).strip():
+                drop.add(below)
+                below += 1
+    return "".join(line for number, line in enumerate(lines) if number not in drop)
+
+
+def _conditional(line: str) -> bool:
+    found = _directive(line)
+    return found is not None and found[0] in ("if", "elif", "else", "endif")
+
+
 def format_conditional(
     source: str,
     format_masked: Callable[[str], str],
     same_code: Callable[[str, str], bool],
     usable: Callable[[str], bool] = parses,
+    *,
+    tight: bool = False,
 ) -> str | None:
     """Format each symbol set's view of the file in turn.
 
     Returns None when no symbol set gives text that is ``usable`` (parses,
     by default). Raises ConditionalError when the result, seen through any
     of the symbol sets used, is not the same code as the source
-    (``same_code`` compares two masked texts).
+    (``same_code`` compares two masked texts). With ``tight``, blank lines
+    next to conditional directives are dropped.
     """
     sets = covering_sets(source, usable)
     if not sets:
@@ -388,7 +423,10 @@ def format_conditional(
     text = source
     for symbols in sets:
         masked = mask(text, symbols)
-        text = restore(format_masked(masked.text), masked.hidden)
+        formatted = format_masked(masked.text)
+        if tight:
+            formatted = tighten(formatted, masked.hidden)
+        text = restore(formatted, masked.hidden)
     for symbols in sets:
         if not same_code(mask(source, symbols).text, mask(text, symbols).text):
             raise BranchChanged("a branch of an #if would change in meaning")

{prettycsharp-1.1.4 → prettycsharp-1.1.6}/src/prettycsharp/formatter.py

@@ -92,6 +92,7 @@ def _format(source: str, settings: Settings, lang_version: float) -> FormatResul
                 functools.partial(_format_view, settings=hiding, lang_version=lang_version, around=around, kept=kept),
                 functools.partial(_same_view, around=around),
                 _usable_around if around else conditional.parses,
+                tight=settings.directive_blank_lines == "remove",
             )
         except conditional.BranchChanged as error:
             raise FormattingError(str(error)) from None

{prettycsharp-1.1.4 → prettycsharp-1.1.6}/src/prettycsharp/printer/core.py

@@ -72,6 +72,9 @@ _MERGING_PAIRS = {
 _URL = re.compile(r"\w+://")
 _LIST_ITEM = re.compile(r"^(?:[-*+]\s|\d+[.)]\s)")
 
+# Directives that open a conditional branch; as list items they end in #endif.
+_CONDITIONAL_TYPES = frozenset({"preproc_if", "preproc_elif", "preproc_else"})
+
 _INDENTING = frozenset(
     {"declaration_list", "block", "accessor_list", "enum_member_declaration_list"}
 )
@@ -344,6 +347,22 @@ class Core:
             return first.leading[0].newlines_before >= 2
         return first.newlines_before >= 2
 
+    def tight_directive(self, previous: Node, item: Node) -> bool:
+        """Whether ``directive_blank_lines`` removes the blank line between two items.
+
+        An #if item ends in #endif; a member can start with an #if around its
+        attributes. A comment above an #if keeps the blank line above it,
+        since that line is not next to the directive.
+        """
+        if self.settings.directive_blank_lines != "remove":
+            return False
+        if previous.type in _CONDITIONAL_TYPES:
+            return True
+        starts_with_if = item.type in _CONDITIONAL_TYPES or (
+            bool(item.children) and item.children[0].type == "preproc_if_in_attribute_list"
+        )
+        return starts_with_if and not self.has_comments_before(item)
+
     def has_comments_before(self, node: Node) -> bool:
         first = node.first_token()
         return first is not None and bool(first.leading)

{prettycsharp-1.1.4 → prettycsharp-1.1.6}/src/prettycsharp/printer/declarations.py

@@ -71,6 +71,8 @@ class Declarations(Statements):
         return parts
 
     def top_blank(self, previous: Node, item: Node) -> bool:
+        if self.tight_directive(previous, item):
+            return False
         if previous.type == "file_scoped_namespace_declaration":
             return self.settings.max_blank_lines > 0
         if previous.type in DIRECTIVE_TYPES or item.type in DIRECTIVE_TYPES:
@@ -141,7 +143,8 @@ class Declarations(Statements):
             node.text is not None and node.text.startswith("#") and node.column == 0 and not node.leading
         )
         line: Doc = HARDLINE
-        if self.has_blank_before(node):
+        # Every line placed here is next to a directive line.
+        if self.has_blank_before(node) and self.settings.directive_blank_lines != "remove":
             line = [HARDLINE, HARDLINE]
         return [line, TRIM_INDENT] if at_zero else line
 
@@ -222,6 +225,8 @@ class Declarations(Statements):
         return self.print_list(items, self.member_blank, aligned=aligned)
 
     def member_blank(self, previous: Node, item: Node) -> bool:
+        if self.tight_directive(previous, item):
+            return False
         if previous.type in DIRECTIVE_TYPES or item.type in DIRECTIVE_TYPES:
             return self.directive_blank(previous, item)
         if self.settings.max_blank_lines == 0:

{prettycsharp-1.1.4 → prettycsharp-1.1.6}/src/prettycsharp/printer/expressions.py

@@ -277,11 +277,19 @@ class Expressions(Core):
         if value.verbatim:
             return False
         if value.type in _BLOCK_LIKE:
-            return True
+            # An empty `[]` is one word: it moves to the next line whole.
+            return not self._empty_collection(value)
         if value.type in _CREATION_TYPES:
             return value.child("initializer") is not None or value.first_of("initializer_expression") is not None
         return False
 
+    def _empty_collection(self, node: Node) -> bool:
+        """An empty collection expression with no comments inside: `[]`."""
+        if node.type != "collection_expression" or len(node.children) != 2:
+            return False
+        open_tok, close_tok = node.children
+        return not open_tok.trailing and not close_tok.leading
+
     # Member chains -------------------------------------------------------
 
     def p_invocation_expression(self, node: Node) -> Doc:
@@ -655,6 +663,8 @@ class Expressions(Core):
         open_tok = node.children[0]
         close_tok = node.children[-1]
         items, commas = self.items_and_commas(node)
+        if self._empty_collection(node):
+            return [self.tok(open_tok), self.tok(close_tok)]
         if not items:
             return group([self.tok(open_tok), self.closing(close_tok, SOFTLINE)])
         docs = self._comma_docs(items, commas, may_add=True)
@@ -1005,7 +1015,8 @@ class Expressions(Core):
         return self.join_tokens([(c, self.print(c)) for c in node.children])
 
     def p_array_type(self, node: Node) -> Doc:
-        return self.join_tokens([(c, self.print(c)) for c in node.children])
+        # A rank follows its element type tight, nullable or not: `object?[]`.
+        return [self.print(c) for c in node.children]
 
     def p_array_rank_specifier(self, node: Node) -> Doc:
         parts: list[Doc] = []
@@ -1040,7 +1051,8 @@ class Expressions(Core):
         return self.generic(node)
 
     def p_spread_element(self, node: Node) -> Doc:
-        return self.join_tokens([(c, self.print(c)) for c in node.children])
+        # Visual Studio spaces a spread, `[.. items]`, unlike a range, `items[..2]`.
+        return self.spaced(node.children)
 
 
 class _OperatorMarker(Node):

{prettycsharp-1.1.4 → prettycsharp-1.1.6}/src/prettycsharp/printer/statements.py

@@ -76,6 +76,8 @@ class Statements(Expressions):
         return self.print_list(items, self.statement_blank, aligned=self.aligned_assignments(items))
 
     def statement_blank(self, previous: Node, item: Node) -> bool:
+        if self.tight_directive(previous, item):
+            return False
         if previous.type in DIRECTIVE_TYPES or item.type in DIRECTIVE_TYPES:
             return self.has_blank_before(item)
         if self.settings.blank_lines_around_blocks and (self.is_block_statement(previous) or self.is_block_statement(item)):
@@ -225,18 +227,25 @@ class Statements(Expressions):
         close_tok = node.children[close_index]
         body = node.children[close_index + 1] if close_index + 1 < len(node.children) else None
         open_index = node.children.index(open_tok)
+        header_children = node.children[open_index + 1 : close_index]
+        empty = not any(child.named for child in header_children)
         inner: list[Doc] = []
         pending_space = False
-        for child in node.children[open_index + 1 : close_index]:
+        for child in header_children:
+            if pending_space:
+                inner.append(LINE)
             if child.text in (";", ",") and not child.named:
                 inner.append(self.tok(child))
                 pending_space = True
                 continue
-            if pending_space:
-                inner.append(LINE)
             pending_space = False
             inner.append(self.print(child))
-        header = group([self.tok(keyword), " ", self.tok(open_tok), indent([SOFTLINE, inner]), SOFTLINE, self.tok(close_tok)])
+        header = group(
+            [
+                self.tok(keyword), " ", self.tok(open_tok), indent([SOFTLINE, inner]),
+                LINE if empty else SOFTLINE, self.tok(close_tok),
+            ]
+        )
         if body is None:
             return header
         return [header, self.embedded(body, close_tok, node)]
@@ -321,6 +330,8 @@ class Statements(Expressions):
         return [self.tok(open_tok), body, self.close_comments(close_tok), HARDLINE, self.tok(close_tok, leading=False)]
 
     def section_blank(self, previous: Node, item: Node) -> bool:
+        if self.tight_directive(previous, item):
+            return False
         if previous.type in DIRECTIVE_TYPES or item.type in DIRECTIVE_TYPES:
             return self.has_blank_before(item)
         if not self.settings.switch_case_blank_lines or self.settings.max_blank_lines == 0:

{prettycsharp-1.1.4 → prettycsharp-1.1.6}/src/prettycsharp/settings.py

@@ -58,6 +58,7 @@ class Settings:
     member_blank_lines: str = "group_fields"
     blank_lines_around_blocks: bool = True
     max_blank_lines: int = 1
+    directive_blank_lines: str = "remove"
 
     argument_wrap: str = "one_per_line"
     chain_break_threshold: int = 2
@@ -128,6 +129,7 @@ _CHOICES: dict[str, tuple[str, ...]] = {
     "braces": ("preserve", "always", "single_line_only"),
     "empty_bodies": ("inline", "allman"),
     "member_blank_lines": ("group_fields", "all", "preserve"),
+    "directive_blank_lines": ("remove", "preserve"),
     "argument_wrap": ("one_per_line", "one_per_line_close_on_last", "fill", "align"),
     "expression_body_chain": ("own_line", "hang"),
     "binary_wrap": ("before_operator_paren_own_line", "before_operator", "after_operator"),

{prettycsharp-1.1.4 → prettycsharp-1.1.6}/tests/test_conditional.py

@@ -87,6 +87,106 @@ def test_covering_sets_reach_every_branch() -> None:
     assert frozenset({"B"}) in sets
 
 
+def test_no_blank_lines_next_to_conditional_directives() -> None:
+    # The first parses whole; the second splits a class header, so each view
+    # is formatted on its own.
+    check(
+        """
+        class C
+        {
+            int a;
+
+        #if X
+
+            int b;
+
+        #else
+
+            int c;
+
+        #endif
+
+            void M() { A();
+
+        #if DEBUG
+                Log();
+        #endif
+
+                B(); }
+
+        #if X
+            [A]
+        #endif
+            void N() { }
+        }
+        """,
+        """
+        class C
+        {
+            int a;
+        #if X
+            int b;
+        #else
+            int c;
+        #endif
+            void M()
+            {
+                A();
+        #if DEBUG
+                Log();
+        #endif
+                B();
+            }
+        #if X
+            [A]
+        #endif
+            void N() { }
+        }
+        """,
+    )
+    check(
+        """
+        #if NET
+
+        class A : B
+        {
+
+        #else
+
+        class A
+        {
+
+        #endif
+
+            int a;
+
+        #if X
+
+            int b;
+
+        #endif
+
+            void M() { }
+        }
+        """,
+        """
+        #if NET
+        class A : B
+        {
+        #else
+        class A
+        {
+        #endif
+            int a;
+        #if X
+            int b;
+        #endif
+            void M() { }
+        }
+        """,
+    )
+
+
 def test_split_class_header_formats_every_branch() -> None:
     check(
         """
@@ -120,7 +220,6 @@ def test_split_class_header_formats_every_branch() -> None:
         #endif
             {
                 public static int Size = 3;
-
         #if NET10_0_OR_GREATER
                 public ValueTask DisposeAsync() => ValueTask.CompletedTask;
         #else
@@ -194,7 +293,6 @@ def test_usings_do_not_move_across_directives() -> None:
         #endif
         using Beta;
         using Gamma;
-
         #if NET
         class C : I
         #else

{prettycsharp-1.1.4 → prettycsharp-1.1.6}/tests/test_layout.py

@@ -1,8 +1,30 @@
 """The default layout, one DESIGN.md decision per test."""
 
+import pytest
+
 from support import check, fmt
 
 
+@pytest.mark.parametrize(
+    ("source", "expected"),
+    [
+        (";;", "; ; "),
+        ("int i=0;;", "int i = 0; ;"),
+        (";i<10;", "; i < 10;"),
+        (";;i++", "; ; i++"),
+        ("int i=0;i<10;", "int i = 0; i < 10;"),
+        ("int i=0;;i++", "int i = 0; ; i++"),
+        (";i<10;i++", "; i < 10; i++"),
+        ("int i=0;i<10;i++", "int i = 0; i < 10; i++"),
+        ("int i=0,j=1;;i++,j--", "int i = 0, j = 1; ; i++, j--"),
+        ("var start=query[0]=='?'?1:0;;", "var start = query[0] == '?' ? 1 : 0; ;"),
+        ("int i=0;/* condition omitted */;", "int i = 0; /* condition omitted */ ;"),
+    ],
+)
+def test_for_header_spacing_with_omitted_clauses(source: str, expected: str) -> None:
+    check(f"for({source}){{break;}}", f"for ({expected})\n{{\n    break;\n}}\n")
+
+
 def test_allman_braces_with_blank_line_before_continuations() -> None:
     check(
         """
@@ -707,6 +729,42 @@ def test_obvious_parentheses_are_removed_and_clarifying_ones_kept() -> None:
     )
 
 
+def test_nullable_array_types_stay_tight() -> None:
+    source = (
+        "void M(params object?[]? values) { }\n"
+        "\n"
+        "int?[] a = new int?[3];\n"
+        "List<string?[]> b = (string?[][])o;\n"
+        "var c = x is int?[] d;\n"
+        "var e = f ? [1] : [2];\n"
+        "var g = h?[i];\n"
+    )
+    assert fmt(source) == source
+
+
+def test_empty_collection_moves_to_the_next_line_whole() -> None:
+    check(
+        "class C { IEnumerable<Entry> Entries(string path, IMimeTypeProvider provider) => []; int[] xs = []; }\n",
+        """
+        class C
+        {
+            IEnumerable<Entry> Entries(string path, IMimeTypeProvider provider) =>
+                [];
+
+            int[] xs = [];
+        }
+        """,
+        max_line_length=74,
+    )
+
+
+def test_spread_elements_are_spaced_and_ranges_are_not() -> None:
+    assert fmt("x = [..entries, 1, ..more];\n") == "x = [.. entries, 1, .. more];\n"
+    assert fmt("var r = entries[1..] + entries[..2] + entries[..];\n") == (
+        "var r = entries[1..] + entries[..2] + entries[..];\n"
+    )
+
+
 def test_empty_body_after_a_header_that_spans_lines_gets_its_own_line() -> None:
     # Visual Studio (IDE0055) keeps `{ }` on the header's line only when the
     # header is one line.

{prettycsharp-1.1.4 → prettycsharp-1.1.6}/tests/test_settings.py

@@ -315,6 +315,12 @@ def test_comment_space_and_wrap_off() -> None:
     )
 
 
+def test_directive_blank_lines_preserve() -> None:
+    source = "class C\n{\n    int a;\n\n#if X\n\n    int b;\n\n#endif\n\n    int c;\n}\n"
+    assert fmt(source, directive_blank_lines="preserve") == source
+    assert fmt(source) == "class C\n{\n    int a;\n#if X\n    int b;\n#endif\n    int c;\n}\n"
+
+
 def test_max_blank_lines_zero() -> None:
     assert fmt("void M() { A();\n\n B(); }\n", max_blank_lines=0) == "void M()\n{\n    A();\n    B();\n}\n"