perf: only run PreprocessorSymbols when #if found

Src/CSharpier.Core/CSharp/CSharpFormatter.cs

@@ -44,6 +44,7 @@ public static Task<CodeFormatterResult> FormatAsync(
             syntaxTree,
             (options ?? new()).ToPrinterOptions(),
             SourceCodeKind.Regular,
+            new PrintingContext.CodeInformation(true, true),
             cancellationToken
         );
     }
@@ -68,10 +69,13 @@ CancellationToken cancellationToken
     {
         var initialSymbolSet = Array.Empty<string>();
 
+        var codeInformation = CSharpScanner.Scan(code);
+
         return FormatAsync(
             ParseText(code, initialSymbolSet, sourceCodeKind, cancellationToken),
             printerOptions,
             sourceCodeKind,
+            codeInformation,
             cancellationToken
         );
     }
@@ -99,6 +103,7 @@ internal static async Task<CodeFormatterResult> FormatAsync(
         SyntaxTree syntaxTree,
         PrinterOptions printerOptions,
         SourceCodeKind sourceCodeKind,
+        PrintingContext.CodeInformation information,
         CancellationToken cancellationToken
     )
     {
@@ -156,6 +161,7 @@ bool TryGetCompilationFailure(out CodeFormatterResult compilationResult)
                     IndentSize = printerOptions.IndentSize,
                     UseTabs = printerOptions.UseTabs,
                 },
+                Information = information,
             };
             var document = Node.Print(rootNode, printingContext);
             var formattedCode = DocPrinter.DocPrinter.Print(document, printerOptions, lineEnding);
@@ -165,36 +171,49 @@ bool TryGetCompilationFailure(out CodeFormatterResult compilationResult)
                 .ReorderedUsingsWithDisabledText;
             var movedTrailingTrivia = printingContext.State.MovedTrailingTrivia;
 
-            foreach (var symbolSet in PreprocessorSymbols.GetSets(syntaxTree))
+            if (printingContext.Information.HasPreprocessorSymbols)
             {
-                syntaxTree = ParseText(formattedCode, symbolSet, sourceCodeKind, cancellationToken);
-
-                if (TryGetCompilationFailure(out result))
+                foreach (var symbolSet in PreprocessorSymbols.GetSets(syntaxTree))
                 {
-                    return result;
-                }
+                    syntaxTree = ParseText(
+                        formattedCode,
+                        symbolSet,
+                        sourceCodeKind,
+                        cancellationToken
+                    );
 
-                var formattingContext2 = new PrintingContext
-                {
-                    Options = new PrintingContext.PrintingContextOptions
+                    if (TryGetCompilationFailure(out result))
                     {
-                        LineEnding = lineEnding,
-                        IndentSize = printerOptions.IndentSize,
-                        UseTabs = printerOptions.UseTabs,
-                    },
-                };
-                document = Node.Print(
-                    await syntaxTree.GetRootAsync(cancellationToken),
-                    formattingContext2
-                );
-                formattedCode = DocPrinter.DocPrinter.Print(document, printerOptions, lineEnding);
-                reorderedModifiers =
-                    reorderedModifiers || formattingContext2.State.ReorderedModifiers;
-                reorderedUsingsWithDisabledText =
-                    reorderedUsingsWithDisabledText
-                    || formattingContext2.State.ReorderedUsingsWithDisabledText;
-                movedTrailingTrivia =
-                    movedTrailingTrivia || formattingContext2.State.MovedTrailingTrivia;
+                        return result;
+                    }
+
+                    var formattingContext2 = new PrintingContext
+                    {
+                        Options = new PrintingContext.PrintingContextOptions
+                        {
+                            LineEnding = lineEnding,
+                            IndentSize = printerOptions.IndentSize,
+                            UseTabs = printerOptions.UseTabs,
+                        },
+                        Information = printingContext.Information,
+                    };
+                    document = Node.Print(
+                        await syntaxTree.GetRootAsync(cancellationToken),
+                        formattingContext2
+                    );
+                    formattedCode = DocPrinter.DocPrinter.Print(
+                        document,
+                        printerOptions,
+                        lineEnding
+                    );
+                    reorderedModifiers =
+                        reorderedModifiers || formattingContext2.State.ReorderedModifiers;
+                    reorderedUsingsWithDisabledText =
+                        reorderedUsingsWithDisabledText
+                        || formattingContext2.State.ReorderedUsingsWithDisabledText;
+                    movedTrailingTrivia =
+                        movedTrailingTrivia || formattingContext2.State.MovedTrailingTrivia;
+                }
             }
 
             return new CodeFormatterResult

Src/CSharpier.Core/CSharp/CSharpScanner.cs

