[libc++] Suppress -Wctad-maybe-unsupported on types w/o deduction guides

[ldionne]

Summary

There are a handful of standard library types that are intended
to support CTAD but don't need any explicit deduction guides to
do so.

This patch adds a dummy deduction guide to those types to suppress
-Wctad-maybe-unsupported (which gets emitted in user code).

This is a re-application of the original patch by Eric Fiselier in
fcd549a7d828 which had been reverted due to reasons lost at this point.
I also added the macro to a few more types. Reviving this patch was
prompted by the discussion on https://llvm.org/D133425.

[Mordante]

I noticed the original patch was from 2019 and thus doesn't adds the markers for the types in std::format. Using a recent Clang seems to fails to build our benchmarks. The errors look the same as the C++2b CI failure.

Otherwise the patch LGTM!

[ldionne]

Update several types that were missing the annotation.

[ldionne]

Rebase, trigger CI and remove warning suppression from libc++'s own build.

[ldionne]

Fix C++11/C++03

[ldionne]

Address issue in C++17

[ldionne]

Remove variant test. @Mordante you uncommented that and it failed with this patch due to CTAD.

I was going to add an allowance for variant to silence the warning, and then I thought to myself: does it really make sense?
I can't think of any other CTAD with variant that would make sense other than the copy constructor, which seems extremely weak,
since CTAD always makes sense with a copy ctor.

In particular, I think the code std::variant v{3} is extremely suspicious (why on earth would you create a variant
that always contains an int -- this must usually be a mistake). So instead, I'm tempted to let the warning warn when
CTAD is used with variant.

[Mordante]

In D133535#3825383, @ldionne wrote:

In particular, I think the code std::variant v{3} is extremely suspicious (why on earth would you create a variant
that always contains an int -- this must usually be a mistake). So instead, I'm tempted to let the warning warn when
CTAD is used with variant.

I think there are valid cases.

#ifdef FOO
std::variant<int, double> v{foo(...);};
#else
std::variant<int, double> v{42};
#endif

But since it's only a warning users can just compile without the flag and be happy. So I don't think we need to support this feature. But I feel the test should be fixed instead of removed.

I like the format contexts also to keep using CTAD, I don't feel writing the template types there makes the code easier to understand.

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.bool.pass.cpp

47

nice catch.

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/ctor.pass.cpp

43

Here too I prefer CTAD to work.

libcxx/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp

258 ↗

(On Diff #464058)

This line is what is tested, this is no longer ill-formed. So I would prefer to keep this test and instead adjust the construction.

I wonder how many libc++ users use this construct. Does it only warn when the types are convertible or always?
For example will this also generate a diagnostic?

std::variant<int, std::string_view> v1(3);

[ldionne]

I like the format contexts also to keep using CTAD, I don't feel writing the template types there makes the code easier to understand.

Instead, I would suggest going through all the types in format and considering which ones it makes sense to use CTAD with. Does that sound reasonable? This patch is only trying to get the library+tests compiling with the warning enabled with as little changes as possible.

[ldionne]

Fix backdeployment issue.

[Mordante]

In D133535#3828360, @ldionne wrote:

I like the format contexts also to keep using CTAD, I don't feel writing the template types there makes the code easier to understand.

Instead, I would suggest going through all the types in format and considering which ones it makes sense to use CTAD with. Does that sound reasonable? This patch is only trying to get the library+tests compiling with the warning enabled with as little changes as possible.

These types are public types, so we can't just add CTAD to them. But I wouldn't mind to commit the format part as-is and afterwards I rework the format patch in a followup. (This followup will be a partial revert of this commit.)

[ldionne]

In D133535#3831086, @Mordante wrote:

In D133535#3828360, @ldionne wrote:

I like the format contexts also to keep using CTAD, I don't feel writing the template types there makes the code easier to understand.

Instead, I would suggest going through all the types in format and considering which ones it makes sense to use CTAD with. Does that sound reasonable? This patch is only trying to get the library+tests compiling with the warning enabled with as little changes as possible.

These types are public types, so we can't just add CTAD to them. But I wouldn't mind to commit the format part as-is and afterwards I rework the format patch in a followup. (This followup will be a partial revert of this commit.)

Yes, I think that's fine. We wouldn't add CTAD to those types, we would simply add the _LIBCPP_CTAD_ENABLED_FOR_TYPE(foo); fake deduction guide to them. That should be conforming.

[ldionne]

This wasn't actually reverted, @Mordante 's change only added more types that support CTAD.

libcxx/CMakeLists.txt

target_add_compile_flags_if_supported(${target} PRIVATE -Wextra -W -Wwrite-strings
                                                           -Wno-unused-parameter -Wno-long-long
                                                           -Werror=return-type -Wextra-semi -Wundef
                                                           -Wformat-nonliteral)
   if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
     target_add_compile_flags_if_supported(${target} PRIVATE
       -Wno-user-defined-literals
       -Wno-covered-switch-default
       -Wno-suggest-override
-      -Wno-ctad-maybe-unsupported
     )
     if (LIBCXX_TARGETING_CLANG_CL)
       target_add_compile_flags_if_supported(${target} PRIVATE
         -Wno-c++98-compat
         -Wno-c++98-compat-pedantic
         -Wno-c++11-compat
         -Wno-undef
         -Wno-reserved-id-macro

libcxx/include/__config

 // __cpp_char8_t feature test macro is not defined, then a char8_t typedef
 // will be declared as well.
 #  if defined(_LIBCPP_GLIBC_PREREQ) && defined(__GLIBC_USE)
 #    if _LIBCPP_GLIBC_PREREQ(2, 36) && (defined(__cpp_char8_t) || __GLIBC_USE(ISOC2X))
 #      undef _LIBCPP_HAS_NO_C8RTOMB_MBRTOC8
 #    endif
 #  endif
 
+// There are a handful of standard library types that are intended to support CTAD but don't need any
+// explicit deduction guides to do so. This macro is used to mark them as such, which suppresses the
+// '-Wctad-maybe-unsupported' compiler warning when CTAD is used in user code with these classes.
+#if _LIBCPP_STD_VER >= 17
+#  define _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(_ClassName)                                                                  \
+    template <class _Tag = void>                                                                                       \
+    _ClassName(typename _Tag::__allow_ctad) -> _ClassName<_Tag>
+#else
+#  define _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(_ClassName) static_assert(true, "")
+#endif
+
 #endif // __cplusplus
 
 #endif // _LIBCPP___CONFIG

libcxx/include/__format/format_args.h

private:
   union {
     struct {
       const __basic_format_arg_value<_Context>* __values_;
       uint64_t __types_;
     };
     const basic_format_arg<_Context>* __args_;
   };
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(basic_format_args);
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_FORMAT_ARGS_H

libcxx/include/__format/format_context.h

  * This is needed since the constructor is private.
  */
 template <class _OutIt, class _CharT>
 _LIBCPP_HIDE_FROM_ABI basic_format_context<_OutIt, _CharT>
 __format_context_create(
     _OutIt __out_it,
     basic_format_args<basic_format_context<_OutIt, _CharT>> __args,
     optional<_VSTD::locale>&& __loc = nullopt) {
-  return _VSTD::basic_format_context(_VSTD::move(__out_it), __args,
+  return _VSTD::basic_format_context<_OutIt, _CharT>(_VSTD::move(__out_it), __args,
                                                      _VSTD::move(__loc));
 }
 #else
 template <class _OutIt, class _CharT>
 _LIBCPP_HIDE_FROM_ABI basic_format_context<_OutIt, _CharT>
 __format_context_create(
     _OutIt __out_it,
     basic_format_args<basic_format_context<_OutIt, _CharT>> __args) {
-  return _VSTD::basic_format_context(_VSTD::move(__out_it), __args);
+  return _VSTD::basic_format_context<_OutIt, _CharT>(_VSTD::move(__out_it), __args);
 }
 #endif
 
 using format_context =
     basic_format_context<back_insert_iterator<__format::__output_buffer<char>>,
                          char>;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 using wformat_context = basic_format_context<

libcxx/include/__format/format_functions.h

#      endif
   }
   __throw_format_error("Invalid argument");
 }
 
 template <class _CharT, class _ParseCtx, class _Ctx>
 _LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
 __handle_replacement_field(const _CharT* __begin, const _CharT* __end,
                            _ParseCtx& __parse_ctx, _Ctx& __ctx) {
-  __format::__parse_number_result __r =
+  __format::__parse_number_result<_CharT> __r =
       __format::__parse_arg_id(__begin, __end, __parse_ctx);
 
   bool __parse = *__r.__ptr == _CharT(':');
   switch (*__r.__ptr) {
   case _CharT(':'):
     // The arg-id has a format-specifier, advance the input to the format-spec.
     __parse_ctx.advance_to(__r.__ptr + 1);
     break;

 
 template <class _OutIt, class _CharT, class _FormatOutIt>
 requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt
     __vformat_to(
         _OutIt __out_it, basic_string_view<_CharT> __fmt,
         basic_format_args<basic_format_context<_FormatOutIt, _CharT>> __args) {
   if constexpr (same_as<_OutIt, _FormatOutIt>)
     return _VSTD::__format::__vformat_to(
-        basic_format_parse_context{__fmt, __args.__size()},
+        basic_format_parse_context<_CharT>{__fmt, __args.__size()},
         _VSTD::__format_context_create(_VSTD::move(__out_it), __args));
   else {
     __format::__format_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it)};
     _VSTD::__format::__vformat_to(
-        basic_format_parse_context{__fmt, __args.__size()},
+        basic_format_parse_context<_CharT>{__fmt, __args.__size()},
         _VSTD::__format_context_create(__buffer.__make_output_iterator(),
                                        __args));
     return _VSTD::move(__buffer).__out_it();
   }
 }
 
 // The function is _LIBCPP_ALWAYS_INLINE since the compiler is bad at inlining
 // https://reviews.llvm.org/D110499#inline-1180704

 }
 #endif
 
 template <class _Context, class _OutIt, class _CharT>
 _LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> __vformat_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n,
                                                                 basic_string_view<_CharT> __fmt,
                                                                 basic_format_args<_Context> __args) {
   __format::__format_to_n_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it), __n};
