prettycsharp 1.0.0__tar.gz → 1.1.1__tar.gz

{prettycsharp-1.0.0 → prettycsharp-1.1.1}/AGENTS.md

@@ -10,7 +10,12 @@ token-changing rewrites; `printer/` turns nodes into a layout document
 (`core.py` dispatch, tokens, comments and lists; `expressions.py`,
 `statements.py` and `declarations.py` the handlers, each `p_<node type>`);
 `doc.py` fits the document to the width; `verify.py` reparses the output and
-compares canonical trees. `settings.py`, `config.py`, `project.py`,
+compares canonical trees. When `#if` branches split code so the file does
+not parse whole, `conditional.py` formats one view (set of defined symbols)
+at a time, with directive lines and inactive branches behind placeholder
+comments, and checks every view at the end. With `syntax_errors =
+"format_around"`, `isolate.py` finds the fewest lines whose removal lets the
+file parse and hides them behind the same placeholders. `settings.py`, `config.py`, `project.py`,
 `ignore.py` and `cli.py` are the settings, files and command line.
 
 ## Commands

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

@@ -2,6 +2,39 @@
 
 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
+  class header with a different base list in each branch, are formatted
+  instead of refused. Each view of the file (a set of defined symbols) is
+  formatted on its own with the other branches set aside, so every branch
+  is formatted, and the result is checked through every view. On ten
+  open-source repositories this formats 94 of the 108 files that 1.0.0
+  skipped.
+- A file that ends in a directive without a final line break, such as
+  `#pragma warning restore`, parses.
+- A new setting, `syntax_errors = "format_around"`, formats files that hold
+  syntax newer than the parser, such as C# 14's null-conditional assignment
+  or the `#:` directives of file-based apps. The fewest lines the parser
+  cannot read are left as written, moved to the new indentation, and the
+  rest is formatted; the command line names the lines it kept. The default,
+  `skip_file`, leaves such files untouched as before.
+- `format_details()` returns the formatted text with the lines left as
+  written.
+
 ## [1.0.0] - 2026-10-17
 
 The first release: a complete formatter for C# files, projects and

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

@@ -322,9 +322,60 @@ On by default:
 
 `--no-ignore` turns off both ignore files for one run.
 
+## Conditional compilation
+
+tree-sitter's C# grammar parses every `#if` branch as code. When the
+branches together are valid C#, the file is formatted as a whole. When they
+are not, because a declaration or statement is split between branches, the
+file is formatted one view at a time (`conditional.py`):
+
+1. A view is a set of defined symbols. Conditions are evaluated as the
+   compiler does (`!`, `&&`, `||`, `==`, `!=`, parentheses, `true`, `false`),
+   with `#define` and `#undef` honoured where they are compiled.
+2. In a view, each directive line and each run of inactive lines is replaced
+   by a placeholder comment. What is left is the code the compiler sees, and
+   it is formatted normally, verification included. The placeholders then go
+   back to the text they stood for, exactly as written.
+3. Views are tried simplest first (no symbols, each symbol alone, all, all
+   but one, at most 16) and kept when they parse and make a branch active
+   that no earlier view did, so every branch is formatted in its own view.
+4. The result is checked through every view used: with the same lines set
+   aside, it must be the same code as the source. Otherwise the file is left
+   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, 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
+
+| Setting | Default | Alternatives |
+| --- | --- | --- |
+| `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
+`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
+formatted and verified, and they go back exactly as written, moved to the
+indentation their placeholder was printed at (unless they could hold a
+multi-line string). Each hidden line must sit between the same two code
+tokens before and after formatting, so the order of the code cannot change.
+The command line names the lines left as written.
+
+No more than half a file's lines are hidden, and some code must be left to
+format; otherwise the file is skipped as before.
+
 ## Limits
 
-tree-sitter's C# grammar parses every `#if` branch as code, so a declaration
-or statement split between `#if` and `#else` does not parse. Neither does
-syntax newer than the grammar. Such files are reported with their line and
-column and left untouched.
+A file still is not formatted when no view of its `#if` branches parses and,
+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.0.0 → prettycsharp-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: prettycsharp
-Version: 1.0.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
@@ -147,10 +147,14 @@ and left untouched.
 From Python:
 
 ```python
-from prettycsharp import CSharpSyntaxError, FormattingError, Settings, format_source
+from prettycsharp import CSharpSyntaxError, FormattingError, Settings, format_details, format_source
 
 formatted = format_source(source)
 narrow = format_source(source, Settings().with_values({"max_line_length": 100}))
+
+# format_details also says which lines were left as written (format_around).
+result = format_details(source, Settings().with_values({"syntax_errors": "format_around"}))
+print(result.text, result.kept_lines)
 ```
 
 ## Settings
@@ -199,13 +203,42 @@ same words. If anything else differs, the file is not changed and the
 command reports the difference. String literals, including verbatim, raw and
 interpolated strings, are printed exactly as written.
 
