clang/test/SemaCXX/scope-check.cpp

   1 // RUN: %clang_cc1 -triple x86_64-windows -fsyntax-only -verify -fblocks -fcxx-exceptions -fms-extensions %s -Wno-unreachable-code
   2 // RUN: %clang_cc1 -triple x86_64-windows -fsyntax-only -verify -fblocks -fcxx-exceptions -fms-extensions -std=gnu++11 %s -Wno-unreachable-code
   3
   4 namespace testInvalid {
   5 Invalid inv; // expected-error {{unknown type name}}
   6 // Make sure this doesn't assert.
   7 void fn()
   8 {
   9     int c = 0;
  10     if (inv)
  11 Here: ;
  12     goto Here;
  13 }
  14 }
  15
  16 namespace test0 {
  17   struct D { ~D(); };
  18
  19   int f(bool b) {
  20     if (b) {
  21       D d;
  22       goto end;
  23     }
  24
  25   end:
  26     return 1;
  27   }
  28 }
  29
  30 namespace test1 {
  31   struct C { C(); };
  32
  33   int f(bool b) {
  34     if (b)
  35       goto foo; // expected-error {{cannot jump}}
  36     C c; // expected-note {{jump bypasses variable initialization}}
  37   foo:
  38     return 1;
  39   }
  40 }
  41
  42 namespace test2 {
  43   struct C { C(); };
  44
  45   int f(void **ip) {
  46     static void *ips[] = { &&lbl1, &&lbl2 };
  47
  48     C c;
  49     goto *ip;
  50   lbl1:
  51     return 0;
  52   lbl2:
  53     return 1;
  54   }
  55 }
  56
  57 namespace test3 {
  58   struct C { C(); };
  59
  60   int f(void **ip) {
  61     static void *ips[] = { &&lbl1, &&lbl2 };
  62
  63     goto *ip;
  64   lbl1: {
  65     C c;
  66     return 0;
  67   }
  68   lbl2:
  69     return 1;
  70   }
  71 }
  72
  73 namespace test4 {
  74   struct C { C(); };
  75   struct D { ~D(); };
  76
  77   int f(void **ip) {
  78     static void *ips[] = { &&lbl1, &&lbl2 };
  79
  80     C c0;
  81
  82     goto *ip; // expected-error {{cannot jump}}
  83     C c1; // expected-note {{jump bypasses variable initialization}}
  84   lbl1: // expected-note {{possible target of indirect goto}}
  85     return 0;
  86   lbl2:
  87     return 1;
  88   }
  89 }
  90
  91 namespace test5 {
  92   struct C { C(); };
  93   struct D { ~D(); };
  94
  95   int f(void **ip) {
  96     static void *ips[] = { &&lbl1, &&lbl2 };
  97     C c0;
  98
  99     goto *ip;
 100   lbl1: // expected-note {{possible target of indirect goto}}
 101     return 0;
 102   lbl2:
 103     if (ip[1]) {
 104       D d; // expected-note {{jump exits scope of variable with non-trivial destructor}}
 105       ip += 2;
 106       goto *ip; // expected-error {{cannot jump}}
 107     }
 108     return 1;
 109   }
 110 }
 111
 112 namespace test6 {
 113   struct C { C(); };
 114
 115   unsigned f(unsigned s0, unsigned s1, void **ip) {
 116     static void *ips[] = { &&lbl1, &&lbl2, &&lbl3, &&lbl4 };
 117     C c0;
 118
 119     goto *ip;
 120   lbl1:
 121     s0++;
 122     goto *++ip;
 123   lbl2:
 124     s0 -= s1;
 125     goto *++ip;
 126   lbl3: {
 127     unsigned tmp = s0;
 128     s0 = s1;
 129     s1 = tmp;
 130     goto *++ip;
 131   }
 132   lbl4:
 133     return s0;
 134   }
 135 }
 136
 137 // C++0x says it's okay to skip non-trivial initializers on static
 138 // locals, and we implement that in '03 as well.
 139 namespace test7 {
 140   struct C { C(); };
 141
 142   void test() {
 143     goto foo;
 144     static C c;
 145   foo:
 146     return;
 147   }
 148 }
 149
 150 // PR7789
 151 namespace test8 {
 152   void test1(int c) {
 153     switch (c) {
 154     case 0:
 155       int x = 56; // expected-note {{jump bypasses variable initialization}}
 156     case 1:       // expected-error {{cannot jump}}
 157       x = 10;
 158     }
 159   }
 160
 161   void test2() {
 162     goto l2;     // expected-error {{cannot jump}}
 163   l1: int x = 5; // expected-note {{jump bypasses variable initialization}}
 164   l2: x++;
 165   }
 166 }
 167
 168 namespace test9 {
 169   struct S { int i; };
 170   void test1() {
 171     goto foo;
 172     S s;
 173   foo:
 174     return;
 175   }
 176   unsigned test2(unsigned x, unsigned y) {
 177     switch (x) {
 178     case 2:
 179       S s;
 180       if (y > 42) return x + y;
 181     default:
 182       return x - 2;
 183     }
 184   }
 185 }
 186
 187 // http://llvm.org/PR10462
 188 namespace PR10462 {
 189   enum MyEnum {
 190     something_valid,
 191     something_invalid
 192   };
 193
 194   bool recurse() {
 195     MyEnum K;
 196     switch (K) { // do not warn that 'something_invalid' is not listed;
 197                  // 'what_am_i_thinking' might have been intended to be that case.
 198     case something_valid:
 199     case what_am_i_thinking: // expected-error {{use of undeclared identifier}}
 200       int *X = 0;
 201       if (recurse()) {
 202       }
 203
 204       break;
 205     }
 206   }
 207 }
 208
 209 namespace test10 {
 210   int test() {
 211     static void *ps[] = { &&a0 };
 212     goto *&&a0; // expected-error {{cannot jump}}
 213     int a = 3; // expected-note {{jump bypasses variable initialization}}
 214   a0:
 215     return 0;
 216   }
 217 }
 218
 219 // pr13812
 220 namespace test11 {
 221   struct C {
 222     C(int x);
 223     ~C();
 224   };
 225   void f(void **ip) {
 226     static void *ips[] = { &&l0 };
 227   l0:  // expected-note {{possible target of indirect goto}}
 228     C c0 = 42; // expected-note {{jump exits scope of variable with non-trivial destructor}}
 229     goto *ip; // expected-error {{cannot jump}}
 230   }
 231 }
 232
 233 namespace test12 {
 234   struct C {
 235     C(int x);
 236     ~C();
 237   };
 238   void f(void **ip) {
 239     static void *ips[] = { &&l0 };
 240     const C c0 = 17;
 241   l0: // expected-note {{possible target of indirect goto}}
 242     const C &c1 = 42; // expected-note {{jump exits scope of lifetime-extended temporary with non-trivial destructor}}
 243     const C &c2 = c0;
 244     goto *ip; // expected-error {{cannot jump}}
 245   }
 246 }
 247
 248 namespace test13 {
 249   struct C {
 250     C(int x);
 251     ~C();
 252     int i;
 253   };
 254   void f(void **ip) {
 255     static void *ips[] = { &&l0 };
 256   l0: // expected-note {{possible target of indirect goto}}
 257     const int &c1 = C(1).i; // expected-note {{jump exits scope of lifetime-extended temporary with non-trivial destructor}}
 258     goto *ip;  // expected-error {{cannot jump}}
 259   }
 260 }
 261
 262 namespace test14 {
 263   struct C {
 264     C(int x);
 265     ~C();
 266     operator int&() const;
 267   };
 268   void f(void **ip) {
 269     static void *ips[] = { &&l0 };
 270   l0:
 271     // no warning since the C temporary is destructed before the goto.
 272     const int &c1 = C(1);
 273     goto *ip;
 274   }
 275 }
 276
 277 // PR14225
 278 namespace test15 {
 279   void f1() try {
 280     goto x; // expected-error {{cannot jump}}
 281   } catch(...) {  // expected-note {{jump bypasses initialization of catch block}}
 282     x: ;
 283   }
 284   void f2() try {  // expected-note {{jump bypasses initialization of try block}}
 285     x: ;
 286   } catch(...) {
 287     goto x; // expected-error {{cannot jump}}
 288   }
 289 }
 290
 291 namespace test16 {
 292   struct S { int n; };
 293   int f() {
 294     goto x; // expected-error {{cannot jump}}
 295     const S &s = S(); // expected-note {{jump bypasses variable initialization}}
 296 x:  return s.n;
 297   }
 298 }
 299
 300 #if __cplusplus >= 201103L
 301 namespace test17 {
 302   struct S { int get(); private: int n; };
 303   int f() {
 304     goto x; // expected-error {{cannot jump}}
 305     S s = {}; // expected-note {{jump bypasses variable initialization}}
 306 x:  return s.get();
 307   }
 308 }
 309 #endif
 310
 311 namespace test18 {
 312   struct A { ~A(); };
 313   struct B { const int &r; const A &a; };
 314   int f() {
 315     void *p = &&x;
 316     const A a = A();
 317   x:
 318     B b = { 0, a }; // ok
 319     goto *p;
 320   }
 321   int g() {
 322     void *p = &&x;
 323   x: // expected-note {{possible target of indirect goto}}
 324     B b = { 0, A() }; // expected-note {{jump exits scope of lifetime-extended temporary with non-trivial destructor}}
 325     goto *p; // expected-error {{cannot jump}}
 326   }
 327 }
 328
 329 #if __cplusplus >= 201103L
 330 namespace std {
 331   typedef decltype(sizeof(int)) size_t;
 332   template<typename T> struct initializer_list {
 333     const T *begin;
 334     size_t size;
 335     initializer_list(const T *, size_t);
 336   };
 337 }
 338 namespace test19 {
 339   struct A { ~A(); };
 340
 341   int f() {
 342     void *p = &&x;
 343     A a;
 344   x: // expected-note {{possible target of indirect goto}}
 345     std::initializer_list<A> il = { a }; // expected-note {{jump exits scope of lifetime-extended temporary with non-trivial destructor}}
 346     goto *p; // expected-error {{cannot jump}}
 347   }
 348 }
 349
 350 namespace test20 {
 351   struct A { ~A(); };
 352   struct B {
 353     const A &a;
 354   };
 355
 356   int f() {
 357     void *p = &&x;
 358     A a;
 359   x:
 360     std::initializer_list<B> il = {
 361       a,
 362       a
 363     };
 364     goto *p;
 365   }
 366   int g() {
 367     void *p = &&x;
 368     A a;
 369   x: // expected-note {{possible target of indirect goto}}
 370     std::initializer_list<B> il = {
 371       a,
 372       { A() } // expected-note {{jump exits scope of lifetime-extended temporary with non-trivial destructor}}
 373     };
 374     goto *p; // expected-error {{cannot jump}}
 375   }
 376 }
 377 #endif
 378
 379 namespace test21 {
 380   template<typename T> void f() {
 381   goto x; // expected-error {{cannot jump}}
 382     T t; // expected-note {{bypasses}}
 383  x: return;
 384   }
 385
 386   template void f<int>();
 387   struct X { ~X(); };
 388   template void f<X>(); // expected-note {{instantiation of}}
 389 }
 390
 391 namespace PR18217 {
 392   typedef int *X;
 393
 394   template <typename T>
 395   class MyCl {
 396     T mem;
 397   };
 398
 399   class Source {
 400     MyCl<X> m;
 401   public:
 402     int getKind() const;
 403   };
 404
 405   bool b;
 406   template<typename TT>
 407   static void foo(const Source &SF, MyCl<TT *> Source::*m) {
 408     switch (SF.getKind()) {
 409       case 1: return;
 410       case 2: break;
 411       case 3:
 412       case 4: return;
 413     };
 414     if (b) {
 415       auto &y = const_cast<MyCl<TT *> &>(SF.*m); // expected-warning 0-1{{extension}}
 416     }
 417   }
 418
 419   int Source::getKind() const {
 420     foo(*this, &Source::m);
 421     return 0;
 422   }
 423 }
 424
 425 namespace test_recovery {
 426   // Test that jump scope checking recovers when there are unspecified errors
 427   // in the function declaration or body.
 428
 429   void test(nexist, int c) { // expected-error {{}}
 430     nexist_fn(); // expected-error {{}}
 431     goto nexist_label; // expected-error {{use of undeclared label}}
 432     goto a0; // expected-error {{cannot jump}}
 433     int a = 0; // expected-note {{jump bypasses variable initialization}}
 434     a0:;
 435
 436     switch (c) {
 437     case $: // expected-error {{}}
 438     case 0:
 439       int x = 56; // expected-note {{jump bypasses variable initialization}}
 440     case 1: // expected-error {{cannot jump}}
 441       x = 10;
 442     }
 443   }
 444 }
 445
 446 namespace seh {
 447
 448 // Jumping into SEH try blocks is not permitted.
 449
 450 void jump_into_except() {
 451   goto into_try_except_try; // expected-error {{cannot jump from this goto statement to its label}}
 452   __try { // expected-note {{jump bypasses initialization of __try block}}
 453   into_try_except_try:
 454     ;
 455   } __except(0) {
 456   }
 457
 458   goto into_try_except_except; // expected-error {{cannot jump from this goto statement to its label}}
 459   __try {
 460   } __except(0) { // expected-note {{jump bypasses initialization of __except block}}
 461   into_try_except_except:
 462     ;
 463   }
 464 }
 465
 466 void jump_into_finally() {
 467   goto into_try_except_try; // expected-error {{cannot jump from this goto statement to its label}}
 468   __try { // expected-note {{jump bypasses initialization of __try block}}
 469   into_try_except_try:
 470     ;
 471   } __finally {
 472   }
 473
 474   goto into_try_except_finally; // expected-error {{cannot jump from this goto statement to its label}}
 475   __try {
 476   } __finally { // expected-note {{jump bypasses initialization of __finally block}}
 477   into_try_except_finally:
 478     ;
 479   }
 480 }
 481
 482 // Jumping out of SEH try blocks ok in general. (Jumping out of a __finally
 483 // has undefined behavior.)
 484
 485 void jump_out_of_except() {
 486   __try {
 487     goto out_of_except_try;
 488   } __except(0) {
 489   }
 490 out_of_except_try:
 491   ;
 492
 493   __try {
 494   } __except(0) {
 495     goto out_of_except_except;
 496   }
 497 out_of_except_except:
 498   ;
 499 }
 500
 501 void jump_out_of_finally() {
 502   __try {
 503   goto out_of_finally_try;
 504   } __finally {
 505   }
 506 out_of_finally_try:
 507   ;
 508
 509   __try {
 510   } __finally {
 511     goto out_of_finally_finally; // expected-warning {{jump out of __finally block has undefined behavior}}
 512   }
 513
 514   __try {
 515   } __finally {
 516     goto *&&out_of_finally_finally; // expected-warning {{jump out of __finally block has undefined behavior}}
 517   }
 518 out_of_finally_finally:
 519   ;
 520 }
 521
 522 // Jumping between protected scope and handler is not permitted.
 523
 524 void jump_try_except() {
 525   __try {
 526     goto from_try_to_except; // expected-error {{cannot jump from this goto statement to its label}}
 527   } __except(0) { // expected-note {{jump bypasses initialization of __except block}}
 528   from_try_to_except:
 529     ;
 530   }
 531
 532   __try { // expected-note {{jump bypasses initialization of __try block}}
 533   from_except_to_try:
 534     ;
 535   } __except(0) {
 536     goto from_except_to_try; // expected-error {{cannot jump from this goto statement to its label}}
 537   }
 538 }
 539
 540 void jump_try_finally() {
 541   __try {
 542     goto from_try_to_finally; // expected-error {{cannot jump from this goto statement to its label}}
 543   } __finally { // expected-note {{jump bypasses initialization of __finally block}}
 544   from_try_to_finally:
 545     ;
 546   }
 547
 548   __try { // expected-note {{jump bypasses initialization of __try block}}
 549   from_finally_to_try:
 550     ;
 551   } __finally {
 552     goto from_finally_to_try; // expected-error {{cannot jump from this goto statement to its label}} expected-warning {{jump out of __finally block has undefined behavior}}
 553   }
 554 }
 555
 556 void nested() {
 557   // These are not permitted.
 558   __try {
 559     __try {
 560     } __finally {
 561       goto outer_except; // expected-error {{cannot jump from this goto statement to its label}}
 562     }
 563   } __except(0) { // expected-note {{jump bypasses initialization of __except bloc}}
 564   outer_except:
 565     ;
 566   }
 567
 568   __try {
 569     __try{
 570     } __except(0) {
 571       goto outer_finally; // expected-error {{cannot jump from this goto statement to its label}}
 572     }
 573   } __finally { // expected-note {{jump bypasses initialization of __finally bloc}}
 574   outer_finally:
 575     ;
 576   }
 577
 578   // These are permitted.
 579   __try {
 580     __try {
 581     } __finally {
 582       goto after_outer_except; // expected-warning {{jump out of __finally block has undefined behavior}}
 583     }
 584   } __except(0) {
 585   }
 586 after_outer_except:
 587   ;
 588
 589   __try {
 590     __try{
 591     } __except(0) {
 592       goto after_outer_finally;
 593     }
 594   } __finally {
 595   }
 596 after_outer_finally:
 597   ;
 598 }
 599
 600 // This section is academic, as MSVC doesn't support indirect gotos.
 601
 602 void indirect_jumps(void **ip) {
 603   static void *ips[] = { &&l };
 604
 605   __try { // expected-note {{jump exits __try block}}
 606     // FIXME: Should this be allowed? Jumping out of the guarded section of a
 607     // __try/__except doesn't require unwinding.
 608     goto *ip; // expected-error {{cannot jump from this indirect goto statement to one of its possible targets}}
 609   } __except(0) {
 610   }
 611
 612   __try {
 613   } __except(0) { // expected-note {{jump exits __except block}}
 614     // FIXME: What about here?
 615     goto *ip; // expected-error {{cannot jump from this indirect goto statement to one of its possible targets}}
 616   }
 617
 618   __try { // expected-note {{jump exits __try block}}
 619     goto *ip; // expected-error {{cannot jump from this indirect goto statement to one of its possible targets}}
 620   } __finally {
 621   }
 622
 623   __try {
 624   } __finally { // expected-note {{jump exits __finally block}}
 625     goto *ip; // expected-error {{cannot jump from this indirect goto statement to one of its possible targets}}
 626   }
 627 l: // expected-note 4 {{possible target of indirect goto statement}}
 628   ;
 629 }
 630
 631 } // namespace seh
 632
 633 void continue_scope_check() {
 634   // These are OK.
 635   for (; ({break; true;});) {}
 636   for (; ({continue; true;});) {}
 637   for (; int n = ({break; 0;});) {}
 638   for (; int n = 0; ({break;})) {}
 639   for (; int n = 0; ({continue;})) {}
 640
 641   // This would jump past the initialization of 'n' to the increment (where 'n'
 642   // is in scope).
 643   for (; int n = ({continue; 0;});) {} // expected-error {{cannot jump from this continue statement to the loop increment; jump bypasses initialization of loop condition variable}}
 644
 645   // An intervening loop makes it OK again.
 646   for (; int n = ({while (true) continue; 0;});) {}
 647 }