prettycsharp 1.1.0__tar.gz → 1.1.1__tar.gz

{prettycsharp-1.1.0 → prettycsharp-1.1.1}/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 Each release's section becomes the body of its GitHub release.
 
+## [1.1.1] - 2026-10-17
+
+- `syntax_errors = "format_around"` now works inside each view of a file
+  split by `#if`: a view that does not parse is formatted around its own
+  unreadable lines, so both branches of a split class header are formatted
+  even when a method holds syntax newer than the parser. Before, the
+  fallback ran on the whole file and kept the branch lines as written.
+- A comma followed only by hidden `#if` lines before the closing brace is no
+  longer removed as a trailing comma, since in another view it separates
+  items. Files like this were skipped before; on ten open-source
+  repositories the default settings now skip 11 files instead of 14, and
+  `format_around` skips 2.
+
 ## [1.1.0] - 2026-10-17
 
 - Files whose `#if` branches split a declaration or statement, such as a

{prettycsharp-1.1.0 → prettycsharp-1.1.1}/DESIGN.md

@@ -344,8 +344,14 @@ file is formatted one view at a time (`conditional.py`):
    untouched.
 
 In this mode no rewrite moves code across a directive: the namespace style
-is left as it is, a using never moves past a directive, and modifiers split
-by one keep their order.
+is left as it is, a using never moves past a directive, modifiers split by
+one keep their order, and a comma with hidden lines between it and the
+closing brace is not taken for a trailing comma.
+
+With `syntax_errors = "format_around"` (below), a view that does not parse
+is still used when hiding its fewest unreadable lines makes it parse: the
+view is formatted around those lines, and the final check hides the same
+lines, found by their text, in the view of the source and of the result.
 
 ## Code the parser cannot read
 
@@ -370,5 +376,6 @@ format; otherwise the file is skipped as before.
 ## Limits
 
 A file still is not formatted when no view of its `#if` branches parses and,
-with `format_around`, hiding lines does not make it parse either, as when an
-`#if` stands inside an expression.
+with `format_around`, hiding lines makes neither a view nor the whole file
+parse. Lines are hidden whole, so a one-line member that holds unreadable
+syntax is kept as written in full.

