dr17xx.cpp
3.26 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
namespace dr1715 { // dr1715: 3.9
#if __cplusplus >= 201103L
struct B {
template<class T> B(T, typename T::Q);
};
class S {
using Q = int;
template<class T> friend B::B(T, typename T::Q);
};
struct D : B {
using B::B;
};
struct E : B { // expected-note 2{{candidate}}
template<class T> E(T t, typename T::Q q) : B(t, q) {} // expected-note {{'Q' is a private member}}
};
B b(S(), 1);
D d(S(), 2);
E e(S(), 3); // expected-error {{no match}}
#endif
}
namespace dr1736 { // dr1736: 3.9
#if __cplusplus >= 201103L
struct S {
template <class T> S(T t) {
struct L : S {
using S::S;
};
typename T::type value; // expected-error {{no member}}
L l(value); // expected-note {{instantiation of}}
}
};
struct Q { typedef int type; } q;
S s(q); // expected-note {{instantiation of}}
#endif
}
namespace dr1753 { // dr1753: 11
typedef int T;
struct A { typedef int T; };
namespace B { typedef int T; }
void f(T n) {
n.~T();
n.T::~T();
n.dr1753::~T(); // expected-error {{'dr1753' does not refer to a type name in pseudo-destructor}}
n.dr1753::T::~T();
n.A::~T(); // expected-error {{the type of object expression ('dr1753::T' (aka 'int')) does not match the type being destroyed ('dr1753::A') in pseudo-destructor expression}}
n.A::T::~T();
n.B::~T(); // expected-error {{'B' does not refer to a type name in pseudo-destructor expression}}
n.B::T::~T();
#if __cplusplus >= 201103L
n.decltype(n)::~T(); // expected-error {{not a class, namespace, or enumeration}}
n.T::~decltype(n)(); // expected-error {{expected a class name after '~'}}
n.~decltype(n)(); // OK
#endif
}
}
namespace dr1756 { // dr1756: 3.7
#if __cplusplus >= 201103L
// Direct-list-initialization of a non-class object
int a{0};
struct X { operator int(); } x;
int b{x};
#endif
}
namespace dr1758 { // dr1758: 3.7
#if __cplusplus >= 201103L
// Explicit conversion in copy/move list initialization
struct X { X(); };
struct Y { explicit operator X(); } y;
X x{y};
struct A {
A() {}
A(const A &) {}
};
struct B {
operator A() { return A(); }
} b;
A a{b};
#endif
}
namespace dr1722 { // dr1722: 9
#if __cplusplus >= 201103L
void f() {
const auto lambda = [](int x) { return x + 1; };
// Without the DR applied, this static_assert would fail.
static_assert(
noexcept((int (*)(int))(lambda)),
"Lambda-to-function-pointer conversion is expected to be noexcept");
}
#endif
} // namespace dr1722
namespace dr1778 { // dr1778: 9
// Superseded by P1286R2.
#if __cplusplus >= 201103L
struct A { A() noexcept(true) = default; };
struct B { B() noexcept(false) = default; };
static_assert(noexcept(A()), "");
static_assert(!noexcept(B()), "");
struct C { A a; C() noexcept(false) = default; };
struct D { B b; D() noexcept(true) = default; };
static_assert(!noexcept(C()), "");
static_assert(noexcept(D()), "");
#endif
}