[ADT] Rename value to val (NFC)

[kazu]

Summary

I'd like to introduce functions, such as value, value_or, has_value,
etc to make llvm::Optional look more like std::optional. Renaming
value to val avoids name conflicts.

[dblaikie]

Sure, sounds like a great direction, thanks!

llvm/include/llvm/ADT/Optional.h

template <typename T,
                   std::is_trivially_copy_assignable<T>::value &&
                   (llvm::is_trivially_move_constructible<T>::value ||
                    !std::is_move_constructible<T>::value) &&
                   (std::is_trivially_move_assignable<T>::value ||
                    !std::is_move_assignable<T>::value))>
 class OptionalStorage {
   union {
     char empty;
-    T value;
+    T val;
   };
   bool hasVal = false;
 
 public:
   ~OptionalStorage() { reset(); }
 
   constexpr OptionalStorage() noexcept : empty() {}
 
   constexpr OptionalStorage(OptionalStorage const &other) : OptionalStorage() {
     if (other.hasValue()) {
-      emplace(other.value);
+      emplace(other.val);
     }
   }
   constexpr OptionalStorage(OptionalStorage &&other) : OptionalStorage() {
     if (other.hasValue()) {
-      emplace(std::move(other.value));
+      emplace(std::move(other.val));
     }
   }
 
   template <class... Args>
   constexpr explicit OptionalStorage(in_place_t, Args &&...args)
-      : value(std::forward<Args>(args)...), hasVal(true) {}
+      : val(std::forward<Args>(args)...), hasVal(true) {}
 
   void reset() noexcept {
     if (hasVal) {
-      value.~T();
+      val.~T();
       hasVal = false;
     }
   }
 
   constexpr bool hasValue() const noexcept { return hasVal; }
 
   T &getValue() &noexcept {
     assert(hasVal);
-    return value;
+    return val;
   }
   constexpr T const &getValue() const &noexcept {
     assert(hasVal);
-    return value;
+    return val;
   }
   T &&getValue() &&noexcept {
     assert(hasVal);
-    return std::move(value);
+    return std::move(val);
   }
 
   template <class... Args> void emplace(Args &&...args) {
     reset();
-    ::new ((void *)std::addressof(value)) T(std::forward<Args>(args)...);
+    ::new ((void *)std::addressof(val)) T(std::forward<Args>(args)...);
     hasVal = true;
   }
 
   OptionalStorage &operator=(T const &y) {
     if (hasValue()) {
-      value = y;
+      val = y;
     } else {
-      ::new ((void *)std::addressof(value)) T(y);
+      ::new ((void *)std::addressof(val)) T(y);
       hasVal = true;
     }
     return *this;
   }
   OptionalStorage &operator=(T &&y) {
     if (hasValue()) {
-      value = std::move(y);
+      val = std::move(y);
     } else {
-      ::new ((void *)std::addressof(value)) T(std::move(y));
+      ::new ((void *)std::addressof(val)) T(std::move(y));
       hasVal = true;
     }
     return *this;
   }
 
   OptionalStorage &operator=(OptionalStorage const &other) {
     if (other.hasValue()) {
       if (hasValue()) {
-        value = other.value;
+        val = other.val;
       } else {
-        ::new ((void *)std::addressof(value)) T(other.value);
+        ::new ((void *)std::addressof(val)) T(other.val);
         hasVal = true;
       }
     } else {
       reset();
     }
     return *this;
   }
 
   OptionalStorage &operator=(OptionalStorage &&other) {
     if (other.hasValue()) {
       if (hasValue()) {
-        value = std::move(other.value);
+        val = std::move(other.val);
       } else {
-        ::new ((void *)std::addressof(value)) T(std::move(other.value));
+        ::new ((void *)std::addressof(val)) T(std::move(other.val));
         hasVal = true;
       }
     } else {
       reset();
     }
     return *this;
   }
 };
 
 template <typename T> class OptionalStorage<T, true> {
   union {
     char empty;
-    T value;
+    T val;
   };
   bool hasVal = false;
 
 public:
   ~OptionalStorage() = default;
 
   constexpr OptionalStorage() noexcept : empty{} {}
 
   constexpr OptionalStorage(OptionalStorage const &other) = default;
   constexpr OptionalStorage(OptionalStorage &&other) = default;
 
   OptionalStorage &operator=(OptionalStorage const &other) = default;
   OptionalStorage &operator=(OptionalStorage &&other) = default;
 
   template <class... Args>
-  constexpr explicit OptionalStorage(in_place_t, Args &&... args)
-      : value(std::forward<Args>(args)...), hasVal(true) {}
+  constexpr explicit OptionalStorage(in_place_t, Args &&...args)
+      : val(std::forward<Args>(args)...), hasVal(true) {}
 
   void reset() noexcept {
     if (hasVal) {
-      value.~T();
+      val.~T();
       hasVal = false;
     }
   }
 
   constexpr bool hasValue() const noexcept { return hasVal; }
 
   T &getValue() &noexcept {
     assert(hasVal);
-    return value;
+    return val;
   }
   constexpr T const &getValue() const &noexcept {
     assert(hasVal);
-    return value;
+    return val;
   }
   T &&getValue() &&noexcept {
     assert(hasVal);
-    return std::move(value);
+    return std::move(val);
   }
 
   template <class... Args> void emplace(Args &&...args) {
     reset();
-    ::new ((void *)std::addressof(value)) T(std::forward<Args>(args)...);
+    ::new ((void *)std::addressof(val)) T(std::forward<Args>(args)...);
     hasVal = true;
   }
 
   OptionalStorage &operator=(T const &y) {
     if (hasValue()) {
-      value = y;
+      val = y;
     } else {
-      ::new ((void *)std::addressof(value)) T(y);
+      ::new ((void *)std::addressof(val)) T(y);
       hasVal = true;
     }
     return *this;
   }
   OptionalStorage &operator=(T &&y) {
     if (hasValue()) {
-      value = std::move(y);
+      val = std::move(y);
     } else {
-      ::new ((void *)std::addressof(value)) T(std::move(y));
+      ::new ((void *)std::addressof(val)) T(std::move(y));
       hasVal = true;
     }
     return *this;
   }
 };
 
 } // namespace optional_detail