clang/test/Parser/cxx-class.cpp

// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify -pedantic -fcxx-exceptions %s
// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -fcxx-exceptions -std=c++98 %s
// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -fcxx-exceptions -std=c++11 %s

class C;
class C {
public:
protected:
  typedef int A,B;
  static int sf(), u;

  struct S {};
  enum {}; // expected-warning{{declaration does not declare anything}}
  int; // expected-warning {{declaration does not declare anything}}
  int : 1, : 2;

public:
  void m0() {}; // ok, one extra ';' is permitted
  void m1() {}
  ; // ok, one extra ';' is permitted
  void m() {
    int l = 2;
  };; // expected-warning{{extra ';' after member function definition}}

  template<typename T> void mt(T) { }
  ;
  ; // expected-warning{{extra ';' inside a class}}

  virtual int vf() const volatile = 0;

  virtual int vf0() = 0l; // expected-error {{does not look like a pure-specifier}}
  virtual int vf1() = 1; // expected-error {{does not look like a pure-specifier}}
  virtual int vf2() = 00; // expected-error {{does not look like a pure-specifier}}
  virtual int vf3() = 0x0; // expected-error {{does not look like a pure-specifier}}
  virtual int vf4() = 0.0; // expected-error {{does not look like a pure-specifier}}
  virtual int vf5(){0}; // expected-error +{{}} expected-warning {{unused}}
  virtual int vf5a(){0;}; // function definition, expected-warning {{unused}}
  virtual int vf6()(0); // expected-error +{{}} expected-note +{{}}
  virtual int vf7() = { 0 }; // expected-error {{does not look like a pure-specifier}}
  virtual int PR45267() = \
                        0; // ok, despite escaped newline

private:
  int x,f(),y,g();
  inline int h();
  static const int sci = 10;
  mutable int mi;
};
void glo()
{
  struct local {};
}

// PR3177
typedef union {
  __extension__ union {
    int a;
    float b;
  } y;
} bug3177;

// check that we don't consume the token after the access specifier
// when it's not a colon
class D {
public // expected-error{{expected ':'}}
  int i;
};

// consume the token after the access specifier if it's a semicolon
// that was meant to be a colon
class E {
public; // expected-error{{expected ':'}}
  int i;
};

class F {
    int F1 { return 1; }
#if __cplusplus <= 199711L
    // expected-error@-2 {{function definition does not declare parameters}}
#else
    // expected-error@-4 {{expected expression}}
    // expected-error@-5 {{expected}}
    // expected-note@-6 {{to match this '{'}}
    // expected-error@-7 {{expected ';' after class}}
#endif

    void F2 {}
#if __cplusplus <= 199711L
    // expected-error@-2 {{function definition does not declare parameters}}
#else
    // expected-error@-4 {{variable has incomplete type 'void'}}
    // expected-error@-5 {{expected ';' after top level declarator}}
#endif

    typedef int F3() { return 0; } // expected-error{{function definition declared 'typedef'}}
    typedef void F4() {} // expected-error{{function definition declared 'typedef'}}
};
#if __cplusplus >= 201103L
// expected-error@-2 {{extraneous closing brace}}
#endif

namespace ctor_error {
  class Foo {}; // #defined-here
  // By [class.qual]p2, this is a constructor declaration.
  Foo::Foo (F) = F(); // expected-error{{does not match any declaration in 'ctor_error::Foo'}}
                      // expected-note@#defined-here{{defined here}}

  class Ctor { // expected-note{{not complete until the closing '}'}}
    Ctor(f)(int); // ok
    Ctor(g(int)); // ok
    Ctor(x[5]); // expected-error{{incomplete type}}

    Ctor(UnknownType *); // expected-error{{unknown type name 'UnknownType'}}
    void operator+(UnknownType*); // expected-error{{unknown type name 'UnknownType'}}
  };

  Ctor::Ctor (x) = { 0 }; // \
    // expected-error{{qualified reference to 'Ctor' is a constructor name}}

  Ctor::Ctor(UnknownType *) {} // \
    // expected-error{{unknown type name 'UnknownType'}}
  void Ctor::operator+(UnknownType*) {} // \
    // expected-error{{unknown type name 'UnknownType'}}
}

namespace nns_decl {
  struct A {
    struct B;
  };
  namespace N {
    union C;
  }
  struct A::B; // expected-error {{forward declaration of struct cannot have a nested name specifier}}
  union N::C; // expected-error {{forward declaration of union cannot have a nested name specifier}}
}

// PR13775: Don't assert here.
namespace PR13775 {
  class bar
  {
   public:
    void foo ();
    void baz ();
  };
  void bar::foo ()
  {
    baz x(); // expected-error 3{{}}
  }
}

class pr16989 {
  void tpl_mem(int *) {
    return;
    class C2 {
      void f();
    };
    void C2::f() {} // expected-error{{function definition is not allowed here}}
  };
};

namespace CtorErrors {
  struct A {
    A(NonExistent); // expected-error {{unknown type name 'NonExistent'}}
  };
  struct B {
    B(NonExistent) : n(0) {} // expected-error {{unknown type name 'NonExistent'}}
    int n;
  };
  struct C {
    C(NonExistent) try {} catch (...) {} // expected-error {{unknown type name 'NonExistent'}}
  };
  struct D {
    D(NonExistent) {} // expected-error {{unknown type name 'NonExistent'}}
  };
}

