[libc++][NFC] Qualify declval

[philnik]

Summary

While it's not necessary to qualify calls to declval it makes error messages very crypric if the declaration isn't reachable anymore

For example:

/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:53:66: error: no type named 'type' in 'std::common_type<long, long>'
    typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__type_traits/common_type.h:107:14: note: in instantiation of template class 'std::common_type<std::chrono::duration<long, std::ratio<3600, 1>>, std::chrono::duration<long, std::ratio<3600, 1>>>' requested here
    : public common_type<_Tp, _Tp> {};
             ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:279:58: note: in instantiation of template class 'std::common_type<std::chrono::duration<long, std::ratio<3600, 1>>>' requested here
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
                                                         ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:308:54: note: in instantiation of template class 'std::chrono::duration<long, std::ratio<3600, 1>>' requested here
typedef duration<     int, ratio_multiply<ratio<24>, hours::period>>         days;
                                                     ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:280:81: error: no type named 'type' in 'std::common_type<std::chrono::duration<long, std::ratio<3600, 1>>>'
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);}
                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:308:54: note: in instantiation of template class 'std::chrono::duration<long, std::ratio<3600, 1>>' requested here
typedef duration<     int, ratio_multiply<ratio<24>, hours::period>>         days;
                                                     ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:53:66: error: no type named 'type' in 'std::common_type<int, int>'
    typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__type_traits/common_type.h:107:14: note: in instantiation of template class 'std::common_type<std::chrono::duration<int, std::ratio<86400, 1>>, std::chrono::duration<int, std::ratio<86400, 1>>>' requested here
    : public common_type<_Tp, _Tp> {};
             ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:279:58: note: in instantiation of template class 'std::common_type<std::chrono::duration<int, std::ratio<86400, 1>>>' requested here
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
                                                         ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:309:55: note: in instantiation of template class 'std::chrono::duration<int, std::ratio<86400, 1>>' requested here
typedef duration<     int, ratio_multiply<ratio<7>,   days::period>>         weeks;
                                                      ^
19 similar errors omitted

changes with qualification added to:

While building module 'std' imported from /home/nikolask/llvm-projects/libcxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp:13:
In file included from <module-includes>:17:
In file included from /home/nikolask/llvm-projects/libcxx/build/include/c++/v1/math.h:309:
In file included from /home/nikolask/llvm-projects/libcxx/build/include/c++/v1/limits:107:
In file included from /home/nikolask/llvm-projects/libcxx/build/include/c++/v1/type_traits:432:
In file included from /home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__type_traits/common_reference.h:13:
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__type_traits/common_type.h:28:43: error: declaration of 'declval' must be imported from module 'std.utility.__utility.declval' before it is required
using __cond_type = decltype(false ? std::declval<_Tp>() : std::declval<_Up>());
                                          ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__utility/declval.h:30:34: note: declaration here is not visible
decltype(std::__declval<_Tp>(0)) declval() _NOEXCEPT;
                                 ^
/home/nikolask/llvm-projects/libcxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp:13:10: fatal error: could not build module 'std'
#include <functional>
 ~~~~~~~~^
2 errors generated.

[Mordante]

Can you update the commit message with a before and after, showing the improvement?
That makes the reason for the change less "cryptic".

SGTM modulo some nits. I really want to have a second look, mainly to make sure I didn't miss some places in this review.

libcxx/include/__iterator/move_iterator.h

52

libcxx/include/__memory/construct_at.h

32

40

libcxx/include/__memory/ranges_construct_at.h

41

libcxx/include/__utility/declval.h

30

This looks off, you only ADL-proved the call to __declval. (This isn't needed, but I don't object against this change.)

[philnik]

• Address comments

[philnik]

I don't know if this should go into the commit message. It's a bit wordy.
When removing qualifications and the include from __type_traits/common_type.h, running std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp results in

/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:53:66: error: no type named 'type' in 'std::common_type<long, long>'
    typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__type_traits/common_type.h:107:14: note: in instantiation of template class 'std::common_type<std::chrono::duration<long, std::ratio<3600, 1>>, std::chrono::duration<long, std::ratio<3600, 1>>>' requested here
    : public common_type<_Tp, _Tp> {};
             ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:279:58: note: in instantiation of template class 'std::common_type<std::chrono::duration<long, std::ratio<3600, 1>>>' requested here
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
                                                         ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:308:54: note: in instantiation of template class 'std::chrono::duration<long, std::ratio<3600, 1>>' requested here
typedef duration<     int, ratio_multiply<ratio<24>, hours::period>>         days;
                                                     ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:280:81: error: no type named 'type' in 'std::common_type<std::chrono::duration<long, std::ratio<3600, 1>>>'
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);}
                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:308:54: note: in instantiation of template class 'std::chrono::duration<long, std::ratio<3600, 1>>' requested here
typedef duration<     int, ratio_multiply<ratio<24>, hours::period>>         days;
                                                     ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:53:66: error: no type named 'type' in 'std::common_type<int, int>'
    typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__type_traits/common_type.h:107:14: note: in instantiation of template class 'std::common_type<std::chrono::duration<int, std::ratio<86400, 1>>, std::chrono::duration<int, std::ratio<86400, 1>>>' requested here
    : public common_type<_Tp, _Tp> {};
             ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:279:58: note: in instantiation of template class 'std::common_type<std::chrono::duration<int, std::ratio<86400, 1>>>' requested here
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
                                                         ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:309:55: note: in instantiation of template class 'std::chrono::duration<int, std::ratio<86400, 1>>' requested here
typedef duration<     int, ratio_multiply<ratio<7>,   days::period>>         weeks;
                                                      ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:280:81: error: no type named 'type' in 'std::common_type<std::chrono::duration<int, std::ratio<86400, 1>>>'
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);}
                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:309:55: note: in instantiation of template class 'std::chrono::duration<int, std::ratio<86400, 1>>' requested here
typedef duration<     int, ratio_multiply<ratio<7>,   days::period>>         weeks;
                                                      ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:53:66: error: no type named 'type' in 'std::common_type<int, int>'
    typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__type_traits/common_type.h:107:14: note: in instantiation of template class 'std::common_type<std::chrono::duration<int, std::ratio<31556952, 1>>, std::chrono::duration<int, std::ratio<31556952, 1>>>' requested here
    : public common_type<_Tp, _Tp> {};
             ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:279:58: note: in instantiation of template class 'std::common_type<std::chrono::duration<int, std::ratio<31556952, 1>>>' requested here
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
                                                         ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:311:41: note: in instantiation of template class 'std::chrono::duration<int, std::ratio<31556952, 1>>' requested here
