[Threading][Windows] Try to avoid declaring _RTL_SRWLOCK

Declaring _RTL_SRWLOCK ourselves causes clashes with <windows.h>.
Rather than doing that, declare an equivalent struct, and some overloads.

rdar://90776105

Author: al45tair

include/swift/Threading/Impl/Win32.h

@@ -35,31 +35,31 @@ inline bool threads_same(thread_id a, thread_id b) { return a == b; }
 
 // .. Mutex support ..........................................................
 
-using mutex_handle = ::SRWLOCK;
+using mutex_handle = SWIFT_SRWLOCK;
 
 inline void mutex_init(mutex_handle &handle, bool checked=false) {
   handle = SRWLOCK_INIT;
 }
 inline void mutex_destroy(mutex_handle &handle) { }
 
 inline void mutex_lock(mutex_handle &handle) {
-  ::AcquireSRWLockExclusive(&handle);
+  AcquireSRWLockExclusive(&handle);
 }
 inline void mutex_unlock(mutex_handle &handle) {
-  ::ReleaseSRWLockExclusive(&handle);
+  ReleaseSRWLockExclusive(&handle);
 }
 inline bool mutex_try_lock(mutex_handle &handle) {
-  return !!::TryAcquireSRWLockExclusive(&handle);
+  return !!TryAcquireSRWLockExclusive(&handle);
 }
 
 inline void mutex_unsafe_lock(mutex_handle &handle) {
-  ::AcquireSRWLockExclusive(&handle);
+  AcquireSRWLockExclusive(&handle);
 }
 inline void mutex_unsafe_unlock(mutex_handle &handle) {
-  ::ReleaseSRWLockExclusive(&handle);
+  ReleaseSRWLockExclusive(&handle);
 }
 
-using lazy_mutex_handle = ::SRWLOCK;
+using lazy_mutex_handle = SWIFT_SRWLOCK;
 
 // We don't need to be lazy here because Win32 has SRWLOCK_INIT.
 inline constexpr lazy_mutex_handle lazy_mutex_initializer() {
@@ -68,20 +68,20 @@ inline constexpr lazy_mutex_handle lazy_mutex_initializer() {
 inline void lazy_mutex_destroy(lazy_mutex_handle &handle) { }
 
 inline void lazy_mutex_lock(lazy_mutex_handle &handle) {
-  ::AcquireSRWLockExclusive(&handle);
+  AcquireSRWLockExclusive(&handle);
 }
 inline void lazy_mutex_unlock(lazy_mutex_handle &handle) {
-  ::ReleaseSRWLockExclusive(&handle);
+  ReleaseSRWLockExclusive(&handle);
 }
 inline bool lazy_mutex_try_lock(lazy_mutex_handle &handle) {
-  return !!::TryAcquireSRWLockExclusive(&handle);
+  return !!TryAcquireSRWLockExclusive(&handle);
 }
 
 inline void lazy_mutex_unsafe_lock(lazy_mutex_handle &handle) {
-  ::AcquireSRWLockExclusive(&handle);
+  AcquireSRWLockExclusive(&handle);
 }
 inline void lazy_mutex_unsafe_unlock(lazy_mutex_handle &handle) {
-  ::ReleaseSRWLockExclusive(&handle);
+  ReleaseSRWLockExclusive(&handle);
 }
 
 // .. Once ...................................................................

include/swift/Threading/Impl/Win32/Win32Defs.h

@@ -39,15 +39,8 @@ typedef unsigned long DWORD;
 
 typedef VOID (NTAPI* PFLS_CALLBACK_FUNCTION)(PVOID lpFlsData);
 
-// We can't define this struct if <winnt.h> already did so
-#ifndef _WINNT_
-struct _RTL_SRWLOCK {
-  PVOID Ptr;
-};
-#endif // _WINNT_
-
-typedef struct _RTL_SRWLOCK RTL_SRWLOCK, *PRTL_SRWLOCK;
-typedef RTL_SRWLOCK         SRWLOCK, *PSRWLOCK;
+typedef struct _RTL_SRWLOCK *PRTL_SRWLOCK;
+typedef PRTL_SRWLOCK PSRWLOCK;
 
 // These have to be #defines, to avoid problems with <windows.h>
 #define RTL_SRWLOCK_INIT   {0}
@@ -68,4 +61,31 @@ extern "C" {
   WINBASEAPI BOOL WINAPI  FlsFree(DWORD dwFlsIndex);
 }
 
+namespace swift {
+namespace threading_impl {
+
+// We do this because we can't declare _RTL_SRWLOCK here in case someone
+// later includes <windows.h>
+struct SWIFT_SRWLOCK {
+  PVOID Ptr;
+};
+
+typedef SWIFT_SRWLOCK *PSWIFT_SRWLOCK;
+
+inline VOID InitializeSRWLock(PSWIFT_SRWLOCK SRWLock) {
+  ::InitializeSRWLock(reinterpret_cast<PSRWLOCK>(SRWLock));
+}
+inline VOID ReleaseSRWLockExclusive(PSWIFT_SRWLOCK SRWLock) {
+  ::ReleaseSRWLockExclusive(reinterpret_cast<PSRWLOCK>(SRWLock));
+}
+inline VOID AcquireSRWLockExclusive(PSWIFT_SRWLOCK SRWLock) {
+  ::AcquireSRWLockExclusive(reinterpret_cast<PSRWLOCK>(SRWLock));
+}
+inline BOOLEAN TryAcquireSRWLockExclusive(PSWIFT_SRWLOCK SRWLock) {
+  return ::TryAcquireSRWLockExclusive(reinterpret_cast<PSRWLOCK>(SRWLock));
+}
+
+}
+}
+
 #endif // SWIFT_THREADING_IMPL_WIN32_DEFS_H