perf: batch individual file inputs for parallel formatting

When multiple individual file paths are passed to CSharpier (e.g. from
pre-commit hooks), each file was previously processed sequentially with
its own OptionsProvider and FormattingCache. This caused severe
performance degradation (~15x slower than directory input).

Refactored FormatPhysicalFiles to collect individual file paths, compute
their common ancestor directory, and create a single shared
OptionsProvider and FormattingCache. Files are then formatted in
parallel using Task.WhenAll, matching the directory input code path.

Added tests for multi-file formatting, per-directory config resolution,
mixed file/directory input, and the GetCommonAncestor helper method.

Author: ansemb

Src/CSharpier.Cli/CommandLineFormatter.cs

@@ -178,6 +178,15 @@ CancellationToken cancellationToken
             writer = new FileSystemFormattedFileWriter(fileSystem);
         }
 
+        // Collect individual file paths so they can be processed in batches
+        // instead of one-by-one (which re-creates OptionsProvider, reads/writes
+        // the formatting cache, and loses parallelism for every single file).
+        var pendingFiles = new List<(
+            string DirectoryName,
+            string ActualPath,
+            string OriginalPath
+        )>();
+
         for (var x = 0; x < commandLineOptions.DirectoryOrFilePaths.Length; x++)
         {
             var directoryOrFilePath = commandLineOptions.DirectoryOrFilePaths[x];
@@ -193,30 +202,8 @@ CancellationToken cancellationToken
                 return 1;
             }
 
-            var directoryName = isFile
-                ? fileSystem.Path.GetDirectoryName(directoryOrFilePath)
-                : directoryOrFilePath;
-
-            ArgumentNullException.ThrowIfNull(directoryName);
-
-            var optionsProvider = await OptionsProvider.Create(
-                directoryName,
-                commandLineOptions.ConfigPath,
-                commandLineOptions.IgnorePath,
-                fileSystem,
-                logger,
-                cancellationToken
-            );
-
             var originalDirectoryOrFile = commandLineOptions.OriginalDirectoryOrFilePaths[x];
 
-            var formattingCache = await FormattingCacheFactory.InitializeAsync(
-                commandLineOptions,
-                optionsProvider,
-                fileSystem,
-                cancellationToken
-            );
-
             if (!Path.IsPathRooted(originalDirectoryOrFile))
             {
                 if (!originalDirectoryOrFile.StartsWith('.'))
@@ -226,81 +213,32 @@ CancellationToken cancellationToken
                 }
             }
 
-            async IAsyncEnumerable<string> EnumerateNonignoredFiles(string directory)
+            if (isFile)
             {
-                foreach (var file in fileSystem.Directory.EnumerateFiles(directory))
-                {
-                    yield return file;
-                }
-
-                foreach (var subdirectory in fileSystem.Directory.EnumerateDirectories(directory))
-                {
-                    if (await optionsProvider.IsIgnoredAsync(subdirectory, cancellationToken))
-                    {
-                        continue;
-                    }
-
-                    await foreach (var file in EnumerateNonignoredFiles(subdirectory))
-                    {
-                        yield return file;
-                    }
-                }
+                var directoryName = fileSystem.Path.GetDirectoryName(directoryOrFilePath);
+                ArgumentNullException.ThrowIfNull(directoryName);
+                pendingFiles.Add((directoryName, directoryOrFilePath, originalDirectoryOrFile));
             }
