[libc++] Change _LIBCPP_CONSTEXPR_SINCE_XXX to constexpr in the dylib

[ldionne]

Summary

Since we build the dylib with C++20, there's no need to use conditional
macros anymore.

[Mordante]

LGTM! Thanks for the cleanup.

libcxx/src/chrono.cpp

 static system_clock::time_point __libcpp_system_clock_now() {
   // FILETIME is in 100ns units
   using filetime_duration =
       _VSTD::chrono::duration<__int64,
                               _VSTD::ratio_multiply<_VSTD::ratio<100, 1>,
                                                     nanoseconds::period>>;
 
   // The Windows epoch is Jan 1 1601, the Unix epoch Jan 1 1970.
-  static _LIBCPP_CONSTEXPR const seconds nt_to_unix_epoch{11644473600};
+  static constexpr const seconds nt_to_unix_epoch{11644473600};
 
   FILETIME ft;
 #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8 && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)) || \
     (_WIN32_WINNT >= _WIN32_WINNT_WIN10)
   GetSystemTimePreciseAsFileTime(&ft);
 #elif !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
   GetSystemTimeAsFileTime(&ft);
 #else

libcxx/src/condition_variable.cpp

if (!lk.owns_lock())
         __throw_system_error(EPERM,
                             "condition_variable::timed wait: mutex not locked");
     nanoseconds d = tp.time_since_epoch();
     if (d > nanoseconds(0x59682F000000E941))
         d = nanoseconds(0x59682F000000E941);
     __libcpp_timespec_t ts;
     seconds s = duration_cast<seconds>(d);
     typedef decltype(ts.tv_sec) ts_sec;
-    _LIBCPP_CONSTEXPR ts_sec ts_sec_max = numeric_limits<ts_sec>::max();
+    constexpr ts_sec ts_sec_max = numeric_limits<ts_sec>::max();
     if (s.count() < ts_sec_max)
     {
         ts.tv_sec = static_cast<ts_sec>(s.count());
         ts.tv_nsec = static_cast<decltype(ts.tv_nsec)>((d - s).count());
     }
     else
     {
         ts.tv_sec = ts_sec_max;

libcxx/src/experimental/memory_resource.cpp

 namespace {
 
 union ResourceInitHelper {
   struct {
     __new_delete_memory_resource_imp new_delete_res;
     __null_memory_resource_imp       null_res;
   } resources;
   char dummy;
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 ResourceInitHelper() : resources() {}
+  constexpr ResourceInitHelper() : resources() {}
   ~ResourceInitHelper() {}
 };
 
 // Pretend we're inside a system header so the compiler doesn't flag the use of the init_priority
 // attribute with a value that's reserved for the implementation (we're the implementation).
 #include "memory_resource_init_helper.h"
 
 } // end namespace

libcxx/src/filesystem/error.h

 inline error_code make_windows_error(int err) {
   return make_error_code(__win_err_to_errc(err));
 }
 #endif
 
 template <class T>
 T error_value();
 template <>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX14 void error_value<void>() {}
+inline constexpr void error_value<void>() {}
 template <>
 inline bool error_value<bool>() {
   return false;
 }
 #if __SIZEOF_SIZE_T__ != __SIZEOF_LONG_LONG__
 template <>
 inline size_t error_value<size_t>() {
   return size_t(-1);
 }
 #endif
 template <>
 inline uintmax_t error_value<uintmax_t>() {
   return uintmax_t(-1);
 }
 template <>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX14 file_time_type error_value<file_time_type>() {
+inline constexpr file_time_type error_value<file_time_type>() {
   return file_time_type::min();
 }
 template <>
 inline path error_value<path>() {
   return {};
 }
 
 template <class T>

libcxx/src/filesystem/time_utils.h

struct time_util_base {
 
   static constexpr rep min_nsec_timespec =
       duration_cast<fs_nanoseconds>(
           (FileTimeT::duration::min() - fs_seconds(min_seconds)) +
           fs_seconds(1))
           .count();
 
 private:
-  static _LIBCPP_CONSTEXPR fs_duration get_min_nsecs() {
+  static constexpr fs_duration get_min_nsecs() {
     return duration_cast<fs_duration>(
         fs_nanoseconds(min_nsec_timespec) -
         duration_cast<fs_nanoseconds>(fs_seconds(1)));
   }
   // Static assert that these values properly round trip.
   static_assert(fs_seconds(min_seconds) + get_min_nsecs() ==
                     FileTimeT::duration::min(),
                 "value doesn't roundtrip");
 
-  static _LIBCPP_CONSTEXPR_SINCE_CXX14 bool check_range() {
+  static constexpr bool check_range() {
     // This kinda sucks, but it's what happens when we don't have __int128_t.
     if (sizeof(TimeT) == sizeof(rep)) {
       typedef duration<long long, ratio<3600 * 24 * 365> > Years;
       return duration_cast<Years>(fs_seconds(max_seconds)) > Years(250) &&
              duration_cast<Years>(fs_seconds(min_seconds)) < Years(-250);
     }
     return max_seconds >= numeric_limits<TimeT>::max() &&
            min_seconds <= numeric_limits<TimeT>::min();
struct time_util : time_util_base<FileTimeT, TimeT> {
 
   using typename Base::fs_duration;
   using typename Base::fs_microseconds;
   using typename Base::fs_nanoseconds;
   using typename Base::fs_seconds;
 
 public:
   template <class CType, class ChronoType>
-  static _LIBCPP_CONSTEXPR_SINCE_CXX14 bool checked_set(CType* out,
+  static constexpr bool checked_set(CType* out,
                                                         ChronoType time) {
     using Lim = numeric_limits<CType>;
     if (time > Lim::max() || time < Lim::min())
       return false;
     *out = static_cast<CType>(time);
     return true;
   }
 
-  static _LIBCPP_CONSTEXPR_SINCE_CXX14 bool is_representable(TimeSpecT tm) {
+  static constexpr bool is_representable(TimeSpecT tm) {
     if (tm.tv_sec >= 0) {
       return tm.tv_sec < max_seconds ||
              (tm.tv_sec == max_seconds && tm.tv_nsec <= max_nsec);
     } else if (tm.tv_sec == (min_seconds - 1)) {
       return tm.tv_nsec >= min_nsec_timespec;
     } else {
       return tm.tv_sec >= min_seconds;
     }
   }
 
-  static _LIBCPP_CONSTEXPR_SINCE_CXX14 bool is_representable(FileTimeT tm) {
+  static constexpr bool is_representable(FileTimeT tm) {
     auto secs = duration_cast<fs_seconds>(tm.time_since_epoch());
     auto nsecs = duration_cast<fs_nanoseconds>(tm.time_since_epoch() - secs);
     if (nsecs.count() < 0) {
       secs = secs + fs_seconds(1);
       nsecs = nsecs + fs_seconds(1);
     }
     using TLim = numeric_limits<TimeT>;
     if (secs.count() >= 0)
       return secs.count() <= TLim::max();
     return secs.count() >= TLim::min();
   }
 
-  static _LIBCPP_CONSTEXPR_SINCE_CXX14 FileTimeT
+  static constexpr FileTimeT
   convert_from_timespec(TimeSpecT tm) {
     if (tm.tv_sec >= 0 || tm.tv_nsec == 0) {
       return FileTimeT(fs_seconds(tm.tv_sec) +
                        duration_cast<fs_duration>(fs_nanoseconds(tm.tv_nsec)));
     } else { // tm.tv_sec < 0
       auto adj_subsec = duration_cast<fs_duration>(fs_seconds(1) -
                                                    fs_nanoseconds(tm.tv_nsec));
       auto Dur = fs_seconds(tm.tv_sec + 1) - adj_subsec;
       return FileTimeT(Dur);
     }
   }
 
   template <class SubSecT>
-  static _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+  static constexpr bool
   set_times_checked(TimeT* sec_out, SubSecT* subsec_out, FileTimeT tp) {
     auto dur = tp.time_since_epoch();
     auto sec_dur = duration_cast<fs_seconds>(dur);
     auto subsec_dur = duration_cast<fs_nanoseconds>(dur - sec_dur);
     // The tv_nsec and tv_usec fields must not be negative so adjust accordingly
     if (subsec_dur.count() < 0) {
       if (sec_dur.count() > min_seconds) {
         sec_dur = sec_dur - fs_seconds(1);
         subsec_dur = subsec_dur + fs_seconds(1);
       } else {
         subsec_dur = fs_nanoseconds::zero();
       }
     }
     return checked_set(sec_out, sec_dur.count()) &&
            checked_set(subsec_out, subsec_dur.count());
   }
-  static _LIBCPP_CONSTEXPR_SINCE_CXX14 bool convert_to_timespec(TimeSpecT& dest,
+  static constexpr bool convert_to_timespec(TimeSpecT& dest,
                                                                 FileTimeT tp) {
     if (!is_representable(tp))
       return false;
     return set_times_checked(&dest.tv_sec, &dest.tv_nsec, tp);
   }
 };
 
 #if defined(_LIBCPP_WIN32API)

libcxx/src/locale.cpp

 {
     static typename aligned_storage<sizeof(T)>::type buf;
     auto *obj = ::new (&buf) T(args...);
     return *obj;
 }
 
 template <typename T, size_t N>
 inline
-_LIBCPP_CONSTEXPR
+constexpr
 size_t
 countof(const T (&)[N])
 {
     return N;
 }
 
 template <typename T>
 inline
-_LIBCPP_CONSTEXPR
+constexpr
 size_t
 countof(const T * const begin, const T * const end)
 {
     return static_cast<size_t>(end - begin);
 }
 
 }
 

 extern "C" const int ** __ctype_tolower_loc();
 extern "C" const int ** __ctype_toupper_loc();
 #endif
 
 #ifdef _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE
 const ctype<char>::mask*
 ctype<char>::classic_table() noexcept
 {
-    static _LIBCPP_CONSTEXPR const ctype<char>::mask builtin_table[table_size] = {
+    static constexpr const ctype<char>::mask builtin_table[table_size] = {
         cntrl,                          cntrl,
         cntrl,                          cntrl,
         cntrl,                          cntrl,
         cntrl,                          cntrl,
         cntrl,                          cntrl | space | blank,
         cntrl | space,                  cntrl | space,
         cntrl | space,                  cntrl | space,
         cntrl,                          cntrl,

libcxx/src/memory.cpp

static constinit __libcpp_mutex_t mut_back[__sp_mut_count] =
     _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
     _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
     _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
     _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
     _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
     _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER
 };
 
-_LIBCPP_CONSTEXPR __sp_mut::__sp_mut(void* p) noexcept
+constexpr __sp_mut::__sp_mut(void* p) noexcept
    : __lx_(p)
 {
 }
 
 void
 __sp_mut::lock() noexcept
 {
     auto m = static_cast<__libcpp_mutex_t*>(__lx_);

libcxx/src/memory_resource.cpp

 namespace {
 
 union ResourceInitHelper {
   struct {
     __new_delete_memory_resource_imp new_delete_res;
     __null_memory_resource_imp null_res;
   } resources;
   char dummy;
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 ResourceInitHelper() : resources() {}
+  constexpr ResourceInitHelper() : resources() {}
   ~ResourceInitHelper() {}
 };
 
 // Pretend we're inside a system header so the compiler doesn't flag the use of the init_priority
 // attribute with a value that's reserved for the implementation (we're the implementation).
 #include "memory_resource_init_helper.h"
 
 } // end namespace

libcxx/test/libcxx/input.output/filesystems/class.directory_entry/directory_entry.mods/last_write_time.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03
+// UNSUPPORTED: c++03, c++11
 // UNSUPPORTED: availability-filesystem-missing
 // UNSUPPORTED: no-filesystem
 // ADDITIONAL_COMPILE_FLAGS: -I %S/../../../../../../src
 
 // This test relies on calling functions from the libcxx internal headers
 // of <filesystem>; the Windows implementation uses different
 // internals and doesn't provide the same set_file_times function as for
 // other platforms.