typedef duration<     int, ratio_divide<years::period, ratio<12>>>           months;
                                        ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:280:81: error: no type named 'type' in 'std::common_type<std::chrono::duration<int, std::ratio<31556952, 1>>>'
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);}
                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:311:41: note: in instantiation of template class 'std::chrono::duration<int, std::ratio<31556952, 1>>' requested here
typedef duration<     int, ratio_divide<years::period, ratio<12>>>           months;
                                        ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:53:66: error: no type named 'type' in 'std::common_type<long double, long double>'
    typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__type_traits/common_type.h:107:14: note: in instantiation of template class 'std::common_type<std::chrono::duration<long double, std::ratio<3600, 1>>, std::chrono::duration<long double, std::ratio<3600, 1>>>' requested here
    : public common_type<_Tp, _Tp> {};
             ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:279:58: note: in instantiation of template class 'std::common_type<std::chrono::duration<long double, std::ratio<3600, 1>>>' requested here
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
                                                         ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:542:60: note: in instantiation of template class 'std::chrono::duration<long double, std::ratio<3600, 1>>' requested here
    constexpr chrono::duration<long double, ratio<3600,1>> operator""h(long double __h)
                                                           ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:280:81: error: no type named 'type' in 'std::common_type<std::chrono::duration<long double, std::ratio<3600, 1>>>'
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);}
                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:542:60: note: in instantiation of template class 'std::chrono::duration<long double, std::ratio<3600, 1>>' requested here
    constexpr chrono::duration<long double, ratio<3600,1>> operator""h(long double __h)
                                                           ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:53:66: error: no type named 'type' in 'std::common_type<long, long>'
    typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__type_traits/common_type.h:107:14: note: in instantiation of template class 'std::common_type<std::chrono::duration<long, std::ratio<60, 1>>, std::chrono::duration<long, std::ratio<60, 1>>>' requested here
    : public common_type<_Tp, _Tp> {};
             ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:279:58: note: in instantiation of template class 'std::common_type<std::chrono::duration<long, std::ratio<60, 1>>>' requested here
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
                                                         ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:548:31: note: in instantiation of template class 'std::chrono::duration<long, std::ratio<60, 1>>' requested here
    constexpr chrono::minutes operator""min(unsigned long long __m)
                              ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:280:81: error: no type named 'type' in 'std::common_type<std::chrono::duration<long, std::ratio<60, 1>>>'
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);}
                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:548:31: note: in instantiation of template class 'std::chrono::duration<long, std::ratio<60, 1>>' requested here
    constexpr chrono::minutes operator""min(unsigned long long __m)
                              ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:53:66: error: no type named 'type' in 'std::common_type<long double, long double>'
    typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__type_traits/common_type.h:107:14: note: in instantiation of template class 'std::common_type<std::chrono::duration<long double, std::ratio<60, 1>>, std::chrono::duration<long double, std::ratio<60, 1>>>' requested here
    : public common_type<_Tp, _Tp> {};
             ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:279:58: note: in instantiation of template class 'std::common_type<std::chrono::duration<long double, std::ratio<60, 1>>>' requested here
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
                                                         ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:553:58: note: in instantiation of template class 'std::chrono::duration<long double, std::ratio<60, 1>>' requested here
    constexpr chrono::duration<long double, ratio<60,1>> operator""min(long double __m)
                                                         ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:280:81: error: no type named 'type' in 'std::common_type<std::chrono::duration<long double, std::ratio<60, 1>>>'
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);}
                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:553:58: note: in instantiation of template class 'std::chrono::duration<long double, std::ratio<60, 1>>' requested here
    constexpr chrono::duration<long double, ratio<60,1>> operator""min(long double __m)
                                                         ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:53:66: error: no type named 'type' in 'std::common_type<long long, long long>'
    typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__type_traits/common_type.h:107:14: note: in instantiation of template class 'std::common_type<std::chrono::duration<long long>, std::chrono::duration<long long>>' requested here
    : public common_type<_Tp, _Tp> {};
             ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:279:58: note: in instantiation of template class 'std::common_type<std::chrono::duration<long long>>' requested here
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
                                                         ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:559:31: note: in instantiation of template class 'std::chrono::duration<long long>' requested here
    constexpr chrono::seconds operator""s(unsigned long long __s)
                              ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:280:81: error: no type named 'type' in 'std::common_type<std::chrono::duration<long long>>'
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);}
                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:559:31: note: in instantiation of template class 'std::chrono::duration<long long>' requested here
    constexpr chrono::seconds operator""s(unsigned long long __s)
                              ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:53:66: error: no type named 'type' in 'std::common_type<long double, long double>'
    typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__type_traits/common_type.h:107:14: note: in instantiation of template class 'std::common_type<std::chrono::duration<long double>, std::chrono::duration<long double>>' requested here
    : public common_type<_Tp, _Tp> {};
             ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:279:58: note: in instantiation of template class 'std::common_type<std::chrono::duration<long double>>' requested here
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
                                                         ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:564:45: note: in instantiation of template class 'std::chrono::duration<long double>' requested here
    constexpr chrono::duration<long double> operator""s(long double __s)
                                            ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:280:81: error: no type named 'type' in 'std::common_type<std::chrono::duration<long double>>'
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);}
                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:564:45: note: in instantiation of template class 'std::chrono::duration<long double>' requested here
    constexpr chrono::duration<long double> operator""s(long double __s)
                                            ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:53:66: error: no type named 'type' in 'std::common_type<long long, long long>'
    typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__type_traits/common_type.h:107:14: note: in instantiation of template class 'std::common_type<std::chrono::duration<long long, std::ratio<1, 1000>>, std::chrono::duration<long long, std::ratio<1, 1000>>>' requested here
    : public common_type<_Tp, _Tp> {};
             ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:279:58: note: in instantiation of template class 'std::common_type<std::chrono::duration<long long, std::ratio<1, 1000>>>' requested here
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
                                                         ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:570:36: note: in instantiation of template class 'std::chrono::duration<long long, std::ratio<1, 1000>>' requested here
    constexpr chrono::milliseconds operator""ms(unsigned long long __ms)
                                   ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:280:81: error: no type named 'type' in 'std::common_type<std::chrono::duration<long long, std::ratio<1, 1000>>>'
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);}
                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:570:36: note: in instantiation of template class 'std::chrono::duration<long long, std::ratio<1, 1000>>' requested here
    constexpr chrono::milliseconds operator""ms(unsigned long long __ms)
                                   ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:53:66: error: no type named 'type' in 'std::common_type<long double, long double>'
    typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__type_traits/common_type.h:107:14: note: in instantiation of template class 'std::common_type<std::chrono::duration<long double, std::ratio<1, 1000>>, std::chrono::duration<long double, std::ratio<1, 1000>>>' requested here
    : public common_type<_Tp, _Tp> {};
             ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:279:58: note: in instantiation of template class 'std::common_type<std::chrono::duration<long double, std::ratio<1, 1000>>>' requested here
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
                                                         ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:575:52: note: in instantiation of template class 'std::chrono::duration<long double, std::ratio<1, 1000>>' requested here
    constexpr chrono::duration<long double, milli> operator""ms(long double __ms)
                                                   ^
