Use PrintName (Dos) instead of SubstituteName (NT)

src/libraries/System.IO.FileSystem/tests/Base/SymbolicLinks/BaseSymbolicLinks.FileSystem.cs

@@ -21,31 +21,6 @@ public abstract class BaseSymbolicLinks_FileSystem : BaseSymbolicLinks
         /// <summary>Calls the actual public API for resolving the symbolic link target.</summary>
         protected abstract FileSystemInfo ResolveLinkTarget(string linkPath, bool returnFinalTarget = false);
 
-        /// <summary>
-        /// Verifies that FileSystemInfo.LinkTarget matches the specified expected path.
-        /// If the current platform is Windows and <paramref name="actual"/> is absolute, this method asserts that <paramref name="actual"/> starts with \\?\.
-        /// </summary>
-        protected static void AssertLinkTargetEquals(string expected, string actual)
-        {
-#if WINDOWS
-            if (Path.IsPathFullyQualified(actual))
-            {
-                actual.StartsWith(ExtendedPrefix);
-                expected = Path.Join(ExtendedPrefix, expected);
-            }
-
-            // Windows syscalls remove the redundant segments in the link target path.
-            // We will remove them from the expected path when testing Windows but keep them when testing Unix, which doesn't remove them.
-            int rootLength = PathInternal.GetRootLength(expected);
-            if (rootLength > 0)
-            {
-                expected = PathInternal.RemoveRelativeSegments(expected, rootLength);
-            }
-#endif
-            Assert.Equal(expected, actual);
-        }
-
-
         /// <summary>
         /// Asserts that the FullPath of the FileSystemInfo returned by ResolveLinkTarget() matches with the expected path of the file created.
         /// Trims the Windows device prefix, in case there's any, before comparing.
@@ -188,7 +163,7 @@ public void ResolveLinkTarget_Succeeds(string pathToTarget, bool returnFinalTarg
             FileSystemInfo linkInfo = CreateSymbolicLink(linkPath, pathToTarget);
             AssertLinkExists(linkInfo);
             AssertIsCorrectTypeAndDirectoryAttribute(linkInfo);
-            AssertLinkTargetEquals(pathToTarget, linkInfo.LinkTarget);
+            Assert.Equal(pathToTarget, linkInfo.LinkTarget);
 
             FileSystemInfo targetInfo = ResolveLinkTarget(linkPath, returnFinalTarget);
             Assert.NotNull(targetInfo);
@@ -379,22 +354,22 @@ private void ResolveLinkTarget_ReturnFinalTarget(string link1Path, string link1T
             Assert.True(link2Info.Exists);
             Assert.True(link2Info.Attributes.HasFlag(FileAttributes.ReparsePoint));
             AssertIsCorrectTypeAndDirectoryAttribute(link2Info);
-            AssertLinkTargetEquals(link2Target, link2Info.LinkTarget);
+            Assert.Equal(link2Target, link2Info.LinkTarget);
 
             // link1 to link2
             FileSystemInfo link1Info = CreateSymbolicLink(link1Path, link1Target);
             Assert.True(link1Info.Exists);
             Assert.True(link1Info.Attributes.HasFlag(FileAttributes.ReparsePoint));
             AssertIsCorrectTypeAndDirectoryAttribute(link1Info);
-            AssertLinkTargetEquals(link1Target, link1Info.LinkTarget);
+            Assert.Equal(link1Target, link1Info.LinkTarget);
 
             // link1: do not follow symlinks
             FileSystemInfo link1TargetInfo = ResolveLinkTarget(link1Path);
             Assert.True(link1TargetInfo.Exists);
             AssertIsCorrectTypeAndDirectoryAttribute(link1TargetInfo);
             Assert.True(link1TargetInfo.Attributes.HasFlag(FileAttributes.ReparsePoint));
             AssertFullNameEquals(link2Path, link1TargetInfo.FullName);
-            AssertLinkTargetEquals(link2Target, link1TargetInfo.LinkTarget);
+            Assert.Equal(link2Target, link1TargetInfo.LinkTarget);
 
             // link2: do not follow symlinks
             FileSystemInfo link2TargetInfo = ResolveLinkTarget(link2Path);

src/libraries/System.IO.FileSystem/tests/Base/SymbolicLinks/BaseSymbolicLinks.FileSystemInfo.cs

@@ -48,7 +48,7 @@ public void LinkTarget_Succeeds(string pathToTarget)
             FileSystemInfo linkInfo = CreateSymbolicLink(GetRandomLinkPath(), pathToTarget);
 
             AssertLinkExists(linkInfo);
-            AssertLinkTargetEquals(pathToTarget, linkInfo.LinkTarget);
+            Assert.Equal(pathToTarget, linkInfo.LinkTarget);
         }
 
         public static IEnumerable<object[]> LinkTarget_PathToTarget_Data

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

@@ -468,7 +468,7 @@ internal static void CreateSymbolicLink(string path, string pathToTarget, bool i
                 }
             }
 
