prettycsharp 1.1.7__tar.gz → 1.1.9__tar.gz

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

@@ -2,6 +2,32 @@
 
 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
+  `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.9}/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,14 @@ 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.
+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(
     customer.Id,
@@ -220,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 };
 
@@ -369,8 +385,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.9}/PKG-INFO

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

prettycsharp-1.1.9/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.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,
@@ -27,7 +28,9 @@ from prettycsharp.syntax import Node
 _PRECEDENCE = {
     "??": 1,
     "||": 2,
+    "or": 2,
     "&&": 3,
+    "and": 3,
     "|": 4,
     "^": 5,
     "&": 6,
@@ -158,7 +161,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
@@ -676,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,
         )
 
@@ -868,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])
@@ -897,16 +911,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,13 +953,49 @@ class Expressions(Core):
         return self.spaced(node.children)
 
     def p_and_pattern(self, node: Node) -> Doc:
-        return self.spaced(node.children)
+        return self.logical_pattern(node)
 
     def p_or_pattern(self, node: Node) -> Doc:
-        return self.spaced(node.children)
+        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)
@@ -951,6 +1004,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.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.7 → prettycsharp-1.1.9}/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.9/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.9}/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()