-
-            async Task FormatFile(
-                string actualFilePath,
-                string originalFilePath,
-                bool warnForUnsupported = false
-            )
+            else if (isDirectory)
             {
-                if (
-                    (
-                        !commandLineOptions.IncludeGenerated
-                        && GeneratedCodeUtilities.IsGeneratedCodeFile(actualFilePath)
-                    ) || await optionsProvider.IsIgnoredAsync(actualFilePath, cancellationToken)
-                )
-                {
-                    return;
-                }
+                var directoryName = directoryOrFilePath;
 
-                var printerOptions = await optionsProvider.GetPrinterOptionsForAsync(
-                    actualFilePath,
+                var optionsProvider = await OptionsProvider.Create(
+                    directoryName,
+                    commandLineOptions.ConfigPath,
+                    commandLineOptions.IgnorePath,
+                    fileSystem,
+                    logger,
                     cancellationToken
                 );
 
-                if (printerOptions is { Formatter: not Formatter.Unknown })
-                {
-                    printerOptions.IncludeGenerated = commandLineOptions.IncludeGenerated;
-                    await FormatPhysicalFile(
-                        actualFilePath,
-                        originalFilePath,
-                        fileSystem,
-                        logger,
-                        commandLineFormatterResult,
-                        writer,
-                        commandLineOptions,
-                        printerOptions,
-                        formattingCache,
-                        cancellationToken
-                    );
-                }
-                else if (warnForUnsupported)
-                {
-                    var fileIssueLogger = new FileIssueLogger(
-                        originalFilePath,
-                        logger,
-                        logFormat: LogFormat.Console
-                    );
-                    fileIssueLogger.WriteWarning("Is an unsupported file type.");
-                }
-            }
+                var formattingCache = await FormattingCacheFactory.InitializeAsync(
+                    commandLineOptions,
+                    optionsProvider,
+                    fileSystem,
+                    cancellationToken
+                );
 
-            if (isFile)
-            {
-                await FormatFile(directoryOrFilePath, originalDirectoryOrFile, true);
-            }
-            else if (isDirectory)
-            {
                 if (
                     !commandLineOptions.NoMSBuildCheck
                     && await HasMismatchedCliAndMsBuildVersions.Check(
@@ -314,14 +252,47 @@ await FormatPhysicalFile(
                     return 1;
                 }
 
+                async IAsyncEnumerable<string> EnumerateNonignoredFiles(string directory)
+                {
+                    foreach (var file in fileSystem.Directory.EnumerateFiles(directory))
+                    {
+                        yield return file;
+                    }
+
+                    foreach (
+                        var subdirectory in fileSystem.Directory.EnumerateDirectories(directory)
+                    )
+                    {
+                        if (
+                            await optionsProvider.IsIgnoredAsync(subdirectory, cancellationToken)
+                        )
+                        {
+                            continue;
+                        }
+
+                        await foreach (var file in EnumerateNonignoredFiles(subdirectory))
+                        {
+                            yield return file;
+                        }
+                    }
+                }
+
                 var tasks = new List<Task>();
                 await foreach (
                     var file in EnumerateNonignoredFiles(directoryOrFilePath)
                         .WithCancellation(cancellationToken)
                 )
                 {
                     var relativePath = file.Replace(directoryOrFilePath, originalDirectoryOrFile);
-                    tasks.Add(FormatFile(file, relativePath));
+                    tasks.Add(
+                        FormatFile(
+                            file,
+                            relativePath,
+                            optionsProvider,
+                            formattingCache,
+                            warnForUnsupported: false
+                        )
+                    );
                 }
 
                 try
@@ -335,12 +306,123 @@ var file in EnumerateNonignoredFiles(directoryOrFilePath)
                         throw;
                     }
                 }
+
+                await formattingCache.ResolveAsync(cancellationToken);
+            }
+        }
+
+        // Process individual files using a single shared OptionsProvider
+        // rooted at their common ancestor directory. This mirrors the directory
+        // path: one config lookup with internal caching, one formatting cache,
+        // and parallel formatting.
+        if (pendingFiles.Count > 0)
+        {
+            // Find the common ancestor directory of all pending files so we
+            // create exactly one OptionsProvider whose internal caches cover
+            // every subdirectory (same as the directory-input path).
+            var commonRoot = pendingFiles[0].DirectoryName;
+            for (var i = 1; i < pendingFiles.Count; i++)
+            {
+                commonRoot = GetCommonAncestor(commonRoot, pendingFiles[i].DirectoryName);
+            }
+
+            var optionsProvider = await OptionsProvider.Create(
+                commonRoot,
+                commandLineOptions.ConfigPath,
+                commandLineOptions.IgnorePath,
+                fileSystem,
+                logger,
+                cancellationToken
+            );
+
+            var sharedFormattingCache = await FormattingCacheFactory.InitializeAsync(
+                commandLineOptions,
+                optionsProvider,
+                fileSystem,
+                cancellationToken
+            );
+
+            var tasks = new List<Task>();
+
+            foreach (var (_, actualPath, originalPath) in pendingFiles)
+            {
+                tasks.Add(
+                    FormatFile(
+                        actualPath,
+                        originalPath,
+                        optionsProvider,
+                        sharedFormattingCache,
+                        warnForUnsupported: true
+                    )
+                );
+            }
+
+            try
+            {
+                await Task.WhenAll(tasks).WaitAsync(cancellationToken);
+            }
+            catch (OperationCanceledException ex)
+            {
+                if (ex.CancellationToken != cancellationToken)
+                {
+                    throw;
+                }
             }
 
-            await formattingCache.ResolveAsync(cancellationToken);
+            await sharedFormattingCache.ResolveAsync(cancellationToken);
         }
 
         return 0;
+
+        async Task FormatFile(
+            string actualFilePath,
+            string originalFilePath,
+            OptionsProvider optionsProvider,
+            IFormattingCache formattingCache,
+            bool warnForUnsupported
+        )
+        {
+            if (
+                (
+                    !commandLineOptions.IncludeGenerated
+                    && GeneratedCodeUtilities.IsGeneratedCodeFile(actualFilePath)
+                ) || await optionsProvider.IsIgnoredAsync(actualFilePath, cancellationToken)
+            )
+            {
+                return;
+            }
+
+            var printerOptions = await optionsProvider.GetPrinterOptionsForAsync(
+                actualFilePath,
+                cancellationToken
+            );
+
+            if (printerOptions is { Formatter: not Formatter.Unknown })
+            {
+                printerOptions.IncludeGenerated = commandLineOptions.IncludeGenerated;
+                await FormatPhysicalFile(
+                    actualFilePath,
+                    originalFilePath,
+                    fileSystem,
+                    logger,
+                    commandLineFormatterResult,
+                    writer,
+                    commandLineOptions,
+                    printerOptions,
+                    formattingCache,
+                    cancellationToken
+                );
+            }
+            else if (warnForUnsupported)
+            {
+                var fileIssueLogger = new FileIssueLogger(
+                    originalFilePath,
+                    logger,
+                    logFormat: LogFormat.Console
+                );
+                fileIssueLogger.WriteWarning("Is an unsupported file type.");
+            }
+        }
     }
 
     private static async Task FormatPhysicalFile(
@@ -386,6 +468,29 @@ await PerformFormattingSteps(
         );
     }
 
+    internal static string GetCommonAncestor(string pathA, string pathB)
+    {
+        var separators = new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar };
+        var partsA = pathA.Split(separators);
+        var partsB = pathB.Split(separators);
+        var commonLength = 0;
+        for (var i = 0; i < Math.Min(partsA.Length, partsB.Length); i++)
+        {
+            if (string.Equals(partsA[i], partsB[i], StringComparison.Ordinal))
+            {
+                commonLength = i + 1;
+            }
+            else
+            {
+                break;
+            }
+        }
+
+        return commonLength > 0
+            ? string.Join(Path.DirectorySeparatorChar, partsA.Take(commonLength))
+            : pathA;
+    }
+
     private static int ReturnExitCode(
         CommandLineOptions commandLineOptions,
         CommandLineFormatterResult result