Add APIs that remove redundant segments from paths

src/libraries/Microsoft.IO.Redist/src/Microsoft.IO.Redist.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>net472</TargetFrameworks>
     <DefineConstants>$(DefineConstants);MS_IO_REDIST</DefineConstants>
@@ -120,6 +120,10 @@
              Link="System\IO\PathInternal.cs" />
     <Compile Include="$(CoreLibSharedDir)System\IO\PathInternal.Windows.cs"
              Link="System\IO\PathInternal.Windows.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\IO\RedundantSegmentHelper.cs"
+             Link="System\IO\RedundantSegmentHelper.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\IO\RedundantSegmentHelper.Windows.cs"
+             Link="System\IO\RedundantSegmentHelper.Windows.cs" />
     <Compile Include="$(CommonPath)System\IO\Win32Marshal.cs"
              Link="Common\System\IO\Win32Marshal.cs" />
     <Compile Include="$(CommonPath)System\Text\ValueStringBuilder.cs"

src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems

@@ -403,6 +403,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\PathInternal.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\PathTooLongException.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\PinnedBufferMemoryStream.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\IO\RedundantSegmentHelper.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\SeekOrigin.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Stream.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\StreamReader.cs" />
@@ -1610,14 +1611,15 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Globalization\GlobalizationMode.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Globalization\HijriCalendar.Win32.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Guid.Windows.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\IO\DisableMediaInsertionPrompt.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\DriveInfoInternal.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\FileStream.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\FileStream.Win32.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\FileStreamCompletionSource.Win32.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Path.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\PathHelper.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\PathInternal.Windows.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)System\IO\DisableMediaInsertionPrompt.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\IO\RedundantSegmentHelper.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\PasteArguments.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Loader\LibraryNameVariation.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\MemoryFailPoint.Windows.cs" />
@@ -1822,6 +1824,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Path.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\PathInternal.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\PersistedFiles.Names.Unix.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\IO\RedundantSegmentHelper.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\PasteArguments.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Loader\LibraryNameVariation.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\MemoryFailPoint.Unix.cs" />

src/libraries/System.Private.CoreLib/src/System/IO/Path.Unix.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+#nullable enable
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Text;
@@ -33,7 +34,7 @@ public static string GetFullPath(string path)
 
             // We would ideally use realpath to do this, but it resolves symlinks, requires that the file actually exist,
             // and turns it into a full path, which we only want if fullCheck is true.
-            string collapsedString = PathInternal.RemoveRelativeSegments(path, PathInternal.GetRootLength(path));
+            string collapsedString = Path.RemoveRedundantSegments(path);
 
             Debug.Assert(collapsedString.Length < path.Length || collapsedString.ToString() == path,
                 "Either we've removed characters, or the string should be unmodified from the input path.");
@@ -57,9 +58,12 @@ public static string GetFullPath(string path, string basePath)
             if (basePath.Contains('\0') || path.Contains('\0'))
                 throw new ArgumentException(SR.Argument_InvalidPathChars);
 
-            if (IsPathFullyQualified(path))
+            if (Path.IsPathRooted(path))
                 return GetFullPath(path);
 
+            if (PathInternal.IsEffectivelyEmpty(path.AsSpan()))
+                return basePath;
+
             return GetFullPath(CombineInternal(basePath, path));
         }
 

src/libraries/System.Private.CoreLib/src/System/IO/Path.Windows.cs

@@ -128,9 +128,7 @@ public static string GetFullPath(string path, string basePath)
             // to Windows APIs won't do anything by design. Additionally, GetFullPathName() in Windows doesn't root
             // them properly. As such we need to manually remove segments and not use GetFullPath().
 
-            return PathInternal.IsDevice(combinedPath.AsSpan())
-                ? PathInternal.RemoveRelativeSegments(combinedPath, PathInternal.GetRootLength(combinedPath.AsSpan()))
-                : GetFullPath(combinedPath);
+            return PathInternal.IsDevice(combinedPath.AsSpan()) ? RemoveRedundantSegments(combinedPath) : GetFullPath(combinedPath);
         }
 
         public static string GetTempPath()

