[libc++] Enable -Wunused-template

[philnik]

Summary

Clang wants to enable this flag by default, but libc++ isn't working with it yet.

[philnik]

Try to fix CI

[philnik]

libcxx/test/std/time/time.hms/time.hms.nonmembers/ostream.pass.cpp

56 ↗

(On Diff #500169)

@Mordante Did you forget to use this function while implementing the test?

[Mordante]

LGTM, please wait for D144737 before landing this.

libcxx/test/std/time/time.hms/time.hms.nonmembers/ostream.pass.cpp

56 ↗

(On Diff #500169)

Yes the good old copy paste bugs ;-) See D144737 for the fix.

[Mordante]

FYI I landed the Japanese fixes.

[ldionne]

libcxx/include/__algorithm/make_projected.h

63–76 ↗

(On Diff #500169)

Those are templates, so they are implicitly inline. I would suggest not marking them at all.

89 ↗

(On Diff #500169)

Here too.

libcxx/include/__memory/shared_ptr.h

436–439

Here too.

libcxx/include/__type_traits/is_nothrow_convertible.h

30–33

Here too.

libcxx/src/filesystem/filesystem_common.h

51

Which functions in this file trigger the warning?

[philnik]

Address comments

[philnik]

libcxx/src/filesystem/filesystem_common.h

51

I don't know exactly, but this has to be cleaned up anyways. Currently, everything in this file is inside an anonymous namespace and marked static. I don't know why it's this way, but I don't think there is a good reason for it.

[EricWF]

How is libc++ not working with it yet a blocker for them? We disable warnings in our headers except outside of our build?

[philnik]

In D144667#4176253, @EricWF wrote:

How is libc++ not working with it yet a blocker for them? We disable warnings in our headers except outside of our build?

TBH I don't know exactly why. It's a good idea to enable anyways.

[philnik]

Try to fix CI

[philnik]

Next try

libcxx/CMakeLists.txt

function(cxx_add_warning_flags target)
   target_compile_definitions(${target} PUBLIC -D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
   if (MSVC)
     # -W4 is the cl.exe/clang-cl equivalent of -Wall. (In cl.exe and clang-cl,
     # -Wall is equivalent to -Weverything in GCC style compiler drivers.)
     target_add_compile_flags_if_supported(${target} PRIVATE -W4)
   else()
     target_add_compile_flags_if_supported(${target} PRIVATE -Wall)
   endif()
-  target_add_compile_flags_if_supported(${target} PRIVATE -Wextra -W -Wwrite-strings
-                                                          -Wno-unused-parameter -Wno-long-long
-                                                          -Werror=return-type -Wextra-semi -Wundef
+  target_add_compile_flags_if_supported(${target} PRIVATE -Wextra
+                                                          -W
+                                                          -Wwrite-strings
+                                                          -Wno-unused-parameter
+                                                          -Wno-long-long
+                                                          -Werror=return-type
+                                                          -Wextra-semi
+                                                          -Wundef
+                                                          -Wunused-template
                                                           -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
     )
     if (LIBCXX_TARGETING_CLANG_CL)

libcxx/include/__config

 #    endif
 #  endif
 
 // There are a handful of public 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
+#  if _LIBCPP_STD_VER >= 17
 #    define _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(_ClassName)                                                                \
-      template <class ..._Tag>                                                                                         \
-      _ClassName(typename _Tag::__allow_ctad...) -> _ClassName<_Tag...>
-#else
-#  define _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(_ClassName) static_assert(true, "")
-#endif
+      template <class... _Tag>                                                                                         \
+      [[maybe_unused]] _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/__memory/shared_ptr.h

 
 template <class _Ptr, class = void>
 struct __is_array_deletable : false_type { };
 template <class _Ptr>
 struct __is_array_deletable<_Ptr, decltype(delete[] std::declval<_Ptr>())> : true_type { };
 
 template <class _Dp, class _Pt,
     class = decltype(std::declval<_Dp>()(std::declval<_Pt>()))>
-static true_type __well_formed_deleter_test(int);
+inline true_type __well_formed_deleter_test(int);
 
 template <class, class>
-static false_type __well_formed_deleter_test(...);
+inline false_type __well_formed_deleter_test(...);
 
 template <class _Dp, class _Pt>
 struct __well_formed_deleter : decltype(std::__well_formed_deleter_test<_Dp, _Pt>(0)) {};
 
 template<class _Dp, class _Yp, class _Tp>
 struct __shared_ptr_deleter_ctor_reqs
 {
     static const bool value = __raw_pointer_compatible_with<_Yp, _Tp>::value &&

libcxx/include/__type_traits/is_nothrow_convertible.h

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

libcxx/src/filesystem/filesystem_common.h

 #if !defined(__APPLE__)
 // We can use the presence of UTIME_OMIT to detect platforms that provide
 // utimensat.
 #if defined(UTIME_OMIT)
 #define _LIBCPP_USE_UTIMENSAT
 #endif
 #endif
 
+// TODO: Check whether these functions actually need internal linkage, or if they can be made normal header functions
 _LIBCPP_DIAGNOSTIC_PUSH
 _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wunused-function")
 _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wunused-function")
+_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wunused-template")
 
 #if defined(_LIBCPP_WIN32API)
 #  define PATHSTR(x) (L##x)
 #  define PATH_CSTR_FMT "\"%ls\""
 #else
 #  define PATHSTR(x) (x)
 #  define PATH_CSTR_FMT "\"%s\""
 #endif

libcxx/utils/libcxx/test/params.py

 
 _warningFlags = [
   '-Werror',
   '-Wall',
   '-Wctad-maybe-unsupported',
   '-Wextra',
   '-Wshadow',
   '-Wundef',
+  '-Wunused-template',
   '-Wno-unused-command-line-argument',
   '-Wno-attributes',
   '-Wno-pessimizing-move',
   '-Wno-c++11-extensions',
   '-Wno-noexcept-type',
   '-Wno-aligned-allocation-unavailable',
   '-Wno-atomic-alignment',