prettycsharp 1.1.7__tar.gz → 1.1.8__tar.gz

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

@@ -2,6 +2,19 @@
 
 Each release's section becomes the body of its GitHub release.
 
+## [1.1.8] - 2026-10-18
+
+- Long `or` and `and` patterns wrap at the configured line width using
+  `binary_wrap`, while short patterns stay inline.
+- A multiline property pattern moves its opening brace onto its own line
+  with Allman braces, including patterns in catch filters, avoiding IDE0055.
+- Assignments to a variable named `required`, including compound assignments,
+  format without mistaking the identifier for a member modifier.
+- C# 14 null-conditional member and element assignments, such as
+  `telemetry?.Route = value` and `items?[index] += value`, format instead of
+  being refused. Original tokens, comments, and conditional-access semantics
+  are preserved, and malformed input is still refused.
+
 ## [1.1.7] - 2026-10-18
 
 - Comments after the final `switch` section align with its statements

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

@@ -108,6 +108,9 @@ stops the search, and the file nearest the source wins.
 
 Short auto-property accessors always stay on one line: `public int Id { get; set; }`.
 
+Property patterns stay inline when they fit. When broken across lines,
+their opening brace follows `brace_style` for statements.
+
 ```csharp
 if (order.IsPaid)
 {
@@ -174,6 +177,8 @@ 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` |
 
+`binary_wrap` also controls line breaks in `or` and `and` patterns.
+
 ```csharp
 var invoice = invoiceService.CreateInvoice(
     customer.Id,
@@ -369,8 +374,15 @@ lines, found by their text, in the view of the source and of the result.
 | --- | --- | --- |
 | `syntax_errors` | `skip_file`: a file that does not parse is reported and left untouched | `format_around` |
 
-Syntax newer than the grammar, such as C# 14's null-conditional assignment
-or the `#:` directives of file-based apps, does not parse. With
+The parser supports assignments to the contextual identifier `required`
+and C# 14 null-conditional member and element assignments. For these two
+grammar gaps, a compatibility pass uses same-width lexical stand-ins,
+requires a complete error-free parse, and restores the original tokens and
+conditional-access syntax before printing and verification. Invalid input
+is still refused; the canonical verifier is unchanged.
+
+Other syntax newer than the grammar, such as the `#:` directives of
+file-based apps, does not parse. With
 `format_around`, the formatter looks for the fewest whole lines whose removal
 lets the file parse (`isolate.py`), trying the lines around each error in
 turn. Those lines are hidden behind placeholder comments, the rest is

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: prettycsharp
-Version: 1.1.7
+Version: 1.1.8
 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
@@ -225,9 +225,10 @@ where any branch would change in meaning is left untouched.
 
 ## Code the parser cannot read
 
-prettycsharp reads C# through tree-sitter's C# grammar, and syntax newer
-than the grammar, such as C# 14's null-conditional assignment, does not
-parse. By default such a file is reported with its line and column and left
+prettycsharp reads C# through tree-sitter's C# grammar, with compatibility
+support for assignments to `required` and C# 14 null-conditional assignments.
+Other unsupported syntax, such as the `#:` directives of file-based apps,
+does not parse. By default such a file is reported with its line and column and left
 untouched. With `syntax_errors = "format_around"`, the formatter finds the
 fewest lines it cannot read, leaves just those as written, formats the rest,
 and names the lines it kept:

{prettycsharp-1.1.7 → prettycsharp-1.1.8}/README.md

@@ -190,9 +190,10 @@ where any branch would change in meaning is left untouched.
 
 ## Code the parser cannot read
 
-prettycsharp reads C# through tree-sitter's C# grammar, and syntax newer
-than the grammar, such as C# 14's null-conditional assignment, does not
-parse. By default such a file is reported with its line and column and left
+prettycsharp reads C# through tree-sitter's C# grammar, with compatibility
+support for assignments to `required` and C# 14 null-conditional assignments.
+Other unsupported syntax, such as the `#:` directives of file-based apps,
+does not parse. By default such a file is reported with its line and column and left
 untouched. With `syntax_errors = "format_around"`, the formatter finds the
 fewest lines it cannot read, leaves just those as written, formats the rest,
 and names the lines it kept:

