clang/test/Parser/recovery.cpp

   1 // RUN: %clang_cc1 -verify -std=c++11 -fms-extensions %s
   2
   3 8gi///===--- recovery.cpp ---===// // expected-error {{unqualified-id}}
   4 namespace Std { // expected-note {{here}}
   5   typedef int Important;
   6 }
   7
   8 / redeclare as an inline namespace // expected-error {{unqualified-id}}
   9 inline namespace Std { // expected-error {{cannot be reopened as inline}}
  10   Important n;
  11 } / end namespace Std // expected-error {{unqualified-id}}
  12 int x;
  13 Std::Important y;
  14
  15 extenr "C" { // expected-error {{did you mean 'extern'}}
  16   void f();
  17 }
  18 void g() {
  19   z = 1; // expected-error {{undeclared}}
  20   f();
  21 }
  22
  23 struct S {
  24   int a, b, c;
  25   S();
  26   int x // expected-error {{expected ';'}}
  27   friend void f()
  28 };
  29 8S::S() : a{ 5 }, b{ 6 }, c{ 2 } { // expected-error {{unqualified-id}}
  30   return;
  31 }
  32 int k;
  33 int l = k // expected-error {{expected ';'}}
  34 constexpr int foo();
  35
  36 5int m = { l }, n = m; // expected-error {{unqualified-id}}
  37
  38 namespace MissingBrace {
  39   struct S { // expected-error {{missing '}' at end of definition of 'MissingBrace::S'}}
  40     int f();
  41   // };
  42
  43   namespace N { int g(); } // expected-note {{still within definition of 'MissingBrace::S' here}}
  44
  45   int k1 = S().h(); // expected-error {{no member named 'h' in 'MissingBrace::S'}}
  46   int k2 = S().f() + N::g();
  47
  48   template<typename T> struct PR17949 { // expected-error {{missing '}' at end of definition of 'MissingBrace::PR17949'}}
  49
  50   namespace X { // expected-note {{still within definition of 'MissingBrace::PR17949' here}}
  51   }
  52 }
  53
  54 namespace N {
  55   int
  56 } // expected-error {{unqualified-id}}
  57
  58 strcut Uuuu { // expected-error {{did you mean 'struct'}} \
  59               // expected-note {{'Uuuu' declared here}}
  60 } *u[3];
  61 uuuu v; // expected-error {{did you mean 'Uuuu'}}
  62
  63 struct Redefined { // expected-note {{previous}}
  64   Redefined() {}
  65 };
  66 struct Redefined { // expected-error {{redefinition}}
  67   Redefined() {}
  68 };
  69
  70 struct MissingSemi5;
  71 namespace N {
  72   typedef int afterMissingSemi4;
  73   extern MissingSemi5 afterMissingSemi5;
  74 }
  75
  76 struct MissingSemi1 {} // expected-error {{expected ';' after struct}}
  77 static int afterMissingSemi1();
  78
  79 class MissingSemi2 {} // expected-error {{expected ';' after class}}
  80 MissingSemi1 *afterMissingSemi2;
  81
  82 enum MissingSemi3 {} // expected-error {{expected ';' after enum}}
  83 ::MissingSemi1 afterMissingSemi3;
  84
  85 extern N::afterMissingSemi4 afterMissingSemi4b;
  86 union MissingSemi4 { MissingSemi4(int); } // expected-error {{expected ';' after union}}
  87 N::afterMissingSemi4 (afterMissingSemi4b);
  88
  89 int afterMissingSemi5b;
  90 struct MissingSemi5 { MissingSemi5(int); } // ok, no missing ';' here
  91 N::afterMissingSemi5 (afterMissingSemi5b);
  92
  93 template<typename T> struct MissingSemiT {
  94 } // expected-error {{expected ';' after struct}}
  95 MissingSemiT<int> msi;
  96
  97 struct MissingSemiInStruct {
  98   struct Inner1 {} // expected-error {{expected ';' after struct}}
  99   static MissingSemi5 ms1;
 100
 101   struct Inner2 {} // ok, no missing ';' here
 102   static MissingSemi1;
 103
 104   struct Inner3 {} // expected-error {{expected ';' after struct}}
 105   static MissingSemi5 *p;
 106 };
 107
 108 void MissingSemiInFunction() {
 109   struct Inner1 {} // expected-error {{expected ';' after struct}}
 110   if (true) {}
 111
 112   // FIXME: It would be nice to at least warn on this.
 113   struct Inner2 { Inner2(int); } // ok, no missing ';' here
 114   k = l;
 115
 116   struct Inner3 {} // expected-error {{expected ';' after struct}}
 117   Inner1 i1;
 118
 119   struct Inner4 {} // ok, no missing ';' here
 120   Inner5;
 121 }
 122
 123 namespace NS {
 124   template<typename T> struct Foo {};
 125 }
 126 struct MissingSemiThenTemplate1 {} // expected-error {{expected ';' after struct}}
 127 NS::Foo<int> missingSemiBeforeFunctionReturningTemplateId1();
 128
 129 using NS::Foo;
 130 struct MissingSemiThenTemplate2 {} // expected-error {{expected ';' after struct}}
 131 Foo<int> missingSemiBeforeFunctionReturningTemplateId2();
 132
 133 namespace PR17084 {
 134 enum class EnumID {};
 135 template <typename> struct TempID;
 136 template <> struct TempID<BadType> // expected-error{{use of undeclared identifier 'BadType'}}
 137   : BadType, // expected-error {{expected class name}}
 138     EnumID::Garbage // expected-error {{expected class name}}
 139   ; // expected-error@-1 {{expected '{' after base class list}}
 140 }
 141
 142 namespace pr15133 {
 143   namespace ns {
 144     const int V1 = 1;   // expected-note {{declared here}}
 145   }
 146   struct C1 {
 147     enum E1 { V2 = 2 }; // expected-note {{declared here}}
 148     static const int V3 = 3; // expected-note {{declared here}}
 149   };
 150   enum E2 {
 151     V4 = 4,   // expected-note {{declared here}}
 152     V6        // expected-note {{declared here}}
 153   };
 154   enum class EC3 { V0 = 0, V5 = 5 }; // expected-note {{declared here}}
 155   void func_3();
 156
 157   void func_1(int x) {
 158     switch(x) {
 159     case 0: break;
 160     case ns::V1:: break; // expected-error{{'V1' cannot appear before '::' because it is not a class, namespace, or enumeration; did you mean ':'?}}
 161     case C1::V2:: break; // expected-error{{'V2' cannot appear before '::' because it is not a class, namespace, or enumeration; did you mean ':'?}}
 162     case C1::V3:: break; // expected-error{{'V3' cannot appear before '::' because it is not a class, namespace, or enumeration; did you mean ':'?}}
 163     case V4:: break; // expected-error{{'V4' cannot appear before '::' because it is not a class, namespace, or enumeration; did you mean ':'?}}
 164     case V6:: func_3();   // expected-error{{'V6' cannot appear before '::' because it is not a class, namespace, or enumeration; did you mean ':'?}}
 165     }
 166   }
 167   void func_2(EC3 x) {
 168     switch(x) {
 169     case EC3::V0:  break;
 170     case EC3::V5:: break; // expected-error{{'V5' cannot appear before '::' because it is not a class, namespace, or enumeration; did you mean ':'?}}
 171     }
 172   }
 173
 174   template<class T> struct TS1 {
 175     typedef int A;
 176   };
 177   template<class T> void func(int x) {
 178     switch(x) {
 179     case TS1<T>::A:: break;  // expected-error{{expected unqualified-id}}
 180     }
 181   };
 182   void mainf() {
 183     func<int>(1);
 184   }
 185
 186   struct S {
 187     static int n;  // expected-note{{declared here}}
 188     int nn;        // expected-note 2 {{declared here}}
 189   };
 190
 191   int func_3(int x) {
 192     return x ? S::n :: 0;  // expected-error{{'n' cannot appear before '::' because it is not a class, namespace, or enumeration; did you mean ':'?}}
 193   }
 194   int func_4(int x, S &s) {
 195     return x ? s.nn :: x;  // expected-error{{'nn' cannot appear before '::' because it is not a class, namespace, or enumeration; did you mean ':'?}}
 196   }
 197   int func_5(int x, S &s) {
 198     return x ? s.nn :: S::n;  // expected-error{{'nn' cannot appear before '::' because it is not a class, namespace, or enumeration; did you mean ':'?}}
 199   }
 200
 201   struct S2 {
 202     struct S3;
 203   };
 204
 205   struct S2 :: S3 :: public S2 {  // expected-error{{'public' cannot be a part of nested name specifier; did you mean ':'?}}
 206   };
 207 }
 208
 209 namespace InvalidEmptyNames {
 210 // These shouldn't crash, the diagnostics aren't important.
 211 struct ::, struct ::; // expected-error 2 {{expected identifier}} expected-error 2 {{declaration of anonymous struct must be a definition}} expected-warning {{declaration does not declare anything}}
 212 enum ::, enum ::; // expected-error 2 {{expected identifier}}
 213 struct ::__super, struct ::__super; // expected-error 2 {{expected identifier}} expected-error 2 {{expected '::' after '__super'}}
 214 struct ::template foo, struct ::template bar; // expected-error 2 {{expected identifier}} expected-error 2 {{declaration of anonymous struct must be a definition}} expected-warning {{declaration does not declare anything}}
 215 struct ::foo struct::; // expected-error {{no struct named 'foo' in the global namespace}} expected-error {{expected identifier}}
 216 class :: : {} a;  // expected-error {{expected identifier}} expected-error {{expected class name}}
 217 }