namespace DtorErrors {
  struct A { ~A(); int n; } a;
  ~A::A() { n = 0; } // expected-error {{'~' in destructor name should be after nested name specifier}} expected-note {{previous}}
  A::~A() {} // expected-error {{redefinition}}

  struct B { ~B(); } *b;
  DtorErrors::~B::B() {} // expected-error {{'~' in destructor name should be after nested name specifier}}

  void f() {
    a.~A::A(); // expected-error {{'~' in destructor name should be after nested name specifier}}
    b->~DtorErrors::~B::B(); // expected-error {{'~' in destructor name should be after nested name specifier}}
  }

  struct C; // expected-note {{forward decl}}
  ~C::C() {} // expected-error {{incomplete}} expected-error {{'~' in destructor name should be after nested name specifier}}

  struct D { struct X {}; ~D() throw(X); };
  ~D::D() throw(X) {} // expected-error {{'~' in destructor name should be after nested name specifier}}

  ~Undeclared::Undeclared() {} // expected-error {{use of undeclared identifier 'Undeclared'}} expected-error {{'~' in destructor name should be after nested name specifier}}
  ~Undeclared:: {} // expected-error {{expected identifier}} expected-error {{'~' in destructor name should be after nested name specifier}}

  struct S {
    // For another struct's destructor, emit the same diagnostic like for
    // A::~A() in addition to the "~ in the wrong place" one.
    ~A::A() {} // expected-error {{'~' in destructor name should be after nested name specifier}} expected-error {{non-friend class member '~A' cannot have a qualified name}}
    A::~A() {} // expected-error {{non-friend class member '~A' cannot have a qualified name}}

    // An inline destructor with a redundant class name should also get the
    // same diagnostic as S::~S.
    ~S::S() {} // expected-error {{'~' in destructor name should be after nested name specifier}} expected-error {{extra qualification on member '~S'}}

    // This just shouldn't crash.
    int I; // expected-note {{declared here}}
    ~I::I() {} // expected-error {{'I' is not a class, namespace, or enumeration}} expected-error {{'~' in destructor name should be after nested name specifier}}
  };

  struct T {};
  T t1 = t1.T::~T<int>; // expected-error {{destructor name 'T' does not refer to a template}}
  // Emit the same diagnostic as for the previous case, plus something about ~.
  T t2 = t2.~T::T<int>; // expected-error {{'~' in destructor name should be after nested name specifier}} expected-error {{destructor name 'T' does not refer to a template}}
}

namespace BadFriend {
  struct A {
    friend int : 3; // expected-error {{friends can only be classes or functions}}
    friend void f() = 123; // expected-error {{illegal initializer}}
    friend virtual void f(); // expected-error {{'virtual' is invalid in friend declarations}}
    friend void f() final; // expected-error {{'final' is invalid in friend declarations}}
    friend void f() override; // expected-error {{'override' is invalid in friend declarations}}
  };
}

class PR20760_a {
  int a = ); // expected-error {{expected expression}}
#if __cplusplus <= 199711L
  // expected-warning@-2 {{default member initializer for non-static data member is a C++11 extension}}
#endif

  int b = }; // expected-error {{expected expression}}
#if __cplusplus <= 199711L
  // expected-warning@-2 {{default member initializer for non-static data member is a C++11 extension}}
#endif

  int c = ]; // expected-error {{expected expression}}
#if __cplusplus <= 199711L
  // expected-warning@-2 {{default member initializer for non-static data member is a C++11 extension}}
#endif

};
class PR20760_b {
  int d = d); // expected-error {{expected ';'}}
#if __cplusplus <= 199711L
  // expected-warning@-2 {{default member initializer for non-static data member is a C++11 extension}}
#endif

  int e = d]; // expected-error {{expected ';'}}
#if __cplusplus <= 199711L
  // expected-warning@-2 {{default member initializer for non-static data member is a C++11 extension}}
#endif

  int f = d // expected-error {{expected ';'}}
#if __cplusplus <= 199711L
  // expected-warning@-2 {{default member initializer for non-static data member is a C++11 extension}}
#endif

};

namespace PR20887 {
class X1 { a::operator=; }; // expected-error {{undeclared identifier 'a'}}
class X2 { a::a; }; // expected-error {{undeclared identifier 'a'}}
}

class BadExceptionSpec {
  void f() throw(int; // expected-error {{expected ')'}} expected-note {{to match}}
  void g() throw(
      int(
          ; // expected-error {{unexpected ';' before ')'}}
          ));
};

namespace PR41192 {
extern struct A a;
struct A {} ::PR41192::a; // ok, no missing ';' here  expected-warning {{extra qualification}}

#if __cplusplus >= 201103L
struct C;
struct D { static C c; };
struct C {} decltype(D())::c; // expected-error {{a 'decltype' specifier cannot be used in a declarative nested name specifier}}
#endif
}

namespace ArrayMemberAccess {
  struct A {
    int x;
    template<typename T> int f() const;
  };
  void f(const A (&a)[]) {
    // OK: not a template-id.
    bool cond = a->x < 10 && a->x > 0;
    // OK: a template-id.
    a->f<int>();
  }
}

namespace UndeclaredBaseTemplate {
  template<class> struct imp;
  template<class T> struct is_member_function_pointer : undeclared<imp<T>::member> {}; // expected-error {{unknown template name 'undeclared'}}
}

// PR11109 must appear at the end of the source file
class pr11109r3 { // expected-note{{to match this '{'}}
  public // expected-error{{expected ':'}} expected-error{{expected '}'}} expected-error{{expected ';' after class}}