{prettycsharp-1.1.0 → prettycsharp-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: prettycsharp
-Version: 1.1.0
+Version: 1.1.1
 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
@@ -236,8 +236,9 @@ and names the lines it kept:
 prettycsharp format src/ -o syntax_errors=format_around
 ```
 
-A file is still left untouched when hiding lines does not make it parse, as
-when an `#if` stands inside an expression.
+This works together with conditional compilation: in a file split by `#if`,
+each view is formatted around its own unreadable lines. A file is still left
+untouched when hiding lines does not make it parse.
 
 ## License
 

{prettycsharp-1.1.0 → prettycsharp-1.1.1}/README.md

@@ -201,8 +201,9 @@ and names the lines it kept:
 prettycsharp format src/ -o syntax_errors=format_around
 ```
 
-A file is still left untouched when hiding lines does not make it parse, as
-when an `#if` stands inside an expression.
+This works together with conditional compilation: in a file split by `#if`,
+each view is formatted around its own unreadable lines. A file is still left
+untouched when hiding lines does not make it parse.
 
 ## License
 

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

{prettycsharp-1.1.0 → prettycsharp-1.1.1}/src/prettycsharp/conditional.py

@@ -219,11 +219,13 @@ def mask(source: str, defined: Iterable[str]) -> Masked:
     return masked
 
 
-def hide(lines: Sequence[str], keep: Sequence[bool], *, reindent: bool = False) -> Masked:
+def hide(lines: Sequence[str], keep: Sequence[bool], *, reindent: bool = False, salt: str = "") -> Masked:
     """Replace each run of lines not kept by one placeholder comment line.
 
-    ``lines`` keep their line breaks. With ``reindent``, ``restore`` moves the
-    hidden lines to the indentation their placeholder was printed at.
+    ``lines`` keep their line breaks. ``salt`` keeps the ids of a second
+    hiding, inside text already hidden once, apart from the first. With
+    ``reindent``, ``restore`` moves the hidden lines to the indentation their
+    placeholder was printed at.
     """
     out: list[str] = []
     hidden: dict[str, str] = {}
@@ -234,7 +236,7 @@ def hide(lines: Sequence[str], keep: Sequence[bool], *, reindent: bool = False)
             return
         text = "".join(run)
         # The position makes two runs with the same text distinct.
-        identifier = hashlib.sha256(f"{len(hidden)}:{text}".encode()).hexdigest()[:16]
+        identifier = hashlib.sha256(f"{salt}{len(hidden)}:{text}".encode()).hexdigest()[:16]
         hidden[identifier] = text.rstrip("\r\n")
         out.append(f"//#prettycsharp-hidden {identifier}{line_break}")
         run.clear()
@@ -254,19 +256,20 @@ def _line_break(line: str) -> str:
     return line[len(content) :] or "\n"
 
 
-def restore(text: str, hidden: dict[str, str], *, reindent: bool = False) -> str:
+def restore(text: str, hidden: dict[str, str], *, reindent: bool = False, nested: bool = False) -> str:
     """Put back the text each placeholder line stands for.
 
     With ``reindent``, hidden lines move to the indentation their placeholder
     was printed at, unless they could hold a multi-line string, whose
-    content must not change.
+    content must not change. With ``nested``, placeholders of an outer
+    hiding are left for its own restore.
     """
     seen: set[str] = set()
     out: list[str] = []
     for line in _split_lines(text):
         content = _content(line)
         match = _PLACEHOLDER.match(content)
-        if match is None:
+        if match is None or (nested and match.group(1) not in hidden):
             out.append(line)
             continue
         identifier = match.group(1)
@@ -337,8 +340,16 @@ def branches(source: str) -> set[int]:
     return found
 
 
-def covering_sets(source: str) -> list[frozenset[str]]:
-    """Symbol sets whose masked text parses and that together reach every branch they can."""
+def parses(text: str) -> bool:
+    try:
+        parse(text)
+    except CSharpSyntaxError:
+        return False
+    return True
+
+
+def covering_sets(source: str, usable: Callable[[str], bool] = parses) -> list[frozenset[str]]:
+    """Symbol sets whose masked text is ``usable`` and that together reach every branch they can."""
     wanted = branches(source)
     chosen: list[frozenset[str]] = []
     covered: set[int] = set()
@@ -349,9 +360,7 @@ def covering_sets(source: str) -> list[frozenset[str]]:
         new = masked.active_branches - covered
         if chosen and not new:
             continue
-        try:
-            parse(masked.text)
-        except CSharpSyntaxError:
+        if not usable(masked.text):
             continue
         chosen.append(candidate)
         covered |= masked.active_branches
@@ -361,16 +370,19 @@ def covering_sets(source: str) -> list[frozenset[str]]:
 
 
 def format_conditional(
-    source: str, format_masked: Callable[[str], str], same_code: Callable[[str, str], bool]
+    source: str,
+    format_masked: Callable[[str], str],
+    same_code: Callable[[str, str], bool],
+    usable: Callable[[str], bool] = parses,
 ) -> str | None:
     """Format each symbol set's view of the file in turn.
 
-    Returns None when no symbol set gives text that parses. Raises
-    ConditionalError when the result, seen through any of the symbol sets
-    used, is not the same code as the source (``same_code`` compares two
-    masked texts).
+    Returns None when no symbol set gives text that is ``usable`` (parses,
+    by default). Raises ConditionalError when the result, seen through any
+    of the symbol sets used, is not the same code as the source
+    (``same_code`` compares two masked texts).
     """
-    sets = covering_sets(source)
+    sets = covering_sets(source, usable)
     if not sets:
         return None
     text = source

{prettycsharp-1.1.0 → prettycsharp-1.1.1}/src/prettycsharp/formatter.py

@@ -10,9 +10,10 @@ crashing the interpreter.
 from __future__ import annotations
 
 import dataclasses
+import functools
 import sys
 import threading
-from collections.abc import Callable
+from collections.abc import Callable, Iterable
 from typing import TypeVar
 
 from prettycsharp import conditional
@@ -80,25 +81,59 @@ def _format(source: str, settings: Settings, lang_version: float) -> FormatResul
         syntax_error = error
     # Neither rewrite may move a namespace's braces across hidden lines.
     hiding = dataclasses.replace(settings, namespace_style="preserve")
+    around = settings.syntax_errors == "format_around"
     if conditional.has_conditionals(source):
-        # The #if branches together are not valid C#: format one view at a time.
+        # The #if branches together are not valid C#: format one view at a time,
+        # and with format_around, within a view, around the lines it cannot read.
+        kept: list[str] = []
         try:
             result = conditional.format_conditional(
-                source, lambda text: _format_parsed(text, hiding, lang_version), _same_view
+                source,
+                functools.partial(_format_view, settings=hiding, lang_version=lang_version, around=around, kept=kept),
+                functools.partial(_same_view, around=around),
+                _usable_around if around else conditional.parses,
             )
         except conditional.BranchChanged as error:
             raise FormattingError(str(error)) from None
         except conditional.ConditionalError:
             raise syntax_error from None
         if result is not None:
-            return FormatResult(result)
-    if settings.syntax_errors == "format_around":
-        around = _format_around(source, hiding, lang_version)
-        if around is not None:
-            return around
+            return FormatResult(result, _source_rows(source, kept))
+    if around:
+        whole = _format_around(source, hiding, lang_version)
+        if whole is not None:
+            return whole
     raise syntax_error
 
 
+def _format_view(text: str, *, settings: Settings, lang_version: float, around: bool, kept: list[str]) -> str:
+    """Format one view of an #if-split file, around unreadable lines if allowed."""
+    try:
+        return _format_parsed(text, settings, lang_version)
+    except CSharpSyntaxError:
+        if not around:
+            raise
+    masked = isolate(text)
+    if masked is None:
+        raise CSharpSyntaxError(1, 1)
+    formatted = _format_parsed(masked.text, settings, lang_version)
+    if _placements(masked.text) != _placements(formatted):
+        raise FormattingError("a line the parser cannot read would move")
+    kept.extend(masked.hidden.values())
+    return conditional.restore(formatted, masked.hidden, reindent=True, nested=True)
+
+
+def _usable_around(text: str) -> bool:
+    """A view that parses, or would once its fewest unreadable lines are hidden."""
+    return conditional.parses(text) or isolate(text) is not None
+
+
+def _source_rows(source: str, kept: list[str]) -> tuple[int, ...]:
+    """The source lines (1-based) whose text was left as written in some view."""
+    texts = {line.strip() for hidden in kept for line in hidden.splitlines() if line.strip()}
+    return tuple(number for number, line in enumerate(source.splitlines(), start=1) if line.strip() in texts)
+
+
 def _format_around(source: str, settings: Settings, lang_version: float) -> FormatResult | None:
     """Format all but the fewest lines that keep the source from parsing."""
     masked = isolate(source)
@@ -138,12 +173,28 @@ def _placements(text: str) -> list[tuple[str, str, str]]:
     return out
 
 
-def _same_view(before: str, after: str) -> bool:
-    """Whether two views of a file, with the same branches hidden, are the same code."""
+def _same_view(before: str, after: str, *, around: bool = False) -> bool:
+    """Whether two views of a file, with the same branches hidden, are the same code.
+
+    With ``around``, views that hold unreadable lines are compared with those
+    lines hidden in both, and the hidden lines must match apart from indentation.
+    """
     try:
         old, new = build(before), build(after)
     except CSharpSyntaxError:
-        return False
+        if not around:
+            return False
+        first = isolate(before)
+        if first is None:
+            return False
+        # The same lines, found by their text, are hidden in the formatted view.
+        second = _hide_matching(after, _stripped(first.hidden.values()))
+        if second is None:
+            return False
+        try:
+            old, new = build(first.text), build(second.text)
+        except CSharpSyntaxError:
+            return False
     if canonical(old.root) != canonical(new.root):
         return False
     # Hidden text differs between the views by design: it was formatted in its own view.
@@ -208,3 +259,21 @@ def _run_with_big_stack(work: Callable[[], T]) -> T:
     if failure:
         raise failure[0]
     return result[0]
+
+
+def _stripped(texts: Iterable[str]) -> list[str]:
+    return [line.strip() for text in texts for line in text.splitlines()]
+
+
+def _hide_matching(text: str, wanted: list[str]) -> conditional.Masked | None:
+    """Hide the lines of ``text`` whose stripped text is ``wanted``, in order; None if any is missing."""
+    lines = conditional._split_lines(text)
+    keep = [True] * len(lines)
+    position = 0
+    for number, line in enumerate(lines):
+        if position < len(wanted) and line.strip() == wanted[position]:
+            keep[number] = False
+            position += 1
+    if position != len(wanted):
+        return None
+    return conditional.hide(lines, keep, salt="isolate:")

{prettycsharp-1.1.0 → prettycsharp-1.1.1}/src/prettycsharp/isolate.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 from tree_sitter import Node as TSNode
 
-from prettycsharp.conditional import Masked, _content, _directive, _split_lines, hide
+from prettycsharp.conditional import Masked, _content, _directive, _split_lines, hide, is_placeholder
 from prettycsharp.parsing import parse_tree
 
 # Limits that keep the search quick on any file.
@@ -38,7 +38,7 @@ def isolate(source: str) -> Masked | None:
         if count == 0:
             if all(keep) or not _worth_it(lines, keep):
                 return None
-            masked = hide(lines, keep, reindent=True)
+            masked = hide(lines, keep, reindent=True, salt="isolate:")
             masked.hidden_rows = tuple(number + 1 for number, kept in enumerate(keep) if not kept)
             return masked
         if span is None:
@@ -80,8 +80,12 @@ def _worth_it(lines: list[str], keep: list[bool]) -> bool:
 
 
 def _protected(line: str) -> bool:
-    """#if, #elif, #else and #endif lines hold the branches together: never hidden."""
-    found = _directive(_content(line))
+    """Lines never hidden: #if, #elif, #else and #endif hold the branches
+    together, and a placeholder already stands for hidden text."""
+    content = _content(line)
+    if is_placeholder(content):
+        return True
+    found = _directive(content)
     return found is not None and found[0] in ("if", "elif", "else", "endif")
 
 

{prettycsharp-1.1.0 → prettycsharp-1.1.1}/src/prettycsharp/rewrites.py

@@ -733,6 +733,9 @@ def remove_trailing_commas(root: Node) -> None:
         close = node.children[-1]
         if comma.text != "," or comma.named or close.text not in ("}", "]"):
             continue
+        if any(is_placeholder(c.text) for c in [*comma.trailing, *close.leading]):
+            # Hidden lines follow: in another #if view the comma separates items.
+            continue
         before = node.children[-3].last_token()
         if before is None:
             continue

{prettycsharp-1.1.0 → prettycsharp-1.1.1}/tests/test_conditional.py

@@ -233,6 +233,50 @@ def test_a_damaged_branch_is_refused(monkeypatch: pytest.MonkeyPatch) -> None:
         format_source("#if NET\nclass C : IAsyncDisposable\n#else\nclass C\n#endif\n{ }\n")
 
 
+def test_comma_before_a_hidden_branch_is_not_a_trailing_comma() -> None:
+    check(
+        """
+        class C
+        {
+        #if NET
+            class D : I
+        #else
+            class D
+        #endif
+            {
+            }
+            static readonly HashSet<Type> Types = new()
+            {
+                typeof(Guid), typeof(Uri),
+        #if DATE_ONLY
+                typeof(DateOnly)
+        #endif
+            };
+        }
+        """,
+        """
+        class C
+        {
+        #if NET
+            class D : I
+        #else
+            class D
+        #endif
+            { }
+
+            static readonly HashSet<Type> Types = new()
+            {
+                typeof(Guid),
+                typeof(Uri),
+        #if DATE_ONLY
+                typeof(DateOnly)
+        #endif
+            };
+        }
+        """,
+    )
+
+
 def test_property_split_between_arrow_and_accessors_under_block_bodies() -> None:
     check(
         """

{prettycsharp-1.1.0 → prettycsharp-1.1.1}/tests/test_format_around.py

@@ -63,6 +63,45 @@ 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
+public sealed class Pool : IAsyncDisposable
+#else
+public sealed class Pool : IDisposable
+#endif
+{
+    static public int Size=3;
+    void M()
+    {
+        a?.B = 1;
+        Run( );
+    }
+}
+"""
+
+
+def test_format_around_works_inside_each_if_view() -> None:
+    result = format_details(SPLIT_AND_NEW, 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"
+    )
+    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:
+    with pytest.raises(CSharpSyntaxError):
+        format_source(SPLIT_AND_NEW)
+
+
+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")
+    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 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)