Working on adding xml whitespace ignore.

CSharpier.sln.DotSettings

@@ -1,5 +1,8 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
 	<s:Boolean x:Key="/Default/CodeStyle/CSharpUsing/AddImportsToDeepestScope/@EntryValue">False</s:Boolean>
+	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EUnitTestFramework_002EMigrations_002EEnableDisabledProvidersMigration/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/Environment/UnitTesting/DisabledProviders/=Testing_0020Platform/@EntryIndexedValue">False</s:Boolean>
+
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Concated/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=csharpier/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=csharpierignore/@EntryIndexedValue">True</s:Boolean>

Shell/UpdateCSharpierRepos.psm1

@@ -15,6 +15,7 @@ function CSH-UpdateCSharpierRepos()
     $repositories += "https://github.com/dotnet/runtime.git"
     $repositories += "https://github.com/mono/mono.git"
     $repositories += "https://github.com/increase-POS/Res-Server.git"
+    $repositories += "https://github.com/stride3d/stride.git"
 
     $tempLocation = "c:\temp\UpdateRepos"
 
@@ -46,7 +47,7 @@ function CSH-UpdateCSharpierRepos()
     Set-Location $destination
     & git checkout main
 
-    $extensions = (".csproj", ".props", ".targets", ".xml", ".config", ".cs")
+    $extensions = (".csproj", ".props", ".targets", ".xml", ".config", ".cs", ".xaml", ".axaml")
 
     foreach ($extension in $extensions)
     {

Src/CSharpier.Benchmarks/Program.cs

@@ -28,7 +28,11 @@ public void XDocument_Parse()
     [Benchmark]
     public void CustomParser_Parse()
     {
-        _ = RawNodeReader.ParseXml(this.largeXmlCode, Environment.NewLine);
+        _ = RawNodeReader.ParseXml(
+            this.largeXmlCode,
+            Environment.NewLine,
+            XmlWhitespaceSensitivity.Strict
+        );
     }
 
     [Benchmark]
@@ -49,7 +53,10 @@ public void XmlReader_Parse()
     public void Default_CodeFormatter_Tests()
     {
         CSharpFormatter
-            .FormatAsync(this.largeTestCode, new PrinterOptions(Formatter.CSharp))
+            .FormatAsync(
+                this.largeTestCode,
+                new PrinterOptions(Formatter.CSharp, XmlWhitespaceSensitivity.Strict)
+            )
             .GetAwaiter()
             .GetResult();
     }
@@ -58,7 +65,10 @@ public void Default_CodeFormatter_Tests()
     public void Default_CodeFormatter_Complex()
     {
         CSharpFormatter
-            .FormatAsync(this.largeComplexCode, new PrinterOptions(Formatter.CSharp))
+            .FormatAsync(
+                this.largeComplexCode,
+                new PrinterOptions(Formatter.CSharp, XmlWhitespaceSensitivity.Strict)
+            )
             .GetAwaiter()
             .GetResult();
     }

Src/CSharpier.Cli/EditorConfig/EditorConfigSections.cs

@@ -26,7 +26,10 @@ internal class EditorConfigSections
             return null;
         }
 
-        var printerOptions = new PrinterOptions(parsedFormatter);
+        var printerOptions = new PrinterOptions(
+            parsedFormatter,
+            PrinterOptions.GetXmlWhitespaceSensitivity(filePath)
+        );
 
         if (resolvedConfiguration.MaxLineLength is { } maxLineLength)
         {

Src/CSharpier.Cli/Options/ConfigurationFileOptions.cs

@@ -11,8 +11,7 @@ internal class ConfigurationFileOptions
     public bool UseTabs { get; init; }
 
     [JsonConverter(typeof(CaseInsensitiveEnumConverter<XmlWhitespaceSensitivity>))]
-    public XmlWhitespaceSensitivity XmlWhitespaceSensitivity { get; init; } =
-        XmlWhitespaceSensitivity.Strict;
+    public XmlWhitespaceSensitivity? XmlWhitespaceSensitivity { get; init; }
 
     [JsonConverter(typeof(CaseInsensitiveEnumConverter<EndOfLine>))]
     public EndOfLine EndOfLine { get; init; }
@@ -36,26 +35,32 @@ out var parsedFormatter
                 return null;
             }
 
