prettycsharp 1.1.8__tar.gz → 1.1.10__tar.gz

{prettycsharp-1.1.8 → prettycsharp-1.1.10}/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 Each release's section becomes the body of its GitHub release.
 
+## [1.1.10] - 2026-10-18
+
+- A tuple argument ending in a multiline block lambda closes the tuple and
+  call parentheses on their own line at the call's indentation, matching
+  Visual Studio's formatting. Ordinary lambda arguments keep their layout.
+- Empty argument parentheses without interior comments stay together as
+  `()`. Long empty-constructor assignments break after `=` instead of
+  splitting the parentheses. Interior comments are preserved.
+
+## [1.1.9] - 2026-10-18
+
+- With the default `binary_wrap`, multiline conditions in catch filters,
+  `if`, and loops start below `(` and put `)` on its own line. This includes
+  pattern chains, mixed Boolean conditions, and predicate calls.
+- Inline collection expressions keep tight brackets around complex elements
+  and spreads, such as `[new HpackField(wire, "")]` and `[.. source.Select(...)]`,
+  avoiding Visual Studio's IDE0055 formatting diagnostic.
+- A multiline collection argument no longer adds a blank line after the
+  call's opening parenthesis.
+- Chains of negated patterns, including `is not A and not B` followed by
+  Boolean operators, wrap at one consistent continuation indentation level.
+
 ## [1.1.8] - 2026-10-18
 
 - Long `or` and `and` patterns wrap at the configured line width using

{prettycsharp-1.1.8 → prettycsharp-1.1.10}/DESIGN.md

@@ -177,7 +177,21 @@ parenthesis unless all three clauses are empty: `for (; ; )`.
 | `ternary_wrap` | `before`: break before `?` and `:` when too long | `after`, `always` |
 | `lambda_body` | `hug`: the last argument hangs off the call line when it is a lambda with a block body or a broken member chain, or a creation with a broken initializer | `argument` |
 
+With `lambda_body = "hug"` and `argument_wrap = "one_per_line"`, a single
+tuple argument ending in a multiline block lambda closes both enclosing
+parentheses on their own line at the call's indentation.
+
+Empty argument parentheses without interior comments stay together as `()`.
+An overlong assignment to an empty constructor breaks after `=` instead of
+splitting the empty parentheses.
+
 `binary_wrap` also controls line breaks in `or` and `and` patterns.
+With `before_operator_paren_own_line`, broken conditions in catch
+filters, `if`, `while`, and `do` loops put the expression below `(` and `)`
+on its own line, including predicate calls and mixed Boolean/pattern
+conditions. Pattern operators take one further continuation indent.
+Negated pattern chains and trailing Boolean operators share one continuation
+indent, including `value is not A and not B && condition`.
 
 ```csharp
 var invoice = invoiceService.CreateInvoice(
@@ -225,6 +239,11 @@ orders.ForEach(order =>
 | `simple_lists_inline` | `true`: lists of literals, constants, and plain names stay on one line when they fit | `false` |
 | `trailing_commas` | `remove` | `add`, `preserve` |
 
+Inline collection expressions keep their brackets tight, including complex
+elements: `[new Item()]`. Broken collections put the elements on new lines.
+When a collection starts on an argument's own line, its opening bracket
+does not add another line break.
+
 ```csharp
 var empty = new Order { Id = 42 };
 

{prettycsharp-1.1.8 → prettycsharp-1.1.10}/PKG-INFO

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

{prettycsharp-1.1.8 → prettycsharp-1.1.10}/src/prettycsharp/printer/expressions.py