-## Limits
+## Conditional compilation
+
+`#if` branches can split a declaration, as in:
+
+```csharp
+#if NET10_0_OR_GREATER
+public sealed class Pool : IAsyncDisposable
+#else
+public sealed class Pool : IDisposable
+#endif
+{
+```
+
+Such a file is formatted the way the compiler reads it, one set of defined
+symbols at a time: the directive lines and the inactive branches are set
+aside, the rest is formatted, and they are put back as written. Symbol sets
+are chosen so that every branch is active in one of them, so every branch
+gets formatted. The result is checked under each symbol set, and a file
+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
+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:
+
+```bash
+prettycsharp format src/ -o syntax_errors=format_around
+```
 
-prettycsharp reads C# through tree-sitter's C# grammar, which parses every
-`#if` branch as code. A declaration or statement split between `#if` and
-`#else` therefore does not parse, and neither does syntax newer than the
-grammar (such as C# 14's null-conditional assignment). Such files are
-reported with their line and column and left untouched.
+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.0.0 → prettycsharp-1.1.1}/README.md

@@ -112,10 +112,14 @@ and left untouched.
 From Python:
 
 ```python
-from prettycsharp import CSharpSyntaxError, FormattingError, Settings, format_source
+from prettycsharp import CSharpSyntaxError, FormattingError, Settings, format_details, format_source
 
 formatted = format_source(source)
 narrow = format_source(source, Settings().with_values({"max_line_length": 100}))
+
+# format_details also says which lines were left as written (format_around).
+result = format_details(source, Settings().with_values({"syntax_errors": "format_around"}))
+print(result.text, result.kept_lines)
 ```
 
 ## Settings
@@ -164,13 +168,42 @@ same words. If anything else differs, the file is not changed and the
 command reports the difference. String literals, including verbatim, raw and
 interpolated strings, are printed exactly as written.
 
-## Limits
+## Conditional compilation
+
+`#if` branches can split a declaration, as in:
+
+```csharp
+#if NET10_0_OR_GREATER
+public sealed class Pool : IAsyncDisposable
+#else
+public sealed class Pool : IDisposable
+#endif
+{
+```
+
+Such a file is formatted the way the compiler reads it, one set of defined
+symbols at a time: the directive lines and the inactive branches are set
+aside, the rest is formatted, and they are put back as written. Symbol sets
+are chosen so that every branch is active in one of them, so every branch
+gets formatted. The result is checked under each symbol set, and a file
+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
+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:
+
+```bash
+prettycsharp format src/ -o syntax_errors=format_around
+```
 
-prettycsharp reads C# through tree-sitter's C# grammar, which parses every
-`#if` branch as code. A declaration or statement split between `#if` and
-`#else` therefore does not parse, and neither does syntax newer than the
-grammar (such as C# 14's null-conditional assignment). Such files are
-reported with their line and column and left untouched.
+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.1/src/prettycsharp/__init__.py

@@ -0,0 +1,18 @@
+"""An opinionated formatter for C#, in the spirit of Prettier."""
+
+from prettycsharp.formatter import FormatResult, FormattingError, format_details, format_source
+from prettycsharp.parsing import CSharpSyntaxError
+from prettycsharp.settings import Settings, SettingsError
+
+__version__ = "1.1.1"
+
+__all__ = [
+    "CSharpSyntaxError",
+    "FormatResult",
+    "FormattingError",
+    "Settings",
+    "SettingsError",
+    "__version__",
+    "format_details",
+    "format_source",
+]

{prettycsharp-1.0.0 → prettycsharp-1.1.1}/src/prettycsharp/cli.py

@@ -25,7 +25,7 @@ from pathlib import Path
 
 from prettycsharp import __version__, config, ignore, project
 from prettycsharp.config import settings_for
-from prettycsharp.formatter import FormattingError, format_source
+from prettycsharp.formatter import FormattingError, format_details
 from prettycsharp.ignore import Ignorer
 from prettycsharp.parsing import CSharpSyntaxError
 from prettycsharp.project import compiled_files, lang_version_for, solution_projects
@@ -163,7 +163,12 @@ def _format_text(text: str, path: Path, settings: Settings) -> str:
     """Format text read from ``path``, keeping or changing its byte order mark."""
     bom = _BOM if text.startswith(_BOM) else ""
     lang = lang_version_for(path) if settings.lang_version == "auto" else None
-    formatted = format_source(text[len(bom) :], settings, lang_version=lang)
+    result = format_details(text[len(bom) :], settings, lang_version=lang)
+    formatted = result.text
+    if result.kept_lines:
+        numbers = ", ".join(str(n) for n in result.kept_lines)
+        noun = "line" if len(result.kept_lines) == 1 else "lines"
+        print(f"{path}: {noun} {numbers} left as written; the parser cannot read them", file=sys.stderr)
     if settings.charset == "utf-8-bom":
         bom = _BOM
     elif settings.charset == "utf-8":