@@ -0,0 +1,47 @@
+using System.Buffers;
+using CSharpier.Core.CSharp.SyntaxPrinter;
+
+namespace CSharpier.Core.CSharp;
+
+internal static class CSharpScanner
+{
+    private const string IfPreprocessor = "#if";
+    private const string CSharpierIgnore = "// csharpier-ignore";
+
+#if NET9_0_OR_GREATER
+    private static readonly SearchValues<string> KeyValues = SearchValues.Create(
+        [IfPreprocessor, CSharpierIgnore],
+        StringComparison.Ordinal
+    );
+
+    public static PrintingContext.CodeInformation Scan(string code)
+    {
+        var index = code.AsSpan().IndexOfAny(KeyValues);
+        if (index < 0)
+        {
+            return new PrintingContext.CodeInformation(false, false);
+        }
+
+        var slice = code.AsSpan(index);
+        if (slice.StartsWith(IfPreprocessor))
+        {
+            return new PrintingContext.CodeInformation(
+                true,
+                slice.Contains(CSharpierIgnore.AsSpan(), StringComparison.Ordinal)
+            );
+        }
+
+        return new PrintingContext.CodeInformation(
+            slice.Contains(IfPreprocessor.AsSpan(), StringComparison.Ordinal),
+            true
+        );
+    }
+#else
+    public static PrintingContext.CodeInformation Scan(string code)
+    {
+        var hasPreprocessor = code.Contains(IfPreprocessor);
+        var hasCSharpierIgnore = code.Contains(CSharpierIgnore);
+        return new PrintingContext.CodeInformation(hasPreprocessor, hasCSharpierIgnore);
+    }
+#endif
+}

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

