1 //===----------------------------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 // <utility>
11
12 // template <class T1, class T2> struct pair
13
14 // Test the SFINAE required by LWG Issue #2367.
15 // is_default_constructible<pair>
16
17 // UNSUPPORTED: c++98, c++03
18
19 #include <utility>
20 #include <type_traits>
21 #include <cassert>
22
23 #include "test_macros.h"
24
25 #if TEST_STD_VER > 11
26 #define CONSTEXPR_CXX14 constexpr
27 #define STATIC_ASSERT_CXX14(Pred) static_assert(Pred, "")
28 #else
29 #define CONSTEXPR_CXX14
30 #define STATIC_ASSERT_CXX14(Pred) assert(Pred)
31 #endif
32
33 struct DeletedDefault {
34 // A class with a deleted default constructor. Used to test the SFINAE
35 // on std::pair's default constructor.
DeletedDefaultDeletedDefault36 constexpr explicit DeletedDefault(int x) : value(x) {}
37 constexpr DeletedDefault() = delete;
38 int value;
39 };
40
41 template <class Tp, bool>
42 struct DependantType: public Tp {};
43
44 template <class T, bool Val>
45 using DependantIsDefault = DependantType<std::is_default_constructible<T>, Val>;
46
47 template <class T>
48 struct DefaultSFINAES {
49 template <bool Dummy = false, class = typename std::enable_if<
50 DependantIsDefault<T, Dummy>::value
51 >::type
52 >
DefaultSFINAESDefaultSFINAES53 constexpr DefaultSFINAES() : value() {}
DefaultSFINAESDefaultSFINAES54 constexpr explicit DefaultSFINAES(T const& x) : value(x) {}
55 T value;
56 };
57
58 struct NoDefault {
NoDefaultNoDefault59 constexpr NoDefault(int v) : value(v) {}
60 int value;
61 };
62
63 template <class Tp>
test_not_is_default_constructible()64 void test_not_is_default_constructible()
65 {
66 {
67 typedef std::pair<int, Tp> P;
68 static_assert(!std::is_default_constructible<P>::value, "");
69 static_assert(std::is_constructible<P, int, Tp>::value, "");
70 }
71 {
72 typedef std::pair<Tp, int> P;
73 static_assert(!std::is_default_constructible<P>::value, "");
74 static_assert(std::is_constructible<P, Tp, int>::value, "");
75 }
76 {
77 typedef std::pair<Tp, Tp> P;
78 static_assert(!std::is_default_constructible<P>::value, "");
79 static_assert(std::is_constructible<P, Tp, Tp>::value, "");
80 }
81 }
82
83 template <class Tp>
test_is_default_constructible()84 void test_is_default_constructible()
85 {
86 {
87 typedef std::pair<int, Tp> P;
88 static_assert(std::is_default_constructible<P>::value, "");
89 }
90 {
91 typedef std::pair<Tp, int> P;
92 static_assert(std::is_default_constructible<P>::value, "");
93 }
94 {
95 typedef std::pair<Tp, Tp> P;
96 static_assert(std::is_default_constructible<P>::value, "");
97 }
98 }
99
100 template <class T>
101 struct IllFormedDefaultImp {
IllFormedDefaultImpIllFormedDefaultImp102 constexpr explicit IllFormedDefaultImp(int v) : value(v) {}
IllFormedDefaultImpIllFormedDefaultImp103 constexpr IllFormedDefaultImp() : value(T::DoesNotExistAndShouldNotCompile) {}
104 int value;
105 };
106
107 typedef IllFormedDefaultImp<int> IllFormedDefault;
108 // A class which provides a constexpr default constructor with a valid
109 // signature but an ill-formed body. The A compile error will be emitted if
110 // the default constructor is instantiated.
111
112
113 // Check that the SFINAE on the default constructor is not evaluated when
114 // it isn't needed. If the default constructor of 'IllFormedDefault' is evaluated
115 // in C++11, even with is_default_constructible, then this test should fail to
116 // compile. In C++14 and greater evaluate each test is evaluated as a constant
117 // expression.
118 // See LWG issue #2367
test_illformed_default()119 void test_illformed_default()
120 {
121 {
122 typedef std::pair<IllFormedDefault, int> P;
123 static_assert((std::is_constructible<P, IllFormedDefault, int>::value), "");
124 CONSTEXPR_CXX14 P p(IllFormedDefault(42), -5);
125 STATIC_ASSERT_CXX14(p.first.value == 42 && p.second == -5);
126 }
127 {
128 typedef std::pair<int, IllFormedDefault> P;
129 static_assert((std::is_constructible<P, int, IllFormedDefault>::value), "");
130 CONSTEXPR_CXX14 IllFormedDefault dd(-5);
131 CONSTEXPR_CXX14 P p(42, dd);
132 STATIC_ASSERT_CXX14(p.first == 42 && p.second.value == -5);
133 }
134 {
135 typedef std::pair<IllFormedDefault, IllFormedDefault> P;
136 static_assert((std::is_constructible<P, IllFormedDefault, IllFormedDefault>::value), "");
137 CONSTEXPR_CXX14 P p(IllFormedDefault(42), IllFormedDefault(-5));
138 STATIC_ASSERT_CXX14(p.first.value == 42 && p.second.value == -5);
139 }
140 }
141
142
main()143 int main()
144 {
145 {
146 // Check that pair<T, U> can still be used even if
147 // is_default_constructible<T> or is_default_constructible<U> cause
148 // a compilation error.
149 test_illformed_default();
150 }
151 {
152 // pair::pair() is only disable in C++11 and beyond.
153 test_not_is_default_constructible<NoDefault>();
154 test_not_is_default_constructible<DeletedDefault>();
155 test_not_is_default_constructible<DefaultSFINAES<int&>>();
156 test_not_is_default_constructible<DefaultSFINAES<int&&>>();
157 test_not_is_default_constructible<int&>();
158 test_not_is_default_constructible<int&&>();
159 }
160 {
161 test_is_default_constructible<int>();
162 test_is_default_constructible<DefaultSFINAES<int>>();
163 }
164 }
165