Home | History | Annotate | Download | only in Parser 
      1 // RUN: %clang_cc1 -fsyntax-only -verify %s
      2 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
      3 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
      4 
      5 char *const_cast_test(const char *var)
      6 {
      7   return const_cast<char*>(var);
      8 }
      9 
     10 struct A {
     11   virtual ~A() {}
     12 };
     13 
     14 struct B : public A {
     15 };
     16 
     17 struct B *dynamic_cast_test(struct A *a)
     18 {
     19   return dynamic_cast<struct B*>(a);
     20 }
     21 
     22 char *reinterpret_cast_test()
     23 {
     24   return reinterpret_cast<char*>(0xdeadbeef);
     25 }
     26 
     27 double static_cast_test(int i)
     28 {
     29   return static_cast<double>(i);
     30 }
     31 
     32 char postfix_expr_test()
     33 {
     34   return reinterpret_cast<char*>(0xdeadbeef)[0];
     35 }
     36 
     37 // This was being incorrectly tentatively parsed.
     38 namespace test1 {
     39   template <class T> class A {}; // expected-note 2{{here}}
     40   void foo() { A<int>(*(A<int>*)0); }
     41 }
     42 
     43 typedef char* c;
     44 typedef A* a;
     45 void test2(char x, struct B * b) {
     46   (void)const_cast<::c>(&x);
     47 #if __cplusplus <= 199711L
     48   // expected-error@-2 {{found '<::' after a const_cast which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
     49 #endif
     50 
     51   (void)dynamic_cast<::a>(b);
     52 #if __cplusplus <= 199711L
     53   // expected-error@-2 {{found '<::' after a dynamic_cast which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
     54 #endif
     55 
     56   (void)reinterpret_cast<::c>(x);
     57 #if __cplusplus <= 199711L
     58   // expected-error@-2 {{found '<::' after a reinterpret_cast which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
     59 #endif
     60 
     61   (void)static_cast<::c>(&x);
     62 #if __cplusplus <= 199711L
     63   // expected-error@-2 {{found '<::' after a static_cast which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
     64 #endif
     65 
     66   // Do not do digraph correction.
     67   (void)static_cast<: :c>(&x); //\
     68        expected-error {{expected '<' after 'static_cast'}} \
     69        expected-error {{expected expression}}\
     70        expected-error {{expected ']'}}\
     71        expected-note {{to match this '['}}
     72   (void)static_cast<: // expected-error {{expected '<' after 'static_cast'}} \
     73                          expected-note {{to match this '['}}
     74   :c>(&x); // expected-error {{expected expression}} \
     75               expected-error {{expected ']'}}
     76 #define LC <:
     77 #define C :
     78   test1::A LC:B> c; // expected-error {{class template 'test1::A' requires template arguments}} expected-error 2{{}}
     79   (void)static_cast LC:c>(&x); // expected-error {{expected '<' after 'static_cast'}} expected-error 2{{}} expected-note{{}}
     80   test1::A<:C B> d; // expected-error {{class template 'test1::A' requires template arguments}} expected-error 2{{}}
     81   (void)static_cast<:C c>(&x); // expected-error {{expected '<' after 'static_cast'}} expected-error 2{{}} expected-note{{}}
     82 
     83 #define LCC <::
     84   test1::A LCC B> e;
     85 #if __cplusplus <= 199711L
     86   // expected-error@-2 {{found '<::' after a template name which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
     87 #endif
     88 
     89   (void)static_cast LCC c>(&x);
     90 #if __cplusplus <= 199711L
     91   // expected-error@-2 {{found '<::' after a static_cast which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
     92 #endif
     93 }
     94 
     95                                // This note comes from "::D[:F> A5;"
     96 template <class T> class D {}; // expected-note{{template is declared here}}
     97 template <class T> void E() {};
     98 class F {};
     99 
    100 void test3() {
    101   ::D<::F> A1;
    102 #if __cplusplus <= 199711L
    103   // expected-error@-2 {{found '<::' after a template name which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
    104 #endif
    105 
    106   D<::F> A2;
    107 #if __cplusplus <= 199711L
    108   // expected-error@-2 {{found '<::' after a template name which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
    109 #endif
    110 
    111   ::E<::F>();
    112 #if __cplusplus <= 199711L
    113   // expected-error@-2 {{found '<::' after a template name which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
    114 #endif
    115 
    116   E<::F>();
    117 #if __cplusplus <= 199711L
    118   // expected-error@-2 {{found '<::' after a template name which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
    119 #endif
    120 
    121   ::D< ::F> A3;
    122   D< ::F> A4;
    123   ::E< ::F>();
    124   E< ::F>();
    125 
    126   // Make sure that parser doesn't expand '[:' to '< ::'
    127   ::D[:F> A5; // expected-error {{class template '::D' requires template arguments}} \
    128               // expected-error {{expected expression}} \
    129               // expected-error {{expected unqualified-id}}
    130 }
    131 
    132 // Ensure that a C-style cast doesn't turn off colon protection.
    133 void PR19748() {
    134   struct A {};
    135   int A = 0, b;
    136   int test1 = true ? (int)A : b;
    137 
    138   struct f {};
    139   extern B f(), (*p)();
    140   (true ? (B(*)())f : p)();
    141 }
    142 
    143 void PR19751(int n) {
    144   struct T { void operator++(int); };
    145   (T())++; // ok, not an ill-formed cast to function type
    146   (T())++n; // expected-error {{C-style cast from 'int' to 'T ()' is not allowed}}
    147 }
    148 
    149 // PR13619. Must be at end of file.
    150 int n = reinterpret_cast // expected-error {{expected '<'}} expected-error {{expected ';'}}
    151