[NFC] Use value initializer for OVERLAPPED

[aeubanks]

Summary

To fix
../llvm/lib/Support/Windows/Path.inc(1265,21): warning: missing field
'InternalHigh' initializer [-Wmissing-field-initializers]

OVERLAPPED OV = {0};

[hans]

lgtm, looks like we already do this elsewhere in the file.

[amccarth]

Huh, I thought aggregate initialization was effectively zero-initialization for the remaining fields, so I'm surprised this changes anything. I would have expected the original line, which is idiomatic in Win32 code, to have zero-initialized all of the fields.

But it looks like the field in question is part of a union, so maybe the rules there are different. I'll read up on it, but I don't see any harm here.

[amccarth]

OK, I see. I was looking at the wrong field.

I'm not sure I see the value in this warning. I'd argue the replacement code is less clear. It's contrary to the entrenched idiom for Win32 programming. The old code in valid and correct in both C and C++, but the new code is not allowed in C.

"In C, the braced list of initializers cannot be empty (note that C++ allows empty lists ...)." https://en.cppreference.com/w/c/language/struct_initialization

llvm/lib/Support/Windows/Path.inc

 //=== WARNING: Implementation here must contain only generic Windows code that
 //===          is guaranteed to work on *all* Windows variants.
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/WindowsError.h"
 #include <fcntl.h>
 #include <io.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 
 // These two headers must be included last, and make sure shlobj is required
 // after Windows.h to make sure it picks up our definition of _WIN32_WINNT
 #include "llvm/Support/Windows/WindowsSupport.h"
 #include <shellapi.h>
 #include <shlobj.h>
Expected<size_t> readNativeFileSlice(file_t FileHandle,
   OVERLAPPED Overlapped = {};
   Overlapped.Offset = uint32_t(Offset);
   Overlapped.OffsetHigh = uint32_t(Offset >> 32);
   return readNativeFileImpl(FileHandle, Buf, &Overlapped);
 }
 
 std::error_code tryLockFile(int FD, std::chrono::milliseconds Timeout) {
   DWORD Flags = LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY;
-  OVERLAPPED OV = {0};
+  OVERLAPPED OV = {};
   file_t File = convertFDToNativeFile(FD);
   auto Start = std::chrono::steady_clock::now();
   auto End = Start + Timeout;
   do {
     if (::LockFileEx(File, Flags, 0, MAXDWORD, MAXDWORD, &OV))
       return std::error_code();
     DWORD Error = ::GetLastError();
     if (Error == ERROR_LOCK_VIOLATION) {
       ::Sleep(1);
       continue;
     }
     return mapWindowsError(Error);
   } while (std::chrono::steady_clock::now() < End);
   return mapWindowsError(ERROR_LOCK_VIOLATION);
 }
 
 std::error_code lockFile(int FD) {
   DWORD Flags = LOCKFILE_EXCLUSIVE_LOCK;
-  OVERLAPPED OV = {0};
+  OVERLAPPED OV = {};
   file_t File = convertFDToNativeFile(FD);
   if (::LockFileEx(File, Flags, 0, MAXDWORD, MAXDWORD, &OV))
     return std::error_code();
   DWORD Error = ::GetLastError();
   return mapWindowsError(Error);
 }
 
 std::error_code unlockFile(int FD) {
-  OVERLAPPED OV = {0};
+  OVERLAPPED OV = {};
   file_t File = convertFDToNativeFile(FD);
   if (::UnlockFileEx(File, 0, MAXDWORD, MAXDWORD, &OV))
     return std::error_code();
   return mapWindowsError(::GetLastError());
 }
 
 std::error_code closeFile(file_t &F) {
   file_t TmpF = F;