Add clang-cl build support

- Add clang-cl warning suppressions in xmake.lua matching Linux/macOS set
- Guard /experimental:c11atomics with {tools="cl"} for MSVC-only
- Fix long long / int64_t redefinition in string.h for clang-cl
- Fix unclosed namespace in callstacktrace.cpp #else branch
- Fix missing override in httpplugin.cpp
- Reorder WorkerPool fields to match designated initializer order
- Use INVALID_SOCKET instead of SOCKET_ERROR for SOCKET comparisons

5 files changed, 82 insertions, 74 deletions

diff --git a/src/transports/winsock/winsock.cpp b/src/transports/winsock/winsock.cpp
index f98984726..c1f4f6abe 100644
--- a/src/transports/winsock/winsock.cpp
+++ b/src/transports/winsock/winsock.cpp
@@ -271,7 +271,7 @@ WinsockTransportPlugin::Initialize(TransportServer* ServerInterface)
 	m_ServerInterface = ServerInterface;
 	m_ListenSocket	  = socket(AF_INET6, SOCK_STREAM, 0);
 
-	if (m_ListenSocket == SOCKET_ERROR || m_ListenSocket == INVALID_SOCKET)
+	if (m_ListenSocket == INVALID_SOCKET)
 	{
 		throw std::system_error(std::error_code(WSAGetLastError(), std::system_category()),
 								"socket creation failed in HTTP plugin server init");
@@ -302,7 +302,7 @@ WinsockTransportPlugin::Initialize(TransportServer* ServerInterface)
 
 		do
 		{
-			if (SOCKET ClientSocket = accept(m_ListenSocket, NULL, NULL); ClientSocket != SOCKET_ERROR)
+			if (SOCKET ClientSocket = accept(m_ListenSocket, NULL, NULL); ClientSocket != INVALID_SOCKET)
 			{
 				int Flag = 1;
 				setsockopt(ClientSocket, IPPROTO_TCP, TCP_NODELAY, (char*)&Flag, sizeof(Flag));
diff --git a/src/zencore/include/zencore/string.h b/src/zencore/include/zencore/string.h
index 5a8a66fae..7b46f0e38 100644
--- a/src/zencore/include/zencore/string.h
+++ b/src/zencore/include/zencore/string.h
@@ -331,7 +331,7 @@ public:
 		return AppendAscii(Str);
 	}
 
-#if defined(__clang__) && !defined(__APPLE__)
+#if defined(__clang__) && !defined(__APPLE__) && !defined(_MSC_VER)
 	/* UE Toolchain Clang has different types for int64_t and long long so an override is
 	needed here. Without it, Clang can't disambiguate integer overloads */
 	inline StringBuilderImpl& operator<<(long long n)
diff --git a/src/zencore/memtrack/callstacktrace.cpp b/src/zencore/memtrack/callstacktrace.cpp
index 4a7068568..013c51535 100644
--- a/src/zencore/memtrack/callstacktrace.cpp
+++ b/src/zencore/memtrack/callstacktrace.cpp
@@ -912,92 +912,100 @@ FBacktracer::GetBacktraceId(void* AddressOfReturnAddress)
 
 #	else  // UE_CALLSTACK_TRACE_USE_UNWIND_TABLES
 
-namespace zen {
+////////////////////////////////////////////////////////////////////////////////
+class FBacktracer
+{
+public:
+	FBacktracer(FMalloc* InMalloc);
+	~FBacktracer();
+	static FBacktracer* Get();
+	inline uint32_t		GetBacktraceId(void* AddressOfReturnAddress);
+	uint32_t			GetBacktraceId(uint64_t ReturnAddress);
+	void				AddModule(uintptr_t Base, const char16_t* Name) {}
+	void				RemoveModule(uintptr_t Base) {}
 
-	////////////////////////////////////////////////////////////////////////////////
-	class FBacktracer
-	{
-	public:
-		FBacktracer(FMalloc* InMalloc);
-		~FBacktracer();
-		static FBacktracer* Get();
-		inline uint32_t		GetBacktraceId(void* AddressOfReturnAddress);
-		uint32_t			GetBacktraceId(uint64_t ReturnAddress);
-		void				AddModule(uintptr_t Base, const char16_t* Name) {}
-		void				RemoveModule(uintptr_t Base) {}
-
-	private:
-		static FBacktracer* Instance;
-		FMalloc*			Malloc;
-		FCallstackTracer	CallstackTracer;
-	};
+private:
+	static FBacktracer* Instance;
+	FMalloc*			Malloc;
+	FCallstackTracer	CallstackTracer;
+};
 
-	////////////////////////////////////////////////////////////////////////////////
-	FBacktracer* FBacktracer::Instance = nullptr;
+////////////////////////////////////////////////////////////////////////////////
+FBacktracer* FBacktracer::Instance = nullptr;
 
-	////////////////////////////////////////////////////////////////////////////////
-	FBacktracer::FBacktracer(FMalloc* InMalloc) : Malloc(InMalloc), CallstackTracer(InMalloc) { Instance = this; }
+////////////////////////////////////////////////////////////////////////////////
+FBacktracer::FBacktracer(FMalloc* InMalloc) : Malloc(InMalloc), CallstackTracer(InMalloc)
+{
+	Instance = this;
+}
 
-	////////////////////////////////////////////////////////////////////////////////
-	FBacktracer::~FBacktracer() {}
+////////////////////////////////////////////////////////////////////////////////
+FBacktracer::~FBacktracer()
+{
+}
 
-	////////////////////////////////////////////////////////////////////////////////
-	FBacktracer* FBacktracer::Get() { return Instance; }
+////////////////////////////////////////////////////////////////////////////////
+FBacktracer*
+FBacktracer::Get()
+{
+	return Instance;
+}
 
-	////////////////////////////////////////////////////////////////////////////////
-	uint32_t FBacktracer::GetBacktraceId(void* AddressOfReturnAddress)
-	{
-		const uint64_t ReturnAddress = *(uint64_t*)AddressOfReturnAddress;
-		return GetBacktraceId(ReturnAddress);
-	}
+////////////////////////////////////////////////////////////////////////////////
+uint32_t
+FBacktracer::GetBacktraceId(void* AddressOfReturnAddress)
+{
+	const uint64_t ReturnAddress = *(uint64_t*)AddressOfReturnAddress;
+	return GetBacktraceId(ReturnAddress);
+}
 
-	////////////////////////////////////////////////////////////////////////////////
-	uint32_t FBacktracer::GetBacktraceId(uint64_t ReturnAddress)
-	{
+////////////////////////////////////////////////////////////////////////////////
+uint32_t
+FBacktracer::GetBacktraceId(uint64_t ReturnAddress)
+{
 #		if !UE_BUILD_SHIPPING
-		uint64_t StackFrames[256];
-		int32_t	 NumStackFrames = FPlatformStackWalk::CaptureStackBackTrace(StackFrames, UE_ARRAY_COUNT(StackFrames));
-		if (NumStackFrames > 0)
+	uint64_t StackFrames[256];
+	int32_t	 NumStackFrames = FPlatformStackWalk::CaptureStackBackTrace(StackFrames, UE_ARRAY_COUNT(StackFrames));
+	if (NumStackFrames > 0)
+	{
+		FCallstackTracer::FBacktraceEntry BacktraceEntry;
+		uint64_t						  BacktraceId = 0;
+		uint32_t						  FrameIdx	  = 0;
+		bool							  bUseAddress = false;
+		for (int32_t Index = 0; Index < NumStackFrames; Index++)
 		{
-			FCallstackTracer::FBacktraceEntry BacktraceEntry;
-			uint64_t						  BacktraceId = 0;
-			uint32_t						  FrameIdx	  = 0;
-			bool							  bUseAddress = false;
-			for (int32_t Index = 0; Index < NumStackFrames; Index++)
+			if (!bUseAddress)
 			{
-				if (!bUseAddress)
+				// start using backtrace only after ReturnAddress
+				if (StackFrames[Index] == (uint64_t)ReturnAddress)
 				{
-					// start using backtrace only after ReturnAddress
-					if (StackFrames[Index] == (uint64_t)ReturnAddress)
-					{
-						bUseAddress = true;
-					}
-				}
-				if (bUseAddress || NumStackFrames == 1)
-				{
-					uint64_t RetAddr		= StackFrames[Index];
-					StackFrames[FrameIdx++] = RetAddr;
-
-					// This is a simple order-dependent LCG. Should be sufficient enough
-					BacktraceId += RetAddr;
-					BacktraceId *= 0x30be8efa499c249dull;
+					bUseAddress = true;
 				}
 			}
+			if (bUseAddress || NumStackFrames == 1)
+			{
+				uint64_t RetAddr		= StackFrames[Index];
+				StackFrames[FrameIdx++] = RetAddr;
 
-			// Save the collected id
-			BacktraceEntry.Hash		  = BacktraceId;
-			BacktraceEntry.FrameCount = FrameIdx;
-			BacktraceEntry.Frames	  = StackFrames;
-
-			// Add to queue to be processed. This might block until there is room in the
-			// queue (i.e. the processing thread has caught up processing).
-			return CallstackTracer.AddCallstack(BacktraceEntry);
+				// This is a simple order-dependent LCG. Should be sufficient enough
+				BacktraceId += RetAddr;
+				BacktraceId *= 0x30be8efa499c249dull;
+			}
 		}
-#		endif
 
-		return 0;
+		// Save the collected id
+		BacktraceEntry.Hash		  = BacktraceId;
+		BacktraceEntry.FrameCount = FrameIdx;
+		BacktraceEntry.Frames	  = StackFrames;
+
+		// Add to queue to be processed. This might block until there is room in the
+		// queue (i.e. the processing thread has caught up processing).
+		return CallstackTracer.AddCallstack(BacktraceEntry);
 	}
+#		endif
 
+	return 0;
+}
 }
 
 #	endif	// UE_CALLSTACK_TRACE_USE_UNWIND_TABLES
@@ -1047,7 +1055,7 @@ CallstackTrace_GetCurrentId()
 #	if PLATFORM_USE_CALLSTACK_ADDRESS_POINTER
 		return Instance->GetBacktraceId(StackAddress);
 #	else
-			return Instance->GetBacktraceId((uint64_t)StackAddress);
+		return Instance->GetBacktraceId((uint64_t)StackAddress);
 #	endif
 	}
 
diff --git a/src/zenhttp/servers/httpplugin.cpp b/src/zenhttp/servers/httpplugin.cpp
index 4bf8c61bb..a1bb719c8 100644
--- a/src/zenhttp/servers/httpplugin.cpp
+++ b/src/zenhttp/servers/httpplugin.cpp
@@ -147,7 +147,7 @@ public:
 	HttpPluginServerRequest& operator=(const HttpPluginServerRequest&) = delete;
 
 	// As this is plugin transport connection used for specialized connections we assume it is not a machine local connection
-	virtual bool			 IsLocalMachineRequest() const /* override*/ { return false; }
+	bool					 IsLocalMachineRequest() const override { return false; }
 	virtual std::string_view GetAuthorizationHeader() const override;
 	virtual Oid				 ParseSessionId() const override;
 	virtual uint32_t		 ParseRequestId() const override;
diff --git a/src/zenutil/workerpools.cpp b/src/zenutil/workerpools.cpp
index 1bab39b2a..25f961f77 100644
--- a/src/zenutil/workerpools.cpp
+++ b/src/zenutil/workerpools.cpp
@@ -25,9 +25,9 @@ namespace {
 
 		struct WorkerPool
 		{
-			std::unique_ptr<WorkerThreadPool> Pool;
 			const int						  TreadCount;
 			const std::string_view			  Name;
+			std::unique_ptr<WorkerThreadPool> Pool;
 		};
 
 		WorkerPool BurstLargeWorkerPool		 = {.TreadCount = LargeWorkerThreadPoolTreadCount, .Name = "large"};