-  _VSTD::__format::__vformat_to(basic_format_parse_context{__fmt, __args.__size()},
+  _VSTD::__format::__vformat_to(basic_format_parse_context<_CharT>{__fmt, __args.__size()},
                                 _VSTD::__format_context_create(__buffer.__make_output_iterator(), __args));
   return _VSTD::move(__buffer).__result();
 }
 
 template <output_iterator<const char&> _OutIt, class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt>
 format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, format_string<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::__vformat_to_n<format_context>(_VSTD::move(__out_it), __n, __fmt.get(), _VSTD::make_format_args(__args...));
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <output_iterator<const wchar_t&> _OutIt, class... _Args>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt>
 format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, wformat_string<_Args...> __fmt,
             _Args&&... __args) {
   return _VSTD::__vformat_to_n<wformat_context>(_VSTD::move(__out_it), __n, __fmt.get(), _VSTD::make_wformat_args(__args...));
 }
 #endif
 
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI size_t __vformatted_size(basic_string_view<_CharT> __fmt, auto __args) {
   __format::__formatted_size_buffer<_CharT> __buffer;
-  _VSTD::__format::__vformat_to(basic_format_parse_context{__fmt, __args.__size()},
+  _VSTD::__format::__vformat_to(basic_format_parse_context<_CharT>{__fmt, __args.__size()},
                                 _VSTD::__format_context_create(__buffer.__make_output_iterator(), __args));
   return _VSTD::move(__buffer).__result();
 }
 
 template <class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t
 formatted_size(format_string<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::__vformatted_size(__fmt.get(), basic_format_args{_VSTD::make_format_args(__args...)});

 
 template <class _OutIt, class _CharT, class _FormatOutIt>
 requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt
     __vformat_to(
         _OutIt __out_it, locale __loc, basic_string_view<_CharT> __fmt,
         basic_format_args<basic_format_context<_FormatOutIt, _CharT>> __args) {
   if constexpr (same_as<_OutIt, _FormatOutIt>)
     return _VSTD::__format::__vformat_to(
-        basic_format_parse_context{__fmt, __args.__size()},
+        basic_format_parse_context<_CharT>{__fmt, __args.__size()},
         _VSTD::__format_context_create(_VSTD::move(__out_it), __args,
                                        _VSTD::move(__loc)));
   else {
     __format::__format_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it)};
     _VSTD::__format::__vformat_to(
-        basic_format_parse_context{__fmt, __args.__size()},
+        basic_format_parse_context<_CharT>{__fmt, __args.__size()},
         _VSTD::__format_context_create(__buffer.__make_output_iterator(),
                                        __args, _VSTD::move(__loc)));
     return _VSTD::move(__buffer).__out_it();
   }
 }
 
 template <output_iterator<const char&> _OutIt>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt vformat_to(

 #endif
 
 template <class _Context, class _OutIt, class _CharT>
 _LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> __vformat_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n,
                                                                 locale __loc, basic_string_view<_CharT> __fmt,
                                                                 basic_format_args<_Context> __args) {
   __format::__format_to_n_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it), __n};
   _VSTD::__format::__vformat_to(
-      basic_format_parse_context{__fmt, __args.__size()},
+      basic_format_parse_context<_CharT>{__fmt, __args.__size()},
       _VSTD::__format_context_create(__buffer.__make_output_iterator(), __args, _VSTD::move(__loc)));
   return _VSTD::move(__buffer).__result();
 }
 
 template <output_iterator<const char&> _OutIt, class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt>
 format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, locale __loc, format_string<_Args...> __fmt,
             _Args&&... __args) {
return _VSTD::__vformat_to_n<wformat_context>(_VSTD::move(__out_it), __n, _VSTD::move(__loc), __fmt.get(),
                                                 _VSTD::make_wformat_args(__args...));
 }
 #endif
 
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI size_t __vformatted_size(locale __loc, basic_string_view<_CharT> __fmt, auto __args) {
   __format::__formatted_size_buffer<_CharT> __buffer;
   _VSTD::__format::__vformat_to(
-      basic_format_parse_context{__fmt, __args.__size()},
+      basic_format_parse_context<_CharT>{__fmt, __args.__size()},
       _VSTD::__format_context_create(__buffer.__make_output_iterator(), __args, _VSTD::move(__loc)));
   return _VSTD::move(__buffer).__result();
 }
 
 template <class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t
 formatted_size(locale __loc, format_string<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::__vformatted_size(_VSTD::move(__loc), __fmt.get(), basic_format_args{_VSTD::make_format_args(__args...)});

libcxx/include/__format/format_to_n_result.h

 
 #if _LIBCPP_STD_VER > 17
 
 template <class _OutIt>
 struct _LIBCPP_TEMPLATE_VIS format_to_n_result {
   _OutIt out;
   iter_difference_t<_OutIt> size;
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(format_to_n_result);
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_FORMAT_TO_N_RESULT_H

libcxx/include/__format/parser_std_format_spec.h

 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI constexpr __format::__parse_number_result< _CharT>
 __parse_arg_id(const _CharT* __begin, const _CharT* __end, auto& __parse_ctx) {
   // This function is a wrapper to call the real parser. But it does the
   // validation for the pre-conditions and post-conditions.
   if (__begin == __end)
     __throw_format_error("End of input while parsing format-spec arg-id");
 
-  __format::__parse_number_result __r =
+  __format::__parse_number_result<_CharT> __r =
       __format::__parse_arg_id(__begin, __end, __parse_ctx);
 
   if (__r.__ptr == __end || *__r.__ptr != _CharT('}'))
     __throw_format_error("Invalid arg-id");
 
   ++__r.__ptr;
   return __r;
 }
_LIBCPP_HIDE_FROM_ABI constexpr bool __parse_zero_padding(const _CharT*& __begin) {
     return true;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_width(const _CharT*& __begin, const _CharT* __end, auto& __parse_ctx) {
     if (*__begin == _CharT('0'))
       __throw_format_error("A format-spec width field shouldn't have a leading zero");
 
     if (*__begin == _CharT('{')) {
-      __format::__parse_number_result __r = __format_spec::__parse_arg_id(++__begin, __end, __parse_ctx);
+      __format::__parse_number_result<_CharT> __r = __format_spec::__parse_arg_id(++__begin, __end, __parse_ctx);
       __width_as_arg_ = true;
       __width_ = __r.__value;
       __begin = __r.__ptr;
       return true;
     }
 
     if (*__begin < _CharT('0') || *__begin > _CharT('9'))
       return false;
 
-    __format::__parse_number_result __r = __format::__parse_number(__begin, __end);
+    __format::__parse_number_result<_CharT> __r = __format::__parse_number(__begin, __end);
     __width_ = __r.__value;
     _LIBCPP_ASSERT(__width_ != 0, "A zero value isn't allowed and should be impossible, "
                                   "due to validations in this function");
     __begin = __r.__ptr;
     return true;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_precision(const _CharT*& __begin, const _CharT* __end,
                                                          auto& __parse_ctx) {
     if (*__begin != _CharT('.'))
       return false;
 
     ++__begin;
     if (__begin == __end)
       __throw_format_error("End of input while parsing format-spec precision");
 
     if (*__begin == _CharT('{')) {
-      __format::__parse_number_result __arg_id = __format_spec::__parse_arg_id(++__begin, __end, __parse_ctx);
+      __format::__parse_number_result<_CharT> __arg_id = __format_spec::__parse_arg_id(++__begin, __end, __parse_ctx);
       __precision_as_arg_ = true;
       __precision_ = __arg_id.__value;
       __begin = __arg_id.__ptr;
       return true;
     }
 
     if (*__begin < _CharT('0') || *__begin > _CharT('9'))
       __throw_format_error("The format-spec precision field doesn't contain a value or arg-id");
 
-    __format::__parse_number_result __r = __format::__parse_number(__begin, __end);
+    __format::__parse_number_result<_CharT> __r = __format::__parse_number(__begin, __end);
     __precision_ = __r.__value;
     __precision_as_arg_ = false;
     __begin = __r.__ptr;
     return true;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_locale_specific_form(const _CharT*& __begin) {
     if (*__begin != _CharT('L'))
do {
         break;
       }
     } while (__is_ascii(*__it));
     --__it;
     ++__maximum;
   }
 
   ptrdiff_t __ascii_size = __it - __str.begin();
-  __column_width_result __result =
+  __column_width_result<_CharT> __result =
       __detail::__estimate_column_width_grapheme_clustering(__it, __str.end(), __maximum, __rounding);
 
   __result.__width_ += __ascii_size;
   return __result;
 }
 #  else // !defined(_LIBCPP_HAS_NO_UNICODE)
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI constexpr __column_width_result<_CharT>

libcxx/include/__format/unicode.h

while (true) {
           __prev == __extended_grapheme_custer_property_boundary::__property::__Extended_Pictographic;
 
       if (__at_extended_grapheme_cluster_break(__ri_break_allowed, __has_extened_pictographic, __prev, __next_prop_))
         return __result;
     }
   }
 };
 
+template <class _CharT>
+__extended_grapheme_cluster_view(const _CharT*, const _CharT*) -> __extended_grapheme_cluster_view<_CharT>;
+
 } // namespace __unicode
 
 #  endif //  _LIBCPP_HAS_NO_UNICODE
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_UNICODE_H

libcxx/include/__functional/boyer_moore_searcher.h

for (size_t __i = 0; __i != __count; ++__i) {
       const size_t __j = __count - __scratch[__i];
       const difference_type __k = __i - __scratch[__i] + 1;
 
       if (__suffix_[__j] > __k)
         __suffix_[__j] = __k;
     }
   }
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(boyer_moore_searcher);
 
 template <class _RandomAccessIterator1,
           class _Hash = hash<typename iterator_traits<_RandomAccessIterator1>::value_type>,
           class _BinaryPredicate = equal_to<>>
 class _LIBCPP_TEMPLATE_VIS boyer_moore_horspool_searcher {
 private:
   using difference_type = typename iterator_traits<_RandomAccessIterator1>::difference_type;
   using value_type = typename iterator_traits<_RandomAccessIterator1>::value_type;
while (__current <= __last) {
         if (__j == 0)
           return std::make_pair(__current, __current + __pattern_length_);
       }
       __current += __skip_table[__current[__pattern_length_ - 1]];
     }
     return std::make_pair(__l, __l);
   }
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(boyer_moore_horspool_searcher);
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_STD_VER > 14
 
 #endif // _LIBCPP___FUNCTIONAL_BOYER_MOORE_SEARCHER_H

libcxx/include/__functional/default_searcher.h

operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const
         return std::__search_impl(__f, __l, __first_, __last_, __pred_, __proj, __proj);
     }
 
 private:
     _ForwardIterator __first_;
     _ForwardIterator __last_;
     _BinaryPredicate __pred_;
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(default_searcher);
 
 #endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FUNCTIONAL_DEFAULT_SEARCHER_H

