perf: check for // csharpier-ignore

TimothyMakkison · TimothyMakkison · commit 29b1e39bdcdf · 2025-10-26T20:47:36.000Z
diff --git a/Src/CSharpier.Core/CSharp/CSharpFormatter.cs b/Src/CSharpier.Core/CSharp/CSharpFormatter.cs
@@ -44,7 +44,7 @@ public static Task<CodeFormatterResult> FormatAsync(
             syntaxTree,
             (options ?? new()).ToPrinterOptions(),
             SourceCodeKind.Regular,
-            true,
+            new PrintingContext.CodeInformation(true, true),
             cancellationToken
         );
     }
@@ -68,13 +68,14 @@ CancellationToken cancellationToken
     )
     {
         var initialSymbolSet = Array.Empty<string>();
-        var hasPreprocessorSymbols = code.Contains("#if");
+
+        var codeInformation = CSharpScanner.Scan(code);
 
         return FormatAsync(
             ParseText(code, initialSymbolSet, sourceCodeKind, cancellationToken),
             printerOptions,
             sourceCodeKind,
-            hasPreprocessorSymbols,
+            codeInformation,
             cancellationToken
         );
     }
@@ -102,7 +103,7 @@ internal static async Task<CodeFormatterResult> FormatAsync(
         SyntaxTree syntaxTree,
         PrinterOptions printerOptions,
         SourceCodeKind sourceCodeKind,
-        bool hasPreprocessorSymbols,
+        PrintingContext.CodeInformation information,
         CancellationToken cancellationToken
     )
     {
@@ -160,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);
@@ -169,7 +171,7 @@ bool TryGetCompilationFailure(out CodeFormatterResult compilationResult)
                 .ReorderedUsingsWithDisabledText;
             var movedTrailingTrivia = printingContext.State.MovedTrailingTrivia;
 
-            if (hasPreprocessorSymbols)
+            if (printingContext.Information.HasPreprocessorSymbols)
             {
                 foreach (var symbolSet in PreprocessorSymbols.GetSets(syntaxTree))
                 {
@@ -193,6 +195,7 @@ bool TryGetCompilationFailure(out CodeFormatterResult compilationResult)
                             IndentSize = printerOptions.IndentSize,
                             UseTabs = printerOptions.UseTabs,
                         },
+                        Information = printingContext.Information,
                     };
                     document = Node.Print(
                         await syntaxTree.GetRootAsync(cancellationToken),
diff --git a/Src/CSharpier.Core/CSharp/CSharpScanner.cs b/Src/CSharpier.Core/CSharp/CSharpScanner.cs
@@ -0,0 +1,37 @@
+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
+}
diff --git a/Src/CSharpier.Core/CSharp/SyntaxPrinter/CSharpierIgnore.cs b/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)
diff --git a/Src/CSharpier.Core/CSharp/SyntaxPrinter/MembersWithForcedLines.cs b/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)
diff --git a/Src/CSharpier.Core/CSharp/SyntaxPrinter/PrintingContext.cs b/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);
 }
diff --git a/Src/CSharpier.Core/CSharp/SyntaxPrinter/SeparatedSyntaxList.cs b/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)
diff --git a/Src/CSharpier.Core/CSharp/SyntaxPrinter/SyntaxNodePrinters/AttributeList.cs b/Src/CSharpier.Core/CSharp/SyntaxPrinter/SyntaxNodePrinters/AttributeList.cs
@@ -8,7 +8,7 @@ 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();
         }
diff --git a/Src/CSharpier.Core/CSharp/SyntaxPrinter/SyntaxNodePrinters/BaseMethodDeclaration.cs b/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 })
diff --git a/Src/CSharpier.Core/Xml/XmlFormatter.cs b/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);
diff --git a/Src/CSharpier.Generators/NodePrinterGenerator.sbntxt b/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();
             }
