Clang Project

clang_source_code/test/SemaCXX/implicit-exception-spec.cpp
1// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -verify -std=c++11 -Wall -Wno-unused-local-typedefs %s
2
3template<bool b> struct ExceptionIf { static int f(); };
4template<> 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.
10namespace 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
48namespace 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
56namespace DefaultArgument {
57  struct Default {
58    struct T {
59      T(int = ExceptionIf<noexcept(Default())::f()); // expected-error {{call to implicitly-deleted default constructor}}
60    } t; // expected-note {{has no default constructor}}
61  };
62}
63
64namespace ImplicitDtorExceptionSpec {
65  struct A {
66    virtual ~A();
67
68    struct Inner {
69      ~Inner() throw();
70    };
71    Inner inner;
72  };
73
74  struct B {
75    virtual ~B() {} // expected-note {{here}}
76  };
77
78  struct C : B {
79    virtual ~C() {}
80    A a;
81  };
82
83  struct D : B {
84    ~D(); // expected-error {{more lax than base}}
85    struct E {
86      ~E();
87      struct F {
88        ~F() throw(A);
89      } f;
90    } e;
91  };
92}
93
94struct nothrow_t {} nothrow;
95void *operator new(decltype(sizeof(0)), nothrow_t) noexcept;
96
97namespace PotentiallyConstructed {
98  template<bool NE> struct A {
99    A() noexcept(NE);
100    A(const A&) noexcept(NE);
101    A(A&&) noexcept(NE);
102    A &operator=(const A&) noexcept(NE);
103    A &operator=(A&&) noexcept(NE);
104    ~A() noexcept(NE);
105  };
106
107  template<bool NE> struct B : virtual A<NE> {};
108
109  template<bool NE> struct C : virtual A<NE> {
110    virtual void f() = 0; // expected-note 2{{unimplemented}}
111  };
112
113  template<bool NE> struct D final : C<NE> {
114    void f();
115  };
116
117  template<typename T, bool A, bool B, bool C, bool D, bool E, bool F> void check() {
118    T *p = nullptr;
119    T &a = *p;
120    static_assert(noexcept(a = a) == D, "");
121    static_assert(noexcept(a = static_cast<T&&>(a)) == E, "");
122    static_assert(noexcept(delete &a) == F, "");
123
124    // These are last because the first failure here causes instantiation to bail out.
125    static_assert(noexcept(new (nothrow) T()) == A, ""); // expected-error 2{{abstract}}
126    static_assert(noexcept(new (nothrow) T(a)) == B, "");
127    static_assert(noexcept(new (nothrow) T(static_cast<T&&>(a))) == C, "");
128  }
129
130  template void check<A<false>, 0, 0, 0, 0, 0, 0>();
131  template void check<A<true >, 1, 1, 1, 1, 1, 1>();
132  template void check<B<false>, 0, 0, 0, 0, 0, 0>();
133  template void check<B<true >, 1, 1, 1, 1, 1, 1>();
134  template void check<C<false>, 1, 1, 1, 0, 0, 0>(); // expected-note {{instantiation}}
135  template void check<C<true >, 1, 1, 1, 1, 1, 1>(); // expected-note {{instantiation}}
136  template void check<D<false>, 0, 0, 0, 0, 0, 0>();
137  template void check<D<true >, 1, 1, 1, 1, 1, 1>();
138
139  // ... the above trick doesn't work for this case...
140  struct Cfalse : virtual A<false> {
141    virtual void f() = 0;
142
143    Cfalse() noexcept;
144    Cfalse(const Cfalse&) noexcept;
145    Cfalse(Cfalse&&) noexcept;
146  };
147  Cfalse::Cfalse() noexcept = default;
148  Cfalse::Cfalse(const Cfalse&) noexcept = default;
149  Cfalse::Cfalse(Cfalse&&) noexcept = default;
150}
151
CodeThinker, Enjoy your reading code