@@ -7,6 +7,7 @@ from collections.abc import Sequence
 from dataclasses import dataclass, field
 
 from prettycsharp.doc import (
+    ENSURE_LINE,
     HARDLINE,
     LINE,
     SOFTLINE,
@@ -227,6 +228,14 @@ class Expressions(Core):
         if value.verbatim:
             return False
         kind = value.type
+        if kind in ("object_creation_expression", "implicit_object_creation_expression") and not self.block_like(value):
+            arguments = value.first_of("argument_list")
+            if arguments is not None and len(arguments.children) == 2:
+                opening, closing = arguments.children
+                if not opening.trailing and not closing.leading:
+                    # An empty constructor cannot break internally; move the
+                    # whole value after the assignment operator when needed.
+                    return False
         if kind in _SELF_BREAKING:
             return True
         if kind == "await_expression":
@@ -460,7 +469,31 @@ class Expressions(Core):
         close_tok = node.children[-1]
         items, commas = self.items_and_commas(node)
         if not items:
+            if not open_tok.trailing and not close_tok.leading:
+                return [self.tok(open_tok), self.tok(close_tok)]
             return group([self.tok(open_tok), self.closing(close_tok, SOFTLINE)])
+        if (
+            node.type == "argument_list" and self.settings.lambda_body == "hug"
+            and self.settings.argument_wrap == "one_per_line" and len(items) == 1 and len(items[0]) == 1
+        ):
+            argument = items[0][0]
+            target = argument.children[-1] if argument.type == "argument" and len(argument.children) == 1 else argument
+            if target.type == "tuple_expression" and not target.verbatim:
+                tuple_items, tuple_commas = self.items_and_commas(target)
+                last = tuple_items[-1][0] if tuple_items and len(tuple_items[-1]) == 1 else None
+                value = last.children[-1] if last is not None and last.type == "argument" and last.children else last
+                body = value.child("body") if value is not None and value.type == "lambda_expression" else None
+                if (
+                    body is not None and body.type == "block" and self._can_hug(tuple_items)
+                    and (len(body.children) > 2 or any(t.leading or t.trailing for t in body.tokens()))
+                ):
+                    # Keep the tuple's lambda with the call header, but close
+                    # both parentheses at the call's indentation after its body.
+                    tuple_docs = self._comma_docs(tuple_items, tuple_commas)
+                    return [
+                        self.tok(open_tok), indent([self.tok(target.children[0]), join(" ", tuple_docs)]),
+                        self.closing(target.children[-1], HARDLINE), self.closing(close_tok, ""),
+                    ]
         docs = [self.print_item(item) for item in items]
         for i, comma in enumerate(commas):
             if i < len(docs):
@@ -678,7 +711,10 @@ class Expressions(Core):
             return group([self.tok(open_tok), indent([SOFTLINE, body]), self.closing(close_tok, SOFTLINE)])
         force = self._forced_initializer([[_element_value(i[0])] for i in items if len(i) == 1])
         return group(
-            [SOFTLINE, self.tok(open_tok), indent([LINE, join(LINE, docs)]), self.closing(close_tok, LINE)],
+            [
+                IfBreak(ENSURE_LINE, ""), self.tok(open_tok),
+                indent([SOFTLINE, join(LINE, docs)]), self.closing(close_tok, SOFTLINE),
+            ],
             should_break=force,
         )
 
@@ -870,8 +906,16 @@ class Expressions(Core):
     def p_is_expression(self, node: Node) -> Doc:
         return self.spaced(node.children)
 
-    def p_is_pattern_expression(self, node: Node) -> Doc:
-        return self.spaced(node.children)
+    def p_is_pattern_expression(self, node: Node, *, in_condition: bool = False) -> Doc:
+        pattern = node.child("pattern")
+        if not in_condition or pattern is None or pattern.verbatim or pattern.type not in (
+            "and_pattern", "or_pattern", "negated_pattern"
+        ):
+            return self.spaced(node.children)
+        return join(" ", [
+            self.logical_pattern(child, group_result=False) if child is pattern else self.print(child)
+            for child in node.children
+        ])
 
     def p_range_expression(self, node: Node) -> Doc:
         return self.join_tokens([(c, self.print(c)) for c in node.children])
@@ -941,13 +985,49 @@ class Expressions(Core):
         return self.spaced(node.children)
 
     def p_and_pattern(self, node: Node) -> Doc:
-        return self.binary(node, in_condition=False)
+        return self.logical_pattern(node)
 
     def p_or_pattern(self, node: Node) -> Doc:
-        return self.binary(node, in_condition=False)
+        return self.logical_pattern(node)
 
     def p_negated_pattern(self, node: Node) -> Doc:
-        return self.spaced(node.children)
+        return self.logical_pattern(node)
+
+    def logical_pattern(self, node: Node, *, group_result: bool = True) -> Doc:
+        # The grammar nests `not A and not B` under successive negations,
+        # sometimes including trailing &&/|| expressions in constant patterns.
+        # Share a continuation level without moving any tokens or parentheses.
+        segments: list[list[Node]] = [[]]
+        operators: list[Node] = []
+        stack = [node]
+        while stack:
+            current = stack.pop()
+            if current.type == "constant_pattern" and len(current.children) == 1 and not current.verbatim:
+                value = current.children[0]
+                value_op = value.child("operator")
+                if value.type == "binary_expression" and value_op is not None and value_op.text in ("&&", "||"):
+                    stack.append(value)
+                    continue
+            op = current.child("operator")
+            logical = current.type in ("and_pattern", "or_pattern", "negated_pattern") or (
+                current.type == "binary_expression" and op is not None and op.text in ("&&", "||")
+            )
+            if logical and not current.verbatim:
+                stack.extend(reversed(current.children))
+            elif not current.named and current.text in ("and", "or", "&&", "||"):
+                operators.append(current)
+                segments.append([])
+            else:
+                segments[-1].append(current)
+        first = self.spaced(segments[0])
+        rest: list[Doc] = []
+        for operator, segment in zip(operators, segments[1:], strict=True):
+            if self.settings.binary_wrap == "after_operator":
+                rest.append([" ", self.tok(operator), LINE, self.spaced(segment)])
+            else:
+                rest.append([LINE, self.tok(operator), " ", self.spaced(segment)])
+        contents: Doc = [first, indent(rest)]
+        return group(contents) if group_result else contents
 
     def p_declaration_pattern(self, node: Node) -> Doc:
         return self.spaced(node.children)

{prettycsharp-1.1.8 → prettycsharp-1.1.10}/src/prettycsharp/printer/statements.py

@@ -144,13 +144,18 @@ class Statements(Expressions):
     def condition(self, open_tok: Node, condition: Node, close_tok: Node) -> Doc:
         if (
             self.settings.binary_wrap == "before_operator_paren_own_line"
-            and condition.type == "binary_expression"
             and not condition.verbatim
         ):
+            if condition.type == "binary_expression":
+                contents = self.binary(condition, in_condition=True)
+            elif condition.type == "is_pattern_expression":
+                contents = self.p_is_pattern_expression(condition, in_condition=True)
+            else:
+                contents = self.print(condition)
             return group(
                 [
                     self.tok(open_tok),
-                    indent([SOFTLINE, self.binary(condition, in_condition=True)]),
+                    indent([SOFTLINE, contents]),
                     SOFTLINE,
                     self.tok(close_tok),
                 ]

{prettycsharp-1.1.8 → prettycsharp-1.1.10}/tests/test_layout.py

@@ -113,8 +113,67 @@ def test_catch_filter_wraps_logical_pattern_before_expanding_property_pattern()
         'try { Run(); } catch (Exception error) when (error is ObjectDisposedException or SocketException '
         'or ArgumentException { ParamName: "socketAddress" }) { Stop(); }',
         'try\n{\n    Run();\n}\n\n'
-        'catch (Exception error) when (error is ObjectDisposedException\n'
-        '    or SocketException\n    or ArgumentException { ParamName: "socketAddress" })\n{\n    Stop();\n}\n',
+        'catch (Exception error) when (\n    error is ObjectDisposedException\n'
+        '        or SocketException\n        or ArgumentException { ParamName: "socketAddress" }\n)\n{\n    Stop();\n}\n',
+    )
+
+
+def test_broken_pattern_catch_filter_puts_parentheses_on_own_lines() -> None:
+    check(
+        'try { Run(); } catch (Exception error) when '
+        '(error is SocketException or ObjectDisposedException or OperationCanceledException) { }',
+        'try\n{\n    Run();\n}\n\ncatch (Exception error) when (\n'
+        '    error is SocketException\n        or ObjectDisposedException\n'
+        '        or OperationCanceledException\n)\n{ }\n',
+        max_line_length=90,
+    )
+
+
+@pytest.mark.parametrize("keyword", ["if", "while"])
+def test_broken_pattern_conditions_share_catch_filter_layout(keyword: str) -> None:
+    check(
+        f'{keyword} (error is SocketException or ObjectDisposedException or OperationCanceledException) {{ Stop(); }}',
+        f'{keyword} (\n    error is SocketException\n        or ObjectDisposedException\n'
+        '        or OperationCanceledException\n)\n{\n    Stop();\n}\n',
+        max_line_length=65,
+    )
+
+
+def test_broken_pattern_do_while_condition_has_own_parenthesis_lines() -> None:
+    check(
+        'do { Run(); } while (error is SocketException or ObjectDisposedException or OperationCanceledException);',
+        'do\n{\n    Run();\n}\n\nwhile (\n    error is SocketException\n'
+        '        or ObjectDisposedException\n        or OperationCanceledException\n);\n',
+        max_line_length=65,
+    )
+
+
+@pytest.mark.parametrize("keyword", ["if", "while"])
+def test_short_pattern_condition_stays_inline(keyword: str) -> None:
+    check(f'{keyword} (x is A or B) {{ Run(); }}', f'{keyword} (x is A or B)\n{{\n    Run();\n}}\n')
+
+
+@pytest.mark.parametrize("keyword", ["if", "while"])
+def test_multiline_predicate_condition_uses_own_parenthesis_lines(keyword: str) -> None:
+    check(
+        f'{keyword} (Predicate(veryLongArgumentName, anotherLongArgumentName)) {{ Run(); }}',
+        f'{keyword} (\n    Predicate(\n        veryLongArgumentName,\n'
+        '        anotherLongArgumentName\n    )\n)\n{\n    Run();\n}\n',
+        max_line_length=50,
+    )
+
+
+@pytest.mark.parametrize("wrap", ["before_operator", "after_operator"])
+def test_pattern_conditions_respect_alternative_parenthesis_layout(wrap: str) -> None:
+    if wrap == "after_operator":
+        pattern = 'error is SocketException or\n    ObjectDisposedException or\n    OperationCanceledException'
+    else:
+        pattern = 'error is SocketException\n    or ObjectDisposedException\n    or OperationCanceledException'
+    check(
+        'if (error is SocketException or ObjectDisposedException or OperationCanceledException) { Run(); }',
+        f'if ({pattern})\n{{\n    Run();\n}}\n',
+        max_line_length=65,
+        binary_wrap=wrap,
     )
 
 
@@ -154,6 +213,16 @@ def test_short_logical_patterns_keep_grouping_and_stay_inline(pattern: str) -> N
     check(f"var ok=value is {pattern};", f"var ok = value is {pattern};\n")
 
 
+def test_negated_pattern_chain_and_boolean_tail_share_one_indent() -> None:
+    check(
+        "var persistent = _status is not 400 and not 408 and not 411 and not 413 and not 414 "
+        "and not 500 and not 503 && !_transport.IsDraining && KeepAlive;",
+        "var persistent = _status is not 400\n"
+        "    and not 408\n    and not 411\n    and not 413\n    and not 414\n"
+        "    and not 500\n    and not 503\n    && !_transport.IsDraining\n    && KeepAlive;\n",
+    )
+
+
 def test_call_breaks_one_argument_per_line_with_paren_on_its_own_line() -> None:
     check(
         """
@@ -827,6 +896,30 @@ def test_empty_collection_moves_to_the_next_line_whole() -> None:
     )
 
 
+def test_long_empty_constructor_keeps_parentheses_together() -> None:
+    check(
+        'private readonly ConcurrentDictionary<IPAddress, ConcurrentBag<long>> _failRegexMatches = '
+        'new ConcurrentDictionary<IPAddress, ConcurrentBag<long>>();',
+        'private readonly ConcurrentDictionary<IPAddress, ConcurrentBag<long>> _failRegexMatches =\n'
+        '    new ConcurrentDictionary<IPAddress, ConcurrentBag<long>>();\n',
+    )
+
+
+@pytest.mark.parametrize("wrap", ["one_per_line", "one_per_line_close_on_last", "fill", "align"])
+def test_empty_call_parentheses_never_split(wrap: str) -> None:
+    check(
+        'SomeVeryLongMethodName();', 'SomeVeryLongMethodName();\n',
+        max_line_length=12, argument_wrap=wrap,
+    )
+
+
+def test_comments_inside_empty_constructor_are_preserved() -> None:
+    source = 'var instance = new Item( // Keep this note.\n);'
+    output = fmt(source)
+    assert '// Keep this note.\n' in output
+    assert fmt(output) == output
+
+
 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") == (
@@ -834,6 +927,50 @@ def test_spread_elements_are_spaced_and_ranges_are_not() -> None:
     )
 
 
+@pytest.mark.parametrize("element", ['new HpackField(wire, "")', "GetField()", "wire.Length + 1", "wire"])
+@pytest.mark.parametrize("simple_inline", [True, False])
+def test_inline_collection_brackets_stay_tight(element: str, simple_inline: bool) -> None:
+    check(
+        f"Validate([ {element} ]);",
+        f"Validate([{element}]);\n",
+        simple_lists_inline=simple_inline,
+    )
+
+
+def test_collection_brackets_in_awaited_send_stay_tight() -> None:
+    check(
+        'await SendAsync([ new Http2Frame(6, 1, 0, frame.Payload) ], token).ConfigureAwait(false);',
+        'await SendAsync([new Http2Frame(6, 1, 0, frame.Payload)], token).ConfigureAwait(false);\n',
+    )
+
+
+def test_multiline_collection_argument_has_no_extra_blank_line() -> None:
+    check(
+        'await SendHeadersAsync([new HpackField(":status", "200"), '
+        'new HpackField("content-length", bytes.Length.ToString(CultureInfo.InvariantCulture))], '
+        'bytes.Length == 0 || Request.Method == "HEAD", token).ConfigureAwait(false);',
+        'await SendHeadersAsync(\n'
+        '    [\n'
+        '        new HpackField(":status", "200"),\n'
+        '        new HpackField("content-length", bytes.Length.ToString(CultureInfo.InvariantCulture))\n'
+        '    ],\n'
+        '    bytes.Length == 0 || Request.Method == "HEAD",\n'
+        '    token\n'
+        ').ConfigureAwait(false);\n',
+    )
+
+
+def test_spread_of_call_in_multiline_arguments_keeps_brackets_tight() -> None:
+    check(
+        '_session = Session.Start([ .. _prefixes.Select(value => new ListenerPrefix(value)) ], '
+        '_certificates, TlsPolicy, _native, DeferContinue, Telemetry, _bodyPolicy, _dispatcher);',
+        '_session = Session.Start(\n'
+        '    [.. _prefixes.Select(value => new ListenerPrefix(value))],\n'
+        '    _certificates,\n    TlsPolicy,\n    _native,\n    DeferContinue,\n'
+        '    Telemetry,\n    _bodyPolicy,\n    _dispatcher\n);\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.
@@ -901,9 +1038,9 @@ def test_empty_catch_and_lambda_bodies_after_a_header_that_spans_lines() -> None
             try { }
 
             // Ignored.
-            catch (Exception error) when (IsRecoverable(
-                error
-            ))
+            catch (Exception error) when (
+                IsRecoverable(error)
+            )
             { }
 
             Run((
@@ -967,6 +1104,26 @@ def test_auto_properties_and_empty_bodies_stay_on_one_line() -> None:
     )
 
 
+def test_tuple_block_lambda_closes_parentheses_on_the_call_line_indent() -> None:
+    check(
+        '_dataHandlerPairs.Add((data, (ctx, route) => { handler(ctx, route); return Task.CompletedTask; }));',
+        '_dataHandlerPairs.Add((data, (ctx, route) =>\n'
+        '    {\n        handler(ctx, route);\n        return Task.CompletedTask;\n    }\n));\n',
+    )
+
+
+def test_ordinary_block_lambda_argument_keeps_hugged_parenthesis() -> None:
+    check(
+        'Run(data, (ctx, route) => { handler(ctx, route); return Task.CompletedTask; });',
+        'Run(data, (ctx, route) =>\n'
+        '{\n    handler(ctx, route);\n    return Task.CompletedTask;\n});\n',
+    )
+
+
+def test_empty_tuple_lambda_stays_inline() -> None:
+    check('Run((data, () => { }));', 'Run((data, () => { }));\n')
+
+
 def test_object_initializer_hugs_the_last_argument() -> None:
     check(
         """