fatal error: too many errors emitted, stopping now [-ferror-limit=]
/home/nikolask/llvm-projects/libcxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp:13:10: fatal error: could not build module 'std'
#include <functional>
 ~~~~~~~~^
21 errors generated.

Adding qualifications results in

While building module 'std' imported from /home/nikolask/llvm-projects/libcxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp:13:
In file included from <module-includes>:17:
In file included from /home/nikolask/llvm-projects/libcxx/build/include/c++/v1/math.h:309:
In file included from /home/nikolask/llvm-projects/libcxx/build/include/c++/v1/limits:107:
In file included from /home/nikolask/llvm-projects/libcxx/build/include/c++/v1/type_traits:432:
In file included from /home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__type_traits/common_reference.h:13:
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__type_traits/common_type.h:28:43: error: declaration of 'declval' must be imported from module 'std.utility.__utility.declval' before it is required
using __cond_type = decltype(false ? std::declval<_Tp>() : std::declval<_Up>());
                                          ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__utility/declval.h:30:34: note: declaration here is not visible
decltype(std::__declval<_Tp>(0)) declval() _NOEXCEPT;
                                 ^
/home/nikolask/llvm-projects/libcxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp:13:10: fatal error: could not build module 'std'
#include <functional>
 ~~~~~~~~^
2 errors generated.

libcxx/include/__utility/declval.h

30

Are you asking for something? What else should I have ADL-proofed here?

[Mordante]

LGTM, but I spotted one more missing std.

In D130854#3701255, @philnik wrote:

I don't know if this should go into the commit message. It's a bit wordy.
When removing qualifications and the include from __type_traits/common_type.h, running std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp results in

Maybe something like

/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:53:66: error: no type named 'type' in 'std::common_type<long, long>'
    typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__type_traits/common_type.h:107:14: note: in instantiation of template class 'std::common_type<std::chrono::duration<long, std::ratio<3600, 1>>, std::chrono::duration<long, std::ratio<3600, 1>>>' requested here
    : public common_type<_Tp, _Tp> {};
             ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:279:58: note: in instantiation of template class 'std::common_type<std::chrono::duration<long, std::ratio<3600, 1>>>' requested here
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
                                                         ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:308:54: note: in instantiation of template class 'std::chrono::duration<long, std::ratio<3600, 1>>' requested here
typedef duration<     int, ratio_multiply<ratio<24>, hours::period>>         days;
                                                     ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:280:81: error: no type named 'type' in 'std::common_type<std::chrono::duration<long, std::ratio<3600, 1>>>'
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);}
                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:308:54: note: in instantiation of template class 'std::chrono::duration<long, std::ratio<3600, 1>>' requested here
typedef duration<     int, ratio_multiply<ratio<24>, hours::period>>         days;
                                                     ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:53:66: error: no type named 'type' in 'std::common_type<int, int>'
    typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__type_traits/common_type.h:107:14: note: in instantiation of template class 'std::common_type<std::chrono::duration<int, std::ratio<86400, 1>>, std::chrono::duration<int, std::ratio<86400, 1>>>' requested here
    : public common_type<_Tp, _Tp> {};
             ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:279:58: note: in instantiation of template class 'std::common_type<std::chrono::duration<int, std::ratio<86400, 1>>>' requested here
    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
                                                         ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__chrono/duration.h:309:55: note: in instantiation of template class 'std::chrono::duration<int, std::ratio<86400, 1>>' requested here
typedef duration<     int, ratio_multiply<ratio<7>,   days::period>>         weeks;
                                                      ^
19 similar errors omitted

Adding qualifications results in

While building module 'std' imported from /home/nikolask/llvm-projects/libcxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp:13:
In file included from <module-includes>:17:
In file included from /home/nikolask/llvm-projects/libcxx/build/include/c++/v1/math.h:309:
In file included from /home/nikolask/llvm-projects/libcxx/build/include/c++/v1/limits:107:
In file included from /home/nikolask/llvm-projects/libcxx/build/include/c++/v1/type_traits:432:
In file included from /home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__type_traits/common_reference.h:13:
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__type_traits/common_type.h:28:43: error: declaration of 'declval' must be imported from module 'std.utility.__utility.declval' before it is required
using __cond_type = decltype(false ? std::declval<_Tp>() : std::declval<_Up>());
                                          ^
/home/nikolask/llvm-projects/libcxx/build/include/c++/v1/__utility/declval.h:30:34: note: declaration here is not visible
decltype(std::__declval<_Tp>(0)) declval() _NOEXCEPT;
                                 ^
/home/nikolask/llvm-projects/libcxx/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp:13:10: fatal error: could not build module 'std'
#include <functional>
 ~~~~~~~~^
2 errors generated.

Both have 2 errors and I really prefer the latter... especially since there were 21 instead of 2 before.
This is really a nice improvement for the error messages.

libcxx/include/__memory/allocator_traits.h

214

libcxx/include/__utility/declval.h

30

Nevermind I misread, this declval shouldn't be std::declval.

[philnik]

• Add another one

[Mordante]

I noticed declval is misspelled in the commit title, can you update that before landing?

[ldionne]

