[JSON] Handle uint64_t type

[djtodoro]

Summary

There was no handling of uint64_t in the LLVM JSON library. This patch adds support for that.
The motivation is the https://reviews.llvm.org/D109217.

[djtodoro]

• apply clang-format suggestions

[djtodoro]

ping :)

[StephenTozer]

Looks mostly good, but I don't think the parsing side of things quite works: in order for us to ever parse a JSON value as an unsigned integer - including with parse<uint64_t> - we need to either produce unsigned Values in Parser::parseNumber, or allow getAsUINT64 to produce unsigned values from integer Values. As there is no real way to represent unsigned values in JSON, I think the latter makes more sense as it simply needs a check to ensure that the integer value is not negative.

[djtodoro]

I haven't paid attention to the parse() part, but I should have. Hmm, I think parsing an int as unsigned via getAsUNIT64() is a better way IMO, so I'll do that way.

[djtodoro]

• handle parse()

[StephenTozer]

LGTM.

llvm/include/llvm/Support/JSON.h

 /// These can be list-initialized, or used to build up collections in a loop.
 /// json::ary(Collection) converts all items in a collection to Values.
 ///
 /// === Inspecting values ===
 ///
 /// Each Value is one of the JSON kinds:
 ///   null    (nullptr_t)
 ///   boolean (bool)
-///   number  (double or int64)
+///   number  (double, int64 or uint64)
 ///   string  (StringRef)
 ///   array   (json::Array)
 ///   object  (json::Object)
 ///
 /// The kind can be queried directly, or implicitly via the typed accessors:
 ///   if (Optional<StringRef> S = E.getAsString()
 ///     assert(E.kind() == Value::String);
 ///
public:
   // Boolean (disallow implicit conversions).
   // (The last template parameter is a dummy to keep templates distinct.)
   template <typename T,
             typename = std::enable_if_t<std::is_same<T, bool>::value>,
             bool = false>
   Value(T B) : Type(T_Boolean) {
     create<bool>(B);
   }
-  // Integers (except boolean). Must be non-narrowing convertible to int64_t.
+
+  // Unsigned 64-bit long integers.
+  template <typename T,
+            typename = std::enable_if_t<std::is_same<T, uint64_t>::value>,
+            bool = false, bool = false>
+  Value(T V) : Type(T_UINT64) {
+    create<uint64_t>(uint64_t{V});
+  }
+
+  // Integers (except boolean and uint64_t).
+  // Must be non-narrowing convertible to int64_t.
   template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>,
