Reduce allocations in file path normalization (#9326)

This change is a rewrite of tooling's `FilePathNormalizer` helper
methods to avoid extra allocations associated with string manipulation.
These started showing up in perf tests recently because the new
`ProjectKey` type uses them to construct itself. These changes should
reduce the allocations in those perf tests.

Author: DustinCampbell

src/Compiler/Microsoft.CodeAnalysis.Razor/src/FilePathComparer.cs

@@ -1,31 +1,22 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System;
 using System.Runtime.InteropServices;
 
 namespace Microsoft.CodeAnalysis.Razor;
 
 internal static class FilePathComparer
 {
-    private static StringComparer _instance;
+    private static StringComparer? _instance;
 
     public static StringComparer Instance
     {
         get
         {
-            if (_instance == null && RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-            {
-                _instance = StringComparer.Ordinal;
-            }
-            else if (_instance == null)
-            {
-                _instance = StringComparer.OrdinalIgnoreCase;
-            }
-
-            return _instance;
+            return _instance ??= RuntimeInformation.IsOSPlatform(OSPlatform.Linux)
+                ? StringComparer.Ordinal
+                : StringComparer.OrdinalIgnoreCase;
         }
     }
 }

src/Compiler/Microsoft.CodeAnalysis.Razor/src/FilePathComparison.cs

@@ -1,8 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System;
 using System.Runtime.InteropServices;
 
@@ -16,16 +14,9 @@ public static StringComparison Instance
     {
         get
         {
-            if (_instance == null && RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-            {
-                _instance = StringComparison.Ordinal;
-            }
-            else if (_instance == null)
-            {
-                _instance = StringComparison.OrdinalIgnoreCase;
-            }
-
-            return _instance.Value;
+            return _instance ??= RuntimeInformation.IsOSPlatform(OSPlatform.Linux)
+                ? StringComparison.Ordinal
+                : StringComparison.OrdinalIgnoreCase;
         }
     }
 }

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/ProjectSystem/DefaultRazorProjectService.cs

@@ -105,7 +105,7 @@ void AddDocumentToProject(IProjectSnapshot projectSnapshot, string textDocumentP
             }
 
             var targetFilePath = textDocumentPath;
-            var projectDirectory = FilePathNormalizer.GetDirectory(projectSnapshot.FilePath);
+            var projectDirectory = FilePathNormalizer.GetNormalizedDirectoryName(projectSnapshot.FilePath);
             if (targetFilePath.StartsWith(projectDirectory, FilePathComparison.Instance))
             {
                 // Make relative
@@ -324,7 +324,7 @@ private void UpdateProjectDocuments(IReadOnlyList<DocumentSnapshotHandle> docume
 
         var project = (ProjectSnapshot)_projectSnapshotManagerAccessor.Instance.GetLoadedProject(projectKey);
         var currentHostProject = project.HostProject;
-        var projectDirectory = FilePathNormalizer.GetDirectory(project.FilePath);
+        var projectDirectory = FilePathNormalizer.GetNormalizedDirectoryName(project.FilePath);
         var documentMap = documents.ToDictionary(document => EnsureFullPath(document.FilePath, projectDirectory), FilePathComparer.Instance);
         var miscellaneousProject = (ProjectSnapshot)_snapshotResolver.GetMiscellaneousProject();
 

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/ProjectSystem/SnapshotResolver.cs

@@ -50,7 +50,7 @@ public IEnumerable<IProjectSnapshot> FindPotentialProjects(string documentFilePa
                 continue;
             }
 
-            var projectDirectory = FilePathNormalizer.GetDirectory(projectSnapshot.FilePath);
+            var projectDirectory = FilePathNormalizer.GetNormalizedDirectoryName(projectSnapshot.FilePath);
             if (normalizedDocumentPath.StartsWith(projectDirectory, FilePathComparison.Instance))
             {
                 yield return projectSnapshot;

src/Razor/src/Microsoft.AspNetCore.Razor.ProjectEngineHost/Utilities/FilePathNormalizer.cs

@@ -2,7 +2,7 @@
 // Licensed under the MIT license. See License.txt in the project root for license information.
 
 using System;
-using System.Net;
+using System.Buffers;
 using System.Runtime.InteropServices;
 using Microsoft.CodeAnalysis.Razor;
 
@@ -12,60 +12,186 @@ internal static class FilePathNormalizer
 {
     public static string NormalizeDirectory(string? directoryFilePath)
     {
-        var normalized = Normalize(directoryFilePath);
+        if (directoryFilePath.IsNullOrEmpty())
+        {
+            return "/";
+        }
+
+        var directoryFilePathSpan = directoryFilePath.AsSpan();
+
+        // Ensure that the array is at least 1 character larger, so that we can add
+        // a trailing space after normalization if necessary.
+        var arrayLength = directoryFilePathSpan.Length + 1;
+        using var _ = ArrayPool<char>.Shared.GetPooledArray(arrayLength, out var array);
+        var arraySpan = array.AsSpan(0, arrayLength);
+        var (start, length) = NormalizeCore(directoryFilePathSpan, arraySpan);
+        ReadOnlySpan<char> normalizedSpan = arraySpan.Slice(start, length);
+
+        // Add a trailing slash if the normalized span doesn't end in one.
+        if (normalizedSpan[^1] != '/')
+        {
+            arraySpan[start + length] = '/';
+            normalizedSpan = arraySpan.Slice(start, length + 1);
+        }
 
-        if (!normalized.EndsWith("/", StringComparison.Ordinal))
+        if (directoryFilePathSpan.Equals(normalizedSpan, StringComparison.Ordinal))
         {
-            normalized += '/';
+            return directoryFilePath;
         }
 
-        return normalized;
+        return CreateString(normalizedSpan);
     }
 
     public static string Normalize(string? filePath)
     {
-        if (string.IsNullOrEmpty(filePath))
+        if (filePath.IsNullOrEmpty())
         {
             return "/";
         }
 
-        var decodedPath = filePath.AssumeNotNull().Contains("%") ? WebUtility.UrlDecode(filePath) : filePath;
-        var normalized = decodedPath.Replace('\\', '/');
+        var filePathSpan = filePath.AsSpan();
 
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) &&
-            normalized[0] == '/' &&
-            !normalized.StartsWith("//", StringComparison.OrdinalIgnoreCase))
+        // Rent a buffer for Normalize to write to.
+        using var _ = ArrayPool<char>.Shared.GetPooledArray(filePathSpan.Length, out var array);
+        var normalizedSpan = NormalizeCoreAndGetSpan(filePathSpan, array);
+
+        // If we didn't change anything, just return the original string.
+        if (filePathSpan.Equals(normalizedSpan, StringComparison.Ordinal))
         {
-            // We've been provided a path that probably looks something like /C:/path/to
-            normalized = normalized[1..];
+            return filePath;
         }
-        else
+
+        // Otherwise, create a new string from our normalized char buffer.
+        return CreateString(normalizedSpan);
+    }
+
+    /// <summary>
+    ///  Returns the directory portion of the given file path in normalized form.
+    /// </summary>
+    public static string GetNormalizedDirectoryName(string? filePath)
+    {
+        if (filePath.IsNullOrEmpty())
         {
-            // Already a valid path like C:/path or //path
+            return "/";
+        }
+
+        var filePathSpan = filePath.AsSpan();
+
+        using var _1 = ArrayPool<char>.Shared.GetPooledArray(filePathSpan.Length, out var array);
+        var normalizedSpan = NormalizeCoreAndGetSpan(filePathSpan, array);
+
+        var lastSlashIndex = normalizedSpan.LastIndexOf('/');
+
+        var directoryNameSpan = lastSlashIndex >= 0
+            ? normalizedSpan[..(lastSlashIndex + 1)] // Include trailing slash
+            : normalizedSpan;
+
+        if (filePathSpan.Equals(directoryNameSpan, StringComparison.Ordinal))
+        {
+            return filePath;
         }
 
-        return normalized;
+        return CreateString(directoryNameSpan);
     }
 
-    public static string GetDirectory(string filePath)
+    public static bool FilePathsEquivalent(string? filePath1, string? filePath2)
     {
-        if (string.IsNullOrEmpty(filePath))
+        var filePathSpan1 = filePath1.AsSpanOrDefault();
+        var filePathSpan2 = filePath2.AsSpanOrDefault();
+
+        if (filePathSpan1.IsEmpty)
+        {
+            return filePathSpan2.IsEmpty;
+        }
+        else if (filePathSpan2.IsEmpty)
         {
-            throw new InvalidOperationException(filePath);
+            return false;
         }
 
-        var normalizedPath = Normalize(filePath);
-        var lastSeparatorIndex = normalizedPath.LastIndexOf('/');
+        using var _1 = ArrayPool<char>.Shared.GetPooledArray(filePathSpan1.Length, out var array1);
+        var normalizedSpan1 = NormalizeCoreAndGetSpan(filePathSpan1, array1);
+
+        using var _2 = ArrayPool<char>.Shared.GetPooledArray(filePathSpan2.Length, out var array2);
+        var normalizedSpan2 = NormalizeCoreAndGetSpan(filePathSpan2, array2);
 
-        var directory = normalizedPath[..(lastSeparatorIndex + 1)];
-        return directory;
+        return normalizedSpan1.Equals(normalizedSpan2, FilePathComparison.Instance);
     }
 
-    public static bool FilePathsEquivalent(string filePath1, string filePath2)
+    private static ReadOnlySpan<char> NormalizeCoreAndGetSpan(ReadOnlySpan<char> source, Span<char> destination)
     {
-        var normalizedFilePath1 = Normalize(filePath1);
-        var normalizedFilePath2 = Normalize(filePath2);
+        var (start, length) = NormalizeCore(source, destination);
+        return destination.Slice(start, length);
+    }
 
-        return FilePathComparer.Instance.Equals(normalizedFilePath1, normalizedFilePath2);
+    /// <summary>
+    ///  Normalizes the given <paramref name="source"/> file path and writes the result in <paramref name="destination"/>.
+    /// </summary>
+    /// <param name="source">The span to normalize.</param>
+    /// <param name="destination">The span to write to.</param>
+    /// <returns>
+    ///  Returns a tuple containing the start index and length of the normalized path within <paramref name="destination"/>.
+    /// </returns>
+    private static (int start, int length) NormalizeCore(ReadOnlySpan<char> source, Span<char> destination)
+    {
+        if (source.IsEmpty)
+        {
+            if (destination.Length < 1)
+            {
+                throw new ArgumentException("Destination length must be at least 1 if the source is empty.", nameof(destination));
+            }
+
+            destination[0] = '/';
+
+            return (start: 0, length: 1);
+        }
+
+        if (destination.Length < source.Length)
+        {
+            throw new ArgumentException("Destination length must be greater or equal to the source length.", nameof(destination));
+        }
+
+        int charsWritten;
+
+        // Note: We check for '%' characters before calling UrlDecoder.Decode to ensure that we *only*
+        // decode when there are '%XX' entities. So, calling Normalize on a path and then calling Normalize
+        // on the result will not call Decode twice.
+        if (source.Contains("%".AsSpan(), StringComparison.Ordinal))
+        {
+            UrlDecoder.Decode(source, destination, out charsWritten);
+        }
+        else
+        {
+            source.CopyTo(destination);
+            charsWritten = source.Length;
+        }
+
+        // Replace slashes in our normalized span.
+        destination[..charsWritten].Replace('\\', '/');
+
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) &&
+            destination is ['/', not '/', ..])
+        {
+            // We've been provided a path that probably looks something like /C:/path/to.
+            // So, we adjust the result to skip the leading '/'.
+            return (start: 1, length: charsWritten - 1);
+        }
+        else
+        {
+            // Already a valid path like C:/path or //path
+            return (start: 0, length: charsWritten);
+        }
+    }
+
+    private static unsafe string CreateString(ReadOnlySpan<char> source)
+    {
+        if (source.IsEmpty)
+        {
+            return string.Empty;
+        }
+
+        fixed (char* ptr = source)
+        {
+            return new string(ptr, 0, source.Length);
+        }
     }
 }