LGTM, but the only problem I have with the patch is that there's currently no way of enforcing it. Can we investigate adding a test for this (maybe with clang-query)? Otherwise, we can just grep our headers with something like grep -E 'declval<' -R libcxx/include | grep -v -E 'std::declval<'. Otherwise, I think it's definitely possible to come up with a single regex to do it, using negative lookahead, but I'm not sure all regex engines support it.

[Mordante]

In D130854#3716616, @ldionne wrote:

LGTM, but the only problem I have with the patch is that there's currently no way of enforcing it. Can we investigate adding a test for this (maybe with clang-query)? Otherwise, we can just grep our headers with something like grep -E 'declval<' -R libcxx/include | grep -v -E 'std::declval<'. Otherwise, I think it's definitely possible to come up with a single regex to do it, using negative lookahead, but I'm not sure all regex engines support it.

I would prefer to use clang-query over grep, I noticed in the past that grep based tooling evaluates code in comments.

[philnik]

Address comments

libcxx/include/__concepts/common_with.h

 #if _LIBCPP_STD_VER > 17
 
 // [concept.common]
 
 template<class _Tp, class _Up>
 concept common_with =
   same_as<common_type_t<_Tp, _Up>, common_type_t<_Up, _Tp>> &&
   requires {
-    static_cast<common_type_t<_Tp, _Up>>(declval<_Tp>());
-    static_cast<common_type_t<_Tp, _Up>>(declval<_Up>());
+    static_cast<common_type_t<_Tp, _Up>>(std::declval<_Tp>());
+    static_cast<common_type_t<_Tp, _Up>>(std::declval<_Up>());
   } &&
   common_reference_with<
     add_lvalue_reference_t<const _Tp>,
     add_lvalue_reference_t<const _Up>> &&
   common_reference_with<
     add_lvalue_reference_t<common_type_t<_Tp, _Up>>,
     common_reference_t<
       add_lvalue_reference_t<const _Tp>,
       add_lvalue_reference_t<const _Up>>>;
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___CONCEPTS_COMMON_WITH_H

libcxx/include/__concepts/convertible_to.h

 #if _LIBCPP_STD_VER > 17
 
 // [concept.convertible]
 
 template<class _From, class _To>
 concept convertible_to =
   is_convertible_v<_From, _To> &&
   requires {
-    static_cast<_To>(declval<_From>());
+    static_cast<_To>(std::declval<_From>());
   };
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___CONCEPTS_CONVERTIBLE_TO_H

libcxx/include/__functional/invoke.h

__invoke(_Fp&& __f, _Args&& ...__args)
     _NOEXCEPT_(noexcept(static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...)))
     { return          static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...); }
 
 // __invokable
 template <class _Ret, class _Fp, class ..._Args>
 struct __invokable_r
 {
   template <class _XFp, class ..._XArgs>
-  static decltype(std::__invoke(declval<_XFp>(), declval<_XArgs>()...)) __try_call(int);
+  static decltype(std::__invoke(std::declval<_XFp>(), std::declval<_XArgs>()...)) __try_call(int);
   template <class _XFp, class ..._XArgs>
   static __nat __try_call(...);
 
   // FIXME: Check that _Ret, _Fp, and _Args... are all complete types, cv void,
   // or incomplete array types as required by the standard.
   using _Result = decltype(__try_call<_Fp, _Args...>(0));
 
   using type = typename conditional<

 struct __nothrow_invokable_r_imp<true, false, _Ret, _Fp, _Args...>
 {
     typedef __nothrow_invokable_r_imp _ThisT;
 
     template <class _Tp>
     static void __test_noexcept(_Tp) _NOEXCEPT;
 
     static const bool value = noexcept(_ThisT::__test_noexcept<_Ret>(
-        _VSTD::__invoke(declval<_Fp>(), declval<_Args>()...)));
+        _VSTD::__invoke(std::declval<_Fp>(), std::declval<_Args>()...)));
 };
 
 template <class _Ret, class _Fp, class ..._Args>
 struct __nothrow_invokable_r_imp<true, true, _Ret, _Fp, _Args...>
 {
     static const bool value = noexcept(
-        _VSTD::__invoke(declval<_Fp>(), declval<_Args>()...));
+        _VSTD::__invoke(std::declval<_Fp>(), std::declval<_Args>()...));
 };
 
 template <class _Ret, class _Fp, class ..._Args>
 using __nothrow_invokable_r =
     __nothrow_invokable_r_imp<
             __invokable_r<_Ret, _Fp, _Args...>::value,
             is_void<_Ret>::value,
             _Ret, _Fp, _Args...

libcxx/include/__functional/reference_wrapper.h

public:
     typedef _Tp type;
 private:
     type* __f_;
 
     static void __fun(_Tp&) _NOEXCEPT;
     static void __fun(_Tp&&) = delete;
 
 public:
