perf: optimise IgnoreFile using ValueTask and Span.Replace

Author: TimothyMakkison

Src/CSharpier.Cli/IgnoreFile.cs

@@ -1,3 +1,4 @@
+using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.IO.Abstractions;
 using System.Text.RegularExpressions;
@@ -31,7 +32,15 @@ private IgnoreFile(List<IgnoreWithBasePath> ignores)
 
     public bool IsIgnored(string filePath)
     {
-        filePath = filePath.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
+        Span<char> pathRelativeToIgnoreFile =
+            filePath.Length <= 256 ? stackalloc char[256] : new char[filePath.Length];
+
+        pathRelativeToIgnoreFile = pathRelativeToIgnoreFile[..filePath.Length];
+        filePath.CopyTo(pathRelativeToIgnoreFile);
+        pathRelativeToIgnoreFile.Replace(
+            Path.AltDirectorySeparatorChar,
+            Path.DirectorySeparatorChar
+        );
 
         foreach (var ignore in this.Ignores)
         {
@@ -185,10 +194,19 @@ private class IgnoreWithBasePath(string basePath)
                 return (false, false);
             }
 
-            var pathRelativeToIgnoreFile =
-                path.Length > basePath.Length
-                    ? path[basePath.Length..].Replace('\\', '/')
-                    : string.Empty;
+            var relativePathLength = path.Length - basePath.Length;
+            Span<char> pathRelativeToIgnoreFile =
+                relativePathLength <= 256 ? stackalloc char[256] : new char[path.Length];
+            if (path.Length > basePath.Length)
+            {
+                path.AsSpan()[basePath.Length..].CopyTo(pathRelativeToIgnoreFile);
+                pathRelativeToIgnoreFile = pathRelativeToIgnoreFile[..relativePathLength];
+                pathRelativeToIgnoreFile.Replace('\\', '/');
+            }
+            else
+            {
+                pathRelativeToIgnoreFile = [];
+            }
 
             var isIgnored = false;
             var hasMatchingRule = false;

Src/CSharpier.Cli/Options/OptionsProvider.cs

@@ -34,7 +34,7 @@ ILogger logger
         this.logger = logger;
     }
 
-    public static async Task<OptionsProvider> Create(
+    public static async ValueTask<OptionsProvider> Create(
         string directoryName,
         string? configPath,
         string? ignorePath,
@@ -109,7 +109,7 @@ await EditorConfigLocator.FindForDirectoryNameAsync(
         return optionsProvider;
     }
 
-    public async Task<PrinterOptions?> GetPrinterOptionsForAsync(
+    public async ValueTask<PrinterOptions?> GetPrinterOptionsForAsync(
         string filePath,
         CancellationToken cancellationToken
     )
@@ -147,64 +147,73 @@ CancellationToken cancellationToken
         return formatter != Formatter.Unknown ? new PrinterOptions(formatter) : null;
     }
 
-    private Task<CSharpierConfigData?> FindCSharpierConfigAsync(string directoryName)
+    private ValueTask<CSharpierConfigData?> FindCSharpierConfigAsync(string directoryName)
     {
         return this.FindFileAsync(
             directoryName,
             this.csharpierConfigsByDirectory,
-            searchingDirectory =>
-                this.fileSystem.Directory.EnumerateFiles(
+            (searchingDirectory, cancellationToken) =>
+                this
+                    .fileSystem.Directory.EnumerateFiles(
                         searchingDirectory,
                         ".csharpierrc*",
                         SearchOption.TopDirectoryOnly
                     )
                     .Any(),
-            searchingDirectory =>
+            (searchingDirectory, cancellationToken) =>
                 Task.FromResult(
                     CSharpierConfigParser.FindForDirectoryName(
                         searchingDirectory,
                         this.fileSystem,
                         this.logger
                     )
-                )
+                ),
+            CancellationToken.None
         );
     }
 
-    private async Task<EditorConfigSections?> FindEditorConfigAsync(
+    private async ValueTask<EditorConfigSections?> FindEditorConfigAsync(
         string directoryName,
         CancellationToken cancellationToken
     )
     {
         return await this.FindFileAsync(
             directoryName,
             this.editorConfigByDirectory,
-            searchingDirectory =>
+            (searchingDirectory, cancellationToken) =>
                 this.fileSystem.File.Exists(Path.Combine(searchingDirectory, ".editorconfig")),
-            async searchingDirectory =>
+            async (searchingDirectory, cancellationToken) =>
                 await EditorConfigLocator.FindForDirectoryNameAsync(
                     searchingDirectory,
                     this.fileSystem,
                     await this.FindIgnoreFileAsync(searchingDirectory, cancellationToken),
                     cancellationToken
-                )
+                ),
+            cancellationToken
         );
     }
 
-    private async Task<IgnoreFile> FindIgnoreFileAsync(
+    private async ValueTask<IgnoreFile> FindIgnoreFileAsync(
         string directoryName,
         CancellationToken cancellationToken
     )
     {
         var ignoreFile = await this.FindFileAsync(
             directoryName,
             this.ignoreFilesByDirectory,
-            (searchingDirectory) =>
+            (searchingDirectory, cancellationToken) =>
                 this.fileSystem.File.Exists(Path.Combine(searchingDirectory, ".gitignore"))
                 || this.fileSystem.File.Exists(
                     Path.Combine(searchingDirectory, ".csharpierignore")
                 ),
-            (searchingDirectory) =>
-                IgnoreFile.CreateAsync(searchingDirectory, this.fileSystem, null, cancellationToken)
+            (searchingDirectory, cancellationToken) =>
+                IgnoreFile.CreateAsync(
+                    searchingDirectory,
+                    this.fileSystem,
+                    null,
+                    cancellationToken
+                ),
+            cancellationToken
         );
 
 #pragma warning disable IDE0270
@@ -223,11 +232,12 @@ CancellationToken cancellationToken
     /// When trying to format a file in a given subdirectory if we've already found the appropriate file type then return it
     /// otherwise track it down (parsing if we need to) and set the references for any parent directories
     /// </summary>
-    private async Task<T?> FindFileAsync<T>(
+    private async ValueTask<T?> FindFileAsync<T>(
         string directoryName,
         ConcurrentDictionary<string, T?> dictionary,
-        Func<string, bool> shouldConsiderDirectory,
-        Func<string, Task<T?>> createFileAsync
+        Func<string, CancellationToken, bool> shouldConsiderDirectory,
+        Func<string, CancellationToken, Task<T?>> createFileAsync,
+        CancellationToken cancellationToken
     )
     {
         if (dictionary.TryGetValue(directoryName, out var result))
@@ -242,10 +252,11 @@ searchingDirectory is not null
             && !dictionary.TryGetValue(searchingDirectory.FullName, out result)
         )
         {
-            if (shouldConsiderDirectory(searchingDirectory.FullName))
+            if (shouldConsiderDirectory(searchingDirectory.FullName, cancellationToken))
             {
                 dictionary[searchingDirectory.FullName] = result = await createFileAsync(
-                    searchingDirectory.FullName
+                    searchingDirectory.FullName,
+                    cancellationToken
                 );
                 break;
             }
@@ -262,7 +273,7 @@ searchingDirectory is not null
         return result;
     }
 
-    public async Task<bool> IsIgnoredAsync(
+    public async ValueTask<bool> IsIgnoredAsync(
         string actualFilePath,
         CancellationToken cancellationToken
     )