[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 ↗

(On Diff #464058)

nice catch.

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

43 ↗

(On Diff #464058)

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/include/__config

 #  endif
 
 #  if __has_attribute(__packed__)
 #    define _LIBCPP_PACKED __attribute__((__packed__))
 #  else
 #    define _LIBCPP_PACKED
 #  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<void>
+#else
+#  define _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(_ClassName) static_assert(true, "")
+#endif
+
 #endif // __cplusplus
 
 #endif // _LIBCPP___CONFIG

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/__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/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/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/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/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/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/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',