-    template <class _Up, class = __enable_if_t<!__is_same_uncvref<_Up, reference_wrapper>::value, decltype(__fun(declval<_Up>())) > >
+    template <class _Up, class = __enable_if_t<!__is_same_uncvref<_Up, reference_wrapper>::value, decltype(__fun(std::declval<_Up>())) > >
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-    reference_wrapper(_Up&& __u) _NOEXCEPT_(noexcept(__fun(declval<_Up>()))) {
+    reference_wrapper(_Up&& __u) _NOEXCEPT_(noexcept(__fun(std::declval<_Up>()))) {
         type& __f = static_cast<_Up&&>(__u);
         __f_ = _VSTD::addressof(__f);
     }
 
     // access
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     operator type&() const _NOEXCEPT {return *__f_;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17

libcxx/include/__functional/weak_result_type.h

 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
     using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
 #endif
 };
 
 template <class _Tp, class ..._Args>
 struct __invoke_return
 {
-    typedef decltype(_VSTD::__invoke(declval<_Tp>(), declval<_Args>()...)) type;
+    typedef decltype(_VSTD::__invoke(std::declval<_Tp>(), std::declval<_Args>()...)) type;
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FUNCTIONAL_WEAK_RESULT_TYPE_H

libcxx/include/__iterator/advance.h

 template <class _RandIter>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
 void __advance(_RandIter& __i, typename iterator_traits<_RandIter>::difference_type __n, random_access_iterator_tag) {
   __i += __n;
 }
 
 template <
     class _InputIter, class _Distance,
-    class _IntegralDistance = decltype(_VSTD::__convert_to_integral(declval<_Distance>())),
+    class _IntegralDistance = decltype(_VSTD::__convert_to_integral(std::declval<_Distance>())),
     class = __enable_if_t<is_integral<_IntegralDistance>::value> >
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
 void advance(_InputIter& __i, _Distance __orig_n) {
   typedef typename iterator_traits<_InputIter>::difference_type _Difference;
   _Difference __n = static_cast<_Difference>(_VSTD::__convert_to_integral(__orig_n));
   _LIBCPP_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
                  "Attempt to advance(it, n) with negative n on a non-bidirectional iterator");
   _VSTD::__advance(__i, __n, typename iterator_traits<_InputIter>::iterator_category());

libcxx/include/__iterator/incrementable_traits.h

 concept __has_integral_minus =
   requires(const _Tp& __x, const _Tp& __y) {
     { __x - __y } -> integral;
   };
 
 template<__has_integral_minus _Tp>
 requires (!__has_member_difference_type<_Tp>)
 struct incrementable_traits<_Tp> {
-  using difference_type = make_signed_t<decltype(declval<_Tp>() - declval<_Tp>())>;
+  using difference_type = make_signed_t<decltype(std::declval<_Tp>() - std::declval<_Tp>())>;
 };
 
 template <class>
 struct iterator_traits;
 
 // Let `RI` be `remove_cvref_t<I>`. The type `iter_difference_t<I>` denotes
 // `incrementable_traits<RI>::difference_type` if `iterator_traits<RI>` names a specialization
 // generated from the primary template, and `iterator_traits<RI>::difference_type` otherwise.

libcxx/include/__iterator/move_iterator.h

using iterator_category = _If<
         derived_from<typename iterator_traits<_Iter>::iterator_category, random_access_iterator_tag>,
         random_access_iterator_tag,
         typename iterator_traits<_Iter>::iterator_category
     >;
 };
 
 template<class _Iter, class _Sent>
 concept __move_iter_comparable = requires {
-    { declval<const _Iter&>() == declval<_Sent>() } -> convertible_to<bool>;
+    { std::declval<const _Iter&>() == std::declval<_Sent>() } -> convertible_to<bool>;
 };
 #endif // _LIBCPP_STD_VER > 17
 
 template <class _Iter>
 class _LIBCPP_TEMPLATE_VIS move_iterator
 #if _LIBCPP_STD_VER > 17
     : public __move_iter_category_base<_Iter>
 #endif

libcxx/include/__memory/allocator_traits.h

 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 
 // __has_allocate_hint
 template <class _Alloc, class _SizeType, class _ConstVoidPtr, class = void>
 struct __has_allocate_hint : false_type { };
 
 template <class _Alloc, class _SizeType, class _ConstVoidPtr>
 struct __has_allocate_hint<_Alloc, _SizeType, _ConstVoidPtr, decltype(
-    (void)declval<_Alloc>().allocate(declval<_SizeType>(), declval<_ConstVoidPtr>())
+    (void)std::declval<_Alloc>().allocate(std::declval<_SizeType>(), std::declval<_ConstVoidPtr>())
 )> : true_type { };
 
 // __has_construct
 template <class, class _Alloc, class ..._Args>
 struct __has_construct_impl : false_type { };
 
 template <class _Alloc, class ..._Args>
 struct __has_construct_impl<decltype(
-    (void)declval<_Alloc>().construct(declval<_Args>()...)
+    (void)std::declval<_Alloc>().construct(std::declval<_Args>()...)
 ), _Alloc, _Args...> : true_type { };
 
 template <class _Alloc, class ..._Args>
 struct __has_construct : __has_construct_impl<void, _Alloc, _Args...> { };
 
 // __has_destroy
 template <class _Alloc, class _Pointer, class = void>
 struct __has_destroy : false_type { };
 
 template <class _Alloc, class _Pointer>
 struct __has_destroy<_Alloc, _Pointer, decltype(
-    (void)declval<_Alloc>().destroy(declval<_Pointer>())
+    (void)std::declval<_Alloc>().destroy(std::declval<_Pointer>())
 )> : true_type { };
 
 // __has_max_size
 template <class _Alloc, class = void>
 struct __has_max_size : false_type { };
 
 template <class _Alloc>
 struct __has_max_size<_Alloc, decltype(
     (void)declval<_Alloc&>().max_size()
 )> : true_type { };
 
 // __has_select_on_container_copy_construction
 template <class _Alloc, class = void>
 struct __has_select_on_container_copy_construction : false_type { };
 
 template <class _Alloc>
 struct __has_select_on_container_copy_construction<_Alloc, decltype(
-    (void)declval<_Alloc>().select_on_container_copy_construction()
+    (void)std::declval<_Alloc>().select_on_container_copy_construction()
 )> : true_type { };
 
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 template <class _Alloc>
 struct _LIBCPP_TEMPLATE_VIS allocator_traits
 {
     using allocator_type = _Alloc;

libcxx/include/__memory/construct_at.h

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // construct_at
 
 #if _LIBCPP_STD_VER > 17
 
-template <class _Tp, class... _Args, class = decltype(::new(declval<void*>()) _Tp(declval<_Args>()...))>
+template <class _Tp, class... _Args, class = decltype(::new(std::declval<void*>()) _Tp(std::declval<_Args>()...))>
 _LIBCPP_HIDE_FROM_ABI constexpr _Tp* construct_at(_Tp* __location, _Args&&... __args) {
   _LIBCPP_ASSERT(__location != nullptr, "null pointer given to construct_at");
   return ::new (_VSTD::__voidify(*__location)) _Tp(_VSTD::forward<_Args>(__args)...);
 }
 
 #endif
 
-template <class _Tp, class... _Args, class = decltype(::new(declval<void*>()) _Tp(declval<_Args>()...))>
+template <class _Tp, class... _Args, class = decltype(::new(std::declval<void*>()) _Tp(std::declval<_Args>()...))>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Tp* __construct_at(_Tp* __location, _Args&&... __args) {
 #if _LIBCPP_STD_VER > 17
   return std::construct_at(__location, std::forward<_Args>(__args)...);
 #else
   return _LIBCPP_ASSERT(__location != nullptr, "null pointer given to construct_at"),
          ::new (std::__voidify(*__location)) _Tp(std::forward<_Args>(__args)...);
 #endif
 }

libcxx/include/__memory/ranges_construct_at.h

 namespace ranges {
 
 // construct_at
 
 namespace __construct_at {
 
 struct __fn {
   template<class _Tp, class... _Args, class = decltype(
-    ::new (declval<void*>()) _Tp(declval<_Args>()...)
+    ::new (std::declval<void*>()) _Tp(std::declval<_Args>()...)
   )>
   _LIBCPP_HIDE_FROM_ABI
   constexpr _Tp* operator()(_Tp* __location, _Args&& ...__args) const {
     return _VSTD::construct_at(__location, _VSTD::forward<_Args>(__args)...);
   }
 };
 
 } // namespace __construct_at

libcxx/include/__memory/shared_ptr.h

#if _LIBCPP_STD_VER > 14
     : is_convertible<remove_extent_t<_Tp>*, remove_extent_t<_Up>*> {};
 #else
     : is_convertible<_Tp*, _Up*> {};
 #endif // _LIBCPP_STD_VER > 14
 
 template <class _Ptr, class = void>
 struct __is_deletable : false_type { };
 template <class _Ptr>
-struct __is_deletable<_Ptr, decltype(delete declval<_Ptr>())> : true_type { };
+struct __is_deletable<_Ptr, decltype(delete std::declval<_Ptr>())> : true_type { };
 
 template <class _Ptr, class = void>
 struct __is_array_deletable : false_type { };
 template <class _Ptr>
-struct __is_array_deletable<_Ptr, decltype(delete[] declval<_Ptr>())> : true_type { };
+struct __is_array_deletable<_Ptr, decltype(delete[] std::declval<_Ptr>())> : true_type { };
 
 template <class _Dp, class _Pt,
-    class = decltype(declval<_Dp>()(declval<_Pt>()))>
+    class = decltype(std::declval<_Dp>()(std::declval<_Pt>()))>
 static true_type __well_formed_deleter_test(int);
 
 template <class, class>
 static false_type __well_formed_deleter_test(...);
 
 template <class _Dp, class _Pt>
 struct __well_formed_deleter : decltype(__well_formed_deleter_test<_Dp, _Pt>(0)) {};
 

libcxx/include/__ranges/all.h

namespace __all {
   };
 } // namespace __all
 
 inline namespace __cpo {
   inline constexpr auto all = __all::__fn{};
 } // namespace __cpo
 
 template<ranges::viewable_range _Range>
-using all_t = decltype(views::all(declval<_Range>()));
+using all_t = decltype(views::all(std::declval<_Range>()));
 
 } // namespace ranges::views
 
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_ALL_H

libcxx/include/__ranges/ref_view.h

class ref_view : public view_interface<ref_view<_Range>> {
     _Range *__range_;
 
     static void __fun(_Range&);
     static void __fun(_Range&&) = delete;
 
 public:
     template<class _Tp>
       requires __different_from<_Tp, ref_view> &&
-        convertible_to<_Tp, _Range&> && requires { __fun(declval<_Tp>()); }
+        convertible_to<_Tp, _Range&> && requires { __fun(std::declval<_Tp>()); }
     _LIBCPP_HIDE_FROM_ABI
     constexpr ref_view(_Tp&& __t)
       : __range_(std::addressof(static_cast<_Range&>(std::forward<_Tp>(__t))))
     {}
 
     _LIBCPP_HIDE_FROM_ABI constexpr _Range& base() const { return *__range_; }
 
     _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Range> begin() const { return ranges::begin(*__range_); }

libcxx/include/__ranges/size.h

 
 template <class _Tp>
 concept __difference =
   !__member_size<_Tp> &&
   !__unqualified_size<_Tp> &&
   __class_or_enum<remove_cvref_t<_Tp>> &&
   requires(_Tp&& __t) {
     { ranges::begin(__t) } -> forward_iterator;
-    { ranges::end(__t) } -> sized_sentinel_for<decltype(ranges::begin(declval<_Tp>()))>;
+    { ranges::end(__t) } -> sized_sentinel_for<decltype(ranges::begin(std::declval<_Tp>()))>;
   };
 
 struct __fn {
 
   // `[range.prim.size]`: the array case (for rvalues).
   template <class _Tp, size_t _Sz>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr size_t operator()(_Tp (&&)[_Sz]) const noexcept {
     return _Sz;

libcxx/include/__type_traits/common_type.h

 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 // Let COND_RES(X, Y) be:
 template <class _Tp, class _Up>
-using __cond_type = decltype(false ? declval<_Tp>() : declval<_Up>());
+using __cond_type = decltype(false ? std::declval<_Tp>() : std::declval<_Up>());
 
 template <class _Tp, class _Up, class = void>
 struct __common_type3 {};
 
 // sub-bullet 4 - "if COND_RES(CREF(D1), CREF(D2)) denotes a type..."
 template <class _Tp, class _Up>
 struct __common_type3<_Tp, _Up, void_t<__cond_type<const _Tp&, const _Up&>>>
 {
     using type = remove_cvref_t<__cond_type<const _Tp&, const _Up&>>;
 };
 
 template <class _Tp, class _Up, class = void>
 struct __common_type2_imp : __common_type3<_Tp, _Up> {};
 #else
 template <class _Tp, class _Up, class = void>
 struct __common_type2_imp {};
 #endif
 
 // sub-bullet 3 - "if decay_t<decltype(false ? declval<D1>() : declval<D2>())> ..."
 template <class _Tp, class _Up>
 struct __common_type2_imp<_Tp, _Up,
                           typename __void_t<decltype(
-                                            true ? declval<_Tp>() : declval<_Up>()
+                                            true ? std::declval<_Tp>() : std::declval<_Up>()
                                             )>::type>
 {
   typedef _LIBCPP_NODEBUG typename decay<decltype(
-                         true ? declval<_Tp>() : declval<_Up>()
+                         true ? std::declval<_Tp>() : std::declval<_Up>()
                          )>::type type;
 };
 
 template <class, class = void>
 struct __common_type_impl {};
 
 // Clang provides variadic templates in C++03 as an extension.
 #if !defined(_LIBCPP_CXX03_LANG) || defined(__clang__)

libcxx/include/__type_traits/is_assignable.h

 #if _LIBCPP_STD_VER > 14
 template <class _Tp, class _Arg>
 inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Arg);
 #endif
 
 #else // __has_builtin(__is_assignable)
 
 template <class _Tp, class _Arg>
-typename __select_2nd<decltype((declval<_Tp>() = declval<_Arg>())), true_type>::type
+typename __select_2nd<decltype((std::declval<_Tp>() = std::declval<_Arg>())), true_type>::type
 __is_assignable_test(int);
 
 template <class, class>
 false_type __is_assignable_test(...);
 
 
 template <class _Tp, class _Arg, bool = is_void<_Tp>::value || is_void<_Arg>::value>
 struct __is_assignable_imp

libcxx/include/__type_traits/is_convertible.h

 {
 template <class _Tp> void  __test_convert(_Tp);
 
 template <class _From, class _To, class = void>
 struct __is_convertible_test : public false_type {};
 
 template <class _From, class _To>
 struct __is_convertible_test<_From, _To,
-    decltype(__is_convertible_imp::__test_convert<_To>(declval<_From>()))> : public true_type
+    decltype(__is_convertible_imp::__test_convert<_To>(std::declval<_From>()))> : public true_type
 {};
 
 template <class _Tp, bool _IsArray =    is_array<_Tp>::value,
                      bool _IsFunction = is_function<_Tp>::value,
                      bool _IsVoid =     is_void<_Tp>::value>
                      struct __is_array_function_or_void                          {enum {value = 0};};
 template <class _Tp> struct __is_array_function_or_void<_Tp, true, false, false> {enum {value = 1};};
 template <class _Tp> struct __is_array_function_or_void<_Tp, false, true, false> {enum {value = 2};};

libcxx/include/__type_traits/is_nothrow_assignable.h

 template <class _Tp, class _Arg>
 struct __libcpp_is_nothrow_assignable<false, _Tp, _Arg>
     : public false_type
 {
 };
 
 template <class _Tp, class _Arg>
 struct __libcpp_is_nothrow_assignable<true, _Tp, _Arg>
-    : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Arg>()) >
+    : public integral_constant<bool, noexcept(std::declval<_Tp>() = std::declval<_Arg>()) >
 {
 };
 
 template <class _Tp, class _Arg>
 struct _LIBCPP_TEMPLATE_VIS is_nothrow_assignable
     : public __libcpp_is_nothrow_assignable<is_assignable<_Tp, _Arg>::value, _Tp, _Arg>
 {
 };

libcxx/include/__type_traits/is_nothrow_constructible.h

struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible
     : public integral_constant<bool, __is_nothrow_constructible(_Tp, _Args...)> {};
 
 #else
 
 template <bool, bool, class _Tp, class... _Args> struct __libcpp_is_nothrow_constructible;
 
 template <class _Tp, class... _Args>
 struct __libcpp_is_nothrow_constructible</*is constructible*/true, /*is reference*/false, _Tp, _Args...>
-    : public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
+    : public integral_constant<bool, noexcept(_Tp(std::declval<_Args>()...))>
 {
 };
 
 template <class _Tp>
 void __implicit_conversion_to(_Tp) noexcept { }
 
 template <class _Tp, class _Arg>
 struct __libcpp_is_nothrow_constructible</*is constructible*/true, /*is reference*/true, _Tp, _Arg>
-    : public integral_constant<bool, noexcept(_VSTD::__implicit_conversion_to<_Tp>(declval<_Arg>()))>
+    : public integral_constant<bool, noexcept(_VSTD::__implicit_conversion_to<_Tp>(std::declval<_Arg>()))>
 {
 };
 
 template <class _Tp, bool _IsReference, class... _Args>
 struct __libcpp_is_nothrow_constructible</*is constructible*/false, _IsReference, _Tp, _Args...>
     : public false_type
 {
 };

libcxx/include/__type_traits/is_nothrow_convertible.h

 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
 template <typename _Tp>
 static void __test_noexcept(_Tp) noexcept;
 
 template<typename _Fm, typename _To>
-static bool_constant<noexcept(_VSTD::__test_noexcept<_To>(declval<_Fm>()))>
+static bool_constant<noexcept(_VSTD::__test_noexcept<_To>(std::declval<_Fm>()))>
 __is_nothrow_convertible_test();
 
 template <typename _Fm, typename _To>
 struct __is_nothrow_convertible_helper: decltype(__is_nothrow_convertible_test<_Fm, _To>())
 { };
 
 template <typename _Fm, typename _To>
 struct is_nothrow_convertible : _Or<

libcxx/include/__type_traits/is_nothrow_destructible.h

 template <class _Tp>
 struct __libcpp_is_nothrow_destructible<false, _Tp>
     : public false_type
 {
 };
 
 template <class _Tp>
 struct __libcpp_is_nothrow_destructible<true, _Tp>
-    : public integral_constant<bool, noexcept(declval<_Tp>().~_Tp()) >
+    : public integral_constant<bool, noexcept(std::declval<_Tp>().~_Tp()) >
 {
 };
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible
     : public __libcpp_is_nothrow_destructible<is_destructible<_Tp>::value, _Tp>
 {
 };

libcxx/include/__type_traits/promote.h

struct __numeric_type
    static double __test(unsigned);
    static double __test(long);
    static double __test(unsigned long);
    static double __test(long long);
    static double __test(unsigned long long);
    static double __test(double);
    static long double __test(long double);
 
-   typedef decltype(__test(declval<_Tp>())) type;
+   typedef decltype(__test(std::declval<_Tp>())) type;
    static const bool value = _IsNotSame<type, void>::value;
 };
 
 template <>
 struct __numeric_type<void>
 {
    static const bool value = true;
 };

libcxx/include/__utility/declval.h

 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Tp>
 _Tp&& __declval(int);
 template <class _Tp>
 _Tp __declval(long);
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 template <class _Tp>
-decltype(__declval<_Tp>(0)) declval() _NOEXCEPT;
+decltype(std::__declval<_Tp>(0)) declval() _NOEXCEPT;
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___UTILITY_DECLVAL_H

libcxx/include/istream

#endif // _LIBCPP_NO_EXCEPTIONS
     return __is;
 }
 
 template <class _Stream, class _Tp, class = void>
 struct __is_istreamable : false_type { };
 
 template <class _Stream, class _Tp>
 struct __is_istreamable<_Stream, _Tp, decltype(
-    declval<_Stream>() >> declval<_Tp>(), void()
+    std::declval<_Stream>() >> std::declval<_Tp>(), void()
 )> : true_type { };
 
 template <class _Stream, class _Tp, class = typename enable_if<
     _And<is_base_of<ios_base, _Stream>,
          __is_istreamable<_Stream&, _Tp&&> >::value
 >::type>
 _LIBCPP_INLINE_VISIBILITY
 _Stream&& operator>>(_Stream&& __is, _Tp&& __x)

libcxx/include/scoped_allocator

__scoped_allocator_storage(const outer_allocator_type& __o,
                                const inner_allocator_type& __i) _NOEXCEPT;
 
     template <class...> friend class __scoped_allocator_storage;
 };
 
 // __outermost
 
 template <class _Alloc>
