prettycsharp 1.1.3__tar.gz → 1.1.5__tar.gz

{prettycsharp-1.1.3 → prettycsharp-1.1.5}/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 Each release's section becomes the body of its GitHub release.
 
+## [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,
+  as Visual Studio formats it. Before, `) { }` after a broken parameter
+  list, constructor initializer, `where` clause, base list, catch filter or
+  lambda parameter list was flagged by IDE0055. A header on one line keeps
+  `{ }` beside it.
+
 ## [1.1.3] - 2026-10-17
 
 - A property's accessor list or an enum that holds only a comment no longer

{prettycsharp-1.1.3 → prettycsharp-1.1.5}/DESIGN.md

@@ -104,7 +104,7 @@ stops the search, and the file nearest the source wins.
 | `brace_style` | `allman` | `kr`, `mixed` (Allman for types and members, K&R in method bodies) |
 | `continuation_keywords` | `blank_line`: `else`, `else if`, `catch`, `finally`, and a `do` loop's `while` go on their own line after a blank line | `new_line`, `same_line` |
 | `braces` | `preserve` | `always`, `single_line_only` |
-| `empty_bodies` | `inline`: `{ }` on the declaration line | `allman` |
+| `empty_bodies` | `inline`: `{ }` on the declaration line, or on its own line when the header spans lines | `allman` |
 
 Short auto-property accessors always stay on one line: `public int Id { get; set; }`.
 
@@ -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.

{prettycsharp-1.1.3 → prettycsharp-1.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: prettycsharp
-Version: 1.1.3
+Version: 1.1.5
 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.3 → prettycsharp-1.1.5}/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.3"
+__version__ = "1.1.5"
 
 __all__ = [
     "CSharpSyntaxError",

{prettycsharp-1.1.3 → prettycsharp-1.1.5}/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.3 → prettycsharp-1.1.5}/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.3 → prettycsharp-1.1.5}/src/prettycsharp/printer/core.py

@@ -22,6 +22,7 @@ from prettycsharp.doc import (
     TRIM_INDENT,
     Doc,
     Group,
+    IfBreak,
     LineSuffix,
     Wrapped,
     group,
@@ -71,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"}
 )
@@ -90,6 +94,8 @@ class Core:
         self.file = file
         self.lang = lang_version
         self._blank_stack: list[Callable[[Node, Node], bool]] = []
+        # Tokens whose leading comments were printed ahead of them.
+        self._hoisted: set[int] = set()
         self._handlers: dict[str, Handler] = {}
         for name in dir(self):
             if name.startswith("p_"):
@@ -115,7 +121,7 @@ class Core:
         if t.text is None:
             return self.print(t)
         parts: list[Doc] = []
-        if leading and t.leading:
+        if leading and t.leading and id(t) not in self._hoisted:
             parts.append(self.leading_comments(t))
         parts.append(self.token_text(t))
         if trailing and t.trailing:
@@ -133,6 +139,16 @@ class Core:
         # breaks kept as written, its continuation lines not reindented.
         return [text, BREAK_PARENT]
 
+    def hoist_leading(self, node: Node | None) -> Doc:
+        """The comments before ``node``'s first token, printed now instead of with it."""
+        if node is None or node.verbatim:
+            return ""
+        first = next(node.tokens(), None)
+        if first is None or not first.leading or first.verbatim:
+            return ""
+        self._hoisted.add(id(first))
+        return self.leading_comments(first)
+
     def leading_comments(self, t: Node, *, first_blank_allowed: bool = False) -> Doc:
         """The comments before a token, each on its own line, then the token's line."""
         # Each comment stood on its own line: start one if code is already on this line.
@@ -331,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)
@@ -486,6 +518,13 @@ class Core:
             before.append(HARDLINE)
         return indent([*before, parts])
 
+    def after_header(self, head_id: object | None) -> Doc:
+        """What goes before an empty inline body: a space, or a line break when
+        the header group ``head_id`` spans lines, as Visual Studio formats it."""
+        if head_id is None:
+            return " "
+        return IfBreak(HARDLINE, " ", group_id=head_id)
+
     def open_brace(self, context: str) -> Doc:
         """What goes before an opening brace: a line break or a space."""
         style = self.settings.brace_style

{prettycsharp-1.1.3 → prettycsharp-1.1.5}/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
 
@@ -193,7 +196,7 @@ class Declarations(Statements):
     def p_file_scoped_namespace_declaration(self, node: Node) -> Doc:
         return self.words(node.children)
 
-    def declaration_body(self, body: Node, context: str) -> Doc:
+    def declaration_body(self, body: Node, context: str, head_id: object | None = None) -> Doc:
         if len(body.children) < 2 or body.verbatim:
             return [" ", self.print(body)]
         open_tok = body.children[0]