-            byte[]? buffer = ArrayPool<byte>.Shared.Rent(Interop.Kernel32.MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
+            byte[] buffer = ArrayPool<byte>.Shared.Rent(Interop.Kernel32.MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
             try
             {
                 bool success = Interop.Kernel32.DeviceIoControl(
@@ -503,21 +503,18 @@ internal static void CreateSymbolicLink(string path, string pathToTarget, bool i
                     return null;
                 }
 
-                int substituteNameOffset = sizeof(Interop.Kernel32.REPARSE_DATA_BUFFER) + rdb.ReparseBufferSymbolicLink.SubstituteNameOffset;
-                int substituteNameLength = rdb.ReparseBufferSymbolicLink.SubstituteNameLength;
+                // We use PrintName instead of SubstitutneName given that we don't want to return a NT path.
+                // Unlike SubstituteName and GetFinalPathNameByHandle(), PrintName doesn't start with a prefix.
+                // Another nuance is that SubstituteName does not contain redundant path segments while PrintName does.
+                int printNameNameOffset = sizeof(Interop.Kernel32.REPARSE_DATA_BUFFER) + rdb.ReparseBufferSymbolicLink.PrintNameOffset;
+                int printNameNameLength = rdb.ReparseBufferSymbolicLink.PrintNameLength;
 
-                Span<char> targetPath = MemoryMarshal.Cast<byte, char>(bufferSpan.Slice(substituteNameOffset, substituteNameLength));
+                Span<char> targetPath = MemoryMarshal.Cast<byte, char>(bufferSpan.Slice(printNameNameOffset, printNameNameLength));
+                Debug.Assert(Path.IsPathFullyQualified(targetPath));
+                Debug.Assert((rdb.ReparseBufferSymbolicLink.Flags & Interop.Kernel32.SYMLINK_FLAG_RELATIVE) == 0 ||
+                    targetPath.Length >= 4 && !targetPath.StartsWith(PathInternal.ExtendedPathPrefix) && !targetPath.StartsWith(@"\??\"));
 
-                if ((rdb.ReparseBufferSymbolicLink.Flags & Interop.Kernel32.SYMLINK_FLAG_RELATIVE) == 0)
-                {
-                    // Target path is absolute.
-                    // DeviceIoControl returns a DOS Device path (\??\) which many APIs don't tolerate.
-                    // We should instead return a Win32 path (\\?\).
-                    Debug.Assert(Path.IsPathFullyQualified(targetPath));
-                    Debug.Assert(targetPath[1] == '?');
-                    targetPath[1] = '\\';
-                }
-                else if (normalize)
+                if (normalize && (rdb.ReparseBufferSymbolicLink.Flags & Interop.Kernel32.SYMLINK_FLAG_RELATIVE) != 0)
                 {
                     // Target path is relative and is for ResolveLinkTarget(), we need to append the link directory.
                     return Path.Join(Path.GetDirectoryName(linkPath.AsSpan()), targetPath);
@@ -527,10 +524,7 @@ internal static void CreateSymbolicLink(string path, string pathToTarget, bool i
             }
             finally
             {
-                if (buffer != null)
-                {
-                    ArrayPool<byte>.Shared.Return(buffer);
-                }
+                ArrayPool<byte>.Shared.Return(buffer);
             }
         }