diff --git a/Src/CSharpier.Tests/CSharp/SyntaxPrinter/CSharpierIgnoreTests.cs b/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");

Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@ namespace CSharpier.Core.CSharp.SyntaxPrinter;`
`7`	`7`	`internal class PrintingContext`
`8`	`8`	`{`
`9`	`9`	`public required PrintingContextOptions Options { get; init; }`
	`10`	`+ public required CodeInformation Information { get; init; }`
`10`	`11`	`public PrintingContextState State { get; } = new();`
`11`	`12`
`12`	`13`	`private readonly Dictionary<string, int> groupNumberByValue = [];`
`@@ -59,4 +60,6 @@ public class PrintingContextState`
`59`	`60`	`}`
`60`	`61`
`61`	`62`	`public record TrailingCommaContext(SyntaxTrivia TrailingComment, Doc PrintedTrailingComma);`
	`63`	`+`
	`64`	`+ public record struct CodeInformation(bool HasPreprocessorSymbols, bool HasCSharpierIgnore);`
`62`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ internal static class AttributeList`
`8`	`8`	`{`
`9`	`9`	`public static Doc Print(AttributeListSyntax node, PrintingContext context)`
`10`	`10`	`{`
`11`		`- if (node.Parent is BaseMethodDeclarationSyntax && CSharpierIgnore.HasIgnoreComment(node))`
	`11`	`+ if (context.Information.HasCSharpierIgnore && node.Parent is BaseMethodDeclarationSyntax && CSharpierIgnore.HasIgnoreComment(node))`
`12`	`12`	`{`
`13`	`13`	`return CSharpierIgnore.PrintWithoutFormatting(node, context).Trim();`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -118,19 +118,22 @@ void PrintMethodUnformattedWithoutAttributes(SyntaxTriviaList syntaxTriviaList)`
`118`	`118`	`);`
`119`	`119`	`}`
`120`	`120`
`121`		`- if (modifiers is { Count: > 0 })`
	`121`	`+ if (context.Information.HasCSharpierIgnore)`
`122`	`122`	`{`
`123`		`- if (CSharpierIgnore.HasIgnoreComment(modifiers.Value[0]))`
	`123`	`+ if (modifiers is { Count: > 0 })`
`124`	`124`	`{`
`125`		`- PrintMethodUnformattedWithoutAttributes(modifiers.Value[0].LeadingTrivia);`
	`125`	`+ if (CSharpierIgnore.HasIgnoreComment(modifiers.Value[0]))`
	`126`	`+ {`
	`127`	`+ PrintMethodUnformattedWithoutAttributes(modifiers.Value[0].LeadingTrivia);`
	`128`	`+ return Doc.Group(docs);`
	`129`	`+ }`
	`130`	`+ }`
	`131`	`+ else if (returnType is not null && CSharpierIgnore.HasIgnoreComment(returnType))`
	`132`	`+ {`
	`133`	`+ PrintMethodUnformattedWithoutAttributes(returnType.GetLeadingTrivia());`
`126`	`134`	`return Doc.Group(docs);`
`127`	`135`	`}`
`128`	`136`	`}`
`129`		`- else if (returnType is not null && CSharpierIgnore.HasIgnoreComment(returnType))`
`130`		`- {`
`131`		`- PrintMethodUnformattedWithoutAttributes(returnType.GetLeadingTrivia());`
`132`		`- return Doc.Group(docs);`
`133`		`- }`
`134`	`137`	`}`
`135`	`138`
`136`	`139`	`if (modifiers is { Count: > 0 })`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ namespace CSharpier.Core.CSharp.SyntaxPrinter`
`24`	`24`	`throw new InTooDeepException();`
`25`	`25`	`}`
`26`	`26`
`27`		`- if (CSharpierIgnore.IsNodeIgnored(syntaxNode))`
	`27`	`+ if (context.Information.HasCSharpierIgnore && CSharpierIgnore.IsNodeIgnored(syntaxNode))`
`28`	`28`	`{`
`29`	`29`	`return CSharpierIgnore.PrintWithoutFormatting(syntaxNode, context).Trim();`
`30`	`30`	`}`