@@ -201,7 +204,7 @@ class Declarations(Statements):
         items = body.children[1:-1]
         if not items and not close_tok.leading and not open_tok.trailing:
             if self.settings.empty_bodies == "inline":
-                return [" ", self.tok(open_tok), " ", self.tok(close_tok)]
+                return [self.after_header(head_id), self.tok(open_tok), " ", self.tok(close_tok)]
             return [self.open_brace(context), self.tok(open_tok), HARDLINE, self.tok(close_tok)]
         inner: Doc = ""
         if items:
@@ -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:
@@ -261,14 +266,17 @@ class Declarations(Statements):
         if body is None:
             body = node.first_of("declaration_list", "enum_member_declaration_list")
         attributes, header, constraints, tail = self.split_declaration(node, body)
-        parts: list[Doc] = [self.attribute_lines(attributes), self.header(header)]
+        comments = self.hoist_leading(header[0] if header else None)
+        head: list[Doc] = [self.header(header)]
         if constraints:
-            parts.append(self.constraints(constraints))
+            head.append(self.constraints(constraints))
+        head_id = object()
+        parts: list[Doc] = [self.attribute_lines(attributes), comments, group(head, id=head_id)]
         if body is not None:
             if body.type == "enum_member_declaration_list":
-                parts.append(self.enum_body(body))
+                parts.append(self.enum_body(body, head_id))
             else:
-                parts.append(self.declaration_body(body, "type"))
+                parts.append(self.declaration_body(body, "type", head_id))
         parts.append(self.words(tail) if tail else "")
         return parts
 
@@ -363,7 +371,7 @@ class Declarations(Statements):
 
     # Enums ----------------------------------------------------------------
 
-    def enum_body(self, body: Node) -> Doc:
+    def enum_body(self, body: Node, head_id: object | None = None) -> Doc:
         if len(body.children) < 2 or any(c.type in DIRECTIVE_TYPES for c in body.children):
             return [" ", self.verbatim(body)]
         open_tok = body.children[0]
@@ -371,7 +379,7 @@ class Declarations(Statements):
         items, commas = self.items_and_commas(body)
         if not items and not close_tok.leading:
             if self.settings.empty_bodies == "inline":
-                return [" ", self.tok(open_tok), " ", self.tok(close_tok)]
+                return [self.after_header(head_id), self.tok(open_tok), " ", self.tok(close_tok)]
             return [self.open_brace("type"), self.tok(open_tok), HARDLINE, self.tok(close_tok)]
         members = [item[0] for item in items if len(item) == 1]
         if len(members) != len(items):
@@ -452,17 +460,20 @@ class Declarations(Statements):
                 break
             else:
                 header.append(child)
-        parts: list[Doc] = [self.attribute_lines(attributes), self.header(header)]
+        comments = self.hoist_leading(header[0] if header else None)
+        head: list[Doc] = [self.header(header)]
         if ctor_init is not None:
-            parts.append(group(indent([LINE, self.print(ctor_init)])))
+            head.append(group(indent([LINE, self.print(ctor_init)])))
         if constraints:
-            parts.append(self.constraints(constraints))
+            head.append(self.constraints(constraints))
+        head_id = object()
+        parts: list[Doc] = [self.attribute_lines(attributes), comments, group(head, id=head_id)]
         rest = node.children[tail_start:]
         i = 0
         while i < len(rest):
             child = rest[i]
             if child is body and child.type == "block":
-                parts.append(self.block(child, "member"))
+                parts.append(self.block(child, "member", head_id))
             elif child.type == "arrow_expression_clause":
                 parts.append(self.expression_body(child))
             elif child is accessors:

{prettycsharp-1.1.3 → prettycsharp-1.1.5}/src/prettycsharp/printer/expressions.py

@@ -128,7 +128,7 @@ class _Link:
 
 
 class Expressions(Core):
-    def block(self, block: Node, context: str) -> Doc:  # pragma: no cover - Statements defines it
+    def block(self, block: Node, context: str, head_id: object | None = None) -> Doc:  # pragma: no cover - Statements defines it
         raise NotImplementedError
 
     # Binary operators ---------------------------------------------------
@@ -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)
@@ -724,6 +734,7 @@ class Expressions(Core):
         body = node.child("body")
         if arrow is None or body is None:
             return self.generic(node)
+        comments = self.hoist_leading(node.children[0]) if body.type == "block" else ""
         head: list[Doc] = []
         previous: Node | None = None
         for child in node.children:
@@ -734,7 +745,8 @@ class Expressions(Core):
             head.append(self.print(child))
             previous = child
         if body.type == "block":
-            return [head, " ", self.tok(arrow), self.block(body, "lambda")]
+            head_id = object()
+            return [comments, group([head, " ", self.tok(arrow)], id=head_id), self.block(body, "lambda", head_id)]
         body_doc = self.print(body)
         if self.self_breaking(body) or self.block_like(body):
             return [head, " ", self.tok(arrow), " ", body_doc]