-            typename = std::enable_if_t<!std::is_same<T, bool>::value>>
+            typename = std::enable_if_t<!std::is_same<T, bool>::value>,
+            typename = std::enable_if_t<!std::is_same<T, uint64_t>::value>>
   Value(T I) : Type(T_Integer) {
     create<int64_t>(int64_t{I});
   }
   // Floating point. Must be non-narrowing convertible to double.
   template <typename T,
             typename = std::enable_if_t<std::is_floating_point<T>::value>,
             double * = nullptr>
   Value(T D) : Type(T_Double) {
public:
   Kind kind() const {
     switch (Type) {
     case T_Null:
       return Null;
     case T_Boolean:
       return Boolean;
     case T_Double:
     case T_Integer:
+    case T_UINT64:
       return Number;
     case T_String:
     case T_StringRef:
       return String;
     case T_Object:
       return Object;
     case T_Array:
       return Array;
if (LLVM_LIKELY(Type == T_Boolean))
       return as<bool>();
     return llvm::None;
   }
   llvm::Optional<double> getAsNumber() const {
     if (LLVM_LIKELY(Type == T_Double))
       return as<double>();
     if (LLVM_LIKELY(Type == T_Integer))
       return as<int64_t>();
+    if (LLVM_LIKELY(Type == T_UINT64))
+      return as<uint64_t>();
     return llvm::None;
   }
   // Succeeds if the Value is a Number, and exactly representable as int64_t.
   llvm::Optional<int64_t> getAsInteger() const {
     if (LLVM_LIKELY(Type == T_Integer))
       return as<int64_t>();
     if (LLVM_LIKELY(Type == T_Double)) {
       double D = as<double>();
       if (LLVM_LIKELY(std::modf(D, &D) == 0.0 &&
                       D >= double(std::numeric_limits<int64_t>::min()) &&
                       D <= double(std::numeric_limits<int64_t>::max())))
         return D;
     }
     return llvm::None;
   }
+  llvm::Optional<uint64_t> getAsUINT64() const {
+    if (Type == T_UINT64)
+      return as<uint64_t>();
+    else if (Type == T_Integer) {
+      int64_t N = as<int64_t>();
+      if (N >= 0)
+        return as<uint64_t>();
+    }
+    return llvm::None;
+  }
   llvm::Optional<llvm::StringRef> getAsString() const {
     if (Type == T_String)
       return llvm::StringRef(as<std::string>());
     if (LLVM_LIKELY(Type == T_StringRef))
       return as<llvm::StringRef>();
     return llvm::None;
   }
   const json::Object *getAsObject() const {
template <typename T> T &as() const {
     // Using this two-step static_cast via void * instead of reinterpret_cast
     // silences a -Wstrict-aliasing false positive from GCC6 and earlier.
     void *Storage = static_cast<void *>(&Union);
     return *static_cast<T *>(Storage);
   }
 
   friend class OStream;
 
-  enum ValueType : char {
+  enum ValueType : char16_t {
     T_Null,
     T_Boolean,
     T_Double,
     T_Integer,
+    T_UINT64,
     T_StringRef,
     T_String,
     T_Object,
     T_Array,
   };
   // All members mutable, see moveFrom().
   mutable ValueType Type;
-  mutable llvm::AlignedCharArrayUnion<bool, double, int64_t, llvm::StringRef,
-                                      std::string, json::Array, json::Object>
+  mutable llvm::AlignedCharArrayUnion<bool, double, int64_t, uint64_t,
+                                      llvm::StringRef, std::string, json::Array,
+                                      json::Object>
       Union;
   friend bool operator==(const Value &, const Value &);
 };
 
 bool operator==(const Value &, const Value &);
 inline bool operator!=(const Value &L, const Value &R) { return !(L == R); }
 
 /// ObjectKey is a used to capture keys in Object. Like Value but:

 inline bool fromJSON(const Value &E, bool &Out, Path P) {
   if (auto S = E.getAsBoolean()) {
     Out = *S;
     return true;
   }
   P.report("expected boolean");
   return false;
 }
+inline bool fromJSON(const Value &E, uint64_t &Out, Path P) {
+  if (auto S = E.getAsUINT64()) {
+    Out = *S;
+    return true;
+  }
+  P.report("expected uint64_t");
+  return false;
+}
 inline bool fromJSON(const Value &E, std::nullptr_t &Out, Path P) {
   if (auto S = E.getAsNull()) {
     Out = *S;
     return true;
   }
   P.report("expected null");
   return false;
 }

llvm/lib/Support/JSON.cpp

 
 void Value::copyFrom(const Value &M) {
   Type = M.Type;
   switch (Type) {
   case T_Null:
   case T_Boolean:
   case T_Double:
   case T_Integer:
+  case T_UINT64:
     memcpy(&Union, &M.Union, sizeof(Union));
     break;
   case T_StringRef:
     create<StringRef>(M.as<StringRef>());
     break;
   case T_String:
     create<std::string>(M.as<std::string>());
     break;
   case T_Object:
     create<json::Object>(M.as<json::Object>());
     break;
   case T_Array:
     create<json::Array>(M.as<json::Array>());
     break;
   }
 }
 
 void Value::moveFrom(const Value &&M) {
   Type = M.Type;
   switch (Type) {
   case T_Null:
   case T_Boolean:
   case T_Double:
   case T_Integer:
+  case T_UINT64:
     memcpy(&Union, &M.Union, sizeof(Union));
     break;
   case T_StringRef:
     create<StringRef>(M.as<StringRef>());
     break;
   case T_String:
     create<std::string>(std::move(M.as<std::string>()));
     M.Type = T_Null;

 }
 
 void Value::destroy() {
   switch (Type) {
   case T_Null:
   case T_Boolean:
   case T_Double:
   case T_Integer:
+  case T_UINT64:
     break;
   case T_StringRef:
     as<StringRef>().~StringRef();
     break;
   case T_String:
     as<std::string>().~basic_string();
     break;
   case T_Object:
void llvm::json::OStream::value(const Value &V) {
   case Value::Boolean:
     valueBegin();
     OS << (*V.getAsBoolean() ? "true" : "false");
     return;
   case Value::Number:
     valueBegin();
     if (V.Type == Value::T_Integer)
       OS << *V.getAsInteger();
+    else if (V.Type == Value::T_UINT64)
+      OS << *V.getAsUINT64();
     else
       OS << format("%.*g", std::numeric_limits<double>::max_digits10,
                    *V.getAsNumber());
     return;
   case Value::String:
     valueBegin();
     quote(OS, *V.getAsString());
     return;

llvm/unittests/Support/JSONTest.cpp

for (const auto &T : TestCases) {
     EXPECT_TRUE(!!Doc) << T.Desc;
     EXPECT_EQ(Doc->getAsInteger(), T.AsInt) << T.Desc;
     EXPECT_EQ(Doc->getAsNumber(), T.AsNumber) << T.Desc;
     EXPECT_EQ(T.Val, *Doc) << T.Desc;
     EXPECT_EQ(T.Str, s(*Doc)) << T.Desc;
   }
 }
 
+// Verify uint64_t type.
+TEST(JSONTest, U64Integers) {
+  Value Val = uint64_t{3100100100};
+  uint64_t Var = 3100100100;
+  EXPECT_EQ(Val, Var);
+
+  // Test the parse() part.
+  const char *Str = "4611686018427387905";
+  llvm::Expected<Value> Doc = parse(Str);
+
+  EXPECT_TRUE(!!Doc);
+  EXPECT_EQ(Doc->getAsInteger(), int64_t{4611686018427387905});
+  EXPECT_EQ(Doc->getAsUINT64(), uint64_t{4611686018427387905});
+
+  const char *Str2 = "-78278238238328222";
+  llvm::Expected<Value> Doc2 = parse(Str2);
+  EXPECT_TRUE(!!Doc2);
+  EXPECT_EQ(Doc2->getAsInteger(), int64_t{-78278238238328222});
+  EXPECT_EQ(Doc2->getAsUINT64(), llvm::None);
+}
+
 // Sample struct with typical JSON-mapping rules.
 struct CustomStruct {
   CustomStruct() : B(false) {}
   CustomStruct(std::string S, llvm::Optional<int> I, bool B)
       : S(S), I(I), B(B) {}
   std::string S;
   llvm::Optional<int> I;
   bool B;