[libcxx] Portability fix: add missing includes and static_casts.

[amakc11]

Summary

This patch fixes the following portability issues in the tests.

Issue 1. Some tests use entitites defined in the standard header files, but do not include these headers directly. As a result, these tests do not compile under some conformant implementations.

Issue 2. Types wctrans_t and wctype_t are required to be scalar (ISO/IEC 9899:1999, section 7.25.1). Type std::ios_base::fmtflags is required to be bitmask (see standard requirement). Neither of these types is required to be integer, and therefore can be implemented, for example, as enum. As a result, any assignment of an integer value to variables of these types without an explicit cast does not compile under some conformant implementations.

[mclow.lists]

The includes look fine. The static_casts (as always) look ugly. Once you make the changes that I've requested, you can commit this.

test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long.pass.cpp

114

Don't repeat this over and over.
Declare a const std::ios_base::fmtflags and initialize it once.

test/std/strings/c.strings/cwctype.pass.cpp

95

This is really ugly. I find it hard to believe that any implementation would force this on it's users.

In any case, we don't actually need to initialize these variables at all.
Really, this test should be rewritten to use ASSERT_SAME_TYPE and declval

Just drop this change from the patch, and I'll fix up this test myself.

[amakc11]

In D55777#1334589, @mclow.lists wrote:

The includes look fine. The static_casts (as always) look ugly. Once you make the changes that I've requested, you can commit this.

The requested changes applied. I can't commit the patch myself: I don't have rights to do this.

[mclow.lists]

I can't commit the patch myself: I don't have rights to do this.

Ok; I'll do it.

[mclow.lists]