@@ -1003,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] = []
@@ -1038,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.3 → prettycsharp-1.1.5}/src/prettycsharp/printer/statements.py

@@ -39,10 +39,13 @@ _EMBEDDED_PARENTS = frozenset(
 class Statements(Expressions):
     # Blocks ---------------------------------------------------------------
 
-    def block(self, block: Node, context: str) -> Doc:
-        """A block after a header: the brace's line break or space, then the braces."""
+    def block(self, block: Node, context: str, head_id: object | None = None) -> Doc:
+        """A block after a header: the brace's line break or space, then the braces.
+
+        ``head_id`` names the header's group, for headers whose empty body
+        moves to its own line when the header spans lines."""
         if self.is_empty_block(block) and self.settings.empty_bodies == "inline":
-            return [" ", self.block_braces(block)]
+            return [self.after_header(head_id), self.block_braces(block)]
         return [self.open_brace(context), self.block_braces(block)]
 
     def is_empty_block(self, block: Node) -> bool:
@@ -73,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)):
@@ -318,6 +323,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:
@@ -365,7 +372,9 @@ class Statements(Expressions):
         block = node.children[-1] if node.children else None
         if block is None or block.type != "block":
             return self.generic(node)
-        return [self.spaced(node.children[:-1]), self.block(block, "statement")]
+        comments = self.hoist_leading(node.children[0])
+        head_id = object()
+        return [comments, group(self.spaced(node.children[:-1]), id=head_id), self.block(block, "statement", head_id)]
 
     def p_finally_clause(self, node: Node) -> Doc:
         return self.p_catch_clause(node)

{prettycsharp-1.1.3 → prettycsharp-1.1.5}/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.3 → prettycsharp-1.1.5}/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.3 → prettycsharp-1.1.5}/tests/test_layout.py

@@ -707,6 +707,126 @@ 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.
+    check(
+        """
+        // Redirects.
+        class RedirectModule : ModuleBase
+        {
+            public RedirectModule(string baseRoute, Uri redirectUrl, Func<IHttpContext, bool>? shouldRedirect, HttpStatusCode statusCode) { }
+            public RedirectModule(long alphabetical, long betamaxfactor, long gammaradiation, long deltaforce) : base(alphabetical) { }
+            public void Generic<TFirstTypeParameter, TSecondTypeParameter>(TFirstTypeParameter first, TSecondTypeParameter s) where TFirstTypeParameter : class { }
+            public RedirectModule(int a) : base() { }
+            // Short.
+            public void G<T>() where T : class { }
+        }
+        public abstract class EmptyAbstractWithAVeryLongNameIndeed<TFirstTypeParameter, TSecondTypeParameter> : Base where TFirstTypeParameter : class { }
+        """,
+        """
+        // Redirects.
+        class RedirectModule : ModuleBase
+        {
+            public RedirectModule(
+                string baseRoute,
+                Uri redirectUrl,
+                Func<IHttpContext, bool>? shouldRedirect,
+                HttpStatusCode statusCode
+            )
+            { }
+
+            public RedirectModule(long alphabetical, long betamaxfactor, long gammaradiation, long deltaforce)
+                : base(alphabetical)
+            { }
+
+            public void Generic<TFirstTypeParameter, TSecondTypeParameter>(TFirstTypeParameter first, TSecondTypeParameter s)
+                where TFirstTypeParameter : class
+            { }
+
+            public RedirectModule(int a) : base() { }
+
+            // Short.
+            public void G<T>() where T : class { }
+        }
+
+        public abstract class EmptyAbstractWithAVeryLongNameIndeed<TFirstTypeParameter, TSecondTypeParameter> : Base
+            where TFirstTypeParameter : class
+        { }
+        """,
+    )
+
+
+def test_empty_catch_and_lambda_bodies_after_a_header_that_spans_lines() -> None:
+    check(
+        """
+        void M()
+        {
+            try { }
+            // Ignored.
+            catch (Exception error) when (IsRecoverable(error)) { }
+            Run((first, second, third) => { });
+        }
+        """,
+        """
+        void M()
+        {
+            try { }
+
+            // Ignored.
+            catch (Exception error) when (IsRecoverable(
+                error
+            ))
+            { }
+
+            Run((
+                first,
+                second,
+                third
+            ) =>
+            { });
+        }
+        """,
+        max_line_length=30,
+    )
+
+
 def test_accessor_list_and_enum_holding_only_a_comment() -> None:
     check(
         "class C { int P {\n// c\n} }\nenum E {\n// c\n}\n",

{prettycsharp-1.1.3 → prettycsharp-1.1.5}/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"