llvm-for-llvmta/tools/clang/test/Parser/cxx0x-decl.cpp

// RUN: %clang_cc1 -verify -fsyntax-only -std=c++2a -pedantic-errors -triple x86_64-linux-gnu %s

// Make sure we know these are legitimate commas and not typos for ';'.
namespace Commas {
  int a,
  b [[ ]],
  c alignas(double);
}

struct S {};
enum E { e, };

auto f() -> struct S {
  return S();
}
auto g() -> enum E {
  return E();
}

namespace EnumBase {
  enum E {};
  // PR19810: The ': E' here is not an enum-base, and the ':' is not a typo for '::'.
  E e = true ? *new enum E : E {};
  // PR45726: This ':' is not an enum-base.
  static_assert(_Generic(e, enum E : int{}, int: 1) == 0); // expected-error {{C11 extension}}
  static_assert(_Generic(1, enum E : int{}, int: 1) == 1); // expected-error {{C11 extension}}
}

namespace OpaqueEnumDecl {
  enum E : int; // ok

  // PR44941
  enum E : int n; // expected-error {{non-defining declaration of enumeration with a fixed underlying type is only permitted as a standalone declaration}}
  typedef enum E : int T; // expected-error {{non-defining declaration of enumeration with a fixed underlying type is only permitted as a standalone declaration}}
  typedef enum E : int T; // expected-error {{non-defining declaration of enumeration with a fixed underlying type is only permitted as a standalone declaration}}
  namespace Inner {
    typedef enum E : int T; // expected-error {{non-defining declaration of enumeration with a fixed underlying type is only permitted as a standalone declaration}}
  }

  // GCC incorrectly accepts this one
  using T = enum E : int; // expected-error {{non-defining declaration of enumeration with a fixed underlying type is only permitted as a standalone declaration}}

  // PR19810 comment#2
  int x[sizeof(enum E : int)]; // expected-error {{non-defining declaration of enumeration with a fixed underlying type is only permitted as a standalone declaration}}

  namespace PR24297 {
    enum struct E a; // expected-error {{must use 'enum' not 'enum struct'}}
    enum class F b; // expected-error {{must use 'enum' not 'enum class'}}
    enum G : int c; // expected-error {{only permitted as a standalone declaration}}
    enum struct H : int d; // expected-error {{only permitted as a standalone declaration}}
    enum class I : int e; // expected-error {{only permitted as a standalone declaration}}
    enum X x; // expected-error {{ISO C++ forbids forward reference}} expected-error {{incomplete}} expected-note {{forward declaration}}

    enum struct E *pa; // expected-error {{must use 'enum' not 'enum struct'}}
    enum class F *pb; // expected-error {{must use 'enum' not 'enum class'}}
    enum G : int *pc; // expected-error {{only permitted as a standalone declaration}}
    enum struct H : int *pd; // expected-error {{only permitted as a standalone declaration}}
    enum class I : int *pe; // expected-error {{only permitted as a standalone declaration}}
    enum Y *py; // expected-error {{ISO C++ forbids forward reference}}
  }
}

int decltype(f())::*ptr_mem_decltype;

class ExtraSemiAfterMemFn {
  // Due to a peculiarity in the C++11 grammar, a deleted or defaulted function
  // is permitted to be followed by either one or two semicolons.
  void f() = delete // expected-error {{expected ';' after delete}}
  void g() = delete; // ok
  void h() = delete;; // ok
  void i() = delete;;; // expected-error {{extra ';' after member function definition}}
};

int *const const p = 0; // expected-error {{duplicate 'const' declaration specifier}}
const const int *q = 0; // expected-error {{duplicate 'const' declaration specifier}}

struct MultiCV {
  void f() const const; // expected-error {{duplicate 'const' declaration specifier}}
};

static_assert(something, ""); // expected-error {{undeclared identifier}}

// PR9903
struct SS {
  typedef void d() = default; // expected-error {{function definition declared 'typedef'}} expected-error {{only special member functions and comparison operators may be defaulted}}
};

using PR14855 = int S::; // expected-error {{expected ';' after alias declaration}}

// Ensure that 'this' has a const-qualified type in a trailing return type for
// a constexpr function.
struct ConstexprTrailingReturn {
  int n;
  constexpr auto f() const -> decltype((n));
};
constexpr const int &ConstexprTrailingReturn::f() const { return n; }

