prettycsharp 1.1.2__tar.gz → 1.1.4__tar.gz

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

@@ -2,6 +2,19 @@
 
 Each release's section becomes the body of its GitHub release.
 
+## [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
+  gains a blank line each time the file is formatted. Found by fuzzing.
+
 ## [1.1.2] - 2026-10-17
 
 - Nothing is padded into columns by default any more: `align_assignments`,

{prettycsharp-1.1.2 → prettycsharp-1.1.4}/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; }`.
 

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

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

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

@@ -22,6 +22,7 @@ from prettycsharp.doc import (
     TRIM_INDENT,
     Doc,
     Group,
+    IfBreak,
     LineSuffix,
     Wrapped,
     group,
@@ -90,6 +91,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 +118,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 +136,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.
@@ -486,6 +499,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.2 → prettycsharp-1.1.4}/src/prettycsharp/printer/declarations.py

@@ -193,7 +193,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 +201,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:
@@ -261,14 +261,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 +366,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 +374,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):
@@ -399,7 +402,7 @@ class Declarations(Statements):
         return [
             self.open_brace("type"),
             self.tok(open_tok),
-            indent([HARDLINE, lines]),
+            indent([HARDLINE, lines]) if lines else "",
             self.close_comments(close_tok),
             HARDLINE,
             self.tok(close_tok, leading=False),
@@ -452,17 +455,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:
@@ -522,10 +528,13 @@ class Declarations(Statements):
             return [" ", self.tok(open_tok), " ", join(" ", [self.print(a) for a in accessors]), " ", self.tok(close_tok)]
         if not accessors and not close_tok.leading:
             return [" ", self.tok(open_tok), " ", self.tok(close_tok)]
+        body: Doc = ""
+        if accessors:
+            body = indent([HARDLINE, self.print_list(accessors, lambda a, b: self.has_blank_before(b))])
         return [
             self.open_brace("accessor"),
             self.tok(open_tok),
-            indent([HARDLINE, self.print_list(accessors, lambda a, b: self.has_blank_before(b))]),
+            body,
             self.close_comments(close_tok),
             HARDLINE,
             self.tok(close_tok, leading=False),

{prettycsharp-1.1.2 → prettycsharp-1.1.4}/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 ---------------------------------------------------
@@ -724,6 +724,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 +735,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]

{prettycsharp-1.1.2 → prettycsharp-1.1.4}/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:
@@ -365,7 +368,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.2 → prettycsharp-1.1.4}/tests/test_layout.py

@@ -707,6 +707,110 @@ def test_obvious_parentheses_are_removed_and_clarifying_ones_kept() -> None:
     )
 
 
+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",
+        """
+        class C
+        {
+            int P
+            {
+                // c
+            }
+        }
+
+        enum E
+        {
+            // c
+        }
+        """,
+    )
+
+
 def test_auto_properties_and_empty_bodies_stay_on_one_line() -> None:
     check(
         """