[libc++] Remove C++11 work-arounds in src.

[Mordante]

Summary

Building libcxx requires at least C++17 so remove the old work-arounds.

[Mordante]

Partial revert, since one modification is still required for C++11.

[curdeius]

Isn't it strange that a filesystem test builds the sources with -std=c++11? By source here I mean something under src/, precisely libcxx/src/filesystem/filesystem_common.h.
It seems like a bad separation between the code and the tests.

[Mordante]

In D96200#2546962, @curdeius wrote:

Isn't it strange that a filesystem test builds the sources with -std=c++11? By source here I mean something under src/, precisely libcxx/src/filesystem/filesystem_common.h.
It seems like a bad separation between the code and the tests.

I tend to agree, however this test is a libcxx test and not a std test. So I assume that's the reason it's testing the internals.

[Mordante]

Remove the C++11 comparibility again in filesystem_common.h. Tested with _LIBCPP_CONSTEXPR_AFTER_CXX11 which seems to work locally.

[ldionne]

Thanks!

libcxx/src/experimental/memory_resource.cpp

struct {
     __new_delete_memory_resource_imp new_delete_res;
     __null_memory_resource_imp       null_res;
   } resources;
   char dummy;
   _LIBCPP_CONSTEXPR_AFTER_CXX11 ResourceInitHelper() : resources() {}
   ~ResourceInitHelper() {}
 };
 
-// When compiled in C++14 this initialization should be a constant expression.
-// Only in C++11 is "init_priority" needed to ensure initialization order.
-#if _LIBCPP_STD_VER > 11
-_LIBCPP_SAFE_STATIC
-#endif
-ResourceInitHelper res_init _LIBCPP_INIT_PRIORITY_MAX;
+_LIBCPP_SAFE_STATIC ResourceInitHelper res_init _LIBCPP_INIT_PRIORITY_MAX;
 
 } // end namespace
 
 
 memory_resource * new_delete_resource() _NOEXCEPT {
     return &res_init.resources.new_delete_res;
 }
 

libcxx/src/filesystem/filesystem_common.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:
-#if _LIBCPP_STD_VER > 11 && !defined(_LIBCPP_HAS_NO_CXX14_CONSTEXPR)
-  static constexpr fs_duration get_min_nsecs() {
+  static _LIBCPP_CONSTEXPR_AFTER_CXX11 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 constexpr bool check_range() {
+  static _LIBCPP_CONSTEXPR_AFTER_CXX11 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();
   }
   static_assert(check_range(), "the representable range is unacceptable small");
-#endif
 };
 
 template <class FileTimeT, class TimeT>
 struct time_util_base<FileTimeT, TimeT, true> {
   using rep = typename FileTimeT::rep;
   using fs_duration = typename FileTimeT::duration;
   using fs_seconds = duration<rep>;
   using fs_nanoseconds = duration<rep, nano>;