Home | History | Annotate | Download | only in Parser
      1 // RUN: %clang_cc1 -verify -fsyntax-only -triple i386-linux -pedantic-errors -fcxx-exceptions -fexceptions %s
      2 
      3 const char const *x10; // expected-error {{duplicate 'const' declaration specifier}}
      4 
      5 int x(*g); // expected-error {{use of undeclared identifier 'g'}}
      6 
      7 struct Type {
      8   int Type;
      9 };
     10 
     11 // rdar://8365458
     12 // rdar://9132143
     13 typedef char bool; // expected-error {{redeclaration of C++ built-in type 'bool'}}
     14 
     15 // PR4451 - We should recover well from the typo of '::' as ':' in a2.
     16 namespace y {
     17   struct a { };
     18   typedef int b;
     19 }
     20 
     21 y::a a1;
     22 y:a a2;  // expected-error {{unexpected ':' in nested name specifier}}
     23 y::a a3 = a2;
     24 
     25 // Some valid colons:
     26 void foo() {
     27 y:  // label
     28   y::a s;
     29 
     30   int a = 4;
     31   a = a ? a : a+1;
     32 }
     33 
     34 struct b : y::a {};
     35 
     36 template <typename T>
     37 class someclass {
     38 
     39   int bar() {
     40     T *P;
     41     return 1 ? P->x : P->y;
     42   }
     43 };
     44 
     45 class asm_class_test {
     46   void foo() __asm__("baz");
     47 };
     48 
     49 enum { fooenum = 1, }; // expected-error {{commas at the end of enumerator lists are a C++11 extension}}
     50 
     51 struct a {
     52   int Type : fooenum;
     53 };
     54 
     55 void test(struct Type *P) {
     56   int Type;
     57   Type = 1 ? P->Type : Type;
     58 
     59   Type = (y:b) 4;   // expected-error {{unexpected ':' in nested name specifier}}
     60   Type = 1 ? (
     61               (y:b)  // expected-error {{unexpected ':' in nested name specifier}}
     62               4) : 5;
     63 }
     64 
     65 struct test4 {
     66   int x  // expected-error {{expected ';' at end of declaration list}}
     67   int y;
     68   int z  // expected-error {{expected ';' at end of declaration list}}
     69 };
     70 
     71 // Make sure we know these are legitimate commas and not typos for ';'.
     72 namespace Commas {
     73   struct S {
     74     static int a;
     75     int c,
     76     operator()();
     77   };
     78 
     79   int global1,
     80   __attribute__(()) global2,
     81   (global5),
     82   *global6,
     83   &global7 = global1,
     84   &&global8 = static_cast<int&&>(global1), // expected-error 2{{rvalue reference}}
     85   S::a,
     86   global9,
     87   global10 = 0,
     88   global11 == 0, // expected-error {{did you mean '='}}
     89   global12 __attribute__(()),
     90   global13(0),
     91   global14[2],
     92   global15;
     93 
     94   void g() {
     95     static int a,
     96     b __asm__("ebx"), // expected-error {{expected ';' at end of declaration}}
     97     Statics:return;
     98   }
     99 }
    100 
    101 // PR5825
    102 struct test5 {};
    103 ::new(static_cast<void*>(0)) test5; // expected-error {{expected unqualified-id}}
    104 
    105 
    106 // PR6782
    107 template<class T>
    108 class Class1;
    109 
    110 class Class2 {
    111 } // expected-error {{expected ';' after class}}
    112 
    113 typedef Class1<Class2> Type1;
    114 
    115 // rdar : // 8307865
    116 struct CodeCompleteConsumer {
    117 };
    118 
    119 void CodeCompleteConsumer::() { // expected-error {{xpected unqualified-id}}
    120 }
    121 
    122 ;
    123 
    124 // PR4111
    125 void f(sqrgl); // expected-error {{unknown type name 'sqrgl'}}
    126 
    127 // PR9903
    128 struct S {
    129   typedef void a() { }; // expected-error {{function definition declared 'typedef'}}
    130   typedef void c() try { } catch(...) { } // expected-error {{function definition declared 'typedef'}}
    131   int n, m;
    132   typedef S() : n(1), m(2) { } // expected-error {{function definition declared 'typedef'}}
    133 };
    134 
    135 
    136 namespace TestIsValidAfterTypeSpecifier {
    137 struct s {} v;
    138 
    139 namespace a {
    140 struct s operator++(struct s a)
    141 { return a; }
    142 }
    143 
    144 namespace b {
    145 // The newline after s should make no difference.
    146 struct s
    147 operator++(struct s a)
    148 { return a; }
    149 }
    150 
    151 struct X {
    152   struct s
    153   friend f();
    154   struct s
    155   virtual f();
    156 };
    157 
    158 struct s
    159 &r0 = v;
    160 struct s
    161 bitand r2 = v;
    162 
    163 }
    164 
    165 struct DIE {
    166   void foo() {}
    167 };
    168 
    169 void test (DIE die, DIE *Die, DIE INT, DIE *FLOAT) {
    170   DIE.foo();  // expected-error {{cannot use dot operator on a type}}
    171   die.foo();
    172 
    173   DIE->foo();  // expected-error {{cannot use arrow operator on a type}}
    174   Die->foo();
    175 
    176   int.foo();  // expected-error {{cannot use dot operator on a type}}
    177   INT.foo();
    178 
    179   float->foo();  // expected-error {{cannot use arrow operator on a type}}
    180   FLOAT->foo();
    181 }
    182 
    183 namespace PR15017 {
    184   template<typename T = struct X { int i; }> struct S {}; // expected-error {{'PR15017::X' cannot be defined in a type specifier}}
    185 }
    186 
    187 // Ensure we produce at least some diagnostic for attributes in C++98.
    188 [[]] struct S; // expected-error 2{{}}
    189 
    190 namespace test7 {
    191   struct Foo {
    192     void a();
    193     void b();
    194   };
    195 
    196   void Foo::
    197   // Comment!
    198   a() {}
    199 
    200 
    201   void Foo::  // expected-error {{expected unqualified-id}}
    202   // Comment!
    203 }
    204 
    205 void test8() {
    206   struct {} o;
    207   // This used to crash.
    208   (&o)->(); // expected-error{{expected unqualified-id}}
    209 }
    210 
    211 namespace PR5066 {
    212   template<typename T> struct X {};
    213   X<int N> x; // expected-error {{type-id cannot have a name}}
    214 
    215   using T = int (*T)(); // expected-error {{type-id cannot have a name}} expected-error {{C++11}}
    216 }
    217 
    218 namespace PR17255 {
    219 void foo() {
    220   typename A::template B<>; // expected-error {{use of undeclared identifier 'A'}} \
    221                             // expected-error {{expected a qualified name after 'typename'}} \
    222                             // expected-error {{'template' keyword outside of a template}}
    223 }
    224 }
    225 
    226 namespace PR17567 {
    227   struct Foobar { // expected-note 2{{declared here}}
    228     FooBar(); // expected-error {{missing return type for function 'FooBar'; did you mean the constructor name 'Foobar'?}}
    229     ~FooBar(); // expected-error {{expected the class name after '~' to name a destructor}}
    230   };
    231   FooBar::FooBar() {} // expected-error {{undeclared}} expected-error {{missing return type}}
    232   FooBar::~FooBar() {} // expected-error {{undeclared}} expected-error {{expected the class name}}
    233 }
    234 
    235 namespace DuplicateFriend {
    236   struct A {
    237     friend void friend f(); // expected-warning {{duplicate 'friend' declaration specifier}}
    238     friend struct B friend; // expected-warning {{duplicate 'friend' declaration specifier}}
    239   };
    240 }
    241 
    242 // PR8380
    243 extern ""      // expected-error {{unknown linkage language}}
    244 test6a { ;// expected-error {{C++ requires a type specifier for all declarations}} \
    245      // expected-error {{expected ';' after top level declarator}}
    246 
    247   int test6b;
    248