src/libraries/System.Private.CoreLib/src/System/IO/Path.cs

@@ -32,6 +32,11 @@ public static partial class Path
         // 8 random bytes provides 12 chars in our encoding for the 8.3 name.
         private const int KeyLength = 8;
 
+        // Initial cross-platform length for a buffer that is to be passed to the ValueStringBuilder constructor.
+        // The ValueStringBuilder will increase the internal buffer length when necessary.
+        // The value is equivalent to PathInternal.MaxShortPath, a limitation that only exists in older Windows versions.
+        private const int InitialValueStringBuilderBufferLength = 260;
+
         [Obsolete("Please use GetInvalidPathChars or GetInvalidFileNameChars instead.")]
         public static readonly char[] InvalidPathChars = GetInvalidPathChars();
 
@@ -383,7 +388,7 @@ public static string Combine(params string[] paths)
                     maxSize++;
             }
 
-            var builder = new ValueStringBuilder(stackalloc char[260]); // MaxShortPath on Windows
+            var builder = new ValueStringBuilder(stackalloc char[InitialValueStringBuilderBufferLength]);
             builder.EnsureCapacity(maxSize);
 
             for (int i = firstComponent; i < paths.Length; i++)
@@ -490,7 +495,7 @@ public static string Join(params string?[] paths)
             }
             maxSize += paths.Length - 1;
 
-            var builder = new ValueStringBuilder(stackalloc char[260]); // MaxShortPath on Windows
+            var builder = new ValueStringBuilder(stackalloc char[InitialValueStringBuilderBufferLength]);
             builder.EnsureCapacity(maxSize);
 
             for (int i = 0; i < paths.Length; i++)
