Merge pull request RustPython#3641 from coolreader18/mini-fixes

Small fixes

Author: coolreader18

stdlib/src/socket.rs

@@ -683,7 +683,7 @@ mod _socket {
             let mut buffer = Vec::with_capacity(bufsize);
             let sock = self.sock(vm)?;
             let n = self.sock_op(vm, SelectKind::Read, || {
-                sock.recv_with_flags(spare_capacity_mut(&mut buffer), flags)
+                sock.recv_with_flags(buffer.spare_capacity_mut(), flags)
             })?;
             unsafe { buffer.set_len(n) };
             Ok(buffer)
@@ -719,7 +719,7 @@ mod _socket {
             let mut buffer = Vec::with_capacity(bufsize);
             let (n, addr) = self.sock_op(vm, SelectKind::Read, || {
                 self.sock_io()?
-                    .recv_from_with_flags(spare_capacity_mut(&mut buffer), flags)
+                    .recv_from_with_flags(buffer.spare_capacity_mut(), flags)
             })?;
             unsafe { buffer.set_len(n) };
             Ok((buffer, get_addr_tuple(&addr, vm)))
@@ -1206,16 +1206,6 @@ mod _socket {
         Ok(s.to_string_lossy().into_owned())
     }
 
-    // TODO: use `Vec::spare_capacity_mut` once stable.
-    fn spare_capacity_mut<T>(v: &mut Vec<T>) -> &mut [MaybeUninit<T>] {
-        let (len, cap) = (v.len(), v.capacity());
-        unsafe {
-            std::slice::from_raw_parts_mut(
-                v.as_mut_ptr().add(len) as *mut MaybeUninit<T>,
-                cap - len,
-            )
-        }
-    }
     fn slice_as_uninit<T>(v: &mut [T]) -> &mut [MaybeUninit<T>] {
         unsafe { &mut *(v as *mut [T] as *mut [MaybeUninit<T>]) }
     }
@@ -1667,7 +1657,9 @@ mod _socket {
                     netioapi::ConvertInterfaceLuidToNameW(luid, buf.as_mut_ptr(), buf.len())
                 };
                 if ret == 0 {
-                    Ok(widestring::WideCString::from_vec_with_nul(&buf[..]).unwrap())
+                    Ok(widestring::WideCString::from_ustr_truncate(
+                        widestring::WideStr::from_slice(&buf[..]),
+                    ))
                 } else {
                     Err(io::Error::from_raw_os_error(ret as i32))
                 }

vm/src/stdlib/nt.rs

@@ -303,7 +303,7 @@ pub(crate) mod module {
                 return Err(errno_err(vm));
             }
         }
-        let buffer = widestring::WideCString::from_vec_with_nul(buffer).unwrap();
+        let buffer = widestring::WideCString::from_vec_truncate(buffer);
         path.mode.process_path(buffer.to_os_string(), vm)
     }
 
@@ -318,7 +318,7 @@ pub(crate) mod module {
         if ret == 0 {
             return Err(errno_err(vm));
         }
-        let buffer = widestring::WideCString::from_vec_with_nul(buffer).unwrap();
+        let buffer = widestring::WideCString::from_vec_truncate(buffer);
         path.mode.process_path(buffer.to_os_string(), vm)
     }
 

vm/src/stdlib/thread.rs

@@ -208,9 +208,26 @@ pub(crate) mod _thread {
     }
 
     fn thread_to_id(t: &thread::Thread) -> u64 {
+        use std::hash::{Hash, Hasher};
+        struct U64Hash {
+            v: Option<u64>,
+        }
+        impl Hasher for U64Hash {
+            fn write(&mut self, _: &[u8]) {
+                unreachable!()
+            }
+            fn write_u64(&mut self, i: u64) {
+                self.v = Some(i);
+            }
+            fn finish(&self) -> u64 {
+                self.v.expect("should have written a u64")
+            }
+        }
         // TODO: use id.as_u64() once it's stable, until then, ThreadId is just a wrapper
-        // around NonZeroU64, so this is safe
-        unsafe { std::mem::transmute(t.id()) }
+        // around NonZeroU64, so this should work (?)
+        let mut h = U64Hash { v: None };
+        t.id().hash(&mut h);
+        h.finish()
     }
 
     #[pyfunction]