Did you run these tests after adding the includes?
The "poisoned hash" tests fail - because poisoned_hash_helper.hpp now includes various hash specializations.
In fact, it causes clang to crash (I've reported PR 40093 for that).
I'll remove the changes to "poisoned_hash_helper.hpp" and see what happens.

[mclow.lists]

Committed all of this except "poisoned_hash_helper.hpp" as revision 349566

[amakc11]

I don't use clang. The log of running tests including poisoned_hash_helper.hpp is attached.

poisoned_helper_tests.log3 KBDownload

[ldionne]

In D55777#1335694, @amakc11 wrote:

I don't use clang. The log of running tests including poisoned_hash_helper.hpp is attached.

poisoned_helper_tests.log3 KBDownload

Please start running the test suite with Clang before submitting patches here. Every single time you submit a patch, it doesn't build for me or one of the other maintainers -- that doesn't work.

Don't get me wrong -- I strongly appreciate you cleaning up the test suite, however contributing patches that don't work on the main implementation used to run the test suite is not a viable way forward.

[amakc11]

With respect to this particular patch, I would rather wait for the final verdict on the Clang bug Marshall reported recently. If it is a real bug in compiler, than the patch should be considered as both a portability fix and a bug catcher.

[amakc11]

ping

test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp

 // <unordered_map>
 
 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_map
 
 // unordered_map& operator=(const unordered_map& u);
 
+#include <algorithm>
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cmath>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 

test/std/depr/depr.c.headers/wctype_h.pass.cpp

 
 #ifdef wctrans
 #error wctrans defined
 #endif
 
 int main()
 {
     wint_t w = 0;
-    wctrans_t wctr = 0;
-    wctype_t wct = 0;
+    wctrans_t wctr = static_cast<wctrans_t>(0);
+    wctype_t wct = static_cast<wctype_t>(0);
     static_assert((std::is_same<decltype(iswalnum(w)), int>::value), "");
     static_assert((std::is_same<decltype(iswalpha(w)), int>::value), "");
     static_assert((std::is_same<decltype(iswblank(w)), int>::value), "");
     static_assert((std::is_same<decltype(iswcntrl(w)), int>::value), "");
     static_assert((std::is_same<decltype(iswdigit(w)), int>::value), "");
     static_assert((std::is_same<decltype(iswgraph(w)), int>::value), "");
     static_assert((std::is_same<decltype(iswlower(w)), int>::value), "");
     static_assert((std::is_same<decltype(iswprint(w)), int>::value), "");

test/std/input.output/iostream.format/ext.manip/get_money.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <iomanip>
 
 // template <class moneyT> T7 get_money(moneyT& mon, bool intl = false);
 
 // REQUIRES: locale.en_US.UTF-8
 
 #include <iomanip>
+#include <istream>
 #include <cassert>
 
 #include "platform_support.h" // locale name macros
 
 template <class CharT>
 struct testbuf
     : public std::basic_streambuf<CharT>
 {

test/std/input.output/iostream.format/ext.manip/get_time.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: locale.en_US.UTF-8
 
 // <iomanip>
 
 // template <class charT> T9 get_time(struct tm* tmb, const charT* fmt);
 
 #include <iomanip>
+#include <istream>
 #include <cassert>
 
 #include "platform_support.h" // locale name macros
 
 template <class CharT>
 struct testbuf
     : public std::basic_streambuf<CharT>
 {

test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <iomanip>
 
 // template <class charT, class moneyT> T8 put_money(const moneyT& mon, bool intl = false);
 
 // REQUIRES: locale.en_US.UTF-8
 
 #include <iomanip>
+#include <ostream>
 #include <cassert>
 
 #include "platform_support.h" // locale name macros
 
 template <class CharT>
 class testbuf
     : public std::basic_streambuf<CharT>
 {

test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: locale.en_US.UTF-8
 
 // <iomanip>
 
 // template <class charT> T10 put_time(const struct tm* tmb, const charT* fmt);
 
 #include <iomanip>
+#include <ostream>
 #include <cassert>
 
 #include "platform_support.h" // locale name macros
 
 template <class CharT>
 class testbuf
     : public std::basic_streambuf<CharT>
 {

test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/int.pass.cpp

 // <istream>
 
 // template <class charT, class traits = char_traits<charT> >
 //   class basic_istream;
 
 // operator>>(int& val);
 
 #include <istream>
+#include <limits>
 #include <cassert>
 
 template <class CharT>
 struct testbuf
     : public std::basic_streambuf<CharT>
 {
     typedef std::basic_string<CharT> string_type;
     typedef std::basic_streambuf<CharT> base;

test/std/input.output/iostream.format/input.streams/istream.formatted/istream.formatted.arithmetic/short.pass.cpp

 // <istream>
 
 // template <class charT, class traits = char_traits<charT> >
 //   class basic_istream;
 
 // operator>>(short& val);
 
 #include <istream>
+#include <limits>
 #include <cassert>
 
 template <class CharT>
 struct testbuf
     : public std::basic_streambuf<CharT>
 {
     typedef std::basic_string<CharT> string_type;
     typedef std::basic_streambuf<CharT> base;

test/std/input.output/iostream.format/std.manip/resetiosflags.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <iomanip>
 
 // T1 resetiosflags(ios_base::fmtflags mask);
 
 #include <iomanip>
+#include <istream>
+#include <ostream>
 #include <cassert>
 
 template <class CharT>
 struct testbuf
     : public std::basic_streambuf<CharT>
 {
     testbuf() {}
 };

test/std/input.output/iostream.format/std.manip/setbase.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <iomanip>
 
 // T3 setbase(int base);
 
 #include <iomanip>
+#include <istream>
+#include <ostream>
 #include <cassert>
 
 template <class CharT>
 struct testbuf
     : public std::basic_streambuf<CharT>
 {
     testbuf() {}
 };

test/std/input.output/iostream.format/std.manip/setfill.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <iomanip>
 
 // template<charT> T4 setfill(charT c);
 
 #include <iomanip>
+#include <ostream>
 #include <cassert>
 
 template <class CharT>
 struct testbuf
     : public std::basic_streambuf<CharT>
 {
     testbuf() {}
 };

test/std/input.output/iostream.format/std.manip/setiosflags.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <iomanip>
 
 // T2 setiosflags (ios_base::fmtflags mask);
 
 #include <iomanip>
+#include <istream>
+#include <ostream>
 #include <cassert>
 
 template <class CharT>
 struct testbuf
     : public std::basic_streambuf<CharT>
 {
     testbuf() {}
 };

test/std/input.output/iostream.format/std.manip/setprecision.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <iomanip>
 
 // T5 setprecision(int n);
 
 #include <iomanip>
+#include <istream>
+#include <ostream>
 #include <cassert>
 
 template <class CharT>
 struct testbuf
     : public std::basic_streambuf<CharT>
 {
     testbuf() {}
 };

test/std/input.output/iostream.format/std.manip/setw.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <iomanip>
 
 // T6 setw(int n);
 
 #include <iomanip>
+#include <istream>
+#include <ostream>
 #include <cassert>
 
 template <class CharT>
 struct testbuf
     : public std::basic_streambuf<CharT>
 {
     testbuf() {}
 };

test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_out.pass.cpp

 //            const internT* from, const internT* from_end, const internT*& from_next,
 //            externT* to, externT* to_end, externT*& to_next) const;
 
 #include <locale>
 #include <string>
 #include <vector>
 #include <cassert>
 #include <cstddef>
+#include <cstring>
 
 typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
 
 int main()
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     {

test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long.pass.cpp

 // class num_get<charT, InputIterator>
 
 // iter_type get(iter_type in, iter_type end, ios_base&,
 //               ios_base::iostate& err, long& v) const;
 
 #include <locale>
 #include <ios>
 #include <cassert>
+#include <limits>
 #include <streambuf>
 #include "test_iterators.h"
 
 typedef std::num_get<char, input_iterator<const char*> > F;
 
 class my_facet
     : public F
 {
long v = -1;
                   input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 291);
     }
     {
         const char str[] = "123";
-        ios.setf(0, ios.basefield);
+        ios.setf(static_cast<std::ios_base::fmtflags>(0), ios.basefield);
         std::ios_base::iostate err = ios.goodbit;
         input_iterator<const char*> iter =
             f.get(input_iterator<const char*>(str),
                   input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 123);
     }
     {
         const char str[] = "0x123";
-        ios.setf(0, ios.basefield);
+        ios.setf(static_cast<std::ios_base::fmtflags>(0), ios.basefield);
         std::ios_base::iostate err = ios.goodbit;
         input_iterator<const char*> iter =
             f.get(input_iterator<const char*>(str),
                   input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 291);
     }
     {
         const char str[] = "0123";
-        ios.setf(0, ios.basefield);
+        ios.setf(static_cast<std::ios_base::fmtflags>(0), ios.basefield);
         std::ios_base::iostate err = ios.goodbit;
         input_iterator<const char*> iter =
             f.get(input_iterator<const char*>(str),
                   input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
         assert(v == 83);
     }
     {
         const char str[] = "2-";
-        ios.setf(0, ios.basefield);
+        ios.setf(static_cast<std::ios_base::fmtflags>(0), ios.basefield);
         std::ios_base::iostate err = ios.goodbit;
         input_iterator<const char*> iter =
             f.get(input_iterator<const char*>(str),
                   input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+1);
         assert(err == ios.goodbit);
         assert(v == 2);

test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // class num_get<charT, InputIterator>
 
 // iter_type get(iter_type in, iter_type end, ios_base&,
 //               ios_base::iostate& err, unsigned int& v) const;
 
+#include <limits>
 #include <locale>
 #include <ios>
 #include <cassert>
 #include <streambuf>
 #include <sstream>
 #include <iostream>
 #include "test_iterators.h"
 #include "test_macros.h"

test/std/strings/c.strings/cwchar.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <cwchar>
 
 #include <cwchar>
+#include <ctime>
 #include <cstdarg>
 #include <type_traits>
 
 #ifndef NULL
 #error NULL not defined
 #endif
 
 #ifndef WCHAR_MAX

test/std/strings/c.strings/cwctype.pass.cpp

 
 #ifdef wctrans
 #error wctrans defined
 #endif
 
 int main()
 {
     std::wint_t w = 0;
-    std::wctrans_t wctr = 0;
-    std::wctype_t wct = 0;
+    std::wctrans_t wctr = static_cast<std::wctrans_t>(0);
+    std::wctype_t wct = static_cast<std::wctype_t>(0);
     static_assert((std::is_same<decltype(std::iswalnum(w)), int>::value), "");
     static_assert((std::is_same<decltype(std::iswalpha(w)), int>::value), "");
     static_assert((std::is_same<decltype(std::iswblank(w)), int>::value), "");
     static_assert((std::is_same<decltype(std::iswcntrl(w)), int>::value), "");
     static_assert((std::is_same<decltype(std::iswdigit(w)), int>::value), "");
     static_assert((std::is_same<decltype(std::iswgraph(w)), int>::value), "");
     static_assert((std::is_same<decltype(std::iswlower(w)), int>::value), "");
     static_assert((std::is_same<decltype(std::iswprint(w)), int>::value), "");

test/std/strings/string.conversions/to_string.pass.cpp

 // string to_string(long val);
 // string to_string(unsigned long val);
 // string to_string(long long val);
 // string to_string(unsigned long long val);
 // string to_string(float val);
 // string to_string(double val);
 // string to_string(long double val);
 
+#include <limits>
 #include <string>
 #include <cassert>
 #include <sstream>
 
 template <class T>
 void
 test_signed()
 {

test/std/strings/string.conversions/to_wstring.pass.cpp

 // wstring to_wstring(long val);
 // wstring to_wstring(unsigned long val);
 // wstring to_wstring(long long val);
 // wstring to_wstring(unsigned long long val);
 // wstring to_wstring(float val);
 // wstring to_wstring(double val);
 // wstring to_wstring(long double val);
 
+#include <limits>
 #include <string>
 #include <cassert>
 #include <sstream>
 
 template <class T>
 void
 test_signed()
 {

test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp

 
 // template <class Alloc>
 // struct allocator_traits
 // {
 //     static size_type max_size(const allocator_type& a) noexcept;
 //     ...
 // };
 
+#include <limits>
 #include <memory>
 #include <new>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "incomplete_type_helper.h"
 

test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp

 // <tuple>
 
 // template <class... Types> class tuple;
 
 // tuple& operator=(tuple&& u);
 
 // UNSUPPORTED: c++98, c++03
 
+#include <memory>
 #include <tuple>
 #include <utility>
 #include <cassert>
 
 #include "MoveOnly.h"
 
 struct NonAssignable {
   NonAssignable& operator=(NonAssignable const&) = delete;

test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03
 
 // <tuple>
 
 // See llvm.org/PR20855
 
+#include <functional>
 #include <tuple>
 #include <string>
 #include <cassert>
 #include "test_macros.h"
 
 #if TEST_HAS_BUILTIN_IDENTIFIER(__reference_binds_to_temporary)
 # define ASSERT_REFERENCE_BINDS_TEMPORARY(...) static_assert(__reference_binds_to_temporary(__VA_ARGS__), "")
 # define ASSERT_NOT_REFERENCE_BINDS_TEMPORARY(...) static_assert(!__reference_binds_to_temporary(__VA_ARGS__), "")

test/std/utilities/type.index/type.index.hash/hash.pass.cpp

 // template <>
 // struct hash<type_index>
 //     : public unary_function<type_index, size_t>
 // {
 //     size_t operator()(type_index index) const;
 // };
 
 #include <typeindex>
+#include <type_traits>
 #include <cassert>
 
 int main()
 {
     typedef std::hash<std::type_index> H;
     static_assert((std::is_same<typename H::argument_type, std::type_index>::value), "" );
     static_assert((std::is_same<typename H::result_type, std::size_t>::value), "" );
 
     std::type_index t1 = typeid(int);
     assert(std::hash<std::type_index>()(t1) == t1.hash_code());
 }

test/support/poisoned_hash_helper.hpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #ifndef SUPPORT_POISONED_HASH_HELPER_HPP
 #define SUPPORT_POISONED_HASH_HELPER_HPP
 
+#include <cstddef>
 #include <type_traits>
+#include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_workarounds.h"
 
 #if TEST_STD_VER < 11
 #error this header may only be used in C++11 or newer
 #endif