@@ -916,7 +921,7 @@ private static string GetRelativePath(string relativeTo, string path, StringComp
             //  C:\Foo\Bar C:\Bar\Bar L3, S2 -> ..\..\Bar\Bar
             //  C:\Foo\Foo C:\Foo\Bar L7, S1 -> ..\Bar
 
-            var sb = new ValueStringBuilder(stackalloc char[260]);
+            var sb = new ValueStringBuilder(stackalloc char[InitialValueStringBuilderBufferLength]);
             sb.EnsureCapacity(Math.Max(relativeTo.Length, path.Length));
 
             // Add parent segments for segments past the common on the "from" path
@@ -983,5 +988,97 @@ private static string GetRelativePath(string relativeTo, string path, StringComp
         /// Returns true if the path ends in a directory separator.
         /// </summary>
         public static bool EndsInDirectorySeparator(string path) => PathInternal.EndsInDirectorySeparator(path);
+
+        /// <summary>
+        /// Removes redundant segments from the specified string containing a path.
+        /// </summary>
+        /// <param name="path">The path to remove redundant segments from.</param>
+        /// <returns>The <paramref name="path" /> without redundant segments, or <see langword="null" /> if <paramref name="path"/> is <see langword="null" />, or <see cref="string.Empty"/> if <paramref name="path"/> is effectively empty (an empty string or whitespace characters).</returns>
+        [return: NotNullIfNotNull("path")]
+        public static string? RemoveRedundantSegments(string? path)
+        {
+            if (path == null)
+            {
+                return null;
+            }
+
+            var spanPath = path.AsSpan();
+            if (PathInternal.IsEffectivelyEmpty(spanPath))
+            {
+                return string.Empty;
+            }
+
+            var sb = new ValueStringBuilder(spanPath.Length > InitialValueStringBuilderBufferLength? InitialValueStringBuilderBufferLength: spanPath.Length);
+
+            if (!RedundantSegmentHelper.TryRemoveRedundantSegments(spanPath, ref sb))
+            {
+                sb.Dispose();
+                return path;
+            }
+
+            return sb.ToString(); // Disposes
+        }
+
+        /// <summary>
+        /// Removes redundant segments from the specified read-only span of characters containing a path.
+        /// </summary>
+        /// <param name="path">The path to remove redundant segments from.</param>
+        /// <returns>The <paramref name="path" /> without redundant segments, or <see cref="string.Empty"/> if <paramref name="path"/> is effectively empty (an empty string or whitespace characters).</returns>
+        public static string RemoveRedundantSegments(ReadOnlySpan<char> path)
+        {
+            if (PathInternal.IsEffectivelyEmpty(path))
+            {
+                return string.Empty;
+            }
+
+            var sb = new ValueStringBuilder(path.Length > InitialValueStringBuilderBufferLength ? InitialValueStringBuilderBufferLength : path.Length);
+
+            if (!RedundantSegmentHelper.TryRemoveRedundantSegments(path, ref sb))
+            {
+                sb.Dispose();
+                return path.ToString();
+            }
+            else
+            {
+                return sb.ToString(); // Disposes
+            }
+        }
+
+        /// <summary>
+        /// Tries to remove redundant segments from the specified path read-only span.
+        /// </summary>
+        /// <param name="path">The path to analyze.</param>
+        /// <param name="destination">When this method returns <see langword="true" />, if <paramref name="path"/> contained redundant segments, this parameter contains the <paramref name="path"/> without redundant segments, or if <paramref name="path"/> did not contain redundant segments, or was an invalid path, this parameter contains the value of <paramref name="path"/>, unmodified; when this method returns <see langword="false" />, this parameter does not contain a valid value.</param>
+        /// <param name="charsWritten">The total number of characters written to <paramref name="destination" />, which is less or equal than the length of <paramref name="path" />.</param>
+        /// <returns><see langword="true" /> if the original path was modified and writing into <paramref name="destination" /> was successful; <see langword="false" /> if <paramref name="path" /> is effectively empty (an empty string or whitespace characters) or there was a problem attempting to write into <paramref name="destination"/>.</returns>
+        public static bool TryRemoveRedundantSegments(ReadOnlySpan<char> path, Span<char> destination, out int charsWritten)
+        {
+            charsWritten = 0;
+
+            if (PathInternal.IsEffectivelyEmpty(path))
+            {
+                return false;
+            }
+
+            var sb = new ValueStringBuilder(path.Length > InitialValueStringBuilderBufferLength ? InitialValueStringBuilderBufferLength : path.Length);
+
+            bool result = false;
+
+            if (!RedundantSegmentHelper.TryRemoveRedundantSegments(path, ref sb))
+            {
+                if (path.TryCopyTo(destination))
+                {
+                    charsWritten = path.Length;
+                    result = true;
+                    sb.Dispose();
+                }
+            }
+            else
+            {
+                result = sb.TryCopyTo(destination, out charsWritten); // Disposes
+            }
+
+            return result;
+        }
     }
 }

src/libraries/System.Private.CoreLib/src/System/IO/PathInternal.cs

@@ -100,124 +100,6 @@ internal static bool AreRootsEqual(string? first, string? second, StringComparis
                     comparisonType: comparisonType) == 0;
         }
 
