fix symlink test on windows

Author: Qelxiros

library/std/src/sys/fs/windows.rs

@@ -1033,8 +1033,8 @@ impl Dir {
     }
 
     pub fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(&self, original: P, link: Q) -> io::Result<()> {
-        run_path_with_utf16(original.as_ref(), &|orig| {
-            self.symlink_native(orig, link.as_ref(), original.as_ref().is_relative())
+        run_path_with_utf16(link.as_ref(), &|l| {
+            self.symlink_native(original.as_ref(), l.as_ref(), link.as_ref().is_relative())
         })
     }
 
@@ -1193,18 +1193,17 @@ impl Dir {
         .io_result()
     }
 
-    fn symlink_native(&self, original: &[u16], link: &Path, relative: bool) -> io::Result<()> {
+    fn symlink_native(&self, original: &Path, link: &[u16], relative: bool) -> io::Result<()> {
         const TOO_LONG_ERR: io::Error =
             io::const_error!(io::ErrorKind::InvalidFilename, "File name is too long");
         let mut opts = OpenOptions::new();
         opts.write(true);
-        let linkfile = File::open(link, &opts)?;
-        let utf16: Vec<u16> = original.iter().chain(original).copied().collect();
-        let file_name_len = u16::try_from(original.len()).or(Err(TOO_LONG_ERR))?;
+        let linkfile = self.open_with(original, &opts)?;
+        let file_name_len = u16::try_from(link.len()).or(Err(TOO_LONG_ERR))?;
         let sym_buffer = c::SYMBOLIC_LINK_REPARSE_BUFFER {
             SubstituteNameOffset: 0,
             SubstituteNameLength: file_name_len,
-            PrintNameOffset: file_name_len,
+            PrintNameOffset: 0,
             PrintNameLength: file_name_len,
             Flags: if relative { c::SYMLINK_FLAG_RELATIVE } else { 0 },
             PathBuffer: 0,
@@ -1214,15 +1213,21 @@ impl Dir {
             .extend(Layout::new::<c::SYMBOLIC_LINK_REPARSE_BUFFER>())
             .or(Err(TOO_LONG_ERR))?
             .0;
-        let layout = Layout::array::<u16>(original.len() * 2)
+        let layout = Layout::array::<u16>(link.len())
             .and_then(|arr| layout.extend(arr))
             .or(Err(TOO_LONG_ERR))?
             .0;
         let buffer = unsafe { alloc(layout) }.cast::<c::REPARSE_DATA_BUFFER>();
         unsafe {
             buffer.write(c::REPARSE_DATA_BUFFER {
                 ReparseTag: c::IO_REPARSE_TAG_SYMLINK,
-                ReparseDataLength: u16::try_from(size_of_val(&sym_buffer)).or(Err(TOO_LONG_ERR))?,
+                ReparseDataLength: u16::try_from(
+                    size_of::<c::REPARSE_DATA_BUFFER>()
+                        + size_of::<c::SYMBOLIC_LINK_REPARSE_BUFFER>()
+                        + usize::from(file_name_len)
+                        - offset_of!(c::REPARSE_DATA_BUFFER, Reserved),
+                )
+                .or(Err(TOO_LONG_ERR))?,
                 Reserved: 0,
                 rest: (),
             });
@@ -1231,20 +1236,25 @@ impl Dir {
                 .cast::<c::SYMBOLIC_LINK_REPARSE_BUFFER>()
                 .write(sym_buffer);
             ptr::copy_nonoverlapping(
-                utf16.as_ptr(),
+                link.as_ptr(),
                 buffer
                     .add(offset_of!(c::REPARSE_DATA_BUFFER, rest))
                     .add(offset_of!(c::SYMBOLIC_LINK_REPARSE_BUFFER, PathBuffer))
                     .cast::<u16>(),
-                original.len() * 2,
+                link.len(),
             );
         };
         let result = unsafe {
             c::DeviceIoControl(
                 linkfile.handle.as_raw_handle(),
                 c::FSCTL_SET_REPARSE_POINT,
                 &raw const buffer as *const c_void,
-                u32::try_from(size_of_val(&buffer)).or(Err(TOO_LONG_ERR))?,
+                u32::try_from(
+                    size_of::<c::REPARSE_DATA_BUFFER>()
+                        + size_of::<c::SYMBOLIC_LINK_REPARSE_BUFFER>()
+                        + usize::from(file_name_len),
+                )
+                .or(Err(TOO_LONG_ERR))?,
                 ptr::null_mut(),
                 0,
                 ptr::null_mut(),