Auto merge of #111401 - ChrisDenton:no-windows-allowed, r=workingjubilee

bors · bors · commit cba14074bb4c · 2023-05-10T10:28:38.000Z
Don't force include Windows goop when documenting Why do we need to include all the windows bits on non-windows platforms? Let's try not doing that. Possible alternative to #111394, if it works.
diff --git a/library/std/src/os/windows/io/handle.rs b/library/std/src/os/windows/io/handle.rs
@@ -9,7 +9,7 @@ use crate::io;
 use crate::marker::PhantomData;
 use crate::mem::forget;
 use crate::ptr;
-use crate::sys::c;
+use crate::sys;
 use crate::sys::cvt;
 use crate::sys_common::{AsInner, FromInner, IntoInner};
 
@@ -190,14 +190,14 @@ impl BorrowedHandle<'_> {
     /// object as the existing `BorrowedHandle` instance.
     #[stable(feature = "io_safety", since = "1.63.0")]
     pub fn try_clone_to_owned(&self) -> crate::io::Result<OwnedHandle> {
-        self.duplicate(0, false, c::DUPLICATE_SAME_ACCESS)
+        self.duplicate(0, false, sys::c::DUPLICATE_SAME_ACCESS)
     }
 
     pub(crate) fn duplicate(
         &self,
-        access: c::DWORD,
+        access: u32,
         inherit: bool,
-        options: c::DWORD,
+        options: u32,
     ) -> io::Result<OwnedHandle> {
         let handle = self.as_raw_handle();
 
@@ -211,14 +211,14 @@ impl BorrowedHandle<'_> {
 
         let mut ret = ptr::null_mut();
         cvt(unsafe {
-            let cur_proc = c::GetCurrentProcess();
-            c::DuplicateHandle(
+            let cur_proc = sys::c::GetCurrentProcess();
+            sys::c::DuplicateHandle(
                 cur_proc,
                 handle,
                 cur_proc,
                 &mut ret,
                 access,
-                inherit as c::BOOL,
+                inherit as sys::c::BOOL,
                 options,
             )
         })?;
@@ -233,7 +233,7 @@ impl TryFrom<HandleOrInvalid> for OwnedHandle {
     #[inline]
     fn try_from(handle_or_invalid: HandleOrInvalid) -> Result<Self, InvalidHandleError> {
         let owned_handle = handle_or_invalid.0;
-        if owned_handle.handle == c::INVALID_HANDLE_VALUE {
+        if owned_handle.handle == sys::c::INVALID_HANDLE_VALUE {
             // Don't call `CloseHandle`; it'd be harmless, except that it could
             // overwrite the `GetLastError` error.
             forget(owned_handle);
@@ -365,7 +365,7 @@ impl Drop for OwnedHandle {
     #[inline]
     fn drop(&mut self) {
         unsafe {
-            let _ = c::CloseHandle(self.handle);
+            let _ = sys::c::CloseHandle(self.handle);
         }
     }
 }
diff --git a/library/std/src/os/windows/io/raw.rs b/library/std/src/os/windows/io/raw.rs
@@ -11,7 +11,6 @@ use crate::os::windows::io::{OwnedHandle, OwnedSocket};
 use crate::os::windows::raw;
 use crate::ptr;
 use crate::sys;
-use crate::sys::c;
 use crate::sys_common::{self, AsInner, FromInner, IntoInner};
 
 /// Raw HANDLEs.
@@ -104,42 +103,42 @@ impl AsRawHandle for fs::File {
 #[stable(feature = "asraw_stdio", since = "1.21.0")]
 impl AsRawHandle for io::Stdin {
     fn as_raw_handle(&self) -> RawHandle {
-        stdio_handle(unsafe { c::GetStdHandle(c::STD_INPUT_HANDLE) as RawHandle })
+        stdio_handle(unsafe { sys::c::GetStdHandle(sys::c::STD_INPUT_HANDLE) as RawHandle })
     }
 }
 
 #[stable(feature = "asraw_stdio", since = "1.21.0")]
 impl AsRawHandle for io::Stdout {
     fn as_raw_handle(&self) -> RawHandle {
-        stdio_handle(unsafe { c::GetStdHandle(c::STD_OUTPUT_HANDLE) as RawHandle })
+        stdio_handle(unsafe { sys::c::GetStdHandle(sys::c::STD_OUTPUT_HANDLE) as RawHandle })
     }
 }
 
 #[stable(feature = "asraw_stdio", since = "1.21.0")]
 impl AsRawHandle for io::Stderr {
     fn as_raw_handle(&self) -> RawHandle {
-        stdio_handle(unsafe { c::GetStdHandle(c::STD_ERROR_HANDLE) as RawHandle })
+        stdio_handle(unsafe { sys::c::GetStdHandle(sys::c::STD_ERROR_HANDLE) as RawHandle })
     }
 }
 
 #[stable(feature = "asraw_stdio_locks", since = "1.35.0")]
 impl<'a> AsRawHandle for io::StdinLock<'a> {
     fn as_raw_handle(&self) -> RawHandle {
-        stdio_handle(unsafe { c::GetStdHandle(c::STD_INPUT_HANDLE) as RawHandle })
+        stdio_handle(unsafe { sys::c::GetStdHandle(sys::c::STD_INPUT_HANDLE) as RawHandle })
     }
 }
 
 #[stable(feature = "asraw_stdio_locks", since = "1.35.0")]
 impl<'a> AsRawHandle for io::StdoutLock<'a> {
     fn as_raw_handle(&self) -> RawHandle {
-        stdio_handle(unsafe { c::GetStdHandle(c::STD_OUTPUT_HANDLE) as RawHandle })
+        stdio_handle(unsafe { sys::c::GetStdHandle(sys::c::STD_OUTPUT_HANDLE) as RawHandle })
     }
 }
 
 #[stable(feature = "asraw_stdio_locks", since = "1.35.0")]
 impl<'a> AsRawHandle for io::StderrLock<'a> {
     fn as_raw_handle(&self) -> RawHandle {
-        stdio_handle(unsafe { c::GetStdHandle(c::STD_ERROR_HANDLE) as RawHandle })
+        stdio_handle(unsafe { sys::c::GetStdHandle(sys::c::STD_ERROR_HANDLE) as RawHandle })
     }
 }
 
@@ -152,14 +151,14 @@ fn stdio_handle(raw: RawHandle) -> RawHandle {
     // console. In that case, return null to the user, which is consistent
     // with what they'd get in the parent, and which avoids the problem that
     // `INVALID_HANDLE_VALUE` aliases the current process handle.
-    if raw == c::INVALID_HANDLE_VALUE { ptr::null_mut() } else { raw }
+    if raw == sys::c::INVALID_HANDLE_VALUE { ptr::null_mut() } else { raw }
 }
 
 #[stable(feature = "from_raw_os", since = "1.1.0")]
 impl FromRawHandle for fs::File {
     #[inline]
     unsafe fn from_raw_handle(handle: RawHandle) -> fs::File {
-        let handle = handle as c::HANDLE;
+        let handle = handle as sys::c::HANDLE;
         fs::File::from_inner(sys::fs::File::from_inner(FromInner::from_inner(
             OwnedHandle::from_raw_handle(handle),
         )))
diff --git a/library/std/src/os/windows/io/socket.rs b/library/std/src/os/windows/io/socket.rs
@@ -9,7 +9,6 @@ use crate::marker::PhantomData;
 use crate::mem;
 use crate::mem::forget;
 use crate::sys;
-use crate::sys::c;
 #[cfg(not(target_vendor = "uwp"))]
 use crate::sys::cvt;
 
@@ -76,7 +75,7 @@ impl BorrowedSocket<'_> {
     #[rustc_const_stable(feature = "io_safety", since = "1.63.0")]
     #[stable(feature = "io_safety", since = "1.63.0")]
     pub const unsafe fn borrow_raw(socket: RawSocket) -> Self {
-        assert!(socket != c::INVALID_SOCKET as RawSocket);
+        assert!(socket != sys::c::INVALID_SOCKET as RawSocket);
         Self { socket, _phantom: PhantomData }
     }
 }
@@ -94,7 +93,11 @@ impl OwnedSocket {
     #[cfg(not(target_vendor = "uwp"))]
     pub(crate) fn set_no_inherit(&self) -> io::Result<()> {
         cvt(unsafe {
-            c::SetHandleInformation(self.as_raw_socket() as c::HANDLE, c::HANDLE_FLAG_INHERIT, 0)
+            sys::c::SetHandleInformation(
+                self.as_raw_socket() as sys::c::HANDLE,
+                sys::c::HANDLE_FLAG_INHERIT,
+                0,
+            )
         })
         .map(drop)
     }
@@ -110,43 +113,47 @@ impl BorrowedSocket<'_> {
     /// object as the existing `BorrowedSocket` instance.
     #[stable(feature = "io_safety", since = "1.63.0")]
     pub fn try_clone_to_owned(&self) -> io::Result<OwnedSocket> {
-        let mut info = unsafe { mem::zeroed::<c::WSAPROTOCOL_INFOW>() };
+        let mut info = unsafe { mem::zeroed::<sys::c::WSAPROTOCOL_INFOW>() };
         let result = unsafe {
-            c::WSADuplicateSocketW(self.as_raw_socket(), c::GetCurrentProcessId(), &mut info)
+            sys::c::WSADuplicateSocketW(
+                self.as_raw_socket(),
+                sys::c::GetCurrentProcessId(),
+                &mut info,
+            )
         };
         sys::net::cvt(result)?;
         let socket = unsafe {
-            c::WSASocketW(
+            sys::c::WSASocketW(
                 info.iAddressFamily,
                 info.iSocketType,
                 info.iProtocol,
                 &mut info,
                 0,
-                c::WSA_FLAG_OVERLAPPED | c::WSA_FLAG_NO_HANDLE_INHERIT,
+                sys::c::WSA_FLAG_OVERLAPPED | sys::c::WSA_FLAG_NO_HANDLE_INHERIT,
             )
         };
 
-        if socket != c::INVALID_SOCKET {
+        if socket != sys::c::INVALID_SOCKET {
             unsafe { Ok(OwnedSocket::from_raw_socket(socket)) }
         } else {
-            let error = unsafe { c::WSAGetLastError() };
+            let error = unsafe { sys::c::WSAGetLastError() };
 
-            if error != c::WSAEPROTOTYPE && error != c::WSAEINVAL {
+            if error != sys::c::WSAEPROTOTYPE && error != sys::c::WSAEINVAL {
                 return Err(io::Error::from_raw_os_error(error));
             }
 
             let socket = unsafe {
-                c::WSASocketW(
+                sys::c::WSASocketW(
                     info.iAddressFamily,
                     info.iSocketType,
                     info.iProtocol,
                     &mut info,
                     0,
-                    c::WSA_FLAG_OVERLAPPED,
+                    sys::c::WSA_FLAG_OVERLAPPED,
                 )
             };
 
-            if socket == c::INVALID_SOCKET {
+            if socket == sys::c::INVALID_SOCKET {
                 return Err(last_error());
             }
 
@@ -161,7 +168,7 @@ impl BorrowedSocket<'_> {
 
 /// Returns the last error from the Windows socket interface.
 fn last_error() -> io::Error {
-    io::Error::from_raw_os_error(unsafe { c::WSAGetLastError() })
+    io::Error::from_raw_os_error(unsafe { sys::c::WSAGetLastError() })
 }
 
 #[stable(feature = "io_safety", since = "1.63.0")]
@@ -194,7 +201,7 @@ impl IntoRawSocket for OwnedSocket {
 impl FromRawSocket for OwnedSocket {
     #[inline]
     unsafe fn from_raw_socket(socket: RawSocket) -> Self {
-        debug_assert_ne!(socket, c::INVALID_SOCKET as RawSocket);
+        debug_assert_ne!(socket, sys::c::INVALID_SOCKET as RawSocket);
         Self { socket }
     }
 }
@@ -204,7 +211,7 @@ impl Drop for OwnedSocket {
     #[inline]
     fn drop(&mut self) {
         unsafe {
-            let _ = c::closesocket(self.socket);
+            let _ = sys::c::closesocket(self.socket);
         }
     }
 }
diff --git a/library/std/src/sys/mod.rs b/library/std/src/sys/mod.rs
@@ -52,31 +52,6 @@ cfg_if::cfg_if! {
     }
 }
 
-// Import essential modules from platforms used in `std::os` when documenting.
-//
-// Note that on some platforms those modules don't compile
-// (missing things in `libc` which is empty), so they are not included in `std::os` and can be
-// omitted here as well.
-
-#[cfg(doc)]
-#[cfg(not(any(
-    all(target_arch = "wasm32", not(target_os = "wasi")),
-    all(target_vendor = "fortanix", target_env = "sgx")
-)))]
-cfg_if::cfg_if! {
-    if #[cfg(not(windows))] {
-        // On non-Windows platforms (aka linux/osx/etc) pull in a "minimal"
-        // amount of windows goop which ends up compiling
-
-        #[macro_use]
-        #[path = "windows/compat.rs"]
-        pub mod compat;
-
-        #[path = "windows/c.rs"]
-        pub mod c;
-    }
-}
-
 cfg_if::cfg_if! {
     // Fuchsia components default to full backtrace.
     if #[cfg(target_os = "fuchsia")] {

Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,6 @@ use crate::os::windows::io::{OwnedHandle, OwnedSocket};`
`11`	`11`	`use crate::os::windows::raw;`
`12`	`12`	`use crate::ptr;`
`13`	`13`	`use crate::sys;`
`14`		`-use crate::sys::c;`
`15`	`14`	`use crate::sys_common::{self, AsInner, FromInner, IntoInner};`
`16`	`15`
`17`	`16`	`/// Raw HANDLEs.`
`@@ -104,42 +103,42 @@ impl AsRawHandle for fs::File {`
`104`	`103`	`#[stable(feature = "asraw_stdio", since = "1.21.0")]`
`105`	`104`	`impl AsRawHandle for io::Stdin {`
`106`	`105`	`fn as_raw_handle(&self) -> RawHandle {`
`107`		`- stdio_handle(unsafe { c::GetStdHandle(c::STD_INPUT_HANDLE) as RawHandle })`
	`106`	`+ stdio_handle(unsafe { sys::c::GetStdHandle(sys::c::STD_INPUT_HANDLE) as RawHandle })`
`108`	`107`	`}`
`109`	`108`	`}`
`110`	`109`
`111`	`110`	`#[stable(feature = "asraw_stdio", since = "1.21.0")]`
`112`	`111`	`impl AsRawHandle for io::Stdout {`
`113`	`112`	`fn as_raw_handle(&self) -> RawHandle {`
`114`		`- stdio_handle(unsafe { c::GetStdHandle(c::STD_OUTPUT_HANDLE) as RawHandle })`
	`113`	`+ stdio_handle(unsafe { sys::c::GetStdHandle(sys::c::STD_OUTPUT_HANDLE) as RawHandle })`
`115`	`114`	`}`
`116`	`115`	`}`
`117`	`116`
`118`	`117`	`#[stable(feature = "asraw_stdio", since = "1.21.0")]`
`119`	`118`	`impl AsRawHandle for io::Stderr {`
`120`	`119`	`fn as_raw_handle(&self) -> RawHandle {`
`121`		`- stdio_handle(unsafe { c::GetStdHandle(c::STD_ERROR_HANDLE) as RawHandle })`
	`120`	`+ stdio_handle(unsafe { sys::c::GetStdHandle(sys::c::STD_ERROR_HANDLE) as RawHandle })`
`122`	`121`	`}`
`123`	`122`	`}`
`124`	`123`
`125`	`124`	`#[stable(feature = "asraw_stdio_locks", since = "1.35.0")]`
`126`	`125`	`impl<'a> AsRawHandle for io::StdinLock<'a> {`
`127`	`126`	`fn as_raw_handle(&self) -> RawHandle {`
`128`		`- stdio_handle(unsafe { c::GetStdHandle(c::STD_INPUT_HANDLE) as RawHandle })`
	`127`	`+ stdio_handle(unsafe { sys::c::GetStdHandle(sys::c::STD_INPUT_HANDLE) as RawHandle })`
`129`	`128`	`}`
`130`	`129`	`}`
`131`	`130`
`132`	`131`	`#[stable(feature = "asraw_stdio_locks", since = "1.35.0")]`
`133`	`132`	`impl<'a> AsRawHandle for io::StdoutLock<'a> {`
`134`	`133`	`fn as_raw_handle(&self) -> RawHandle {`
`135`		`- stdio_handle(unsafe { c::GetStdHandle(c::STD_OUTPUT_HANDLE) as RawHandle })`
	`134`	`+ stdio_handle(unsafe { sys::c::GetStdHandle(sys::c::STD_OUTPUT_HANDLE) as RawHandle })`
`136`	`135`	`}`
`137`	`136`	`}`
`138`	`137`
`139`	`138`	`#[stable(feature = "asraw_stdio_locks", since = "1.35.0")]`
`140`	`139`	`impl<'a> AsRawHandle for io::StderrLock<'a> {`
`141`	`140`	`fn as_raw_handle(&self) -> RawHandle {`
`142`		`- stdio_handle(unsafe { c::GetStdHandle(c::STD_ERROR_HANDLE) as RawHandle })`
	`141`	`+ stdio_handle(unsafe { sys::c::GetStdHandle(sys::c::STD_ERROR_HANDLE) as RawHandle })`
`143`	`142`	`}`
`144`	`143`	`}`
`145`	`144`
`@@ -152,14 +151,14 @@ fn stdio_handle(raw: RawHandle) -> RawHandle {`
`152`	`151`	`// console. In that case, return null to the user, which is consistent`
`153`	`152`	`// with what they'd get in the parent, and which avoids the problem that`
`154`	`153`	// `INVALID_HANDLE_VALUE` aliases the current process handle.
`155`		`- if raw == c::INVALID_HANDLE_VALUE { ptr::null_mut() } else { raw }`
	`154`	`+ if raw == sys::c::INVALID_HANDLE_VALUE { ptr::null_mut() } else { raw }`
`156`	`155`	`}`
`157`	`156`
`158`	`157`	`#[stable(feature = "from_raw_os", since = "1.1.0")]`
`159`	`158`	`impl FromRawHandle for fs::File {`
`160`	`159`	`#[inline]`
`161`	`160`	`unsafe fn from_raw_handle(handle: RawHandle) -> fs::File {`
`162`		`- let handle = handle as c::HANDLE;`
	`161`	`+ let handle = handle as sys::c::HANDLE;`
`163`	`162`	`fs::File::from_inner(sys::fs::File::from_inner(FromInner::from_inner(`
`164`	`163`	`OwnedHandle::from_raw_handle(handle),`
`165`	`164`	`)))`