1 // RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -verify -std=c++11 -Wall -Wno-unused-local-typedefs %s
2 
3 template<bool b> struct ExceptionIf { static int f(); };
4 template<> struct ExceptionIf<false> { typedef int f; };
5 
6 // The exception specification of a defaulted default constructor depends on
7 // the contents of in-class member initializers. However, the in-class member
8 // initializers can depend on the exception specification of the constructor,
9 // since the class is considered complete within them. We reject any such cases.
10 namespace InClassInitializers {
11   // Noexcept::Noexcept() is implicitly declared as noexcept(false), because it
12   // directly invokes ThrowSomething(). However...
13   //
14   // If noexcept(Noexcept()) is false, then Noexcept() is a constant expression,
15   // so noexcept(Noexcept()) is true. But if noexcept(Noexcept()) is true, then
16   // Noexcept::Noexcept is not declared constexpr, therefore noexcept(Noexcept())
17   // is false.
18   bool ThrowSomething() noexcept(false);
19   struct ConstExpr { // expected-error {{default member initializer for 'b' needed}}
20     bool b = // expected-note {{declared here}}
21       noexcept(ConstExpr()) && ThrowSomething(); // expected-note {{in evaluation of exception spec}}
22   };
23 
24   // Much more obviously broken: we can't parse the initializer without already
25   // knowing whether it produces a noexcept expression.
26   struct TemplateArg { // expected-error {{default member initializer for 'n' needed}}
27     int n = // expected-note {{declared here}}
28       ExceptionIf<noexcept(TemplateArg())>::f(); // expected-note {{in evaluation of exception spec}}
29   };
30 
31   // And within a nested class.
32   struct Nested {
33     struct Inner { // expected-error {{default member initializer for 'n' needed}}
34       int n = // expected-note {{declared here}}
35         ExceptionIf<noexcept(Nested())>::f(); // expected-note {{in evaluation of exception spec}}
36     } inner; // expected-note {{in evaluation of exception spec}}
37   };
38 
39   struct Nested2 {
40     struct Inner;
41     int n = Inner().n; // expected-note {{in evaluation of exception spec}}
42     struct Inner { // expected-error {{initializer for 'n' needed}}
43       int n = ExceptionIf<noexcept(Nested2())>::f(); // expected-note {{declared here}}
44     } inner;
45   };
46 }
47 
48 namespace ExceptionSpecification {
49   struct Nested {
50     struct T {
51       T() noexcept(!noexcept(Nested())); // expected-note {{in evaluation of exception spec}}
52     } t; // expected-error{{exception specification is not available until end of class definition}}
53   };
54 }
55 
56 namespace DefaultArgument {
57   // FIXME: We should detect and diagnose the cyclic dependence of
58   // noexcept(Default()) on itself here.
59   struct Default {
60     struct T {
61       T(int = ExceptionIf<noexcept(Default())>::f());
62     } t;
63   };
64 }
65 
66 namespace ImplicitDtorExceptionSpec {
67   struct A {
68     virtual ~A();
69 
70     struct Inner {
71       ~Inner() throw();
72     };
73     Inner inner;
74   };
75 
76   struct B {
~BImplicitDtorExceptionSpec::B77     virtual ~B() {} // expected-note {{here}}
78   };
79 
80   struct C : B {
~CImplicitDtorExceptionSpec::C81     virtual ~C() {}
82     A a;
83   };
84 
85   struct D : B {
86     ~D(); // expected-error {{more lax than base}}
87     struct E {
88       ~E();
89       struct F {
90         ~F() throw(A);
91       } f;
92     } e;
93   };
94 }
95 
96 struct nothrow_t {} nothrow;
97 void *operator new(decltype(sizeof(0)), nothrow_t) noexcept;
98 
99 namespace PotentiallyConstructed {
100   template<bool NE> struct A {
101     A() noexcept(NE);
102     A(const A&) noexcept(NE);
103     A(A&&) noexcept(NE);
104     A &operator=(const A&) noexcept(NE);
105     A &operator=(A&&) noexcept(NE);
106     ~A() noexcept(NE);
107   };
108 
109   template<bool NE> struct B : virtual A<NE> {};
110 
111   template<bool NE> struct C : virtual A<NE> {
112     virtual void f() = 0; // expected-note 2{{unimplemented}}
113   };
114 
115   template<bool NE> struct D final : C<NE> {
116     void f();
117   };
118 
check()119   template<typename T, bool A, bool B, bool C, bool D, bool E, bool F> void check() {
120     T *p = nullptr;
121     T &a = *p;
122     static_assert(noexcept(a = a) == D, "");
123     static_assert(noexcept(a = static_cast<T&&>(a)) == E, "");
124     static_assert(noexcept(delete &a) == F, "");
125 
126     // These are last because the first failure here causes instantiation to bail out.
127     static_assert(noexcept(new (nothrow) T()) == A, ""); // expected-error 2{{abstract}}
128     static_assert(noexcept(new (nothrow) T(a)) == B, "");
129     static_assert(noexcept(new (nothrow) T(static_cast<T&&>(a))) == C, "");
130   }
131 
132   template void check<A<false>, 0, 0, 0, 0, 0, 0>();
133   template void check<A<true >, 1, 1, 1, 1, 1, 1>();
134   template void check<B<false>, 0, 0, 0, 0, 0, 0>();
135   template void check<B<true >, 1, 1, 1, 1, 1, 1>();
136   template void check<C<false>, 1, 1, 1, 0, 0, 0>(); // expected-note {{instantiation}}
137   template void check<C<true >, 1, 1, 1, 1, 1, 1>(); // expected-note {{instantiation}}
138   template void check<D<false>, 0, 0, 0, 0, 0, 0>();
139   template void check<D<true >, 1, 1, 1, 1, 1, 1>();
140 
141   // ... the above trick doesn't work for this case...
142   struct Cfalse : virtual A<false> {
143     virtual void f() = 0;
144 
145     Cfalse() noexcept;
146     Cfalse(const Cfalse&) noexcept;
147     Cfalse(Cfalse&&) noexcept;
148   };
149   Cfalse::Cfalse() noexcept = default;
150   Cfalse::Cfalse(const Cfalse&) noexcept = default;
151   Cfalse::Cfalse(Cfalse&&) noexcept = default;
152 }
153