1 // RUN: %clang_cc1 -fsyntax-only -verify %s 2 typedef int INT; 3 4 class Foo { 5 Foo(); 6 (Foo)(float) { } 7 explicit Foo(int); // expected-note {{previous declaration is here}} 8 Foo(const Foo&); 9 10 ((Foo))(INT); // expected-error{{cannot be redeclared}} 11 12 Foo(Foo foo, int i = 17, int j = 42); // expected-error{{copy constructor must pass its first argument by reference}} 13 14 static Foo(short, short); // expected-error{{constructor cannot be declared 'static'}} 15 virtual Foo(double); // expected-error{{constructor cannot be declared 'virtual'}} 16 Foo(long) const; // expected-error{{'const' qualifier is not allowed on a constructor}} 17 18 int Foo(int, int); // expected-error{{constructor cannot have a return type}} 19 20 volatile Foo(float); // expected-error{{constructor cannot have a return type}} 21 }; 22 23 Foo::Foo(const Foo&) { } 24 25 typedef struct { 26 int version; 27 } Anon; 28 extern const Anon anon; 29 extern "C" const Anon anon2; 30 31 // PR3188: The extern declaration complained about not having an appropriate 32 // constructor. 33 struct x; 34 extern x a; 35 36 // A similar case. 37 struct y { 38 y(int); 39 }; 40 extern y b; 41 42 struct Length { 43 Length l() const { return *this; } 44 }; 45 46 struct mmst_reg{ 47 char mmst_reg[10]; 48 }; 49 50 // PR3948 51 namespace PR3948 { 52 // PR3948 53 class a { 54 public: 55 int b(int a()); 56 }; 57 int x(); 58 void y() { 59 a z; z.b(x); 60 } 61 } 62 63 namespace A { 64 struct S { 65 S(); 66 S(int); 67 void f1(); 68 void f2(); 69 operator int (); 70 ~S(); 71 }; 72 } 73 74 A::S::S() {} 75 76 void A::S::f1() {} 77 78 struct S {}; 79 80 A::S::S(int) {} 81 82 void A::S::f2() {} 83 84 A::S::operator int() { return 1; } 85 86 A::S::~S() {} 87 88 namespace PR38286 { 89 // FIXME: It'd be nice to give more consistent diagnostics for these cases 90 // (but they're all failing for somewhat different reasons...). 91 template<typename> struct A; 92 template<typename T> A<T>::A() {} // expected-error {{incomplete type 'A' named in nested name specifier}} 93 /*FIXME: needed to recover properly from previous error*/; 94 template<typename> struct B; 95 template<typename T> void B<T>::f() {} // expected-error {{out-of-line definition of 'f' from class 'B<type-parameter-0-0>'}} 96 template<typename> struct C; // expected-note {{non-type declaration found}} 97 template<typename T> C<T>::~C() {} // expected-error {{identifier 'C' after '~' in destructor name does not name a type}} 98 } 99