-            return new PrinterOptions(parsedFormatter)
+            return new PrinterOptions(
+                parsedFormatter,
+                matchingOverride.XmlWhitespaceSensitivity
+                    ?? PrinterOptions.GetXmlWhitespaceSensitivity(filePath)
+            )
             {
                 IndentSize = matchingOverride.IndentSize,
                 UseTabs = matchingOverride.UseTabs,
                 Width = matchingOverride.PrintWidth,
                 EndOfLine = matchingOverride.EndOfLine,
-                XmlWhitespaceSensitivity = matchingOverride.XmlWhitespaceSensitivity,
             };
         }
 
         var formatter = PrinterOptions.GetFormatter(filePath);
         if (formatter != Formatter.Unknown)
         {
-            return new PrinterOptions(formatter)
+            return new PrinterOptions(
+                formatter,
+                this.XmlWhitespaceSensitivity
+                    ?? PrinterOptions.GetXmlWhitespaceSensitivity(filePath)
+            )
             {
                 IndentSize = this.IndentSize ?? (formatter == Formatter.XML ? 2 : 4),
                 UseTabs = this.UseTabs,
                 Width = this.PrintWidth,
                 EndOfLine = this.EndOfLine,
-                XmlWhitespaceSensitivity = this.XmlWhitespaceSensitivity,
             };
         }
 
@@ -80,8 +85,7 @@ internal class Override
     public bool UseTabs { get; init; }
 
     [JsonConverter(typeof(CaseInsensitiveEnumConverter<XmlWhitespaceSensitivity>))]
-    public XmlWhitespaceSensitivity XmlWhitespaceSensitivity { get; init; } =
-        XmlWhitespaceSensitivity.Strict;
+    public XmlWhitespaceSensitivity? XmlWhitespaceSensitivity { get; init; }
 
     [JsonConverter(typeof(CaseInsensitiveEnumConverter<EndOfLine>))]
     public EndOfLine EndOfLine { get; init; }

Src/CSharpier.Cli/Options/OptionsProvider.cs

@@ -147,7 +147,9 @@ CancellationToken cancellationToken
         }
 
         var formatter = PrinterOptions.GetFormatter(filePath);
-        return formatter != Formatter.Unknown ? new PrinterOptions(formatter) : null;
+        return formatter != Formatter.Unknown
+            ? new PrinterOptions(formatter, PrinterOptions.GetXmlWhitespaceSensitivity(filePath))
+            : null;
     }
 
     private Task<CSharpierConfigData?> FindCSharpierConfigAsync(string directoryName)

Src/CSharpier.Core/CSharp/CSharpFormatter.cs

@@ -155,6 +155,7 @@ bool TryGetCompilationFailure(out CodeFormatterResult compilationResult)
                     LineEnding = lineEnding,
                     IndentSize = printerOptions.IndentSize,
                     UseTabs = printerOptions.UseTabs,
+                    XmlWhitespaceSensitivity = XmlWhitespaceSensitivity.Strict,
                 },
             };
             var document = Node.Print(rootNode, printingContext);
@@ -181,6 +182,7 @@ bool TryGetCompilationFailure(out CodeFormatterResult compilationResult)
                         LineEnding = lineEnding,
                         IndentSize = printerOptions.IndentSize,
                         UseTabs = printerOptions.UseTabs,
+                        XmlWhitespaceSensitivity = XmlWhitespaceSensitivity.Strict,
                     },
                 };
                 document = Node.Print(

Src/CSharpier.Core/CSharp/SyntaxPrinter/PrintingContext.cs

@@ -36,6 +36,7 @@ public class PrintingContextOptions
         public required string LineEnding { get; init; }
         public required int IndentSize { get; init; }
         public required bool UseTabs { get; init; }
+        public required XmlWhitespaceSensitivity XmlWhitespaceSensitivity { get; init; }
     }
 
     public class PrintingContextState