-decltype(declval<_Alloc>().outer_allocator(), true_type())
+decltype(std::declval<_Alloc>().outer_allocator(), true_type())
 __has_outer_allocator_test(_Alloc&& __a);
 
 template <class _Alloc>
 false_type
 __has_outer_allocator_test(const volatile _Alloc& __a);
 
 template <class _Alloc>
 struct __has_outer_allocator
struct __outermost
     type& operator()(type& __a) const _NOEXCEPT {return __a;}
 };
 
 template <class _Alloc>
 struct __outermost<_Alloc, true>
 {
     typedef typename remove_reference
                      <
-                        decltype(declval<_Alloc>().outer_allocator())
+                        decltype(std::declval<_Alloc>().outer_allocator())
                      >::type                                    _OuterAlloc;
     typedef typename __outermost<_OuterAlloc>::type             type;
     _LIBCPP_INLINE_VISIBILITY
     type& operator()(_Alloc& __a) const _NOEXCEPT
         {return __outermost<_OuterAlloc>()(__a.outer_allocator());}
 };
 
 template <class _OuterAlloc, class... _InnerAllocs>

libcxx/include/type_traits

 {
 // ALL generic swap overloads MUST already have a declaration available at this point.
 
 template <class _Tp, class _Up = _Tp,
           bool _NotVoid = !is_void<_Tp>::value && !is_void<_Up>::value>
 struct __swappable_with
 {
     template <class _LHS, class _RHS>
-    static decltype(swap(declval<_LHS>(), declval<_RHS>()))
+    static decltype(swap(std::declval<_LHS>(), std::declval<_RHS>()))
     __test_swap(int);
     template <class, class>
     static __nat __test_swap(long);
 
     // Extra parens are needed for the C++03 definition of decltype.
     typedef decltype((__test_swap<_Tp, _Up>(0))) __swap1;
     typedef decltype((__test_swap<_Up, _Tp>(0))) __swap2;
 
     static const bool value = _IsNotSame<__swap1, __nat>::value
                            && _IsNotSame<__swap2, __nat>::value;
 };
 
 template <class _Tp, class _Up>
 struct __swappable_with<_Tp, _Up,  false> : false_type {};
 
 template <class _Tp, class _Up = _Tp, bool _Swappable = __swappable_with<_Tp, _Up>::value>
 struct __nothrow_swappable_with {
   static const bool value =
 #ifndef _LIBCPP_HAS_NO_NOEXCEPT
-      noexcept(swap(declval<_Tp>(), declval<_Up>()))
-  &&  noexcept(swap(declval<_Up>(), declval<_Tp>()));
+      noexcept(swap(std::declval<_Tp>(), std::declval<_Up>()))
+  &&  noexcept(swap(std::declval<_Up>(), std::declval<_Tp>()));
 #else
       false;
 #endif
 };
 
 template <class _Tp, class _Up>
 struct __nothrow_swappable_with<_Tp, _Up, false> : false_type {};
 

libcxx/include/variant

struct __no_narrowing_check {
   template <class _Dest, class _Source>
   using _Apply = __type_identity<_Dest>;
 };
 
 struct __narrowing_check {
   template <class _Dest>
   static auto __test_impl(_Dest (&&)[1]) -> __type_identity<_Dest>;
   template <class _Dest, class _Source>
-  using _Apply _LIBCPP_NODEBUG = decltype(__test_impl<_Dest>({declval<_Source>()}));
+  using _Apply _LIBCPP_NODEBUG = decltype(__test_impl<_Dest>({std::declval<_Source>()}));
 };
 
 template <class _Dest, class _Source>
 using __check_for_narrowing _LIBCPP_NODEBUG =
   typename _If<
 #ifdef _LIBCPP_ENABLE_NARROWING_CONVERSIONS_IN_VARIANT
     false &&
 #endif
const bool __valueless =
       (... || _VSTD::__as_variant(__vs).valueless_by_exception());
   if (__valueless) {
     __throw_bad_variant_access();
   }
 }
 
 template <
     class _Visitor, class... _Vs,
