1 // RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -verify -std=c++11 -Wall %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 {
20     bool b = noexcept(ConstExpr()) && ThrowSomething(); // expected-error {{cannot be used by non-static data member initializer}}
21   };
22   // We can use it now.
23   bool w = noexcept(ConstExpr());
24 
25   // Much more obviously broken: we can't parse the initializer without already
26   // knowing whether it produces a noexcept expression.
27   struct TemplateArg {
28     int n = ExceptionIf<noexcept(TemplateArg())>::f(); // expected-error {{cannot be used by non-static data member initializer}}
29   };
30   bool x = noexcept(TemplateArg());
31 
32   // And within a nested class.
33   // FIXME: The diagnostic location is terrible here.
34   struct Nested {
35     struct Inner {
36       int n = ExceptionIf<noexcept(Nested())>::f();
37     } inner; // expected-error {{cannot be used by non-static data member initializer}}
38   };
39   bool y = noexcept(Nested());
40   bool z = noexcept(Nested::Inner());
41 
42   struct Nested2 {
43     struct Inner;
44     int n = Inner().n; // expected-error {{cannot be used by non-static data member initializer}}
45     struct Inner {
46       int n = ExceptionIf<noexcept(Nested())>::f();
47     } inner;
48   };
49 }
50 
51 namespace ExceptionSpecification {
52   // A type is permitted to be used in a dynamic exception specification when it
53   // is still being defined, but isn't complete within such an exception
54   // specification.
55   struct Nested { // expected-note {{not complete}}
56     struct T {
57       T() noexcept(!noexcept(Nested())); // expected-error{{incomplete type}}
58     } t;
59   };
60 }
61 
62 namespace DefaultArgument {
63   struct Default {
64     struct T {
65       T(int = ExceptionIf<noexcept(Default())::f()); // expected-error {{call to implicitly-deleted default constructor}}
66     } t; // expected-note {{has no default constructor}}
67   };
68 }
69 
70 namespace ImplicitDtorExceptionSpec {
71   struct A {
72     virtual ~A();
73 
74     struct Inner {
75       ~Inner() throw();
76     };
77     Inner inner;
78   };
79 
80   struct B {
81     virtual ~B() {} // expected-note {{here}}
82   };
83 
84   struct C : B {
85     virtual ~C() {}
86     A a;
87   };
88 
89   struct D : B {
90     ~D(); // expected-error {{more lax than base}}
91     struct E {
92       ~E();
93       struct F {
94         ~F() throw(A);
95       } f;
96     } e;
97   };
98 }
99