namespace TestIsValidAfterTypeSpecifier {
struct s {} v;

struct s
thread_local tl;

struct s
&r0 = v;

struct s
&&r1 = s();

struct s
bitand r2 = v;

struct s
and r3 = s();

enum E {};
enum E
[[]] e;

}

namespace PR5066 {
  using T = int (*f)(); // expected-error {{type-id cannot have a name}}
  template<typename T> using U = int (*f)(); // expected-error {{type-id cannot have a name}}
  auto f() -> int (*f)(); // expected-error {{only variables can be initialized}} expected-error {{expected ';'}}
  auto g = []() -> int (*f)() {}; // expected-error {{type-id cannot have a name}}
}

namespace FinalOverride {
  struct Base {
    virtual void *f();
    virtual void *g();
    virtual void *h();
    virtual void *i();
  };
  struct Derived : Base {
    virtual auto f() -> void *final;
    virtual auto g() -> void *override;
    virtual auto h() -> void *final override;
    virtual auto i() -> void *override final;
  };
}

namespace UsingDeclAttrs {
  using T __attribute__((aligned(1))) = int;
  using T [[gnu::aligned(1)]] = int;
  static_assert(alignof(T) == 1, "");

  using [[gnu::aligned(1)]] T = int; // expected-error {{an attribute list cannot appear here}}
  using T = int [[gnu::aligned(1)]]; // expected-error {{'aligned' attribute cannot be applied to types}}
}

namespace DuplicateSpecifier {
  constexpr constexpr int f(); // expected-error {{duplicate 'constexpr' declaration specifier}}
  constexpr int constexpr a = 0; // expected-error {{duplicate 'constexpr' declaration specifier}}

  struct A {
    friend constexpr int constexpr friend f(); // expected-warning {{duplicate 'friend' declaration specifier}} \
                                               // expected-error {{duplicate 'constexpr' declaration specifier}}
    friend struct A friend; // expected-warning {{duplicate 'friend'}} expected-error {{'friend' must appear first}}
  };

  constinit constexpr int n1 = 0; // expected-error {{cannot combine with previous 'constinit'}}
  constexpr constinit int n2 = 0; // expected-error {{cannot combine with previous 'constexpr'}}
  constinit constinit int n3 = 0; // expected-error {{duplicate 'constinit' declaration specifier}}

  consteval constexpr int f1(); // expected-error {{cannot combine with previous 'consteval'}}
  constexpr consteval int f2(); // expected-error {{cannot combine with previous 'constexpr'}}
  consteval consteval int f3(); // expected-error {{duplicate 'consteval' declaration specifier}}

  constinit consteval int wat = 0; // expected-error {{cannot combine with previous 'constinit'}}
  consteval constinit int huh(); // expected-error {{cannot combine with previous 'consteval'}}
}

namespace ColonColonDecltype {
  struct S { struct T {}; };
  ::decltype(S())::T invalid; // expected-error {{expected unqualified-id}}
}

namespace AliasDeclEndLocation {
  template<typename T> struct A {};
  // Ensure that we correctly determine the end of this declaration to be the
  // end of the annotation token, not the beginning.
  using B = AliasDeclEndLocation::A<int
    > // expected-error {{expected ';' after alias declaration}}
    +;
  using C = AliasDeclEndLocation::A<int
    >\
> // expected-error {{expected ';' after alias declaration}}
    ;
  using D = AliasDeclEndLocation::A<int
    > // expected-error {{expected ';' after alias declaration}}
  // FIXME: After splitting this >> into two > tokens, we incorrectly determine
  // the end of the template-id to be after the *second* '>'.
  using E = AliasDeclEndLocation::A<int>>;
#define GGG >>>
  using F = AliasDeclEndLocation::A<int GGG;
  // expected-error@-1 {{expected ';' after alias declaration}}
  B something_else;
}

class PR47176 {
  friend void f(PR47176, int = 0) noexcept(true) {}
};
static_assert(noexcept(f(PR47176())), "");

struct Base { virtual void f() = 0; virtual void g() = 0; virtual void h() = 0; };
struct MemberComponentOrder : Base {
  void f() override __asm__("foobar") __attribute__(( )) {}
  void g() __attribute__(( )) override;
  void h() __attribute__(( )) override {}
};

void NoMissingSemicolonHere(struct S
                            [3]);
template<int ...N> void NoMissingSemicolonHereEither(struct S
                                                     ... [N]);

// This must be at the end of the file; we used to look ahead past the EOF token here.
// expected-error@+1 {{expected unqualified-id}} expected-error@+1{{expected ';'}}
using