libcxx/include/__functional/operations.h

 struct _LIBCPP_TEMPLATE_VIS plus
     : __binary_function<_Tp, _Tp, _Tp>
 {
     typedef _Tp __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x + __y;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(plus);
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS plus<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const

 struct _LIBCPP_TEMPLATE_VIS minus
     : __binary_function<_Tp, _Tp, _Tp>
 {
     typedef _Tp __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x - __y;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(minus);
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS minus<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const

 struct _LIBCPP_TEMPLATE_VIS multiplies
     : __binary_function<_Tp, _Tp, _Tp>
 {
     typedef _Tp __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x * __y;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(multiplies);
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS multiplies<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const

 struct _LIBCPP_TEMPLATE_VIS divides
     : __binary_function<_Tp, _Tp, _Tp>
 {
     typedef _Tp __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x / __y;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(divides);
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS divides<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const

 struct _LIBCPP_TEMPLATE_VIS modulus
     : __binary_function<_Tp, _Tp, _Tp>
 {
     typedef _Tp __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x % __y;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(modulus);
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS modulus<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const

 struct _LIBCPP_TEMPLATE_VIS negate
     : __unary_function<_Tp, _Tp>
 {
     typedef _Tp __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return -__x;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(negate);
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS negate<void>
 {
     template <class _Tp>
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_Tp&& __x) const

 struct _LIBCPP_TEMPLATE_VIS bit_and
     : __binary_function<_Tp, _Tp, _Tp>
 {
     typedef _Tp __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x & __y;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_and);
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS bit_and<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const
         noexcept(noexcept(_VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u)))
         -> decltype(      _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u))
         { return          _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u); }
     typedef void is_transparent;
 };
 #endif
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 struct _LIBCPP_TEMPLATE_VIS bit_not
     : __unary_function<_Tp, _Tp>
 {
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x) const
         {return ~__x;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_not);
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS bit_not<void>
 {
     template <class _Tp>
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_Tp&& __x) const
         noexcept(noexcept(~_VSTD::forward<_Tp>(__x)))

 struct _LIBCPP_TEMPLATE_VIS bit_or
     : __binary_function<_Tp, _Tp, _Tp>
 {
     typedef _Tp __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x | __y;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_or);
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS bit_or<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const

 struct _LIBCPP_TEMPLATE_VIS bit_xor
     : __binary_function<_Tp, _Tp, _Tp>
 {
     typedef _Tp __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x ^ __y;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_xor);
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS bit_xor<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const

 struct _LIBCPP_TEMPLATE_VIS equal_to
     : __binary_function<_Tp, _Tp, bool>
 {
     typedef bool __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x == __y;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(equal_to);
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS equal_to<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const

 struct _LIBCPP_TEMPLATE_VIS not_equal_to
     : __binary_function<_Tp, _Tp, bool>
 {
     typedef bool __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x != __y;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(not_equal_to);
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS not_equal_to<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const

 struct _LIBCPP_TEMPLATE_VIS less
     : __binary_function<_Tp, _Tp, bool>
 {
     typedef bool __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x < __y;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(less);
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS less<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const

 struct _LIBCPP_TEMPLATE_VIS less_equal
     : __binary_function<_Tp, _Tp, bool>
 {
     typedef bool __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x <= __y;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(less_equal);
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS less_equal<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const

 struct _LIBCPP_TEMPLATE_VIS greater_equal
     : __binary_function<_Tp, _Tp, bool>
 {
     typedef bool __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x >= __y;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(greater_equal);
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS greater_equal<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const

 struct _LIBCPP_TEMPLATE_VIS greater
     : __binary_function<_Tp, _Tp, bool>
 {
     typedef bool __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x > __y;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(greater);
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS greater<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const

 struct _LIBCPP_TEMPLATE_VIS logical_and
     : __binary_function<_Tp, _Tp, bool>
 {
     typedef bool __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x && __y;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_and);
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS logical_and<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const

 struct _LIBCPP_TEMPLATE_VIS logical_not
     : __unary_function<_Tp, bool>
 {
     typedef bool __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x) const
         {return !__x;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_not);
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS logical_not<void>
 {
     template <class _Tp>
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_Tp&& __x) const

 struct _LIBCPP_TEMPLATE_VIS logical_or
     : __binary_function<_Tp, _Tp, bool>
 {
     typedef bool __result_type;  // used by valarray
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x || __y;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_or);
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS logical_or<void>
 {
     template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const

libcxx/include/__iterator/back_insert_iterator.h

_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 back_insert_iterator& operator=(typename _Container::value_type&& __value)
         {container->push_back(_VSTD::move(__value)); return *this;}
 #endif // _LIBCPP_CXX03_LANG
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 back_insert_iterator& operator*()     {return *this;}
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 back_insert_iterator& operator++()    {return *this;}
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 back_insert_iterator  operator++(int) {return *this;}
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Container* __get_container() const { return container; }
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(back_insert_iterator);
 
 template <class _Container>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
 back_insert_iterator<_Container>
 back_inserter(_Container& __x)
 {
     return back_insert_iterator<_Container>(__x);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_BACK_INSERT_ITERATOR_H

libcxx/include/__iterator/counted_iterator.h

#endif // _LIBCPP_NO_EXCEPTIONS
   friend constexpr void iter_swap(const counted_iterator& __x, const counted_iterator<_I2>& __y)
     noexcept(noexcept(ranges::iter_swap(__x.__current_, __y.__current_)))
   {
     _LIBCPP_ASSERT(__x.__count_ > 0 && __y.__count_ > 0,
                    "Iterators must not be past end of range.");
     return ranges::iter_swap(__x.__current_, __y.__current_);
   }
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(counted_iterator);
 
 template<input_iterator _Iter>
   requires same_as<_ITER_TRAITS<_Iter>, iterator_traits<_Iter>>
 struct iterator_traits<counted_iterator<_Iter>> : iterator_traits<_Iter> {
   using pointer = conditional_t<contiguous_iterator<_Iter>,
                                 add_pointer_t<iter_reference_t<_Iter>>, void>;
 };
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_COUNTED_ITERATOR_H

libcxx/include/__iterator/front_insert_iterator.h

 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 front_insert_iterator& operator=(typename _Container::value_type&& __value)
         {container->push_front(_VSTD::move(__value)); return *this;}
 #endif // _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 front_insert_iterator& operator*()     {return *this;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 front_insert_iterator& operator++()    {return *this;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 front_insert_iterator  operator++(int) {return *this;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(front_insert_iterator);
 
 template <class _Container>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 front_insert_iterator<_Container>
 front_inserter(_Container& __x)
 {
     return front_insert_iterator<_Container>(__x);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_FRONT_INSERT_ITERATOR_H

libcxx/include/__iterator/move_iterator.h

#if _LIBCPP_STD_VER > 17
     }
 #endif // _LIBCPP_STD_VER > 17
 
 private:
     template<class _It2> friend class move_iterator;
 
     _Iter __current_;
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(move_iterator);
 
 template <class _Iter1, class _Iter2>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
 bool operator==(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
 {
     return __x.base() == __y.base();
 }
 

libcxx/include/__mutex_base

lock_guard(mutex_type& __m, adopt_lock_t) _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
         : __m_(__m) {}
     _LIBCPP_INLINE_VISIBILITY
     ~lock_guard() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) {__m_.unlock();}
 
 private:
     lock_guard(lock_guard const&) = delete;
     lock_guard& operator=(lock_guard const&) = delete;
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(lock_guard);
 
 template <class _Mutex>
 class _LIBCPP_TEMPLATE_VIS unique_lock
 {
 public:
     typedef _Mutex mutex_type;
 
 private:
public:
 
     _LIBCPP_INLINE_VISIBILITY
     bool owns_lock() const _NOEXCEPT {return __owns_;}
     _LIBCPP_INLINE_VISIBILITY
     explicit operator bool() const _NOEXCEPT {return __owns_;}
     _LIBCPP_INLINE_VISIBILITY
     mutex_type* mutex() const _NOEXCEPT {return __m_;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(unique_lock);
 
 template <class _Mutex>
 void
 unique_lock<_Mutex>::lock()
 {
     if (__m_ == nullptr)
         __throw_system_error(EPERM, "unique_lock::lock: references null mutex");
     if (__owns_)

libcxx/include/__ranges/owning_view.h

public:
     _LIBCPP_HIDE_FROM_ABI constexpr auto size() const requires sized_range<const _Rp>
       { return ranges::size(__r_); }
 
     _LIBCPP_HIDE_FROM_ABI constexpr auto data() requires contiguous_range<_Rp>
       { return ranges::data(__r_); }
     _LIBCPP_HIDE_FROM_ABI constexpr auto data() const requires contiguous_range<const _Rp>
       { return ranges::data(__r_); }
   };
+  _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(owning_view);
 
   template<class _Tp>
   inline constexpr bool enable_borrowed_range<owning_view<_Tp>> = enable_borrowed_range<_Tp>;
 
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_OWNING_VIEW_H

libcxx/include/__ranges/range_adaptor.h

 struct __range_adaptor_closure;
 
 // Type that wraps an arbitrary function object and makes it into a range adaptor closure,
 // i.e. something that can be called via the `x | f` notation.
 template <class _Fn>
 struct __range_adaptor_closure_t : _Fn, __range_adaptor_closure<__range_adaptor_closure_t<_Fn>> {
     constexpr explicit __range_adaptor_closure_t(_Fn&& __f) : _Fn(std::move(__f)) { }
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(__range_adaptor_closure_t);
 
 template <class _Tp>
 concept _RangeAdaptorClosure = derived_from<remove_cvref_t<_Tp>, __range_adaptor_closure<remove_cvref_t<_Tp>>>;
 
 template <class _Tp>
 struct __range_adaptor_closure {
     template <ranges::viewable_range _View, _RangeAdaptorClosure _Closure>
         requires same_as<_Tp, remove_cvref_t<_Closure>> &&

libcxx/include/__utility/transaction.h

_LIBCPP_CONSTEXPR_SINCE_CXX20 ~__transaction() {
         if (!__completed_)
             __rollback_();
     }
 
 private:
     _Rollback __rollback_;
     bool __completed_;
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(__transaction);
 
 template <class _Rollback>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __transaction<_Rollback> __make_transaction(_Rollback __rollback) {
   return __transaction<_Rollback>(std::move(__rollback));
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___UTILITY_TRANSACTION_H

libcxx/include/mutex

private:
     template <size_t ..._Indx>
     _LIBCPP_INLINE_VISIBILITY
     static void __unlock_unpack(__tuple_indices<_Indx...>, _MutexTuple& __mt) {
         _VSTD::__unlock(_VSTD::get<_Indx>(__mt)...);
     }
 
     _MutexTuple __t_;
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(scoped_lock);
 
 #endif // _LIBCPP_STD_VER > 14
 #endif // !_LIBCPP_HAS_NO_THREADS
 
 struct _LIBCPP_TEMPLATE_VIS once_flag;
 
 #ifndef _LIBCPP_CXX03_LANG
 

libcxx/include/shared_mutex

public:
     bool owns_lock() const _NOEXCEPT {return __owns_;}
 
     _LIBCPP_INLINE_VISIBILITY
     explicit operator bool () const _NOEXCEPT {return __owns_;}
 
     _LIBCPP_INLINE_VISIBILITY
     mutex_type* mutex() const _NOEXCEPT {return __m_;}
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(shared_lock);
 
 template <class _Mutex>
 void
 shared_lock<_Mutex>::lock()
 {
     if (__m_ == nullptr)
         __throw_system_error(EPERM, "shared_lock::lock: references null mutex");
     if (__owns_)

libcxx/include/string_view

#if _LIBCPP_STD_VER > 20
     bool contains(const value_type* __s) const
     { return find(__s) != npos; }
 #endif
 
 private:
     const   value_type* __data_;
     size_type           __size_;
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(basic_string_view);
 
 #if _LIBCPP_STD_VER > 17
 template <class _CharT, class _Traits>
 inline constexpr bool ranges::enable_view<basic_string_view<_CharT, _Traits>> = true;
 
 template <class _CharT, class _Traits>
 inline constexpr bool ranges::enable_borrowed_range<basic_string_view<_CharT, _Traits> > = true;
 #endif // _LIBCPP_STD_VER > 17

libcxx/src/filesystem/operations.cpp

explicit scope_exit(Cleanup const& cleanup)
     : cleanup_(cleanup)
   { }
 
   ~scope_exit() { cleanup_(); }
 
 private:
   Cleanup cleanup_;
 };
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(scope_exit);
 
 uintmax_t remove_all_impl(int parent_directory, const path& p, error_code& ec) {
   // First, try to open the path as a directory.
   const int options = O_CLOEXEC | O_RDONLY | O_DIRECTORY | O_NOFOLLOW;
   int fd = ::openat(parent_directory, p.c_str(), options);
   if (fd != -1) {
     // If that worked, iterate over the contents of the directory and
     // remove everything in it, recursively.

libcxx/test/libcxx/utilities/function.objects/func.bind.partial/bind_back.pass.cpp

// Some examples by Tim Song
       using X = decltype(std::__bind_back(F{}, T{}));
       static_assert(!std::is_invocable_v<X>);
     }
   }
 
   // Test properties of the constructor of the unspecified-type returned by __bind_back.
   {
     {
-      MoveOnlyCallable value(true);
+      MoveOnlyCallable<bool> value(true);
       auto ret = std::__bind_back(std::move(value), 1);
       assert(ret());
       assert(ret(1, 2, 3));
 
       auto ret1 = std::move(ret);
       assert(!ret());
       assert(ret1());
       assert(ret1(1, 2, 3));
 
       using RetT = decltype(ret);
       static_assert( std::is_move_constructible<RetT>::value);
       static_assert(!std::is_copy_constructible<RetT>::value);
       static_assert(!std::is_move_assignable<RetT>::value);
       static_assert(!std::is_copy_assignable<RetT>::value);
     }
     {
-      CopyCallable value(true);
+      CopyCallable<bool> value(true);
       auto ret = std::__bind_back(value, 1);
       assert(ret());
       assert(ret(1, 2, 3));
 
       auto ret1 = std::move(ret);
       assert(ret1());
       assert(ret1(1, 2, 3));
 

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/types.h

public:
     constexpr explicit assignable_sentinel(const It& it) : base_(base(it)) {}
     constexpr operator It() const { return It(base_); }
     constexpr bool operator==(const It& other) const { return base_ == base(other); }
     friend constexpr It base(const assignable_sentinel& s) { return It(s.base_); }
 private:
     decltype(base(std::declval<It>())) base_;
 };
 
+template <class It>
+assignable_sentinel(const It&) -> assignable_sentinel<It>;
+
 #endif // TEST_STD_ITERATORS_ITERATOR_PRIMITIVES_RANGE_ITER_OPS_TYPES_H

libcxx/test/std/iterators/iterator.requirements/iterator.cust/iterator.cust.move/iter_move.pass.cpp

public:
   constexpr void operator++(int) noexcept { ++base_; }
 
   constexpr bool operator==(iterator_wrapper const& other) const noexcept { return base_ == other.base_; }
 
 private:
   I base_ = I{};
 };
 
+template <class I>
+iterator_wrapper(I) -> iterator_wrapper<I>;
+
 template <typename It, typename Out>
 constexpr void unqualified_lookup_move(It first_, It last_, Out result_first_, Out result_last_) {
   auto first = ::check_unqualified_lookup::unqualified_lookup_wrapper{std::move(first_)};
   auto last = ::check_unqualified_lookup::unqualified_lookup_wrapper{std::move(last_)};
   auto result_first = ::check_unqualified_lookup::unqualified_lookup_wrapper{std::move(result_first_)};
   auto result_last = ::check_unqualified_lookup::unqualified_lookup_wrapper{std::move(result_last_)};
 
   static_assert(!noexcept(std::ranges::iter_move(first)), "unqualified-lookup case not being chosen");

libcxx/test/std/iterators/iterator.requirements/iterator.cust/unqualified_lookup_wrapper.h

public:
   friend constexpr decltype(auto) iter_move(unqualified_lookup_wrapper& i) noexcept(false) {
     return std::ranges::iter_move(i.base_);
   }
 
 private:
   I base_ = I{};
 };
 
+template <class It>
+unqualified_lookup_wrapper(It) -> unqualified_lookup_wrapper<It>;
+
 enum unscoped_enum { a, b, c };
 constexpr unscoped_enum iter_move(unscoped_enum& e) noexcept(false) { return e; }
 
 enum class scoped_enum { a, b, c };
 constexpr scoped_enum* iter_move(scoped_enum&) noexcept { return nullptr; }
 
 union some_union {
   int x;

libcxx/test/std/iterators/predef.iterators/counted.iterator/implicit_ctad.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++98, c++03, c++11, c++14, c++17
+
+// counted_iterator
+
+// Make sure that the implicitly-generated CTAD works.
+
+#include <iterator>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  int array[] = {1, 2, 3};
+  int* p = array;
+  std::counted_iterator iter(p, 3);
+  ASSERT_SAME_TYPE(decltype(iter), std::counted_iterator<int*>);
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/implicit_ctad.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++98, c++03, c++11, c++14
+
+// <iterator>
+
+// back_insert_iterator
+
+// Make sure that the implicitly-generated CTAD works.
+
+#include <iterator>
+#include <string>
+#include <vector>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  {
+    std::string s;
+    std::back_insert_iterator it(s);
+    ASSERT_SAME_TYPE(decltype(it), std::back_insert_iterator<std::string>);
+  }
+  {
+    std::vector<int> v;
+    std::back_insert_iterator it(v);
+    std::back_insert_iterator copy(it);
+    ASSERT_SAME_TYPE(decltype(it), std::back_insert_iterator<std::vector<int>>);
+    ASSERT_SAME_TYPE(decltype(copy), std::back_insert_iterator<std::vector<int>>);
+  }
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/implicit_ctad.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++98, c++03, c++11, c++14
+
+// <iterator>
+
+// front_insert_iterator
+
+// Make sure that the implicitly-generated CTAD works.
+
+#include <deque>
+#include <iterator>
+#include <string>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  {
+    std::string s;
+    std::front_insert_iterator it(s);
+    ASSERT_SAME_TYPE(decltype(it), std::front_insert_iterator<std::string>);
+  }
+  {
+    std::deque<int> v;
+    std::front_insert_iterator it(v);
+    std::front_insert_iterator copy(it);
+    ASSERT_SAME_TYPE(decltype(it), std::front_insert_iterator<std::deque<int>>);
+    ASSERT_SAME_TYPE(decltype(copy), std::front_insert_iterator<std::deque<int>>);
+  }
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/implicit_ctad.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++98, c++03, c++11, c++14
+
+// <iterator>
+
+// move_iterator
+
+// Make sure that the implicitly-generated CTAD works.
+
+#include <iterator>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  int* it = nullptr;
+  std::move_iterator move_it(it);
+  ASSERT_SAME_TYPE(decltype(move_it), std::move_iterator<int*>);
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.nonmember/iter_swap.pass.cpp

 #include "test_macros.h"
 
 constexpr bool test() {
   // Can use `iter_swap` with a regular array.
   {
     constexpr int N = 3;
     int a[N] = {0, 1, 2};
 
-    std::reverse_iterator rb(a + N);
-    std::reverse_iterator re(a + 1);
+    std::reverse_iterator<int*> rb(a + N);
+    std::reverse_iterator<int*> re(a + 1);
     assert(a[0] == 0);
     assert(a[2] == 2);
 
     static_assert(std::same_as<decltype(iter_swap(rb, re)), void>);
     iter_swap(rb, re);
     assert(a[0] == 2);
     assert(a[2] == 0);
   }

libcxx/test/std/ranges/range.adaptors/range.all/range.owning.view/implicit_ctad.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, c++11, c++14, c++17
+
+// owning_view
+
+// Make sure that the implicitly-generated CTAD works.
+
+#include <ranges>
+#include <utility>
+
+#include "test_macros.h"
+
+struct Range {
+  int* begin();
+  int* end();
+};
+
+int main(int, char**) {
+  Range r;
+  std::ranges::owning_view view{std::move(r)};
+  ASSERT_SAME_TYPE(decltype(view), std::ranges::owning_view<Range>);
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/arrow.pass.cpp

 constexpr bool test() {
   Box buffer[4][4] = {{{1111}, {2222}, {3333}, {4444}},
                       {{555}, {666}, {777}, {888}},
                       {{99}, {1010}, {1111}, {1212}},
                       {{13}, {14}, {15}, {16}}};
 
   {
     // Copyable input iterator with arrow.
-    ValueView<Box> children[4] = {ValueView(buffer[0]), ValueView(buffer[1]), ValueView(buffer[2]),
-                                  ValueView(buffer[3])};
+    using BoxView = ValueView<Box>;
+    ValueView<Box> children[4] = {BoxView(buffer[0]), BoxView(buffer[1]), BoxView(buffer[2]), BoxView(buffer[3])};
     std::ranges::join_view jv(ValueView<ValueView<Box>>{children});
     assert(jv.begin()->x == 1111);
     static_assert(HasArrow<decltype(jv.begin())>);
   }
 
   {
     std::ranges::join_view jv(buffer);
     assert(jv.begin()->x == 1111);

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/increment.pass.cpp

// operator++(int);
     std::ranges::join_view jv(buffer1);
     auto iter = jv.begin();
     for (int i = 1; i < 9; ++i) {
       assert(*iter++ == i);
     }
   }
 
   {
-    ValueView<int> children[4] = {ValueView(buffer1[0]), ValueView(buffer1[1]), ValueView(buffer2[0]), ValueView(buffer2[1])};
-    std::ranges::join_view jv(ValueView<ValueView<int>>{children});
+    using IntView = ValueView<int>;
+    IntView children[4] = {IntView(buffer1[0]), IntView(buffer1[1]), IntView(buffer2[0]), IntView(buffer2[1])};
+    std::ranges::join_view jv(ValueView<IntView>{children});
     auto iter = jv.begin();
     for (int i = 1; i < 17; ++i) {
       assert(*iter == i);
       iter++;
     }
 
     ASSERT_SAME_TYPE(decltype(iter++), void);
   }
// operator++();
     std::ranges::join_view jv(buffer1);
     auto iter = jv.begin();
     for (int i = 2; i < 9; ++i) {
       assert(*++iter == i);
     }
   }
 
   {
-    ValueView<int> children[4] = {ValueView(buffer1[0]), ValueView(buffer1[1]), ValueView(buffer2[0]), ValueView(buffer2[1])};
-    std::ranges::join_view jv(ValueView<ValueView<int>>{children});
+    using IntView = ValueView<int>;
+    IntView children[4] = {IntView(buffer1[0]), IntView(buffer1[1]), IntView(buffer2[0]), IntView(buffer2[1])};
+    std::ranges::join_view jv(ValueView<IntView>{children});
     auto iter = jv.begin();
     for (int i = 2; i < 17; ++i) {
       assert(*++iter == i);
     }
 
     ASSERT_SAME_TYPE(decltype(++iter), decltype(iter)&);
   }
 

libcxx/test/std/ranges/range.adaptors/range.join.view/types.h

struct ParentView : std::ranges::view_base {
   ParentView& operator=(ParentView&&) = default;
 
   constexpr iterator begin() { return iterator(ptr_); }
   constexpr const_iterator begin() const { return const_iterator(ptr_); }
   constexpr sentinel end() { return sentinel(iterator(ptr_ + size_)); }
   constexpr const_sentinel end() const { return const_sentinel(const_iterator(ptr_ + size_)); }
 };
 
+template <class T>
+ParentView(T*) -> ParentView<T>;
+
 struct CopyableChild : std::ranges::view_base {
   int* ptr_;
   unsigned size_;
 
   using iterator = cpp17_input_iterator<int*>;
   using const_iterator = cpp17_input_iterator<const int*>;
   using sentinel = sentinel_wrapper<iterator>;
   using const_sentinel = sentinel_wrapper<const_iterator>;

libcxx/test/std/ranges/range.factories/range.iota.view/types.h

struct IntComparableWith {
   friend constexpr difference_type operator-(IntComparableWith lhs, IntComparableWith rhs) {
     return lhs.value_ - rhs.value_;
   }
 
   constexpr IntComparableWith& operator++() { ++value_; return *this; }
   constexpr IntComparableWith  operator++(int) { auto tmp = *this; ++value_; return tmp; }
   constexpr IntComparableWith  operator--() { --value_; return *this; }
 };
+template <class T>
+IntComparableWith(T) -> IntComparableWith<T>;
 
 template<class T>
 struct IntSentinelWith {
   using difference_type = std::iter_difference_t<T>;
 
   T value_;
   constexpr explicit IntSentinelWith(T value = T()) : value_(value) {}
 
struct IntSentinelWith {
   friend constexpr difference_type operator-(T lhs, IntSentinelWith rhs) {
     return lhs - rhs.value_;
   }
 
   constexpr IntSentinelWith& operator++() { ++value_; return *this; }
   constexpr IntSentinelWith  operator++(int) { auto tmp = *this; ++value_; return tmp; }
   constexpr IntSentinelWith  operator--() { --value_; return *this; }
 };
+template <class T>
+IntSentinelWith(T) -> IntSentinelWith<T>;
 
 struct NotIncrementable {
   using difference_type = int;
 
   int value_;
   constexpr explicit NotIncrementable(int value = 0) : value_(value) {}
 
   bool operator==(const NotIncrementable&) const = default;

libcxx/test/std/strings/string.view/string.view.deduct/implicit.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++98, c++03, c++11, c++14
+
+// <string_view>
+
+// basic_string_view
+
+// Make sure that the implicitly-generated CTAD works.
+
+#include <string_view>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  {
+    char const* str = "hello world";
+    std::basic_string_view sv(str);
+    ASSERT_SAME_TYPE(decltype(sv), std::basic_string_view<char>);
+  }
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  {
+    wchar_t const* str = L"hello world";
+    std::basic_string_view sv(str);
+    ASSERT_SAME_TYPE(decltype(sv), std::basic_string_view<wchar_t>);
+  }
+#endif
+
+  return 0;
+}

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.guard/implicit_ctad.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: no-threads
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <mutex>
+
+// lock_guard
+
+// Make sure that the implicitly-generated CTAD works.
+
+#include <mutex>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  std::mutex mutex;
+  {
+    std::lock_guard lock(mutex);
+    ASSERT_SAME_TYPE(decltype(lock), std::lock_guard<std::mutex>);
+  }
+
+  return 0;
+}
+

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.scoped/implicit_ctad.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: no-threads
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <mutex>
+
+// scoped_lock
+
+// Make sure that the implicitly-generated CTAD works.
+
+#include <mutex>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  std::mutex m1;
+  std::recursive_mutex m2;
+  std::recursive_timed_mutex m3;
+  {
+    std::scoped_lock lock(m1);
+    ASSERT_SAME_TYPE(decltype(lock), std::scoped_lock<std::mutex>);
+  }
+  {
+    std::scoped_lock lock(m1, m2);
+    ASSERT_SAME_TYPE(decltype(lock), std::scoped_lock<std::mutex, std::recursive_mutex>);
+  }
+  {
+    std::scoped_lock lock(m1, m2, m3);
+    ASSERT_SAME_TYPE(decltype(lock), std::scoped_lock<std::mutex, std::recursive_mutex, std::recursive_timed_mutex>);
+  }
+
+  return 0;
+}
+

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/implicit_ctad.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: no-threads
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <shared_mutex>
+
+// shared_lock
+
+// Make sure that the implicitly-generated CTAD works.
+
+#include <shared_mutex>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  std::shared_mutex mutex;
+  {
+    std::shared_lock lock(mutex);
+    ASSERT_SAME_TYPE(decltype(lock), std::shared_lock<std::shared_mutex>);
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/implicit_ctad.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: no-threads
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <mutex>
+
+// unique_lock
+
+// Make sure that the implicitly-generated CTAD works.
+
+#include <mutex>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  std::mutex mutex;
+  {
+    std::unique_lock lock(mutex);
+    ASSERT_SAME_TYPE(decltype(lock), std::unique_lock<std::mutex>);
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.semaphore/ctor.compile.pass.cpp

 static_assert(!std::is_default_constructible<std::counting_semaphore<>>::value, "");
 
 static_assert(!std::is_convertible<int, std::binary_semaphore>::value, "");
 static_assert(!std::is_convertible<int, std::counting_semaphore<>>::value, "");
 
 #if TEST_STD_VER > 17
 // Test constexpr-constructibility. (But not destructibility.)
 constinit std::binary_semaphore bs(1);
-constinit std::counting_semaphore cs(1);
+constinit std::counting_semaphore<> cs(1);
 #endif

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/advance_to.pass.cpp

 #include "test_macros.h"
 #include "test_format_context.h"
 
 template <class OutIt, class CharT>
 void test(
     std::basic_format_args<std::basic_format_context<OutIt, CharT>> args) {
   {
     std::basic_string<CharT> str[3];
-    std::basic_format_context context =
+    std::basic_format_context<OutIt, CharT> context =
         test_format_context_create(OutIt{str[0]}, args);
     context.out() = CharT('a');
     context.advance_to(OutIt{str[1]});
     context.out() = CharT('b');
     context.advance_to(OutIt{str[2]});
     context.out() = CharT('c');
 
     assert(str[0].size() == 1);

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/arg.pass.cpp

 template <class OutIt, class CharT>
 void test() {
   std::basic_string<CharT> string = MAKE_STRING(CharT, "string");
   auto store = std::make_format_args<std::basic_format_context<OutIt, CharT>>(
       true, CharT('a'), 42, string);
   std::basic_format_args args = store;
 
   std::basic_string<CharT> output;
-  const std::basic_format_context context =
+  const std::basic_format_context<OutIt, CharT> context =
       test_format_context_create(OutIt{output}, args);
   LIBCPP_ASSERT(args.__size() == 4);
   ASSERT_NOEXCEPT(context.arg(0));
   for (size_t i = 0, e = args.__size(); i != e; ++i) {
     assert(context.arg(i));
   }
   assert(!context.arg(args.__size()));
 

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/ctor.pass.cpp

void test() {
   // to extend the lifetype of the object since args stores a pointer to the
   // data in this object.
   auto format_arg_store = std::make_format_args<std::basic_format_context<OutIt, CharT>>(true, CharT('a'), 42, string);
   std::basic_format_args args = format_arg_store;
 
   {
     std::basic_string<CharT> output;
     OutIt out_it{output};
-    std::basic_format_context context =
-        test_format_context_create(out_it, args);
+    std::basic_format_context<OutIt, CharT> context = test_format_context_create(out_it, args);
     LIBCPP_ASSERT(args.__size() == 4);
 
     assert(test_basic_format_arg(context.arg(0), true));
     assert(test_basic_format_arg(context.arg(1), CharT('a')));
     assert(test_basic_format_arg(context.arg(2), 42));
     assert(test_basic_format_arg(context.arg(3),
                                  std::basic_string_view<CharT>(string)));
 
     context.out() = CharT('a');
     assert(output.size() == 1);
     assert(output.front() == CharT('a'));
 
 #ifndef TEST_HAS_NO_LOCALIZATION
     assert(context.locale() == std::locale());
 #endif
   }
 
 #ifndef TEST_HAS_NO_LOCALIZATION
   std::locale en_US{LOCALE_en_US_UTF_8};
   std::locale fr_FR{LOCALE_fr_FR_UTF_8};
   {
     std::basic_string<CharT> output;
     OutIt out_it{output};
-    std::basic_format_context context =
-        test_format_context_create(out_it, args, en_US);
+    std::basic_format_context<OutIt, CharT> context = test_format_context_create(out_it, args, en_US);
 
     LIBCPP_ASSERT(args.__size() == 4);
     assert(test_basic_format_arg(context.arg(0), true));
     assert(test_basic_format_arg(context.arg(1), CharT('a')));
     assert(test_basic_format_arg(context.arg(2), 42));
     assert(test_basic_format_arg(context.arg(3),
                                  std::basic_string_view<CharT>(string)));
 
     context.out() = CharT('a');
     assert(output.size() == 1);
     assert(output.front() == CharT('a'));
 
     assert(context.locale() != fr_FR);
     assert(context.locale() == en_US);
   }
 
   {
     std::basic_string<CharT> output;
     OutIt out_it{output};
-    std::basic_format_context context =
-        test_format_context_create(out_it, args, fr_FR);
+    std::basic_format_context<OutIt, CharT> context = test_format_context_create(out_it, args, fr_FR);
 
     LIBCPP_ASSERT(args.__size() == 4);
     assert(test_basic_format_arg(context.arg(0), true));
     assert(test_basic_format_arg(context.arg(1), CharT('a')));
     assert(test_basic_format_arg(context.arg(2), 42));
     assert(test_basic_format_arg(context.arg(3),
                                  std::basic_string_view<CharT>(string)));
 

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/locale.pass.cpp

void test() {
   // to extend the lifetype of the object since args stores a pointer to the
   // data in this object.
   auto format_arg_store = std::make_format_args<std::basic_format_context<OutIt, CharT>>(true, CharT('a'), 42, string);
   std::basic_format_args args = format_arg_store;
 
   {
     std::basic_string<CharT> output;
     OutIt out_it{output};
-    std::basic_format_context context =
-        test_format_context_create(out_it, args, en_US);
+    std::basic_format_context<OutIt, CharT> context = test_format_context_create(out_it, args, en_US);
     assert(args.__size() == 4);
     assert(test_basic_format_arg(context.arg(0), true));
     assert(test_basic_format_arg(context.arg(1), CharT('a')));
     assert(test_basic_format_arg(context.arg(2), 42));
     assert(test_basic_format_arg(context.arg(3),
                                  std::basic_string_view<CharT>(string)));
 
     context.out() = CharT('a');
     assert(output.size() == 1);
     assert(output.front() == CharT('a'));
 
     assert(context.locale() != fr_FR);
     assert(context.locale() == en_US);
   }
 
   {
     std::basic_string<CharT> output;
     OutIt out_it{output};
-    std::basic_format_context context =
-        test_format_context_create(out_it, args, fr_FR);
+    std::basic_format_context<OutIt, CharT> context = test_format_context_create(out_it, args, fr_FR);
     assert(args.__size() == 4);
     assert(test_basic_format_arg(context.arg(0), true));
     assert(test_basic_format_arg(context.arg(1), CharT('a')));
     assert(test_basic_format_arg(context.arg(2), 42));
     assert(test_basic_format_arg(context.arg(3),
                                  std::basic_string_view<CharT>(string)));
 
     context.out() = CharT('a');

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/out.pass.cpp

 #include "test_format_context.h"
 
 template <class OutIt, class CharT>
 void test(
     std::basic_format_args<std::basic_format_context<OutIt, CharT>> args) {
   {
     std::basic_string<CharT> str;
     OutIt out_it{str};
-    std::basic_format_context context =
-        test_format_context_create(out_it, args);
+    std::basic_format_context<OutIt, CharT> context = test_format_context_create(out_it, args);
     context.out() = CharT('a');
     context.out() = CharT('b');
     context.out() = CharT('c');
 
     assert(str.size() == 3);
     assert(str[0] == CharT('a'));
     assert(str[1] == CharT('b'));
     assert(str[2] == CharT('c'));

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.handle.pass.cpp

void test(std::string expected, std::string_view fmt, color arg) {
 
   auto it = formatter.parse(parse_ctx);
   assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
 
   std::string result;
   auto out = std::back_inserter(result);
   using FormatCtxT = std::basic_format_context<decltype(out), char>;
 
-  std::basic_format_context format_ctx =
+  FormatCtxT format_ctx =
       test_format_context_create<decltype(out), char>(out, std::make_format_args<FormatCtxT>(arg));
   formatter.format(arg, format_ctx);
   assert(result == expected);
 }
 
 void test_termination_condition(std::string expected, std::string f, color arg) {
   // The format-spec is valid if completely consumed or terminates at a '}'.
   // The valid inputs all end with a '}'. The test is executed twice:

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.bool.pass.cpp

void test(StringT expected, StringViewT fmt, bool arg) {
 
   auto it = formatter.parse(parse_ctx);
   assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
 
   StringT result;
   auto out = std::back_inserter(result);
   using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
 
-  std::basic_format_context format_ctx =
+  FormatCtxT format_ctx =
       test_format_context_create<decltype(out), CharT>(out, std::make_format_args<FormatCtxT>(arg));
   formatter.format(arg, format_ctx);
   assert(result == expected);
 }
 
 template <class StringT>
 void test_termination_condition(StringT expected, StringT f, bool arg) {
   // The format-spec is valid if completely consumed or terminates at a '}'.

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.c_string.pass.cpp

void test(StringT expected, StringViewT fmt, const CharT* a) {
   auto it = formatter.parse(parse_ctx);
   assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
 
   StringT result;
   auto out = std::back_inserter(result);
   using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
 
   auto* arg = const_cast<T>(a);
-  std::basic_format_context format_ctx =
+  FormatCtxT format_ctx =
       test_format_context_create<decltype(out), CharT>(out, std::make_format_args<FormatCtxT>(arg));
   formatter.format(arg, format_ctx);
   assert(result == expected);
 }
 
 template <class ArgumentT, class StringT, class CharT>
 void test_termination_condition(StringT expected, StringT f, const CharT* arg) {
   // The format-spec is valid if completely consumed or terminates at a '}'.

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.char.pass.cpp

void test(StringT expected, StringViewT fmt, ArgumentT arg) {
 
   auto it = formatter.parse(parse_ctx);
   assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
 
   StringT result;
   auto out = std::back_inserter(result);
   using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
 
-  std::basic_format_context format_ctx =
+  FormatCtxT format_ctx =
       test_format_context_create<decltype(out), CharT>(out, std::make_format_args<FormatCtxT>(arg));
   formatter.format(arg, format_ctx);
   assert(result == expected);
 }
 
 template <class StringT, class ArgumentT>
 void test_termination_condition(StringT expected, StringT f, ArgumentT arg) {
   // The format-spec is valid if completely consumed or terminates at a '}'.

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.char_array.pass.cpp

void test(const std::basic_string<CharT>& expected, const std::basic_string_view<CharT>& fmt) const {
     std::basic_string<CharT> result;
     auto out = std::back_inserter(result);
     using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
 
     std::basic_string<CharT> buffer{text, text + N};
     // Note not too found of this hack
     Str* data = reinterpret_cast<Str*>(const_cast<CharT*>(buffer.c_str()));
 
-    std::basic_format_context format_ctx =
+    FormatCtxT format_ctx =
         test_format_context_create<decltype(out), CharT>(out, std::make_format_args<FormatCtxT>(*data));
     formatter.format(*data, format_ctx);
     assert(result == expected);
   }
 
   template <class CharT>
   void test_termination_condition(const std::basic_string<CharT>& expected, const std::basic_string<CharT>& f) const {
     // The format-spec is valid if completely consumed or terminates at a '}'.
     // The valid inputs all end with a '}'. The test is executed twice:
     // - first with the terminating '}',
     // - second consuming the entire input.
     std::basic_string_view<CharT> fmt{f};
     assert(fmt.back() == CharT('}') && "Pre-condition failure");
 
     test(expected, fmt);
     fmt.remove_suffix(1);
     test(expected, fmt);
   }
 };
 
+template <size_t N>
+Tester(const char (&)[N]) -> Tester<N>;
+
 template <Tester t, class CharT>
 void test_helper_wrapper(std::basic_string<CharT> expected, std::basic_string<CharT> fmt) {
   t.test_termination_condition(expected, fmt);
 }
 
 template <class CharT>
 void test_array() {
   test_helper_wrapper<" azAZ09,./<>?">(STR(" azAZ09,./<>?"), STR("}"));

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.const_char_array.pass.cpp

void test(const std::basic_string<CharT>& expected,
     std::basic_string<CharT> result;
     auto out = std::back_inserter(result);
     using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
 
     std::basic_string<CharT> buffer{text, text + N};
     // Note not too found of this hack
     Str* data = reinterpret_cast<Str*>(buffer.c_str());
 
-    std::basic_format_context format_ctx =
+    FormatCtxT format_ctx =
         test_format_context_create<decltype(out), CharT>(out, std::make_format_args<FormatCtxT>(*data));
     formatter.format(*data, format_ctx);
     assert(result == expected);
   }
 
   template <class CharT>
   void test_termination_condition(const std::basic_string<CharT>& expected,
                                   const std::basic_string<CharT>& f) const {
     // The format-spec is valid if completely consumed or terminates at a '}'.
     // The valid inputs all end with a '}'. The test is executed twice:
     // - first with the terminating '}',
     // - second consuming the entire input.
     std::basic_string_view<CharT> fmt{f};
     assert(fmt.back() == CharT('}') && "Pre-condition failure");
 
     test(expected, fmt);
     fmt.remove_suffix(1);
     test(expected, fmt);
   }
 };
 
+template <size_t N>
+Tester(const char (&)[N]) -> Tester<N>;
+
 template <Tester t, class CharT>
 void test_helper_wrapper(std::basic_string<CharT> expected,
                          std::basic_string<CharT> fmt) {
   t.test_termination_condition(expected, fmt);
 }
 
 template <class CharT>
 void test_array() {

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.floating_point.pass.cpp

void test(std::basic_string_view<CharT> fmt, ArithmeticT arg, std::basic_string<CharT> expected) {
 
   auto it = formatter.parse(parse_ctx);
   assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
 
   std::basic_string<CharT> result;
   auto out = std::back_inserter(result);
   using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
 
-  std::basic_format_context format_ctx =
+  FormatCtxT format_ctx =
       test_format_context_create<decltype(out), CharT>(out, std::make_format_args<FormatCtxT>(arg));
   formatter.format(arg, format_ctx);
 
   if (expected.empty()) {
     std::array<char, 128> buffer;
     expected.append(buffer.begin(), std::to_chars(buffer.begin(), buffer.end(), arg).ptr);
   }
 

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.pointer.pass.cpp

void test(StringT expected, StringViewT fmt, PointerT arg) {
 
   auto it = formatter.parse(parse_ctx);
   assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
 
   StringT result;
   auto out = std::back_inserter(result);
   using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
 
-  std::basic_format_context format_ctx =
+  FormatCtxT format_ctx =
       test_format_context_create<decltype(out), CharT>(out, std::make_format_args<FormatCtxT>(arg));
   formatter.format(arg, format_ctx);
 
   if (expected.empty()) {
     std::array<char, 128> buffer;
     buffer[0] = CharT('0');
     buffer[1] = CharT('x');
     expected.append(buffer.begin(),

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.signed_integral.pass.cpp

void test(StringT expected, StringViewT fmt, ArithmeticT arg) {
 
   auto it = formatter.parse(parse_ctx);
   assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
 
   StringT result;
   auto out = std::back_inserter(result);
   using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
 
-  std::basic_format_context format_ctx =
+  FormatCtxT format_ctx =
       test_format_context_create<decltype(out), CharT>(out, std::make_format_args<FormatCtxT>(arg));
   formatter.format(arg, format_ctx);
   assert(result == expected);
 }
 
 template <class StringT, class ArithmeticT>
 void test_termination_condition(StringT expected, StringT f, ArithmeticT arg) {
   // The format-spec is valid if completely consumed or terminates at a '}'.

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.string.pass.cpp

void test(StringT expected, StringViewT fmt, StringT a) {
   auto it = formatter.parse(parse_ctx);
   assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
 
   StringT result;
   auto out = std::back_inserter(result);
   using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
 
   ArgumentT arg = a;
-  std::basic_format_context format_ctx = test_format_context_create<decltype(out), CharT>(
+  FormatCtxT format_ctx = test_format_context_create<decltype(out), CharT>(
       out, std::make_format_args<FormatCtxT>(std::forward<ArgumentT>(arg)));
   formatter.format(arg, format_ctx);
   assert(result == expected);
 }
 
 template <class T, class ArgumentT, class StringT>
 void test_termination_condition(StringT expected, StringT f, StringT arg) {
   // The format-spec is valid if completely consumed or terminates at a '}'.

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.unsigned_integral.pass.cpp

void test(StringT expected, StringViewT fmt, ArithmeticT arg) {
 
   auto it = formatter.parse(parse_ctx);
   assert(it == fmt.end() - (!fmt.empty() && fmt.back() == '}'));
 
   StringT result;
   auto out = std::back_inserter(result);
   using FormatCtxT = std::basic_format_context<decltype(out), CharT>;
 
-  std::basic_format_context format_ctx =
+  FormatCtxT format_ctx =
       test_format_context_create<decltype(out), CharT>(out, std::make_format_args<FormatCtxT>(arg));
   formatter.format(arg, format_ctx);
   assert(result == expected);
 }
 
 template <class StringT, class ArithmeticT>
 void test_termination_condition(StringT expected, StringT f, ArithmeticT arg) {
   // The format-spec is valid if completely consumed or terminates at a '}'.

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/advance_to.pass.cpp

constexpr void test(const CharT* fmt) {
     context.advance_to(context.begin() + 1);
     assert(std::to_address(context.begin()) == fmt + 2);
 
     context.advance_to(context.begin() + 1);
     assert(context.begin() == context.end());
   }
   {
     std::basic_string_view view{fmt};
-    std::basic_format_parse_context context(view);
+    std::basic_format_parse_context<CharT> context(view);
 
     context.advance_to(context.begin() + 1);
     assert(std::to_address(context.begin()) == fmt + 1);
 
     context.advance_to(context.begin() + 1);
     assert(std::to_address(context.begin()) == fmt + 2);
 
     context.advance_to(context.begin() + 1);

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/begin.pass.cpp

 constexpr void test(const CharT* fmt) {
   {
     std::basic_format_parse_context<CharT> context(fmt);
     assert(std::to_address(context.begin()) == &fmt[0]);
     ASSERT_NOEXCEPT(context.begin());
   }
   {
     std::basic_string_view view{fmt};
-    std::basic_format_parse_context context(view);
+    std::basic_format_parse_context<CharT> context(view);
     assert(context.begin() == view.begin());
     ASSERT_NOEXCEPT(context.begin());
   }
 }
 
 constexpr bool test() {
   test("abc");
   test(L"abc");

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/ctor.pass.cpp

constexpr void test(const CharT* fmt) {
   // The move operations are implicitly deleted due to the
   // deleted copy operations.
   static_assert(
       !std::is_move_constructible_v<std::basic_format_parse_context<CharT> >);
   static_assert(
       !std::is_move_assignable_v<std::basic_format_parse_context<CharT> >);
 
   ASSERT_NOEXCEPT(
-      std::basic_format_parse_context{std::basic_string_view<CharT>{}});
+      std::basic_format_parse_context<CharT>{std::basic_string_view<CharT>{}});
   ASSERT_NOEXCEPT(
-      std::basic_format_parse_context{std::basic_string_view<CharT>{}, 42});
+      std::basic_format_parse_context<CharT>{std::basic_string_view<CharT>{}, 42});
 
   {
     std::basic_format_parse_context<CharT> context(fmt);
     assert(std::to_address(context.begin()) == &fmt[0]);
     assert(std::to_address(context.end()) == &fmt[3]);
   }
   {
     std::basic_string_view view{fmt};
-    std::basic_format_parse_context context(view);
+    std::basic_format_parse_context<CharT> context(view);
     assert(context.begin() == view.begin());
     assert(context.end() == view.end());
   }
 }
 
 constexpr bool test() {
   test("abc");
   test(L"abc");

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/end.pass.cpp

 constexpr void test(const CharT* fmt) {
   {
     std::basic_format_parse_context<CharT> context(fmt);
     assert(std::to_address(context.end()) == &fmt[3]);
     ASSERT_NOEXCEPT(context.end());
   }
   {
     std::basic_string_view view{fmt};
-    std::basic_format_parse_context context(view);
+    std::basic_format_parse_context<CharT> context(view);
     assert(context.end() == view.end());
     ASSERT_NOEXCEPT(context.end());
   }
 }
 
 constexpr bool test() {
   test("abc");
   test(L"abc");

libcxx/test/std/utilities/function.objects/func.bind_front/bind_front.pass.cpp

// Some examples by Tim Song
       using X = decltype(std::bind_front(F{}, T{}));
       static_assert(!std::is_invocable_v<X>);
     }
   }
 
   // Test properties of the constructor of the unspecified-type returned by bind_front.
   {
     {
-      MoveOnlyCallable value(true);
+      MoveOnlyCallable<bool> value(true);
       auto ret = std::bind_front(std::move(value), 1);
       assert(ret());
       assert(ret(1, 2, 3));
 
       auto ret1 = std::move(ret);
       assert(!ret());
       assert(ret1());
       assert(ret1(1, 2, 3));
 
       using RetT = decltype(ret);
       static_assert( std::is_move_constructible<RetT>::value);
       static_assert(!std::is_copy_constructible<RetT>::value);
       static_assert(!std::is_move_assignable<RetT>::value);
       static_assert(!std::is_copy_assignable<RetT>::value);
     }
     {
-      CopyCallable value(true);
+      CopyCallable<bool> value(true);
       auto ret = std::bind_front(value, 1);
       assert(ret());
       assert(ret(1, 2, 3));
 
       auto ret1 = std::move(ret);
       assert(ret1());
       assert(ret1(1, 2, 3));
 

libcxx/test/std/utilities/function.objects/func.search/func.search.bm/implicit_ctad.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++98, c++03, c++11, c++14
+
+// <functional>
+
+// boyer_moore_searcher
+
+// Make sure that the implicitly-generated CTAD works.
+
+#include <functional>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  {
+    char const* str = "hello";
+    std::boyer_moore_searcher searcher(str, str + 3);
+    ASSERT_SAME_TYPE(decltype(searcher), std::boyer_moore_searcher<char const*, std::hash<char>, std::equal_to<>>);
+  }
+  {
+    struct myhash : std::hash<char> { };
+    char const* str = "hello";
+    std::boyer_moore_searcher searcher(str, str + 3, myhash{}, std::not_equal_to<>());
+    ASSERT_SAME_TYPE(decltype(searcher), std::boyer_moore_searcher<char const*, myhash, std::not_equal_to<>>);
+  }
+  {
+    struct myhash : std::hash<char> { };
+    char const* str = "hello";
+    std::boyer_moore_searcher searcher(str, str + 3, myhash{});
+    ASSERT_SAME_TYPE(decltype(searcher), std::boyer_moore_searcher<char const*, myhash, std::equal_to<>>);
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/implicit_ctad.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++98, c++03, c++11, c++14
+
+// <functional>
+
+// boyer_moore_horspool_searcher
+
+// Make sure that the implicitly-generated CTAD works.
+
+#include <functional>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  {
+    char const* str = "hello";
+    std::boyer_moore_horspool_searcher searcher(str, str + 3);
+    ASSERT_SAME_TYPE(decltype(searcher), std::boyer_moore_horspool_searcher<char const*, std::hash<char>, std::equal_to<>>);
+  }
+  {
+    struct myhash : std::hash<char> { };
+    char const* str = "hello";
+    std::boyer_moore_horspool_searcher searcher(str, str + 3, myhash{}, std::not_equal_to<>());
+    ASSERT_SAME_TYPE(decltype(searcher), std::boyer_moore_horspool_searcher<char const*, myhash, std::not_equal_to<>>);
+  }
+  {
+    struct myhash : std::hash<char> { };
+    char const* str = "hello";
+    std::boyer_moore_horspool_searcher searcher(str, str + 3, myhash{});
+    ASSERT_SAME_TYPE(decltype(searcher), std::boyer_moore_horspool_searcher<char const*, myhash, std::equal_to<>>);
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/func.search/func.search.default/implicit_ctad.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++98, c++03, c++11, c++14
+
+// <functional>
+
+// default searcher
+
+// Make sure that the implicitly-generated CTAD works.
+
+#include <functional>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  {
+    char const* str = "hello";
+    std::default_searcher searcher(str, str + 3);
+    ASSERT_SAME_TYPE(decltype(searcher), std::default_searcher<char const*, std::equal_to<>>);
+  }
+  {
+    char const* str = "hello";
+    std::default_searcher searcher(str, str + 3, std::not_equal_to<>());
+    ASSERT_SAME_TYPE(decltype(searcher), std::default_searcher<char const*, std::not_equal_to<>>);
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/function.objects/operations.implicit_ctad.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++98, c++03, c++11, c++14
+
+// <functional>
+
+// Make sure that we can use CTAD with operations in <functional>
+
+#include <functional>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+    {
+        std::plus f;
+        ASSERT_SAME_TYPE(decltype(f), std::plus<>);
+    }
+    {
+        std::minus f;
+        ASSERT_SAME_TYPE(decltype(f), std::minus<>);
+    }
+    {
+        std::multiplies f;
+        ASSERT_SAME_TYPE(decltype(f), std::multiplies<>);
+    }
+    {
+        std::divides f;
+        ASSERT_SAME_TYPE(decltype(f), std::divides<>);
+    }
+    {
+        std::modulus f;
+        ASSERT_SAME_TYPE(decltype(f), std::modulus<>);
+    }
+    {
+        std::negate f;
+        ASSERT_SAME_TYPE(decltype(f), std::negate<>);
+    }
+    {
+        std::bit_and f;
+        ASSERT_SAME_TYPE(decltype(f), std::bit_and<>);
+    }
+    {
+        std::bit_not f;
+        ASSERT_SAME_TYPE(decltype(f), std::bit_not<>);
+    }
+    {
+        std::bit_or f;
+        ASSERT_SAME_TYPE(decltype(f), std::bit_or<>);
+    }
+    {
+        std::bit_xor f;
+        ASSERT_SAME_TYPE(decltype(f), std::bit_xor<>);
+    }
+    {
+        std::equal_to f;
+        ASSERT_SAME_TYPE(decltype(f), std::equal_to<>);
+    }
+    {
+        std::not_equal_to f;
+        ASSERT_SAME_TYPE(decltype(f), std::not_equal_to<>);
+    }
+    {
+        std::less f;
+        ASSERT_SAME_TYPE(decltype(f), std::less<>);
+    }
+    {
+        std::less_equal f;
+        ASSERT_SAME_TYPE(decltype(f), std::less_equal<>);
+    }
+    {
+        std::greater_equal f;
+        ASSERT_SAME_TYPE(decltype(f), std::greater_equal<>);
+    }
+    {
+        std::greater f;
+        ASSERT_SAME_TYPE(decltype(f), std::greater<>);
+    }
+    {
+        std::logical_and f;
+        ASSERT_SAME_TYPE(decltype(f), std::logical_and<>);
+    }
+    {
+        std::logical_not f;
+        ASSERT_SAME_TYPE(decltype(f), std::logical_not<>);
+    }
+    {
+        std::logical_or f;
+        ASSERT_SAME_TYPE(decltype(f), std::logical_or<>);
+    }
+
+    return 0;
+}

libcxx/test/support/callable_types.h

 #include "type_id.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 //                       CALLABLE TEST TYPES
 ///////////////////////////////////////////////////////////////////////////////
 
 constexpr bool returns_true() { return true; }
 
-template <class Ret = bool>
+template <class Ret>
 struct MoveOnlyCallable {
   MoveOnlyCallable(MoveOnlyCallable const&) = delete;
   constexpr MoveOnlyCallable(MoveOnlyCallable&& other)
       : value(other.value)
   { other.value = !other.value; }
 
   template <class ...Args>
   constexpr Ret operator()(Args&&...) { return Ret{value}; }
 
   constexpr explicit MoveOnlyCallable(bool x) : value(x) {}
   Ret value;
 };
 
-template <class Ret = bool>
+template <class Ret>
 struct CopyCallable {
   constexpr CopyCallable(CopyCallable const& other)
       : value(other.value) {}
 
   constexpr CopyCallable(CopyCallable&& other)
       : value(other.value) { other.value = !other.value; }
 
   template <class ...Args>
   constexpr Ret operator()(Args&&...) { return Ret{value}; }
 
   constexpr explicit CopyCallable(bool x) : value(x)  {}
   Ret value;
 };
 
 
-template <class Ret = bool>
+template <class Ret>
 struct ConstCallable {
   constexpr ConstCallable(ConstCallable const& other)
       : value(other.value) {}
 
   constexpr ConstCallable(ConstCallable&& other)
       : value(other.value) { other.value = !other.value; }
 
   template <class ...Args>
   constexpr Ret operator()(Args&&...) const { return Ret{value}; }
 
   constexpr explicit ConstCallable(bool x) : value(x)  {}
   Ret value;
 };
 
 
 
-template <class Ret = bool>
+template <class Ret>
 struct NoExceptCallable {
   constexpr NoExceptCallable(NoExceptCallable const& other)
       : value(other.value) {}
 
   template <class ...Args>
   constexpr Ret operator()(Args&&...) noexcept { return Ret{value}; }
 
   template <class ...Args>

libcxx/test/support/test_iterators.h

public:
     TEST_CONSTEXPR_CXX14 cpp17_output_iterator& operator++() {++it_; return *this;}
     TEST_CONSTEXPR_CXX14 cpp17_output_iterator operator++(int) {return cpp17_output_iterator(it_++);}
 
     friend TEST_CONSTEXPR It base(const cpp17_output_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
+#if TEST_STD_VER > 14
+template <class It>
+cpp17_output_iterator(It) -> cpp17_output_iterator<It>;
+#endif
+
 #if TEST_STD_VER > 17
    static_assert(std::output_iterator<cpp17_output_iterator<int*>, int>);
 #endif
 
 // This iterator meets C++20's Cpp17InputIterator requirements, as described
 // in Table 89 ([input.iterators]).
 template <class It, class ItTraits = It>
 class cpp17_input_iterator
public:
     friend TEST_CONSTEXPR bool operator==(const cpp17_input_iterator& x, const cpp17_input_iterator& y) {return x.it_ == y.it_;}
     friend TEST_CONSTEXPR bool operator!=(const cpp17_input_iterator& x, const cpp17_input_iterator& y) {return x.it_ != y.it_;}
 
     friend TEST_CONSTEXPR It base(const cpp17_input_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
+#if TEST_STD_VER > 14
+template <class It>
+cpp17_input_iterator(It) -> cpp17_input_iterator<It>;
+#endif
+
 #if TEST_STD_VER > 17
    static_assert(std::input_iterator<cpp17_input_iterator<int*>>);
 #endif
 
 template <class It>
 class forward_iterator
 {
     It it_;
public:
     friend TEST_CONSTEXPR bool operator==(const forward_iterator& x, const forward_iterator& y) {return x.it_ == y.it_;}
     friend TEST_CONSTEXPR bool operator!=(const forward_iterator& x, const forward_iterator& y) {return x.it_ != y.it_;}
 
     friend TEST_CONSTEXPR It base(const forward_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
+#if TEST_STD_VER > 14
+template <class It>
+forward_iterator(It) -> forward_iterator<It>;
+#endif
 
 template <class It>
 class bidirectional_iterator
 {
     It it_;
 
     template <class U> friend class bidirectional_iterator;
 public:
public:
     friend TEST_CONSTEXPR bool operator==(const bidirectional_iterator& x, const bidirectional_iterator& y) {return x.it_ == y.it_;}
     friend TEST_CONSTEXPR bool operator!=(const bidirectional_iterator& x, const bidirectional_iterator& y) {return x.it_ != y.it_;}
 
     friend TEST_CONSTEXPR It base(const bidirectional_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
+#if TEST_STD_VER > 14
+template <class It>
+bidirectional_iterator(It) -> bidirectional_iterator<It>;
+#endif
 
 template <class It>
 class random_access_iterator
 {
     It it_;
 
     template <class U> friend class random_access_iterator;
 public:
public:
     friend TEST_CONSTEXPR bool operator> (const random_access_iterator& x, const random_access_iterator& y) {return x.it_ >  y.it_;}
     friend TEST_CONSTEXPR bool operator>=(const random_access_iterator& x, const random_access_iterator& y) {return x.it_ >= y.it_;}
 
     friend TEST_CONSTEXPR It base(const random_access_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
+#if TEST_STD_VER > 14
+template <class It>
+random_access_iterator(It) -> random_access_iterator<It>;
+#endif
 
 #if TEST_STD_VER > 17
 
 template <std::random_access_iterator It>
 class cpp20_random_access_iterator {
   It it_;
 
   template <std::random_access_iterator>
friend constexpr bool operator>=(const cpp20_random_access_iterator& x, const cpp20_random_access_iterator& y) {
     return x.it_ >= y.it_;
   }
 
   friend constexpr It base(const cpp20_random_access_iterator& i) { return i.it_; }
 
   template <class T>
   void operator,(T const&) = delete;
 };
+template <class It>
+cpp20_random_access_iterator(It) -> cpp20_random_access_iterator<It>;
 
 static_assert(std::random_access_iterator<cpp20_random_access_iterator<int*>>);
 
 template <class It>
 class contiguous_iterator
 {
     static_assert(std::is_pointer_v<It>, "Things probably break in this case");
 
public:
     friend TEST_CONSTEXPR bool operator> (const contiguous_iterator& x, const contiguous_iterator& y) {return x.it_ >  y.it_;}
     friend TEST_CONSTEXPR bool operator>=(const contiguous_iterator& x, const contiguous_iterator& y) {return x.it_ >= y.it_;}
 
     friend TEST_CONSTEXPR It base(const contiguous_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
+template <class It>
+contiguous_iterator(It) -> contiguous_iterator<It>;
 
 template <class It>
 class three_way_contiguous_iterator
 {
     static_assert(std::is_pointer_v<It>, "Things probably break in this case");
 
     It it_;
 
public:
     friend constexpr difference_type operator-(three_way_contiguous_iterator x, three_way_contiguous_iterator y) {return x.it_ - y.it_;}
 
     friend constexpr auto operator<=>(const three_way_contiguous_iterator& x, const three_way_contiguous_iterator& y) {return x.it_ <=> y.it_;}
     friend constexpr bool operator==(const three_way_contiguous_iterator& x, const three_way_contiguous_iterator& y) {return x.it_ == y.it_;}
 
     template <class T>
     void operator,(T const &) = delete;
 };
+template <class It>
+three_way_contiguous_iterator(It) -> three_way_contiguous_iterator<It>;
 #endif // TEST_STD_VER > 17
 
 template <class Iter> // ADL base() for everything else (including pointers)
 TEST_CONSTEXPR Iter base(Iter i) { return i; }
 
 template <typename T>
 struct ThrowingIterator {
     typedef std::bidirectional_iterator_tag iterator_category;
public:
     constexpr cpp20_input_iterator& operator++() { ++it_; return *this; }
     constexpr void operator++(int) { ++it_; }
 
     friend constexpr It base(const cpp20_input_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
+template <class It>
+cpp20_input_iterator(It) -> cpp20_input_iterator<It>;
+
 static_assert(std::input_iterator<cpp20_input_iterator<int*>>);
 
 template<std::input_or_output_iterator>
 struct iter_value_or_void { using type = void; };
 
 template<std::input_iterator I>
 struct iter_value_or_void<I> {
     using type = std::iter_value_t<I>;
public:
   }
   constexpr cpp20_output_iterator operator++(int) { return cpp20_output_iterator(it_++); }
 
   friend constexpr It base(const cpp20_output_iterator& i) { return i.it_; }
 
   template <class T>
   void operator,(T const&) = delete;
 };
+template <class It>
+cpp20_output_iterator(It) -> cpp20_output_iterator<It>;
 
 static_assert(std::output_iterator<cpp20_output_iterator<int*>, int>);
 
 // Iterator adaptor that counts the number of times the iterator has had a successor/predecessor
 // operation called. Has two recorders:
 // * `stride_count`, which records the total number of calls to an op++, op--, op+=, or op-=.
 // * `stride_displacement`, which records the displacement of the calls. This means that both
 //   op++/op+= will increase the displacement counter by 1, and op--/op-= will decrease the
public:
     template <class T>
     void operator,(T const &) = delete;
 
 private:
     decltype(base(std::declval<It>())) base_;
     difference_type stride_count_ = 0;
     difference_type stride_displacement_ = 0;
 };
+template <class It>
+stride_counting_iterator(It) -> stride_counting_iterator<It>;
 
 #endif // TEST_STD_VER > 17
 
 #if TEST_STD_VER > 17
 template <class It>
 class sentinel_wrapper {
 public:
     explicit sentinel_wrapper() = default;
     constexpr explicit sentinel_wrapper(const It& it) : base_(base(it)) {}
     constexpr bool operator==(const It& other) const { return base_ == base(other); }
     friend constexpr It base(const sentinel_wrapper& s) { return It(s.base_); }
 private:
     decltype(base(std::declval<It>())) base_;
 };
+template <class It>
+sentinel_wrapper(It) -> sentinel_wrapper<It>;
 
 template <class It>
 class sized_sentinel {
 public:
     explicit sized_sentinel() = default;
     constexpr explicit sized_sentinel(const It& it) : base_(base(it)) {}
     constexpr bool operator==(const It& other) const { return base_ == base(other); }
     friend constexpr auto operator-(const sized_sentinel& s, const It& i) { return s.base_ - base(i); }
     friend constexpr auto operator-(const It& i, const sized_sentinel& s) { return base(i) - s.base_; }
     friend constexpr It base(const sized_sentinel& s) { return It(s.base_); }
 private:
     decltype(base(std::declval<It>())) base_;
 };
+template <class It>
+sized_sentinel(It) -> sized_sentinel<It>;
 
 namespace adl {
 
 class Iterator {
  public:
   using value_type = int;
   using reference = int&;
   using difference_type = ptrdiff_t;
friend constexpr ProxyIterator operator-(const ProxyIterator& x, difference_type n)
     return ProxyIterator{x.base_ - n};
   }
 
   friend constexpr difference_type operator-(const ProxyIterator& x, const ProxyIterator& y)
     requires std::random_access_iterator<Base> {
     return x.base_ - y.base_;
   }
 };
+template <class Base>
+ProxyIterator(Base) -> ProxyIterator<Base>;
 
 static_assert(std::indirectly_readable<ProxyIterator<int*>>);
 static_assert(std::indirectly_writable<ProxyIterator<int*>, Proxy<int>>);
 static_assert(std::indirectly_writable<ProxyIterator<int*>, Proxy<int&>>);
 
 template <class BaseSent>
 struct ProxySentinel {
   BaseSent base_;
 
   ProxySentinel() = default;
   constexpr ProxySentinel(BaseSent base) : base_{std::move(base)} {}
 
   template <class Base>
     requires std::equality_comparable_with<Base, BaseSent>
   friend constexpr bool operator==(const ProxyIterator<Base>& p, const ProxySentinel& sent) {
     return p.base_ == sent.base_;
   }
 };
+template <class BaseSent>
+ProxySentinel(BaseSent) -> ProxySentinel<BaseSent>;
 
 template <std::ranges::input_range Base>
   requires std::ranges::view<Base>
 struct ProxyRange {
   Base base_;
 
   constexpr auto begin() { return ProxyIterator{std::ranges::begin(base_)}; }
 

libcxx/utils/libcxx/test/params.py

 #===----------------------------------------------------------------------===##
 #
 # 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
 #
 #===----------------------------------------------------------------------===##
 
 from libcxx.test.dsl import *
 from libcxx.test.features import _isMSVC
 import re
 
 _warningFlags = [
   '-Werror',
   '-Wall',
+  '-Wctad-maybe-unsupported',
   '-Wextra',
   '-Wshadow',
   '-Wundef',
   '-Wno-unused-command-line-argument',
   '-Wno-attributes',
   '-Wno-pessimizing-move',
   '-Wno-c++11-extensions',
   '-Wno-noexcept-type',