{prettycsharp-1.1.7 → prettycsharp-1.1.8}/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.7"
+__version__ = "1.1.8"
 
 __all__ = [
     "CSharpSyntaxError",

prettycsharp-1.1.8/src/prettycsharp/parsing.py

@@ -0,0 +1,135 @@
+"""Parsing C# source into a tree-sitter concrete syntax tree."""
+
+from __future__ import annotations
+
+import tree_sitter_c_sharp
+from tree_sitter import Language, Node, Parser, Tree
+
+_LANGUAGE = Language(tree_sitter_c_sharp.language())
+
+
+class CSharpSyntaxError(ValueError):
+    """The source does not parse as C#, so it is not formatted.
+
+    ``line`` and ``column`` are 1-based and point at the first error the
+    parser found.
+    """
+
+    def __init__(self, line: int, column: int, hint: str = "") -> None:
+        super().__init__(f"syntax error at line {line}, column {column}{hint}")
+        self.line = line
+        self.column = column
+
+
+_CONDITIONAL_HINT = " (seen whole, and with its #if branches taken one view at a time)"
+
+
+def parse_tree(source: str) -> Tree:
+    """Parse ``source``, errors and all."""
+    data = source.encode("utf-8")
+    if not data.endswith((b"\n", b"\r")):
+        # The grammar wants a line break after a directive, even at the end
+        # of the file. The extra byte comes after every node's text.
+        data += b"\n"
+    parser = Parser(_LANGUAGE)
+    tree = parser.parse(data)
+    if not tree.root_node.has_error:
+        return tree
+    return _compatibility_tree(parser, data, tree)
+
+
+def _compatibility_tree(parser: Parser, data: bytes, original: Tree) -> Tree:
+    """Resolve two grammar gaps without discarding tokens or accepting errors.
+
+    Stand-ins have identical byte lengths. The syntax model reads token text
+    from the original source and restores conditional-access node shapes.
+    Only actual lexer tokens are considered, never text in comments/strings.
+    """
+    leaves: list[Node] = []
+    stack = [original.root_node]
+    while stack:
+        node = stack.pop()
+        if node.children:
+            stack.extend(reversed(node.children))
+        elif not node.is_missing and node.type != "comment":
+            leaves.append(node)
+    modified = bytearray(data)
+    questions: set[int] = set()
+    assignment_starts = {
+        "=", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>=", ">>>=", "??=",
+        ".", "[", "(", "++", "--", "?",
+        "+", "-", "*", "/", "%", "&", "|", "^", "<", ">",
+    }
+    for node, following in zip(leaves, leaves[1:], strict=False):
+        if node.type == "required" and following.type in assignment_starts:
+            modified[node.start_byte:node.end_byte] = b"req_ired"
+        elif (
+            node.type == "?"
+            and following.type in (".", "[")
+            and node.parent is not None
+            and node.parent.type not in ("nullable_type", "conditional_expression")
+        ):
+            modified[node.start_byte] = ord("!")
+            questions.add(node.start_byte)
+    if modified == data:
+        return original
+    candidate = parser.parse(bytes(modified))
+    if candidate.root_node.has_error:
+        return original
+    # Only repair null-conditional access along an assignment's receiver
+    # chain. In particular, do not turn conditional ++/-- into valid input.
+    allowed: set[int] = set()
+    stack = [candidate.root_node]
+    while stack:
+        node = stack.pop()
+        if node.type == "!" and node.start_byte in questions and _assignment_receiver(node):
+            allowed.add(node.start_byte)
+        stack.extend(node.children)
+    for position in questions - allowed:
+        modified[position] = ord("?")
+    if questions - allowed:
+        candidate = parser.parse(bytes(modified))
+    return original if candidate.root_node.has_error else candidate
+
+
+def _assignment_receiver(operator: Node) -> bool:
+    receiver = operator.parent
+    if receiver is None or receiver.type != "postfix_unary_expression":
+        return False
+    while receiver.parent is not None:
+        parent = receiver.parent
+        if parent.type == "assignment_expression":
+            return parent.child_by_field_name("left") == receiver
+        field = "function" if parent.type == "invocation_expression" else "expression"
+        if parent.type not in ("member_access_expression", "element_access_expression", "invocation_expression"):
+            return False
+        if parent.child_by_field_name(field) != receiver:
+            return False
+        receiver = parent
+    return False
+
+
+def parse(source: str) -> Tree:
+    """Parse ``source`` and return its tree, or raise CSharpSyntaxError."""
+    tree = parse_tree(source)
+    if tree.root_node.has_error:
+        node = _first_error(tree.root_node)
+        row, column = node.start_point if node is not None else (0, 0)
+        hint = _CONDITIONAL_HINT if "#if" in source else ""
+        raise CSharpSyntaxError(row + 1, column + 1, hint)
+    return tree
+
+
+def _first_error(root: Node) -> Node | None:
+    # An ERROR node often wraps a whole declaration, so follow the first
+    # erroneous child down to the innermost error, which is where the
+    # problem is. A loop, so deep nesting cannot exhaust the Python stack.
+    found = None
+    node = root
+    while True:
+        if node.is_error or node.is_missing:
+            found = node
+        child = next((c for c in node.children if c.is_error or c.is_missing or c.has_error), None)
+        if child is None:
+            return found
+        node = child

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

@@ -27,7 +27,9 @@ from prettycsharp.syntax import Node
 _PRECEDENCE = {
     "??": 1,
     "||": 2,
+    "or": 2,
     "&&": 3,
+    "and": 3,
     "|": 4,
     "^": 5,
     "&": 6,
@@ -158,7 +160,7 @@ class Expressions(Core):
         stack: list[Node] = [node]
         while stack:
             current = stack.pop()
-            current_op = current.child("operator") if current.type == "binary_expression" else None
+            current_op = current.child("operator") if current.type == node.type else None
             if (
                 current_op is not None
                 and _PRECEDENCE.get(current_op.text or "", -1) == level
@@ -897,16 +899,19 @@ class Expressions(Core):
 
     # Patterns ------------------------------------------------------------
 
-    def p_property_pattern_clause(self, node: Node) -> Doc:
+    def p_property_pattern_clause(self, node: Node, *, leading_space: bool = False) -> Doc:
         if len(node.children) < 2:
             return self.generic(node)
         open_tok = node.children[0]
         close_tok = node.children[-1]
         items, commas = self.items_and_commas(node)
+        before: Doc = ""
+        if leading_space:
+            before = LINE if self.settings.brace_style == "allman" else " "
         if not items:
-            return group([self.tok(open_tok), self.closing(close_tok, LINE)])
+            return group([before, self.tok(open_tok), self.closing(close_tok, LINE)])
         docs = self._comma_docs(items, commas)
-        return group([self.tok(open_tok), indent([LINE, join(LINE, docs)]), self.closing(close_tok, LINE)])
+        return group([before, self.tok(open_tok), indent([LINE, join(LINE, docs)]), self.closing(close_tok, LINE)])
 
     def p_positional_pattern_clause(self, node: Node) -> Doc:
         return self.arguments(node)
@@ -936,10 +941,10 @@ class Expressions(Core):
         return self.spaced(node.children)
 
     def p_and_pattern(self, node: Node) -> Doc:
-        return self.spaced(node.children)
+        return self.binary(node, in_condition=False)
 
     def p_or_pattern(self, node: Node) -> Doc:
-        return self.spaced(node.children)
+        return self.binary(node, in_condition=False)
 
     def p_negated_pattern(self, node: Node) -> Doc:
         return self.spaced(node.children)
@@ -951,6 +956,10 @@ class Expressions(Core):
         parts: list[Doc] = []
         previous: Node | None = None
         for child in node.children:
+            if previous is not None and child.type == "property_pattern_clause" and not child.verbatim:
+                parts.append(self.p_property_pattern_clause(child, leading_space=True))
+                previous = child
+                continue
             if previous is not None and not (child.type == "positional_pattern_clause" and previous.named):
                 parts.append(" ")
             parts.append(self.print(child))

{prettycsharp-1.1.7 → prettycsharp-1.1.8}/src/prettycsharp/syntax.py

@@ -226,11 +226,55 @@ def _copy(tree: Tree, data: bytes) -> tuple[Node, list[Node], list[Comment]]:
             node.children.append(child)
             pending.append((ts_child, child))
         stack.extend(reversed(pending))
+    _restore_conditional_assignments(root)
     tokens.extend(root.tokens())
     comments.sort(key=lambda c: c.start)
     return root, tokens, comments
 
 
+def _restore_conditional_assignments(root: Node) -> None:
+    """Restore conditional accesses parsed with same-width ``!`` stand-ins."""
+    nodes: list[Node] = []
+    stack = [root]
+    while stack:
+        node = stack.pop()
+        nodes.append(node)
+        stack.extend(node.children)
+    for node in reversed(nodes):
+        if node.type not in ("member_access_expression", "element_access_expression") or not node.children:
+            continue
+        receiver = node.children[0]
+        if receiver.type != "postfix_unary_expression" or len(receiver.children) != 2:
+            continue
+        condition, question = receiver.children
+        if question.type != "!" or question.text != "?":
+            continue
+        children = node.children[1:]
+        if node.type == "element_access_expression":
+            if len(children) != 1 or children[0].type != "bracketed_argument_list":
+                continue
+            children = children[0].children
+        binding = Node(
+            type="member_binding_expression" if node.type == "member_access_expression" else "element_binding_expression",
+            named=True,
+            start=children[0].start,
+            end=node.end,
+            line=children[0].line,
+            column=children[0].column,
+            end_line=node.end_line,
+            children=children,
+            parent=node,
+        )
+        for child in children:
+            child.parent = binding
+        condition.field = "condition"
+        condition.parent = node
+        question.type = "?"
+        question.parent = node
+        node.type = "conditional_access_expression"
+        node.children = [condition, question, binding]
+
+
 def _new_node(ts_node: TSNode, field_name: str | None, data: bytes) -> Node:
     text = None
     end = ts_node.end_byte

prettycsharp-1.1.8/tests/fuzz_corpus/csharp/conditional_assignments.cs

@@ -0,0 +1,13 @@
+class Assignments
+{
+    public required string Name { get; init; }
+    void Update(dynamic target, int[] items, int index)
+    {
+        long required = 0;
+        required = Math.Max(required, index + 1);
+        required -= index;
+        target?.Route = required;
+        items?[index] += 1;
+        target?.Child?.Route = target?.Route;
+    }
+}

{prettycsharp-1.1.7 → prettycsharp-1.1.8}/tests/test_format_around.py

@@ -10,12 +10,12 @@ from prettycsharp.isolate import isolate
 
 AROUND = Settings().with_values({"syntax_errors": "format_around"})
 
-NEW_SYNTAX = """class C
+UNREADABLE_SOURCE = """class C
 {
     void M()
     {
         Run();
-          a?.B = 1;
+          a?.B = ;
         int   x=1;
     }
 
@@ -26,13 +26,13 @@ NEW_SYNTAX = """class C
 
 def test_skip_file_is_the_default() -> None:
     with pytest.raises(CSharpSyntaxError):
-        format_source(NEW_SYNTAX)
+        format_source(UNREADABLE_SOURCE)
 
 
 def test_unreadable_line_is_kept_and_the_rest_formatted() -> None:
-    result = format_details(NEW_SYNTAX, AROUND)
+    result = format_details(UNREADABLE_SOURCE, AROUND)
     assert result.text == (
-        "class C\n{\n    void M()\n    {\n        Run();\n        a?.B = 1;\n        int x = 1;\n    }\n\n"
+        "class C\n{\n    void M()\n    {\n        Run();\n        a?.B = ;\n        int x = 1;\n    }\n\n"
         "    void N() => Go();\n}\n"
     )
     assert result.kept_lines == (6,)
@@ -40,9 +40,9 @@ def test_unreadable_line_is_kept_and_the_rest_formatted() -> None:
 
 
 def test_isolate_hides_the_fewest_lines() -> None:
-    masked = isolate(NEW_SYNTAX)
+    masked = isolate(UNREADABLE_SOURCE)
     assert masked is not None
-    assert list(masked.hidden.values()) == ["          a?.B = 1;"]
+    assert list(masked.hidden.values()) == ["          a?.B = ;"]
 
 
 def test_file_scoped_directives_of_file_based_apps() -> None:
@@ -63,7 +63,7 @@ def test_genuinely_broken_code_that_no_line_rescues_is_still_refused() -> None:
         format_source("class {\n{\n{\n", AROUND)
 
 
-SPLIT_AND_NEW = """#if NET
+SPLIT_AND_UNREADABLE = """#if NET
 public sealed class Pool : IAsyncDisposable
 #else
 public sealed class Pool : IDisposable
@@ -72,7 +72,7 @@ public sealed class Pool : IDisposable
     static public int Size=3;
     void M()
     {
-        a?.B = 1;
+        a?.B = ;
         Run( );
     }
 }
@@ -80,31 +80,31 @@ public sealed class Pool : IDisposable
 
 
 def test_format_around_works_inside_each_if_view() -> None:
-    result = format_details(SPLIT_AND_NEW, AROUND)
+    result = format_details(SPLIT_AND_UNREADABLE, AROUND)
     assert result.text == (
         "#if NET\npublic sealed class Pool : IAsyncDisposable\n#else\npublic sealed class Pool : IDisposable\n#endif\n"
-        "{\n    public static int Size = 3;\n\n    void M()\n    {\n        a?.B = 1;\n        Run();\n    }\n}\n"
+        "{\n    public static int Size = 3;\n\n    void M()\n    {\n        a?.B = ;\n        Run();\n    }\n}\n"
     )
     assert result.kept_lines == (10,)
     assert format_source(result.text, AROUND) == result.text
 
 
-def test_split_and_new_syntax_is_still_skipped_by_default() -> None:
+def test_split_and_unreadable_syntax_is_still_skipped_by_default() -> None:
     with pytest.raises(CSharpSyntaxError):
-        format_source(SPLIT_AND_NEW)
+        format_source(SPLIT_AND_UNREADABLE)
 
 
-def test_one_line_member_with_new_syntax_keeps_only_that_line() -> None:
-    source = SPLIT_AND_NEW.replace("    void M()\n    {\n        a?.B = 1;\n        Run( );\n    }\n", "    void M() { a?.B = 1; Run( ); }\n")
+def test_one_line_member_with_unreadable_syntax_keeps_only_that_line() -> None:
+    source = SPLIT_AND_UNREADABLE.replace("    void M()\n    {\n        a?.B = ;\n        Run( );\n    }\n", "    void M() { a?.B = ; Run( ); }\n")
     result = format_details(source, AROUND)
     assert "    public static int Size = 3;" in result.text
-    assert "    void M() { a?.B = 1; Run( ); }" in result.text
+    assert "    void M() { a?.B = ; Run( ); }" in result.text
     assert result.kept_lines == (8,)
 
 
 def test_command_line_reports_the_kept_lines(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
     path = tmp_path / "C.cs"
-    path.write_text(NEW_SYNTAX)
+    path.write_text(UNREADABLE_SOURCE)
     assert main(["format", str(path), "-o", "syntax_errors=format_around"]) == 0
     assert "line 6 left as written" in capsys.readouterr().err
     assert "int x = 1;" in path.read_text()

prettycsharp-1.1.8/tests/test_grammar_compatibility.py

@@ -0,0 +1,102 @@
+"""Grammar gaps must not cause valid assignments to be skipped or changed."""
+
+import pytest
+
+from prettycsharp import CSharpSyntaxError, Settings, format_details
+from prettycsharp.syntax import Node, build
+from prettycsharp.verify import canonical
+
+from support import check, fmt
+
+
+@pytest.mark.parametrize("operator", ["=", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>=", ">>>=", "??="])
+def test_required_assignment(operator: str) -> None:
+    check(f"required{operator}value;", f"required {operator} value;\n")
+
+
+@pytest.mark.parametrize("target", ["a?.B", "a?[i]", "a?.B?.C", "a?.B?[i]", "a?[i]?.B", "a?.Get().B"])
+@pytest.mark.parametrize("operator", ["=", "+=", "-=", "??="])
+def test_null_conditional_assignment(target: str, operator: str) -> None:
+    check(f"{target}{operator}value;", f"{target} {operator} value;\n")
+
+
+def test_reported_required_assignments_in_a_loop() -> None:
+    check(
+        "long required=0;foreach(var index in indices){required=Math.Max(required,index+1);required-=range;}",
+        "long required = 0;\n\nforeach (var index in indices)\n{\n"
+        "    required = Math.Max(required, index + 1);\n    required -= range;\n}\n",
+    )
+
+
+def test_comments_literals_and_original_token_text_are_preserved() -> None:
+    source = 'required /* keep */ = Get("required = x; a?.B = x;");\na?./* receiver */B = required;'
+    output = fmt(source)
+    assert '"required = x; a?.B = x;"' in output
+    assert 'required /* keep */ = ' in output
+    assert 'a?. /* receiver */B = required;' in output
+    assert "req_ired" not in output
+    assert fmt(output) == output
+
+
+def test_required_member_modifier_is_preserved() -> None:
+    check(
+        "class C{public required string Name{get;init;}}",
+        "class C\n{\n    public required string Name { get; init; }\n}\n",
+    )
+
+
+@pytest.mark.parametrize("source", ["required = ;", "required -= ;", "a?.B = ;", "a?[i] += ;", "a?. = 1;", "a?[] = 1;", "class { required = value; }", "a?.B = 1; class {"])
+def test_invalid_input_remains_refused(source: str) -> None:
+    with pytest.raises(CSharpSyntaxError):
+        fmt(source)
+
+
+@pytest.mark.parametrize(
+    ("before", "after"),
+    [
+        ("a?.B = 1;", "a.B = 1;"),
+        ("a?.B = 1;", "a!.B = 1;"),
+        ("a?[i] = 1;", "a[i] = 1;"),
+        ("a?.B += 1;", "a?.B = 1;"),
+        ("required = 1;", "req_ired = 1;"),
+    ],
+)
+def test_verifier_distinguishes_semantic_changes(before: str, after: str) -> None:
+    assert canonical(build(before).root) != canonical(build(after).root)
+
+
+def test_supported_syntax_needs_no_format_around_exclusions() -> None:
+    result = format_details("required=1;a?.B=required;", Settings(syntax_errors="format_around"))
+    assert result.text == "required = 1;\na?.B = required;\n"
+    assert result.kept_lines == ()
+
+
+def test_non_ascii_and_crlf_positions_are_preserved() -> None:
+    source = 'var label="' + chr(0xE9) + '";\r\nrequired=1;\r\na?.B=required;\r\n'
+    output = fmt(source)
+    assert output == 'var label = "' + chr(0xE9) + '";\r\nrequired = 1;\r\na?.B = required;\r\n'
+    assert fmt(output) == output
+
+
+def test_nullable_types_and_ternary_collections_are_not_conditional_accesses() -> None:
+    check(
+        "required=1;string?[] values=ok?[1]:[2];a?.B=new string?[0];",
+        "required = 1;\nstring?[] values = ok ? [1] : [2];\na?.B = new string?[0];\n",
+    )
+
+
+@pytest.mark.parametrize("access", ["a?.B", "a?[i]"])
+def test_assignment_target_has_the_native_conditional_access_shape(access: str) -> None:
+    assigned = build(f"{access} = value;")
+    read = build(f"var value = {access};")
+    # Compare actual syntax subtrees, without changing canonicalization.
+    def conditional(node: Node) -> Node:
+        stack = [node]
+        while stack:
+            current = stack.pop()
+            if current.type == "conditional_access_expression":
+                return current
+            stack.extend(current.children)
+        raise LookupError
+
+    assert canonical(conditional(assigned.root)) == canonical(conditional(read.root))

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

@@ -108,6 +108,52 @@ def test_four_space_indent() -> None:
     assert fmt("class A{void M(){Run();Stop();}}") == "class A\n{\n    void M()\n    {\n        Run();\n        Stop();\n    }\n}\n"
 
 
+def test_catch_filter_wraps_logical_pattern_before_expanding_property_pattern() -> None:
+    check(
+        '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',
+    )
+
+
+@pytest.mark.parametrize("style", ["allman", "kr", "mixed"])
+def test_broken_property_pattern_respects_brace_style(style: str) -> None:
+    separator = "\n" if style == "allman" else " "
+    check(
+        'var match = value is SomeType { VeryLongProperty: "a rather long value" };',
+        f'var match = value is SomeType{separator}'
+        '{\n    VeryLongProperty: "a rather long value"\n};\n',
+        max_line_length=45,
+        brace_style=style,
+    )
+
+
+def test_short_property_pattern_remains_inline() -> None:
+    check('var match=value is Type{Id:1};', 'var match = value is Type { Id: 1 };\n')
+
+
+@pytest.mark.parametrize("operator", ["or", "and"])
+@pytest.mark.parametrize("wrap", ["before_operator_paren_own_line", "before_operator", "after_operator"])
+def test_long_logical_patterns_wrap(operator: str, wrap: str) -> None:
+    if wrap == "after_operator":
+        expected = f"var ok = value is LongPatternOne {operator}\n    LongPatternTwo {operator}\n    LongPatternThree;\n"
+    else:
+        expected = f"var ok = value is LongPatternOne\n    {operator} LongPatternTwo\n    {operator} LongPatternThree;\n"
+    check(
+        f"var ok = value is LongPatternOne {operator} LongPatternTwo {operator} LongPatternThree;",
+        expected,
+        max_line_length=50,
+        binary_wrap=wrap,
+    )
+
+
+@pytest.mark.parametrize("pattern", ["A or B", "A and B", "A or B and C", "(A or B) and C"])
+def test_short_logical_patterns_keep_grouping_and_stay_inline(pattern: str) -> None:
+    check(f"var ok=value is {pattern};", f"var ok = value is {pattern};\n")
+
+
 def test_call_breaks_one_argument_per_line_with_paren_on_its_own_line() -> None:
     check(
         """

prettycsharp-1.1.7/src/prettycsharp/parsing.py

@@ -1,60 +0,0 @@
-"""Parsing C# source into a tree-sitter concrete syntax tree."""
-
-from __future__ import annotations
-
-import tree_sitter_c_sharp
-from tree_sitter import Language, Node, Parser, Tree
-
-_LANGUAGE = Language(tree_sitter_c_sharp.language())
-
-
-class CSharpSyntaxError(ValueError):
-    """The source does not parse as C#, so it is not formatted.
-
-    ``line`` and ``column`` are 1-based and point at the first error the
-    parser found.
-    """
-
-    def __init__(self, line: int, column: int, hint: str = "") -> None:
-        super().__init__(f"syntax error at line {line}, column {column}{hint}")
-        self.line = line
-        self.column = column
-
-
-_CONDITIONAL_HINT = " (seen whole, and with its #if branches taken one view at a time)"
-
-
-def parse_tree(source: str) -> Tree:
-    """Parse ``source``, errors and all."""
-    data = source.encode("utf-8")
-    if not data.endswith((b"\n", b"\r")):
-        # The grammar wants a line break after a directive, even at the end
-        # of the file. The extra byte comes after every node's text.
-        data += b"\n"
-    return Parser(_LANGUAGE).parse(data)
-
-
-def parse(source: str) -> Tree:
-    """Parse ``source`` and return its tree, or raise CSharpSyntaxError."""
-    tree = parse_tree(source)
-    if tree.root_node.has_error:
-        node = _first_error(tree.root_node)
-        row, column = node.start_point if node is not None else (0, 0)
-        hint = _CONDITIONAL_HINT if "#if" in source else ""
-        raise CSharpSyntaxError(row + 1, column + 1, hint)
-    return tree
-
-
-def _first_error(root: Node) -> Node | None:
-    # An ERROR node often wraps a whole declaration, so follow the first
-    # erroneous child down to the innermost error, which is where the
-    # problem is. A loop, so deep nesting cannot exhaust the Python stack.
-    found = None
-    node = root
-    while True:
-        if node.is_error or node.is_missing:
-            found = node
-        child = next((c for c in node.children if c.is_error or c.is_missing or c.has_error), None)
-        if child is None:
-            return found
-        node = child