[libc] address lntue's comments

Author: SchrodingerZhu

libc/src/__support/CPP/algorithm.h

@@ -25,14 +25,14 @@ template <class T = void> struct bit_or {};
 template <class T = void> struct bit_xor {};
 
 template <class T>
-LIBC_INLINE constexpr const T &max(LIBC_LIFETIMEBOUND const T &a,
-                                   LIBC_LIFETIMEBOUND const T &b) {
+LIBC_INLINE constexpr const T &max(LIBC_LIFETIME_BOUND const T &a,
+                                   LIBC_LIFETIME_BOUND const T &b) {
   return (a < b) ? b : a;
 }
 
 template <class T>
-LIBC_INLINE constexpr const T &min(LIBC_LIFETIMEBOUND const T &a,
-                                   LIBC_LIFETIMEBOUND const T &b) {
+LIBC_INLINE constexpr const T &min(LIBC_LIFETIME_BOUND const T &a,
+                                   LIBC_LIFETIME_BOUND const T &b) {
   return (a < b) ? a : b;
 }
 

libc/src/__support/CPP/array.h

@@ -31,22 +31,22 @@ template <class T, size_t N> struct array {
   LIBC_INLINE constexpr T *data() { return Data; }
   LIBC_INLINE constexpr const T *data() const { return Data; }
 
-  LIBC_INLINE constexpr T &front() LIBC_LIFETIMEBOUND { return Data[0]; }
-  LIBC_INLINE constexpr const T &front() const LIBC_LIFETIMEBOUND {
+  LIBC_INLINE constexpr T &front() LIBC_LIFETIME_BOUND { return Data[0]; }
+  LIBC_INLINE constexpr const T &front() const LIBC_LIFETIME_BOUND {
     return Data[0];
   }
 
-  LIBC_INLINE constexpr T &back() LIBC_LIFETIMEBOUND { return Data[N - 1]; }
-  LIBC_INLINE constexpr const T &back() const LIBC_LIFETIMEBOUND {
+  LIBC_INLINE constexpr T &back() LIBC_LIFETIME_BOUND { return Data[N - 1]; }
+  LIBC_INLINE constexpr const T &back() const LIBC_LIFETIME_BOUND {
     return Data[N - 1];
   }
 
-  LIBC_INLINE constexpr T &operator[](size_t Index) LIBC_LIFETIMEBOUND {
+  LIBC_INLINE constexpr T &operator[](size_t Index) LIBC_LIFETIME_BOUND {
     return Data[Index];
   }
 
   LIBC_INLINE constexpr const T &
-  operator[](size_t Index) const LIBC_LIFETIMEBOUND {
+  operator[](size_t Index) const LIBC_LIFETIME_BOUND {
     return Data[Index];
   }
 

libc/src/__support/CPP/mutex.h

@@ -29,14 +29,14 @@ template <typename MutexType> class lock_guard {
 
 public:
   // Calls `m.lock()` upon resource acquisition.
-  LIBC_INLINE explicit lock_guard(LIBC_LIFETIMEBOUND MutexType &m) : mutex(m) {
+  LIBC_INLINE explicit lock_guard(LIBC_LIFETIME_BOUND MutexType &m) : mutex(m) {
     mutex.lock();
   }
 
   // Acquires ownership of the mutex object `m` without attempting to lock
   // it. The behavior is undefined if the current thread does not hold the
   // lock on `m`. Does not call `m.lock()` upon resource acquisition.
-  LIBC_INLINE lock_guard(LIBC_LIFETIMEBOUND MutexType &m, adopt_lock_t /* t */)
+  LIBC_INLINE lock_guard(LIBC_LIFETIME_BOUND MutexType &m, adopt_lock_t /* t */)
       : mutex(m) {}
 
   LIBC_INLINE ~lock_guard() { mutex.unlock(); }

libc/src/__support/CPP/optional.h

@@ -108,11 +108,11 @@ template <typename T> class optional {
 
   LIBC_INLINE constexpr void reset() { storage.reset(); }
 
-  LIBC_INLINE constexpr const T &value() const &LIBC_LIFETIMEBOUND {
+  LIBC_INLINE constexpr const T &value() const &LIBC_LIFETIME_BOUND {
     return storage.stored_value;
   }
 
-  LIBC_INLINE constexpr T &value() & LIBC_LIFETIMEBOUND {
+  LIBC_INLINE constexpr T &value() & LIBC_LIFETIME_BOUND {
     return storage.stored_value;
   }
 
@@ -124,10 +124,10 @@ template <typename T> class optional {
     return &storage.stored_value;
   }
   LIBC_INLINE constexpr T *operator->() { return &storage.stored_value; }
-  LIBC_INLINE constexpr const T &operator*() const &LIBC_LIFETIMEBOUND {
+  LIBC_INLINE constexpr const T &operator*() const &LIBC_LIFETIME_BOUND {
     return storage.stored_value;
   }
-  LIBC_INLINE constexpr T &operator*() & LIBC_LIFETIMEBOUND {
+  LIBC_INLINE constexpr T &operator*() & LIBC_LIFETIME_BOUND {
     return storage.stored_value;
   }
 

libc/src/__support/CPP/span.h

@@ -64,12 +64,12 @@ template <typename T> class LIBC_GSL_POINTER span {
 
   template <typename U, size_t N,
             cpp::enable_if_t<is_compatible_v<U>, bool> = true>
-  LIBC_INLINE constexpr span(LIBC_LIFETIMEBOUND U (&arr)[N])
+  LIBC_INLINE constexpr span(LIBC_LIFETIME_BOUND U (&arr)[N])
       : span_data(arr), span_size(N) {}
 
   template <typename U, size_t N,
             cpp::enable_if_t<is_compatible_v<U>, bool> = true>
-  LIBC_INLINE constexpr span(LIBC_LIFETIMEBOUND array<U, N> &arr)
+  LIBC_INLINE constexpr span(LIBC_LIFETIME_BOUND array<U, N> &arr)
       : span_data(arr.data()), span_size(arr.size()) {}
 
   template <typename U, cpp::enable_if_t<is_compatible_v<U>, bool> = true>

libc/src/__support/CPP/string.h

@@ -106,21 +106,21 @@ class string {
   LIBC_INLINE constexpr const char *end() const { return data() + size_; }
   LIBC_INLINE char *end() { return data() + size_; }
 
-  LIBC_INLINE constexpr const char &front() const LIBC_LIFETIMEBOUND {
+  LIBC_INLINE constexpr const char &front() const LIBC_LIFETIME_BOUND {
     return data()[0];
   }
-  LIBC_INLINE char &front() LIBC_LIFETIMEBOUND { return data()[0]; }
+  LIBC_INLINE char &front() LIBC_LIFETIME_BOUND { return data()[0]; }
 
-  LIBC_INLINE constexpr const char &back() const LIBC_LIFETIMEBOUND {
+  LIBC_INLINE constexpr const char &back() const LIBC_LIFETIME_BOUND {
     return data()[size_ - 1];
   }
-  LIBC_INLINE char &back() LIBC_LIFETIMEBOUND { return data()[size_ - 1]; }
+  LIBC_INLINE char &back() LIBC_LIFETIME_BOUND { return data()[size_ - 1]; }
 
   LIBC_INLINE constexpr const char &
-  operator[](size_t index) const LIBC_LIFETIMEBOUND {
+  operator[](size_t index) const LIBC_LIFETIME_BOUND {
     return data()[index];
   }
-  LIBC_INLINE char &operator[](size_t index) LIBC_LIFETIMEBOUND {
+  LIBC_INLINE char &operator[](size_t index) LIBC_LIFETIME_BOUND {
     return data()[index];
   }
 

libc/src/__support/CPP/string_view.h

@@ -78,7 +78,7 @@ class LIBC_GSL_POINTER string_view {
       : Data(Str), Len(N) {}
 
   template <size_t N>
-  LIBC_INLINE constexpr string_view(LIBC_LIFETIMEBOUND const char (&Str)[N])
+  LIBC_INLINE constexpr string_view(LIBC_LIFETIME_BOUND const char (&Str)[N])
       : Data(Str), Len(N) {}
 
   LIBC_INLINE constexpr const char *data() const { return Data; }

libc/src/__support/CPP/utility/forward.h

@@ -19,13 +19,13 @@ namespace cpp {
 // forward
 template <typename T>
 LIBC_INLINE constexpr T &&
-forward(LIBC_LIFETIMEBOUND remove_reference_t<T> &value) {
+forward(LIBC_LIFETIME_BOUND remove_reference_t<T> &value) {
   return static_cast<T &&>(value);
 }
 
 template <typename T>
 LIBC_INLINE constexpr T &&
-forward(LIBC_LIFETIMEBOUND remove_reference_t<T> &&value) {
+forward(LIBC_LIFETIME_BOUND remove_reference_t<T> &&value) {
   static_assert(!is_lvalue_reference_v<T>,
                 "cannot forward an rvalue as an lvalue");
   return static_cast<T &&>(value);

libc/src/__support/CPP/utility/move.h

@@ -18,7 +18,7 @@ namespace cpp {
 // move
 template <class T>
 LIBC_INLINE constexpr cpp::remove_reference_t<T> &&
-move(LIBC_LIFETIMEBOUND T &&t) {
+move(LIBC_LIFETIME_BOUND T &&t) {
   return static_cast<typename cpp::remove_reference_t<T> &&>(t);
 }
 

libc/src/__support/macros/attributes.h

@@ -92,9 +92,9 @@ LIBC_THREAD_MODE_EXTERNAL.
 #endif
 
 #if __has_attribute(lifetimebound)
-#define LIBC_LIFETIMEBOUND [[clang::lifetimebound]]
+#define LIBC_LIFETIME_BOUND [[clang::lifetimebound]]
 #else
-#define LIBC_LIFETIMEBOUND
+#define LIBC_LIFETIME_BOUND
 #endif
 
 #if __has_attribute(lifetime_capture_by)