clang/test/SemaCXX/exceptions.cpp

   1 // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s
   2 // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++98 %s
   3 // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 %s
   4
   5 struct A; // expected-note 4 {{forward declaration of 'A'}}
   6
   7 struct Abstract { virtual void f() = 0; }; // expected-note {{unimplemented pure virtual method 'f'}}
   8
   9 void trys() {
  10   int k = 42;
  11   try {
  12   } catch(int i) { // expected-note {{previous definition}}
  13     int j = i;
  14     int i; // expected-error {{redefinition of 'i'}}
  15   } catch(float i) {
  16   } catch(void v) { // expected-error {{cannot catch incomplete type 'void'}}
  17   } catch(A a) { // expected-error {{cannot catch incomplete type 'A'}}
  18   } catch(A *a) { // expected-error {{cannot catch pointer to incomplete type 'A'}}
  19   } catch(A &a) { // expected-error {{cannot catch reference to incomplete type 'A'}}
  20   } catch(Abstract) { // expected-error {{variable type 'Abstract' is an abstract class}}
  21   } catch(...) {
  22     int ref = k;
  23     {
  24       int ref = k;
  25     }
  26     int j = i; // expected-error {{use of undeclared identifier 'i'}}
  27   }
  28
  29   try {
  30   } catch(...) { // expected-error {{catch-all handler must come last}}
  31   } catch(int) {
  32   }
  33 }
  34
  35 void throws() {
  36   throw;
  37   throw 0;
  38   throw throw; // expected-error {{cannot throw object of incomplete type 'void'}}
  39   throw (A*)0; // expected-error {{cannot throw pointer to object of incomplete type 'A'}}
  40 }
  41
  42 void jumps() {
  43 l1:
  44   goto l5;
  45   goto l4; // expected-error {{cannot jump}}
  46   goto l3; // expected-error {{cannot jump}}
  47   goto l2; // expected-error {{cannot jump}}
  48   goto l1;
  49   try { // expected-note 4 {{jump bypasses initialization of try block}}
  50   l2:
  51     goto l5;
  52     goto l4; // expected-error {{cannot jump}}
  53     goto l3; // expected-error {{cannot jump}}
  54     goto l2;
  55     goto l1;
  56   } catch(int) { // expected-note 4 {{jump bypasses initialization of catch block}}
  57   l3:
  58     goto l5;
  59     goto l4; // expected-error {{cannot jump}}
  60     goto l3;
  61     goto l2; // expected-error {{cannot jump}}
  62     goto l1;
  63   } catch(...) { // expected-note 4 {{jump bypasses initialization of catch block}}
  64   l4:
  65     goto l5;
  66     goto l4;
  67     goto l3; // expected-error {{cannot jump}}
  68     goto l2; // expected-error {{cannot jump}}
  69     goto l1;
  70   }
  71 l5:
  72   goto l5;
  73   goto l4; // expected-error {{cannot jump}}
  74   goto l3; // expected-error {{cannot jump}}
  75   goto l2; // expected-error {{cannot jump}}
  76   goto l1;
  77 }
  78
  79 struct BadReturn {
  80   BadReturn() try {
  81   } catch(...) {
  82     // Try to hide
  83     try {
  84     } catch(...) {
  85       {
  86         if (0)
  87           return; // expected-error {{return in the catch of a function try block of a constructor is illegal}}
  88       }
  89     }
  90   }
  91   BadReturn(int);
  92 };
  93
  94 BadReturn::BadReturn(int) try {
  95 } catch(...) {
  96   // Try to hide
  97   try {
  98   } catch(int) {
  99     return; // expected-error {{return in the catch of a function try block of a constructor is illegal}}
 100   } catch(...) {
 101     {
 102       if (0)
 103         return; // expected-error {{return in the catch of a function try block of a constructor is illegal}}
 104     }
 105   }
 106 }
 107
 108 // Cannot throw an abstract type.
 109 class foo {
 110 public:
 111   foo() {}
 112   void bar () {
 113     throw *this; // expected-error{{cannot throw an object of abstract type 'foo'}}
 114   }
 115   virtual void test () = 0; // expected-note{{unimplemented pure virtual method 'test'}}
 116 };
 117
 118 namespace PR6831 {
 119   namespace NA { struct S; }
 120   namespace NB { struct S; }
 121
 122   void f() {
 123     using namespace NA;
 124     using namespace NB;
 125     try {
 126     } catch (int S) {
 127     }
 128   }
 129 }
 130
 131 namespace Decay {
 132   struct A {
 133     void f() throw (A[10]);
 134   };
 135
 136   template<typename T> struct B {
 137     void f() throw (B[10]);
 138   };
 139   template struct B<int>;
 140
 141   void f() throw (int[10], int(*)());
 142   void f() throw (int*, int());
 143
 144   template<typename T> struct C {
 145     void f() throw (T);
 146 #if __cplusplus <= 199711L
 147     // expected-error@-2 {{pointer to incomplete type 'Decay::E' is not allowed in exception specification}}
 148 #endif
 149   };
 150   struct D {
 151     C<D[10]> c;
 152   };
 153   struct E;
 154 #if __cplusplus <= 199711L
 155   // expected-note@-2 {{forward declaration of 'Decay::E'}}
 156 #endif
 157
 158   C<E[10]> e;
 159 #if __cplusplus <= 199711L
 160   // expected-note@-2 {{in instantiation of template class 'Decay::C<Decay::E[10]>' requested here}}
 161 #endif
 162 }
 163
 164 void rval_ref() throw (int &&); // expected-error {{rvalue reference type 'int &&' is not allowed in exception specification}}
 165 #if __cplusplus <= 199711L
 166 // expected-warning@-2 {{rvalue references are a C++11 extension}}
 167 #endif
 168
 169 namespace HandlerInversion {
 170 struct B {};
 171 struct D : B {};
 172 struct D2 : D {};
 173
 174 void f1() {
 175   try {
 176   } catch (B &b) { // expected-note {{for type 'HandlerInversion::B &'}}
 177   } catch (D &d) { // expected-warning {{exception of type 'HandlerInversion::D &' will be caught by earlier handler}}
 178   }
 179 }
 180
 181 void f2() {
 182   try {
 183   } catch (B *b) { // expected-note {{for type 'HandlerInversion::B *'}}
 184   } catch (D *d) { // expected-warning {{exception of type 'HandlerInversion::D *' will be caught by earlier handler}}
 185   }
 186 }
 187
 188 void f3() {
 189   try {
 190   } catch (D &d) { // Ok
 191   } catch (B &b) {
 192   }
 193 }
 194
 195 void f4() {
 196   try {
 197   } catch (B &b) { // Ok
 198   }
 199 }
 200
 201 void f5() {
 202   try {
 203   } catch (int) {
 204   } catch (float) {
 205   }
 206 }
 207
 208 void f6() {
 209   try {
 210   } catch (B &b) {  // expected-note {{for type 'HandlerInversion::B &'}}
 211   } catch (D2 &d) {  // expected-warning {{exception of type 'HandlerInversion::D2 &' will be caught by earlier handler}}
 212   }
 213 }
 214
 215 void f7() {
 216   try {
 217   } catch (B *b) { // Ok
 218   } catch (D &d) { // Ok
 219   }
 220
 221   try {
 222   } catch (B b) { // Ok
 223   } catch (D *d) { // Ok
 224   }
 225 }
 226
 227 void f8() {
 228   try {
 229   } catch (const B &b) {  // expected-note {{for type 'const HandlerInversion::B &'}}
 230   } catch (D2 &d) {  // expected-warning {{exception of type 'HandlerInversion::D2 &' will be caught by earlier handler}}
 231   }
 232
 233   try {
 234   } catch (B &b) {  // expected-note {{for type 'HandlerInversion::B &'}}
 235   } catch (const D2 &d) {  // expected-warning {{exception of type 'const HandlerInversion::D2 &' will be caught by earlier handler}}
 236   }
 237
 238   try {
 239   } catch (B b) { // expected-note {{for type 'HandlerInversion::B'}}
 240   } catch (D &d) { // expected-warning {{exception of type 'HandlerInversion::D &' will be caught by earlier handler}}
 241   }
 242 }
 243 }
 244
 245 namespace ConstVolatileThrow {
 246 struct S {
 247   S() {}         // expected-note{{candidate constructor not viable}}
 248   S(const S &s); // expected-note{{candidate constructor not viable}}
 249 };
 250
 251 typedef const volatile S CVS;
 252
 253 void f() {
 254   throw CVS(); // expected-error{{no matching constructor for initialization}}
 255 }
 256 }
 257
 258 namespace ConstVolatileCatch {
 259 struct S {
 260   S() {}
 261   S(const volatile S &s);
 262
 263 private:
 264   S(const S &s); // expected-note {{declared private here}}
 265 };
 266
 267 void f();
 268
 269 void g() {
 270   try {
 271     f();
 272   } catch (volatile S s) { // expected-error {{calling a private constructor}}
 273   }
 274 }
 275 }
 276
 277 namespace PR28047 {
 278 void test1(int i) {
 279   try {
 280   } catch (int(*)[i]) { // expected-error{{cannot catch variably modified type}}
 281   }
 282 }
 283 void test2() {
 284   int i;
 285   try {
 286   } catch (int(*)[i]) { // expected-error{{cannot catch variably modified type}}
 287   }
 288 }
 289 }