prettycsharp 1.1.8__tar.gz → 1.1.9__tar.gz

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

@@ -2,6 +2,19 @@
 
 Each release's section becomes the body of its GitHub release.
 
+## [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.9}/DESIGN.md

@@ -178,6 +178,12 @@ parenthesis unless all three clauses are empty: `for (; ; )`.
 | `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` |
 
 `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 +231,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.9}/PKG-INFO

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

{prettycsharp-1.1.8 → prettycsharp-1.1.9}/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,
@@ -678,7 +679,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 +874,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 +953,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.9}/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.9}/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(
         """
@@ -834,6 +903,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 +1014,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((