-    typename = void_t<decltype(_VSTD::__as_variant(declval<_Vs>()))...> >
+    typename = void_t<decltype(_VSTD::__as_variant(std::declval<_Vs>()))...> >
 inline _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr
     decltype(auto) visit(_Visitor&& __visitor, _Vs&&... __vs) {
   using __variant_detail::__visitation::__variant;
   _VSTD::__throw_if_valueless(_VSTD::forward<_Vs>(__vs)...);
   return __variant::__visit_value(_VSTD::forward<_Visitor>(__visitor),
                                   _VSTD::forward<_Vs>(__vs)...);
 }
 
 #if _LIBCPP_STD_VER > 17
 template <
     class _Rp, class _Visitor, class... _Vs,
-    typename = void_t<decltype(_VSTD::__as_variant(declval<_Vs>()))...> >
+    typename = void_t<decltype(_VSTD::__as_variant(std::declval<_Vs>()))...> >
 inline _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr _Rp
     visit(_Visitor&& __visitor, _Vs&&... __vs) {
   using __variant_detail::__visitation::__variant;
   _VSTD::__throw_if_valueless(_VSTD::forward<_Vs>(__vs)...);
   return __variant::__visit_value<_Rp>(_VSTD::forward<_Visitor>(__visitor),
                                        _VSTD::forward<_Vs>(__vs)...);
 }