-        /// <summary>
-        /// Try to remove relative segments from the given path (without combining with a root).
-        /// </summary>
-        /// <param name="path">Input path</param>
-        /// <param name="rootLength">The length of the root of the given path</param>
-        internal static string RemoveRelativeSegments(string path, int rootLength)
-        {
-            var sb = new ValueStringBuilder(stackalloc char[260 /* PathInternal.MaxShortPath */]);
-
-            if (RemoveRelativeSegments(path.AsSpan(), rootLength, ref sb))
-            {
-                path = sb.ToString();
-            }
-
-            sb.Dispose();
-            return path;
-        }
-
-        /// <summary>
-        /// Try to remove relative segments from the given path (without combining with a root).
-        /// </summary>
-        /// <param name="path">Input path</param>
-        /// <param name="rootLength">The length of the root of the given path</param>
-        /// <param name="sb">String builder that will store the result</param>
-        /// <returns>"true" if the path was modified</returns>
-        internal static bool RemoveRelativeSegments(ReadOnlySpan<char> path, int rootLength, ref ValueStringBuilder sb)
-        {
-            Debug.Assert(rootLength > 0);
-            bool flippedSeparator = false;
-
-            int skip = rootLength;
-            // We treat "\.." , "\." and "\\" as a relative segment. We want to collapse the first separator past the root presuming
-            // the root actually ends in a separator. Otherwise the first segment for RemoveRelativeSegments
-            // in cases like "\\?\C:\.\" and "\\?\C:\..\", the first segment after the root will be ".\" and "..\" which is not considered as a relative segment and hence not be removed.
-            if (PathInternal.IsDirectorySeparator(path[skip - 1]))
-                skip--;
-
-            // Remove "//", "/./", and "/../" from the path by copying each character to the output,
-            // except the ones we're removing, such that the builder contains the normalized path
-            // at the end.
-            if (skip > 0)
-            {
-                sb.Append(path.Slice(0, skip));
-            }
-
-            for (int i = skip; i < path.Length; i++)
-            {
-                char c = path[i];
-
-                if (PathInternal.IsDirectorySeparator(c) && i + 1 < path.Length)
-                {
-                    // Skip this character if it's a directory separator and if the next character is, too,
-                    // e.g. "parent//child" => "parent/child"
-                    if (PathInternal.IsDirectorySeparator(path[i + 1]))
-                    {
-                        continue;
-                    }
-
-                    // Skip this character and the next if it's referring to the current directory,
-                    // e.g. "parent/./child" => "parent/child"
-                    if ((i + 2 == path.Length || PathInternal.IsDirectorySeparator(path[i + 2])) &&
-                        path[i + 1] == '.')
-                    {
-                        i++;
-                        continue;
-                    }
-
-                    // Skip this character and the next two if it's referring to the parent directory,
-                    // e.g. "parent/child/../grandchild" => "parent/grandchild"
-                    if (i + 2 < path.Length &&
-                        (i + 3 == path.Length || PathInternal.IsDirectorySeparator(path[i + 3])) &&
-                        path[i + 1] == '.' && path[i + 2] == '.')
-                    {
-                        // Unwind back to the last slash (and if there isn't one, clear out everything).
-                        int s;
-                        for (s = sb.Length - 1; s >= skip; s--)
-                        {
-                            if (PathInternal.IsDirectorySeparator(sb[s]))
-                            {
-                                sb.Length = (i + 3 >= path.Length && s == skip) ? s + 1 : s; // to avoid removing the complete "\tmp\" segment in cases like \\?\C:\tmp\..\, C:\tmp\..
-                                break;
-                            }
-                        }
-                        if (s < skip)
-                        {
-                            sb.Length = skip;
-                        }
-
-                        i += 2;
-                        continue;
-                    }
-                }
-
-                // Normalize the directory separator if needed
-                if (c != PathInternal.DirectorySeparatorChar && c == PathInternal.AltDirectorySeparatorChar)
-                {
-                    c = PathInternal.DirectorySeparatorChar;
-                    flippedSeparator = true;
-                }
-
-                sb.Append(c);
-            }
-
-            // If we haven't changed the source path, return the original
-            if (!flippedSeparator && sb.Length == path.Length)
-            {
-                return false;
-            }
-
-            // We may have eaten the trailing separator from the root when we started and not replaced it
-            if (skip != rootLength && sb.Length < rootLength)
-            {
-                sb.Append(path[rootLength - 1]);
-            }
-
-            return true;
-        }
-
         /// <summary>
         /// Trims one trailing directory separator beyond the root of the path.
         /// </summary>