[ADT][Support] Fix C4146 error from MSVC

[vinograd47]

Summary

Unary minus operator applied to unsigned type, result still unsigned.

Use ~0U instead of -1U and 1 + ~VAL instead of -VAL.

[dblaikie]

Perhaps we could rewrite the code to use ~ or the like instead of unary - if that works?

[RKSimon]

In D94417#2491085, @dblaikie wrote:

Perhaps we could rewrite the code to use ~ or the like instead of unary - if that works?

+1 We currently globally disable C4146 inside llvm-project\llvm\cmake\modules\HandleLLVMOptions.cmake (along with a lot of other warnings that ideally we'd enable and make use of) - it'd be great if you could fix at least the code here instead of adding a lot of pragmas.

[vinograd47]

Reworked the patch. Fixed the warning instead of disabling it.

[dblaikie]

Seems OK - I don't know if there's a nicer way to handle the latter cases that need the 1 + ~N.

[vinograd47]

Update the revision using Arcanist tool

[vinograd47]

Rebased

[dblaikie]

Can you commit this yourself (do you have commit access), or do you need someone to commit it for you?

[vinograd47]

@dblaikie I'm not sure if I have commit access. But after rebase CI shows unit tests failures, I need to investigate them prior to merging.

[vinograd47]

Rebased to the latest main state.

[vinograd47]

@dblaikie I see similar failures locally even on clean main branch without this changes. Is it some known issue?

[vinograd47]

@dblaikie CI now passed. Could you please commit this change to main repo?

llvm/include/llvm/ADT/StringExtras.h

 //===- llvm/ADT/StringExtras.h - Useful string functions --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 ///
 /// If \p C is not a valid hex digit, -1U is returned.
 inline unsigned hexDigitValue(char C) {
   struct HexTable {
     unsigned LUT[255] = {};
     constexpr HexTable() {
       // Default initialize everything to invalid.
       for (int i = 0; i < 255; ++i)
-        LUT[i] = -1U;
+        LUT[i] = ~0U;
       // Initialize `0`-`9`.
       for (int i = 0; i < 10; ++i)
         LUT['0' + i] = i;
       // Initialize `A`-`F` and `a`-`f`.
       for (int i = 0; i < 6; ++i)
         LUT['A' + i] = LUT['a' + i] = 10 + i;
     }
   };
   constexpr HexTable Table;
   return Table.LUT[static_cast<unsigned char>(C)];
 }
 
 /// Checks if character \p C is one of the 10 decimal digits.
 inline bool isDigit(char C) { return C >= '0' && C <= '9'; }
 
 /// Checks if character \p C is a hexadecimal numeric character.
-inline bool isHexDigit(char C) { return hexDigitValue(C) != -1U; }
+inline bool isHexDigit(char C) { return hexDigitValue(C) != ~0U; }
 
 /// Checks if character \p C is a valid letter as classified by "C" locale.
 inline bool isAlpha(char C) {
   return ('a' <= C && C <= 'z') || ('A' <= C && C <= 'Z');
 }
 
 /// Checks whether character \p C is either a decimal digit or an uppercase or
 /// lowercase letter as classified by "C" locale.

 
 /// Store the binary representation of the two provided values, \p MSB and
 /// \p LSB, that make up the nibbles of a hexadecimal digit. If \p MSB or \p LSB
 /// do not correspond to proper nibbles of a hexadecimal digit, this method
 /// returns false. Otherwise, returns true.
 inline bool tryGetHexFromNibbles(char MSB, char LSB, uint8_t &Hex) {
   unsigned U1 = hexDigitValue(MSB);
   unsigned U2 = hexDigitValue(LSB);
-  if (U1 == -1U || U2 == -1U)
+  if (U1 == ~0U || U2 == ~0U)
     return false;
 
   Hex = static_cast<uint8_t>((U1 << 4) | U2);
   return true;
 }
 
 /// Return the binary representation of the two provided values, \p MSB and
 /// \p LSB, that make up the nibbles of a hexadecimal digit.
inline std::string utostr(uint64_t X, bool isNeg = false) {
   }
 
   if (isNeg) *--BufPtr = '-';   // Add negative sign...
   return std::string(BufPtr, std::end(Buffer));
 }
 
 inline std::string itostr(int64_t X) {
   if (X < 0)
-    return utostr(-static_cast<uint64_t>(X), true);
+    return utostr(static_cast<uint64_t>(1) + ~static_cast<uint64_t>(X), true);
   else
     return utostr(static_cast<uint64_t>(X));
 }
 
 /// StrInStrNoCase - Portable version of strcasestr.  Locates the first
 /// occurrence of string 's1' in string 's2', ignoring case.  Returns
 /// the offset of s2 in s1 or npos if s2 cannot be found.
 StringRef::size_type StrInStrNoCase(StringRef s1, StringRef s2);

llvm/include/llvm/Support/MathExtras.h

 //===-- llvm/Support/MathExtras.h - Useful math functions -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
inline uint64_t maxUIntN(uint64_t N) {
   // branch.
   return UINT64_MAX >> (64 - N);
 }
 
 /// Gets the minimum value for a N-bit signed integer.
 inline int64_t minIntN(int64_t N) {
   assert(N > 0 && N <= 64 && "integer width out of range");
 
-  return -(UINT64_C(1)<<(N-1));
+  return UINT64_C(1) + ~(UINT64_C(1) << (N - 1));
 }
 
 /// Gets the maximum value for a N-bit signed integer.
 inline int64_t maxIntN(int64_t N) {
   assert(N > 0 && N <= 64 && "integer width out of range");
 
   // This relies on two's complement wraparound when N == 64, so we convert to
   // int64_t only at the very end to avoid UB.