Made some methods span based. Added a missing PlatformSpecific attrib…

…ute.

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

@@ -213,11 +213,18 @@ public static bool IsPathRooted(ReadOnlySpan<char> path)
             if (PathInternal.IsEffectivelyEmpty(path.AsSpan()))
                 return null;
 
-            ReadOnlySpan<char> result = GetPathRoot(path.AsSpan());
-            if (path!.Length == result.Length)
-                return PathInternal.NormalizeDirectorySeparators(path);
+            int rootLength = PathInternal.GetRootLength(path.AsSpan());
+            if (rootLength <= 0)
+                return null;
 
-            return PathInternal.NormalizeDirectorySeparators(result.ToString());
+            Span<char> destination = stackalloc char[rootLength];
+            // Fails when path already normalized (or empty, but won't happen here)
+            if (PathInternal.TryNormalizeDirectorySeparators(path.AsSpan(0, rootLength), destination, out int charsWritten))
+            {
+                return destination.Slice(0, charsWritten).ToString();
+            }
+            // Reaching here means the path was already normalized
+            return path!.Substring(0, rootLength);
         }
 
         /// <remarks>
@@ -228,8 +235,8 @@ public static ReadOnlySpan<char> GetPathRoot(ReadOnlySpan<char> path)
             if (PathInternal.IsEffectivelyEmpty(path))
                 return ReadOnlySpan<char>.Empty;
 
-            int pathRoot = PathInternal.GetRootLength(path);
-            return pathRoot <= 0 ? ReadOnlySpan<char>.Empty : path.Slice(0, pathRoot);
+            int rootLength = PathInternal.GetRootLength(path);
+            return rootLength <= 0 ? ReadOnlySpan<char>.Empty : path.Slice(0, rootLength);
         }
 
         /// <summary>Gets whether the system is case-sensitive.</summary>

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

@@ -107,7 +107,18 @@ public static partial class Path
                 return null;
 
             int end = GetDirectoryNameOffset(path.AsSpan());
-            return end >= 0 ? PathInternal.NormalizeDirectorySeparators(path.Substring(0, end)) : null;
+
+            if (end >= 0)
+            {
+                Span<char> destination = stackalloc char[end];
+                // Fails when empty or already normalized
+                if (PathInternal.TryNormalizeDirectorySeparators(path.AsSpan(0, end), destination, out int charsWritten))
+                {
+                    return destination.Slice(0, charsWritten).ToString();
+                }
+                return path.Substring(0, end);
+            }
+            return null;
         }
 
         /// <summary>

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

@@ -314,7 +314,7 @@ internal static bool IsDirectorySeparator(char c)
         /// Like the current NormalizePath this will not try and analyze periods/spaces within directory segments.
         /// </summary>
         /// <remarks>
-        /// The only callers that used to use Path.Normalize(fullCheck=false) were Path.GetDirectoryName() and Path.GetPathRoot(). Both usages do
+        /// The only callers that used to use Path.Normalize(fullCheck=false) were Path.GetDirectoryName() and Path.GetPathRoot(string). Both usages do
         /// not need trimming of trailing whitespace here.
         ///
         /// GetPathRoot() could technically skip normalizing separators after the second segment- consider as a future optimization.
@@ -341,6 +341,22 @@ internal static bool IsDirectorySeparator(char c)
             if (string.IsNullOrEmpty(path))
                 return path;
 
+            Span<char> destination = stackalloc char[path.Length];
+            if (!TryNormalizeDirectorySeparators(path.AsSpan(), destination, out int charsWritten))
+            {
+                return path;
+            }
+
+            return destination.Slice(0, charsWritten).ToString();
+        }
+
+        internal static bool TryNormalizeDirectorySeparators(ReadOnlySpan<char> path, Span<char> destination, out int charsWritten)
+        {
+            charsWritten = 0;
+
+            if (IsEffectivelyEmpty(path))
+                return false;
+
             char current;
 
             // Make a pass to see if we need to normalize so we can potentially skip allocating
@@ -360,7 +376,7 @@ internal static bool IsDirectorySeparator(char c)
             }
 
             if (normalized)
-                return path;
+                return false;
 
             var builder = new ValueStringBuilder(stackalloc char[MaxShortPath]);
 
@@ -391,7 +407,7 @@ internal static bool IsDirectorySeparator(char c)
                 builder.Append(current);
             }
 
-            return builder.ToString();
+            return builder.TryCopyTo(destination, out charsWritten);
         }
 
         /// <summary>
@@ -411,5 +427,6 @@ internal static bool IsEffectivelyEmpty(ReadOnlySpan<char> path)
             }
             return true;
         }
+
     }
 }

src/libraries/System.Runtime.Extensions/tests/System/IO/Path.RemoveRedundantSegments.cs

@@ -437,6 +437,7 @@ public static void WindowsValid_String(string path, string expected)
         [MemberData(nameof(WindowsValidCurrentDirectoryData))]
         [MemberData(nameof(WindowsCombinedRedundantData))]
         [MemberData(nameof(WindowsDuplicateSeparatorsData))]
+        [PlatformSpecific(TestPlatforms.Windows)]
         public static void WindowsValid_Span(string path, string expected)
         {
             foreach (string prefix in s_Prefixes)