@@ -78,15 +78,18 @@ PrintingContext context
 
         foreach (var node in list)
         {
-            if (Token.HasLeadingCommentMatching(node, IgnoreEndRegex))
+            if (context.Information.HasCSharpierIgnore)
             {
-                statements.Add(unFormattedCode.AsSpan().Trim().ToString());
-                unFormattedCode.Clear();
-                printUnformatted = false;
-            }
-            else if (Token.HasLeadingCommentMatching(node, IgnoreStartRegex))
-            {
-                printUnformatted = true;
+                if (Token.HasLeadingCommentMatching(node, IgnoreEndRegex))
+                {
+                    statements.Add(unFormattedCode.AsSpan().Trim().ToString());
+                    unFormattedCode.Clear();
+                    printUnformatted = false;
+                }
+                else if (Token.HasLeadingCommentMatching(node, IgnoreStartRegex))
+                {
+                    printUnformatted = true;
+                }
             }
 
             if (printUnformatted)

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

@@ -34,21 +34,24 @@ public static List<Doc> Print<T>(
             var skipAddingLineBecauseIgnoreEnded = false;
             var member = members[memberIndex];
 
-            if (Token.HasLeadingCommentMatching(member, CSharpierIgnore.IgnoreEndRegex))
+            if (context.Information.HasCSharpierIgnore)
             {
-                skipAddingLineBecauseIgnoreEnded = true;
-                result.Add(unFormattedCode.AsSpan().Trim().ToString());
-                unFormattedCode.Clear();
-                printUnformatted = false;
-            }
-            else if (Token.HasLeadingCommentMatching(member, CSharpierIgnore.IgnoreStartRegex))
-            {
-                if (!printUnformatted && memberIndex > 0)
+                if (Token.HasLeadingCommentMatching(member, CSharpierIgnore.IgnoreEndRegex))
+                {
+                    skipAddingLineBecauseIgnoreEnded = true;
+                    result.Add(unFormattedCode.AsSpan().Trim().ToString());
+                    unFormattedCode.Clear();
+                    printUnformatted = false;
+                }
+                else if (Token.HasLeadingCommentMatching(member, CSharpierIgnore.IgnoreStartRegex))
                 {
-                    result.Add(Doc.HardLine);
-                    result.Add(ExtraNewLines.Print(member));
+                    if (!printUnformatted && memberIndex > 0)
+                    {
+                        result.Add(Doc.HardLine);
+                        result.Add(ExtraNewLines.Print(member));
+                    }
+                    printUnformatted = true;
                 }
-                printUnformatted = true;
             }
 
             if (printUnformatted)

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

@@ -7,6 +7,7 @@ namespace CSharpier.Core.CSharp.SyntaxPrinter;
 internal class PrintingContext
 {
     public required PrintingContextOptions Options { get; init; }
+    public required CodeInformation Information { get; init; }
     public PrintingContextState State { get; } = new();
 
     private readonly Dictionary<string, int> groupNumberByValue = [];
@@ -59,4 +60,6 @@ public class PrintingContextState
     }
 
     public record TrailingCommaContext(SyntaxTrivia TrailingComment, Doc PrintedTrailingComma);
+
+    public record struct CodeInformation(bool HasPreprocessorSymbols, bool HasCSharpierIgnore);
 }

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

@@ -56,19 +56,22 @@ private static Doc Print<T>(
         {
             var member = list[x];
 
-            if (Token.HasLeadingCommentMatching(member, CSharpierIgnore.IgnoreEndRegex))
+            if (context.Information.HasCSharpierIgnore)
             {
-                docs.Append(unFormattedCode.AsSpan().Trim().ToString());
-                unFormattedCode.Clear();
-                printUnformatted = false;
-            }
-            else if (Token.HasLeadingCommentMatching(member, CSharpierIgnore.IgnoreStartRegex))
-            {
-                if (!printUnformatted && x > 0)
+                if (Token.HasLeadingCommentMatching(member, CSharpierIgnore.IgnoreEndRegex))
+                {
+                    docs.Append(unFormattedCode.AsSpan().Trim().ToString());
+                    unFormattedCode.Clear();
+                    printUnformatted = false;
+                }
+                else if (Token.HasLeadingCommentMatching(member, CSharpierIgnore.IgnoreStartRegex))
                 {
-                    docs.Append(Doc.HardLine);
+                    if (!printUnformatted && x > 0)
+                    {
+                        docs.Append(Doc.HardLine);
+                    }
+                    printUnformatted = true;
                 }
-                printUnformatted = true;
             }
 
             if (printUnformatted)

Src/CSharpier.Core/CSharp/SyntaxPrinter/SyntaxNodePrinters/AttributeList.cs

@@ -8,7 +8,11 @@ internal static class AttributeList
 {
     public static Doc Print(AttributeListSyntax node, PrintingContext context)
     {
-        if (node.Parent is BaseMethodDeclarationSyntax && CSharpierIgnore.HasIgnoreComment(node))
+        if (
+            context.Information.HasCSharpierIgnore
+            && node.Parent is BaseMethodDeclarationSyntax
+            && CSharpierIgnore.HasIgnoreComment(node)
+        )
         {
             return CSharpierIgnore.PrintWithoutFormatting(node, context).Trim();
         }

Src/CSharpier.Core/CSharp/SyntaxPrinter/SyntaxNodePrinters/BaseMethodDeclaration.cs

@@ -118,19 +118,22 @@ void PrintMethodUnformattedWithoutAttributes(SyntaxTriviaList syntaxTriviaList)
                 );
             }
 
-            if (modifiers is { Count: > 0 })
+            if (context.Information.HasCSharpierIgnore)
             {
-                if (CSharpierIgnore.HasIgnoreComment(modifiers.Value[0]))
+                if (modifiers is { Count: > 0 })
                 {
-                    PrintMethodUnformattedWithoutAttributes(modifiers.Value[0].LeadingTrivia);
+                    if (CSharpierIgnore.HasIgnoreComment(modifiers.Value[0]))
+                    {
+                        PrintMethodUnformattedWithoutAttributes(modifiers.Value[0].LeadingTrivia);
+                        return Doc.Group(docs);
+                    }
+                }
+                else if (returnType is not null && CSharpierIgnore.HasIgnoreComment(returnType))
+                {
+                    PrintMethodUnformattedWithoutAttributes(returnType.GetLeadingTrivia());
                     return Doc.Group(docs);
                 }
             }
-            else if (returnType is not null && CSharpierIgnore.HasIgnoreComment(returnType))
-            {
-                PrintMethodUnformattedWithoutAttributes(returnType.GetLeadingTrivia());
-                return Doc.Group(docs);
-            }
         }
 
         if (modifiers is { Count: > 0 })

Src/CSharpier.Core/Xml/XmlFormatter.cs

@@ -36,6 +36,7 @@ PrinterOptions printerOptions
                     IndentSize = printerOptions.IndentSize,
                     UseTabs = printerOptions.UseTabs,
                 },
+                Information = new PrintingContext.CodeInformation(false, false),
             };
             var doc = Node.Print(rootNode, printingContext);
             var formattedXml = DocPrinter.DocPrinter.Print(doc, printerOptions, lineEnding);

Src/CSharpier.Generators/NodePrinterGenerator.sbntxt

@@ -24,7 +24,7 @@ namespace CSharpier.Core.CSharp.SyntaxPrinter
                 throw new InTooDeepException();
             }
 
-            if (CSharpierIgnore.IsNodeIgnored(syntaxNode))
+            if (context.Information.HasCSharpierIgnore && CSharpierIgnore.IsNodeIgnored(syntaxNode))
             {
                 return CSharpierIgnore.PrintWithoutFormatting(syntaxNode, context).Trim();
             }

Src/CSharpier.Tests/CSharp/SyntaxPrinter/CSharpierIgnoreTests.cs

@@ -74,6 +74,8 @@ private static string PrintWithoutFormatting(string code)
                         IndentSize = 4,
                         UseTabs = false,
                     },
+
+                    Information = new PrintingContext.CodeInformation(false, false),
                 }
             )
             .ReplaceLineEndings("\n");