[ADT] Update Optional Deprecation with fix-it

[njames93]

Summary

When Optional accessors were deprecated, in D131349, the standard c++14 style attribute was used.
Clang has a slightly better deprecated attribute that enables simpler migration by embedding fix-its.

[kazu]

Thanks a lot!

[dblaikie]

Neat!

llvm/include/llvm/ADT/Optional.h

public:
   void reset() noexcept {
     if (hasVal) {
       val.~T();
       hasVal = false;
     }
   }
 
   constexpr bool has_value() const noexcept { return hasVal; }
-  [[deprecated("Use has_value instead.")]] constexpr bool
-  hasValue() const noexcept {
+  LLVM_DEPRECATED("Use has_value instead.", "has_value")
+  constexpr bool hasValue() const noexcept {
     return hasVal;
   }
 
   T &value() &noexcept {
     assert(hasVal);
     return val;
   }
-  [[deprecated("Use value instead.")]] T &getValue() &noexcept {
+  LLVM_DEPRECATED("Use value instead.", "value") T &getValue() &noexcept {
     assert(hasVal);
     return val;
   }
   constexpr T const &value() const &noexcept {
     assert(hasVal);
     return val;
   }
-  [[deprecated("Use value instead.")]] constexpr T const &
-  getValue() const &noexcept {
+  LLVM_DEPRECATED("Use value instead.", "value")
+  constexpr T const &getValue() const &noexcept {
     assert(hasVal);
     return val;
   }
   T &&value() &&noexcept {
     assert(hasVal);
     return std::move(val);
   }
-  [[deprecated("Use value instead.")]] T &&getValue() &&noexcept {
+  LLVM_DEPRECATED("Use value instead.", "value") T &&getValue() &&noexcept {
     assert(hasVal);
     return std::move(val);
   }
 
   template <class... Args> void emplace(Args &&...args) {
     reset();
     ::new ((void *)std::addressof(val)) T(std::forward<Args>(args)...);
     hasVal = true;
public:
   void reset() noexcept {
     if (hasVal) {
       val.~T();
       hasVal = false;
     }
   }
 
   constexpr bool has_value() const noexcept { return hasVal; }
-  [[deprecated("Use has_value instead.")]] constexpr bool
-  hasValue() const noexcept {
+  LLVM_DEPRECATED("Use has_value instead.", "has_value")
+  constexpr bool hasValue() const noexcept {
     return hasVal;
   }
 
   T &value() &noexcept {
     assert(hasVal);
     return val;
   }
-  [[deprecated("Use value instead.")]] T &getValue() &noexcept {
+  LLVM_DEPRECATED("Use value instead.", "value") T &getValue() &noexcept {
     assert(hasVal);
     return val;
   }
   constexpr T const &value() const &noexcept {
     assert(hasVal);
     return val;
   }
-  [[deprecated("Use value instead.")]] constexpr T const &
-  getValue() const &noexcept {
+  LLVM_DEPRECATED("Use value instead.", "value")
+  constexpr T const &getValue() const &noexcept {
     assert(hasVal);
     return val;
   }
   T &&value() &&noexcept {
     assert(hasVal);
     return std::move(val);
   }
-  [[deprecated("Use value instead.")]] T &&getValue() &&noexcept {
+  LLVM_DEPRECATED("Use value instead.", "value") T &&getValue() &&noexcept {
     assert(hasVal);
     return std::move(val);
   }
 
   template <class... Args> void emplace(Args &&...args) {
     reset();
     ::new ((void *)std::addressof(val)) T(std::forward<Args>(args)...);
     hasVal = true;
public:
   }
   Optional &operator=(const Optional &O) = default;
 
   void reset() { Storage.reset(); }
 
   constexpr const T *getPointer() const { return &Storage.value(); }
   T *getPointer() { return &Storage.value(); }
   constexpr const T &value() const & { return Storage.value(); }
-  [[deprecated("Use value instead.")]] constexpr const T &getValue() const & {
+  LLVM_DEPRECATED("Use value instead.", "value")
+  constexpr const T &getValue() const & {
     return Storage.value();
   }
   T &value() & { return Storage.value(); }
-  [[deprecated("Use value instead.")]] T &getValue() & {
+  LLVM_DEPRECATED("Use value instead.", "value") T &getValue() & {
     return Storage.value();
   }
 
   constexpr explicit operator bool() const { return has_value(); }
   constexpr bool has_value() const { return Storage.has_value(); }
-  [[deprecated("Use has_value instead.")]] constexpr bool hasValue() const {
+  LLVM_DEPRECATED("Use has_value instead.", "has_value")
+  constexpr bool hasValue() const {
     return Storage.has_value();
   }
   constexpr const T *operator->() const { return getPointer(); }
   T *operator->() { return getPointer(); }
   constexpr const T &operator*() const & { return value(); }
   T &operator*() & { return value(); }
 
   template <typename U> constexpr T value_or(U &&alt) const & {
     return has_value() ? value() : std::forward<U>(alt);
   }
   template <typename U>
-  [[deprecated("Use value_or instead.")]] constexpr T
-  getValueOr(U &&alt) const & {
+  LLVM_DEPRECATED("Use value_or instead.", "value_or")
+  constexpr T getValueOr(U &&alt) const & {
     return has_value() ? value() : std::forward<U>(alt);
   }
 
   /// Apply a function to the value if present; otherwise return None.
   template <class Function>
   auto map(const Function &F) const & -> Optional<decltype(F(value()))> {
     if (*this)
       return F(value());
     return None;
   }
 
   T &&value() && { return std::move(Storage.value()); }
-  [[deprecated("Use value instead.")]] T &&getValue() && {
+  LLVM_DEPRECATED("Use value instead.", "value") T &&getValue() && {
     return std::move(Storage.value());
   }
   T &&operator*() && { return std::move(Storage.value()); }
 
   template <typename U> T value_or(U &&alt) && {
     return has_value() ? std::move(value()) : std::forward<U>(alt);
   }
   template <typename U>
-  [[deprecated("Use value_or instead.")]] T getValueOr(U &&alt) && {
+  LLVM_DEPRECATED("Use value_or instead.", "value_or")
+  T getValueOr(U &&alt) && {
     return has_value() ? std::move(value()) : std::forward<U>(alt);
   }
 
   /// Apply a function to the value if present; otherwise return None.
   template <class Function>
   auto map(const Function &F)
       && -> Optional<decltype(F(std::move(*this).value()))> {
     if (*this)

llvm/include/llvm/Support/Compiler.h

 #endif
 
 #if __has_attribute(used)
 #define LLVM_ATTRIBUTE_USED __attribute__((__used__))
 #else
 #define LLVM_ATTRIBUTE_USED
 #endif
 
+#if defined(__clang__)
+#define LLVM_DEPRECATED(MSG, FIX) __attribute__((deprecated(MSG, FIX)))
+#else
+#define LLVM_DEPRECATED(MSG, FIX) [[deprecated(MSG)]]
+#endif
+
 /// LLVM_NODISCARD - Warn if a type or return value is discarded.
 
 // Use the 'nodiscard' attribute in C++17 or newer mode.
 #if defined(__cplusplus) && __cplusplus > 201402L && LLVM_HAS_CPP_ATTRIBUTE(nodiscard)
 #define LLVM_NODISCARD [[nodiscard]]
 #elif LLVM_HAS_CPP_ATTRIBUTE(clang::warn_unused_result)
 #define LLVM_NODISCARD [[clang::warn_unused_result]]
 // Clang in C++14 mode claims that it has the 'nodiscard' attribute, but also