Src/CSharpier.Core/CSharpier.Core.csproj

@@ -9,6 +9,7 @@
     <PublicKey>002400000480000094000000060200000024000052534131000400000100010049d266ea1aeae09c0abfce28b8728314d4e4807126ee8bc56155a7ddc765997ed3522908b469ae133fc49ef0bfa957df36082c1c2e0ec8cdc05a4ca4dbd4e1bea6c17fc1008555e15af13a8fc871a04ffc38f5e60e6203bfaf01d16a2a283b90572ade79135801c1675bf38b7a5a60ec8353069796eb53a26ffdddc9ee1273be</PublicKey>
     <LangVersion>13</LangVersion>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <Tester>One</Tester>
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="LovettSoftware.XmlDiff" />

Src/CSharpier.Core/CodeFormatterOptions.cs

@@ -7,10 +7,12 @@ public class CodeFormatterOptions
     public int IndentSize { get; init; } = 4;
     public EndOfLine EndOfLine { get; init; } = EndOfLine.Auto;
     public bool IncludeGenerated { get; init; }
+    public XmlWhitespaceSensitivity XmlWhitespaceSensitivity { get; init; } =
+        XmlWhitespaceSensitivity.Strict;
 
     internal PrinterOptions ToPrinterOptions()
     {
-        return new(Formatter.CSharp)
+        return new(Formatter.CSharp, this.XmlWhitespaceSensitivity)
         {
             Width = this.Width,
             UseTabs = this.IndentStyle == IndentStyle.Tabs,

Src/CSharpier.Core/DocTypes/Doc.cs

@@ -14,9 +14,15 @@ public static implicit operator Doc(string value)
         return StringDoc.Create(value);
     }
 
-    public static NullDoc Null => NullDoc.Instance;
+    public static NullDoc Null
+    {
+        get { return NullDoc.Instance; }
+    }
 
-    public static Doc BreakParent => new BreakParent();
+    public static Doc BreakParent
+    {
+        get { return new BreakParent(); }
+    }
 
     public static readonly HardLine HardLine = new();
 
@@ -39,19 +45,33 @@ public static implicit operator Doc(string value)
 
     public static readonly Trim Trim = new();
 
-    public static LeadingComment LeadingComment(string comment, CommentType commentType) =>
-        new() { Type = commentType, Comment = comment };
+    public static LeadingComment LeadingComment(string comment, CommentType commentType)
+    {
+        return new LeadingComment { Type = commentType, Comment = comment };
+    }
 
-    public static TrailingComment TrailingComment(string comment, CommentType commentType) =>
-        new() { Type = commentType, Comment = comment };
+    public static TrailingComment TrailingComment(string comment, CommentType commentType)
+    {
+        return new TrailingComment { Type = commentType, Comment = comment };
+    }
 
-    public static Doc Concat(List<Doc> contents) =>
-        contents.Count == 1 ? contents[0] : new Concat(contents);
+    public static Doc Concat(List<Doc> contents)
+    {
+        return contents.Count == 0 ? Doc.Null
+            : contents.Count == 1 ? contents[0]
+            : new Concat(contents);
+    }
 
     // prevents allocating an array if there is only a single parameter
-    public static Doc Concat(Doc contents) => contents;
+    public static Doc Concat(Doc contents)
+    {
+        return contents;
+    }
 
-    public static Doc Concat(params Doc[] contents) => new Concat(contents);
+    public static Doc Concat(params Doc[] contents)
+    {
+        return new Concat(contents);
+    }
 
     public static Doc Concat(ref DocListBuilder contents)
     {
@@ -82,14 +102,20 @@ public static Doc Join(Doc separator, IEnumerable<Doc> enumerable)
         return docs.Count == 1 ? docs[0] : Concat(docs);
     }
 
-    public static ForceFlat ForceFlat(List<Doc> contents) =>
-        new() { Contents = contents.Count == 0 ? contents[0] : Concat(contents) };
+    public static ForceFlat ForceFlat(List<Doc> contents)
+    {
+        return new ForceFlat { Contents = contents.Count == 0 ? contents[0] : Concat(contents) };
+    }
 
-    public static ForceFlat ForceFlat(params Doc[] contents) =>
-        new() { Contents = contents.Length == 0 ? contents[0] : Concat(contents) };
+    public static ForceFlat ForceFlat(params Doc[] contents)
+    {
+        return new ForceFlat { Contents = contents.Length == 0 ? contents[0] : Concat(contents) };
+    }
 
-    public static Group Group(List<Doc> contents) =>
-        new() { Contents = contents.Count == 1 ? contents[0] : Concat(contents) };
+    public static Group Group(List<Doc> contents)
+    {
+        return new Group { Contents = contents.Count == 1 ? contents[0] : Concat(contents) };
+    }
 
     public static Group GroupWithId(string groupId, List<Doc> contents)
     {
@@ -124,45 +150,76 @@ public static Group GroupWithId(string groupId, params Doc[] contents)
     }
 
     // prevents allocating an array if there is only a single parameter
-    public static Group Group(Doc contents) => new() { Contents = contents };
+    public static Group Group(Doc contents)
+    {
+        return new Group { Contents = contents };
+    }
 
-    public static Group Group(params Doc[] contents) => new() { Contents = Concat(contents) };
+    public static Group Group(params Doc[] contents)
+    {
+        return new Group { Contents = Concat(contents) };
+    }
 
     // prevents allocating an array if there is only a single parameter
-    public static IndentDoc Indent(Doc contents) => new() { Contents = contents };
+    public static IndentDoc Indent(Doc contents)
+    {
+        return new IndentDoc { Contents = contents };
+    }
 
-    public static IndentDoc Indent(params Doc[] contents) => new() { Contents = Concat(contents) };
+    public static IndentDoc Indent(params Doc[] contents)
+    {
+        return new IndentDoc { Contents = Concat(contents) };
+    }
 
-    public static IndentDoc Indent(List<Doc> contents) => new() { Contents = Concat(contents) };
+    public static IndentDoc Indent(List<Doc> contents)
+    {
+        return new IndentDoc { Contents = Concat(contents) };
+    }
 
     public static Doc IndentIf(bool condition, Doc contents)
     {
         return condition ? Indent(contents) : contents;
     }
 
-    public static IfBreak IfBreak(Doc breakContents, Doc flatContents, string? groupId = null) =>
-        new()
+    public static IfBreak IfBreak(Doc breakContents, Doc flatContents, string? groupId = null)
+    {
+        return new IfBreak
         {
             FlatContents = flatContents,
             BreakContents = breakContents,
             GroupId = groupId,
         };
+    }
 
-    public static IndentIfBreak IndentIfBreak(Doc contents, string groupId) =>
-        new(contents, groupId);
+    public static IndentIfBreak IndentIfBreak(Doc contents, string groupId)
+    {
+        return new IndentIfBreak(contents, groupId);
+    }
 
-    public static Doc Directive(string value) => new StringDoc(value, true);
+    public static Doc Directive(string value)
+    {
+        return new StringDoc(value, true);
+    }
 
-    public static ConditionalGroup ConditionalGroup(params Doc[] options) => new(options);
+    public static ConditionalGroup ConditionalGroup(params Doc[] options)
+    {
+        return new ConditionalGroup(options);
+    }
 
     public static AlwaysFits AlwaysFits(Doc printedTrivia)
     {
         return new AlwaysFits(printedTrivia);
     }
 
-    public static Region BeginRegion(string text) => new(text);
+    public static Region BeginRegion(string text)
+    {
+        return new Region(text);
+    }
 
-    public static Region EndRegion(string text) => new(text) { IsEnd = true };
+    public static Region EndRegion(string text)
+    {
+        return new Region(text) { IsEnd = true };
+    }
 }
 
 internal enum CommentType